1:\\r\\n print(\\\"Model will be instanciated using the following arguments:\\\",\\r\\n self.__dict__)\",\n \"def __init__(\\n self, \\n dim_feat_raw, \\n dim_feat_smooth, \\n dim_label_raw, \\n dim_label_smooth, \\n arch_gnn, \\n aug_feat,\\n num_ensemble, \\n train_params\\n ):\\n super().__init__()\\n self.mulhead = 1\\n self.num_layers = arch_gnn[\\\"num_layers\\\"]\\n self.dropout, self.dropedge = train_params[\\\"dropout\\\"], train_params['dropedge']\\n self.mulhead = int(arch_gnn[\\\"heads\\\"]) # only useful for GAT\\n\\n self.branch_sharing = arch_gnn['branch_sharing'] # only for ensemble\\n\\n self.type_feature_augment = aug_feat\\n assert dim_feat_raw <= dim_feat_smooth, \\\"smoothened feature cannot have smaller shape than the original one\\\"\\n # NOTE: dim_label_raw may be larger than dim_label_smooth ==> label is not used as input\\n self.num_classes = dim_label_raw\\n self.dim_label_in = dim_label_smooth\\n self.dim_feat_in = dim_feat_smooth\\n self.dim_hidden = arch_gnn['dim']\\n # build the model below\\n dim, act = arch_gnn['dim'], arch_gnn['act']\\n self.aug_layers, self.conv_layers, self.res_pool_layers = [], [], []\\n for i in range(num_ensemble):\\n # feat aug\\n if len(self.type_feature_augment) > 0:\\n self.aug_layers.append(nn.ModuleList(\\n nn.Linear(_dim, self.dim_feat_in) for _, _dim in self.type_feature_augment\\n ))\\n # graph convs\\n convs = []\\n if i == 0 or not self.branch_sharing:\\n for j in range(arch_gnn['num_layers']):\\n cls_gconv = DeepGNN.NAME2CLS[arch_gnn['aggr']]\\n dim_in = (self.dim_feat_in + self.dim_label_in) if j == 0 else dim\\n convs.append(cls_gconv(dim_in, dim, dropout=self.dropout, act=act, mulhead=self.mulhead))\\n self.conv_layers.append(nn.Sequential(*convs))\\n else: # i > 0 and branch_sharing\\n self.conv_layers.append(self.conv_layers[-1])\\n # skip-pooling layer\\n type_res = arch_gnn['residue'].lower()\\n type_pool = arch_gnn['pooling'].split('-')[0].lower()\\n cls_res_pool = layers.ResPool\\n args_pool = {}\\n if type_pool == 'sort':\\n args_pool['k'] = int(arch_gnn['pooling'].split('-')[1])\\n self.res_pool_layers.append(\\n cls_res_pool(dim, dim, arch_gnn['num_layers'], type_res, type_pool,\\n dropout=self.dropout, act=act, args_pool=args_pool\\n ))\\n if len(self.aug_layers) > 0:\\n self.aug_layers = nn.ModuleList(self.aug_layers)\\n self.conv_layers = nn.ModuleList(self.conv_layers)\\n self.res_pool_layers = nn.ModuleList(self.res_pool_layers)\\n # ------- ensembler + classifier -------\\n if num_ensemble == 1:\\n self.ensembler = layers.EnsembleDummy()\\n else:\\n self.ensembler = layers.EnsembleAggregator(dim, dim, num_ensemble, dropout=self.dropout, \\n type_dropout=train_params[\\\"ensemble_dropout\\\"], act=arch_gnn[\\\"ensemble_act\\\"])\\n self.classifier = DeepGNN.NAME2CLS['mlp'](dim, self.num_classes, act='I', dropout=0.)\\n # ---- optimizer, etc. ----\\n self.lr = train_params[\\\"lr\\\"]\\n self.sigmoid_loss = arch_gnn[\\\"loss\\\"] == \\\"sigmoid\\\"\\n self.loss, self.opt_op = 0, None\\n self.optimizer = torch.optim.Adam(self.parameters(), lr=self.lr)\\n\\n self.num_ensemble = num_ensemble\",\n \"def _define_model_functions(self):\\n # Input of neurons (Batch size x Number of states)\\n states = Input(shape=(self.num_states,), dtype=tf.float32, name=\\\"states\\\")\\n\\n # Hidden layers\\n layer_1 = layers.Dense(self.hidden_arch[0], activation=self.activation)(states)\\n layers_n = [None for _ in range(len(self.hidden_arch))]\\n layers_n[0] = layer_1\\n for idx, n_neurons in enumerate(self.hidden_arch[1:]):\\n layers_n[idx + 1] = layers.Dense(\\n n_neurons,\\n activation=self.activation,\\n )(layers_n[idx])\\n\\n # Output of neurons is q(s, a) function\\n q_s_a = layers.Dense(self.num_actions, name=\\\"q_s_a\\\")(layers_n[-1])\\n\\n # Get the model\\n self.model = Model(inputs=states, outputs=q_s_a)\\n\\n # Loss function and optimizer\\n self.loss = losses.MeanSquaredError(reduction=\\\"auto\\\", name=\\\"mean_squared_error\\\")\\n\\n self.optimizer = optimizers.Adam(\\n learning_rate=self.learning_rate,\\n beta_1=self.beta1,\\n beta_2=self.beta2,\\n name=\\\"Adam\\\",\\n )\",\n \"def get_model( ):\\n\\n return Lasso(alpha = 1e-3, fit_intercept = True, precompute = True, max_iter = 1e4)\",\n \"def compute_loss(self, obs, returns):\",\n \"def simple_model_fn(features,\\n labels,\\n mode,\\n params):\\n features['alphas'] = tf.reshape(features['alphas'], (params['batch_size'], 1))\\n features['neuron_ids'] = tf.reshape(features['neuron_ids'], (params['batch_size'], params['window_size']))\\n features['w'] = tf.reshape(features['w'], (params['batch_size'], params['window_size']))\\n features['global_features'] = tf.reshape(features['global_features'],\\n (params['batch_size'], params['N_global_features']))\\n features['X'] = tf.reshape(features['X'], (params['batch_size'],\\n params['window_size'] + 2 * params['window_padding']))\\n\\n outputs, normalizers = params['network_fn'](features, mode, params)\\n\\n if mode == learn.ModeKeys.TRAIN:\\n summarize_layer('labels', labels)\\n\\n output = outputs['output']\\n summarize_layer('output', output)\\n\\n if params['use_normalizer']:\\n multipliers = tf.gather(normalizers, features['neuron_ids'])\\n output_norm = multipliers * output\\n else:\\n output_norm = tf.identity(output)\\n\\n output_norm_pre = output_norm\\n output_norm = output_norm * features['alphas']\\n\\n loss = None\\n train_op = None\\n\\n zero_fraction = tf.identity(tf.reduce_mean(\\n tf.nn.zero_fraction(output_norm), keep_dims=True),\\n name=\\\"zero_fraction_tracker\\\")\\n\\n # Calculate Loss (for both TRAIN and EVAL modes)\\n if mode != learn.ModeKeys.INFER:\\n loss = tf.losses.mean_squared_error(\\n labels=tf.reshape(labels, shape=(-1, )),\\n predictions=tf.reshape(output_norm, shape=(-1, )),\\n weights=tf.reshape(features['w'], shape=(-1, ))\\n )\\n\\n # Configure the Training Op (for TRAIN mode)\\n if mode == learn.ModeKeys.TRAIN:\\n global_step = tf.contrib.framework.get_global_step()\\n learning_rate = tf.train.exponential_decay(\\n params['alpha'],\\n global_step,\\n params['decay_every'],\\n params['decay_multiplier'],\\n staircase=True,\\n name='learning_rate')\\n summary.scalar('learning_rate', learning_rate)\\n summary.scalar('sum_weights_train', tf.reduce_sum(labels[:, 1]))\\n train_op = tf.contrib.layers.optimize_loss(\\n loss=loss,\\n global_step=global_step,\\n learning_rate=learning_rate,\\n optimizer=\\\"Adam\\\",\\n clip_gradients=optimizers_lib.adaptive_clipping_fn())\\n elif mode == learn.ModeKeys.EVAL:\\n summary.scalar('sum_weights_eval', tf.reduce_sum(labels[:, 1]))\\n\\n # Generate Predictions\\n predictions = {\\n \\\"relu_output\\\": tf.identity(output_norm, name='relu_output'),\\n \\\"relu_coarse\\\": tf.cast(tf.round(tf.reshape(output_norm, (-1, )) * 1e4),\\n tf.int32,\\n name='relu_coarse'),\\n }\\n\\n if mode != learn.ModeKeys.INFER:\\n eval_metric_ops = {\\n \\\"mse\\\":\\n tf.metrics.mean_squared_error(\\n labels=tf.reshape(labels, (-1, )),\\n predictions=tf.reshape(output_norm, (-1, )),\\n weights=tf.reshape(features['w'], shape=(-1, ))\\n ),\\n }\\n else:\\n eval_metric_ops = None\\n\\n # Return a ModelFnOps object\\n return model_fn_lib.ModelFnOps(\\n mode=mode, predictions=predictions,\\n loss=loss,\\n train_op=train_op,\\n eval_metric_ops=eval_metric_ops)\",\n \"def make_NN(n_hidden, n_epoch, labelsdict, lr, device, model_name, trainloader, validloader, train_data, pretrain, finetune_whole, custom_model):\\n if custom_model == 2:\\n # Use custom two-layer convolution model\\n print(\\\"Using Two-Layer CNN\\\")\\n model = TwoLayerConvNet()\\n elif custom_model == 5:\\n print(\\\"Using Five-Layer CNN\\\")\\n # Use custom five-layer convolution model\\n model = FiveLayerConvNet()\\n else:\\n # Import NN model (either pretrained or not)\\n model = getattr(models, model_name)(pretrained=pretrain)\\n \\\"\\\"\\\" ===================================================================================== \\\"\\\"\\\"\\\"\\n \\n \\\"\\\"\\\" IMPLEMENTATION OF finetune_whole ARGUMENT TO EITHER FREEZE THE PARAMETERS OR NOT (WILBERT ARISTO) \\\"\\\"\\\"\\n # If we do not need to finetune whole model, freeze parameters that we don't need to re-train\\n if not finetune_whole:\\n for param in model.parameters():\\n param.requires_grad = False\\n \\\"\\\"\\\" ===================================================================================== \\\"\\\"\\\"\\\"\\n\\n n_out = len(labelsdict)\\n\\n \\\"\\\"\\\" CHANGED LAST LAYER TO model.fc IF WE ARE USING RESNET MODEL (WILBERT ARISTO) \\\"\\\"\\\"\\n if \\\"resnet\\\" in model_name:\\n # Make classifier\\n n_in = next(model.fc.modules()).in_features\\n model.fc = NN_Classifier(input_size=n_in, output_size=n_out, hidden_layers=n_hidden)\\n \\n \\\"\\\"\\\" IMPLEMENTATION OF finetune_whole ARGUMENT TO EITHER OPTIMIZE ALL PARAMETERS OR JUST THE LAST LAYER'S PARAMS (WILBERT ARISTO) \\\"\\\"\\\"\\n # Define optimizer\\n if finetune_whole:\\n optimizer = optim.Adam(model.parameters(), lr = lr)\\n else:\\n optimizer = optim.Adam(model.fc.parameters(), lr = lr)\\n \\\"\\\"\\\" ============================================================================================================================ \\\"\\\"\\\"\\\"\\n else:\\n # Make classifier\\n n_in = next(model.classifier.modules()).in_features\\n model.classifier = NN_Classifier(input_size=n_in, output_size=n_out, hidden_layers=n_hidden)\\n \\n \\\"\\\"\\\" IMPLEMENTATION OF finetune_whole ARGUMENT TO EITHER OPTIMIZE ALL PARAMETERS OR JUST THE LAST LAYER'S PARAMS (WILBERT ARISTO) \\\"\\\"\\\"\\n # Define optimizer\\n if finetune_whole:\\n optimizer = optim.Adam(model.parameters(), lr = lr)\\n else:\\n optimizer = optim.Adam(model.classifier.parameters(), lr = lr)\\n \\\"\\\"\\\" ============================================================================================================================ \\\"\\\"\\\"\\\"\\n \\\"\\\"\\\" ============================================================================================================================ \\\"\\\"\\\"\\\"\\n\\n # Define criterion\\n criterion = nn.NLLLoss() \\n\\n model.to(device)\\n start = time.time()\\n\\n epochs = n_epoch\\n steps = 0 \\n running_loss = 0\\n print_every = 40\\n for e in range(epochs):\\n model.train()\\n for images, labels in trainloader:\\n images, labels = images.to(device), labels.to(device)\\n\\n steps += 1\\n\\n optimizer.zero_grad()\\n\\n output = model.forward(images)\\n loss = criterion(output, labels)\\n loss.backward()\\n optimizer.step()\\n\\n running_loss += loss.item()\\n\\n if steps % print_every == 0:\\n # Eval mode for predictions\\n model.eval()\\n\\n # Turn off gradients for validation\\n with torch.no_grad():\\n test_loss, accuracy = validation(model, validloader, criterion, device)\\n\\n print(\\\"Epoch: {}/{} - \\\".format(e+1, epochs),\\n \\\"Training Loss: {:.3f} - \\\".format(running_loss/print_every),\\n \\\"Validation Loss: {:.3f} - \\\".format(test_loss/len(validloader)),\\n \\\"Validation Accuracy: {:.3f}\\\".format(accuracy/len(validloader)))\\n\\n running_loss = 0\\n\\n # Make sure training is back on\\n model.train()\\n \\n \\\"\\\"\\\" CHANGED LAST LAYER TO model.fc IF WE ARE USING RESNET MODEL (WILBERT ARISTO) \\\"\\\"\\\"\\n if \\\"resnet\\\" in model_name:\\n # Add model info \\n model.fc.n_in = n_in\\n model.fc.n_hidden = n_hidden\\n model.fc.n_out = n_out\\n model.fc.labelsdict = labelsdict\\n model.fc.lr = lr\\n model.fc.optimizer_state_dict = optimizer.state_dict\\n model.fc.model_name = model_name\\n model.fc.class_to_idx = train_data.class_to_idx\\n else:\\n # Add model info \\n model.classifier.n_in = n_in\\n model.classifier.n_hidden = n_hidden\\n model.classifier.n_out = n_out\\n model.classifier.labelsdict = labelsdict\\n model.classifier.lr = lr\\n model.classifier.optimizer_state_dict = optimizer.state_dict\\n model.classifier.model_name = model_name\\n model.classifier.class_to_idx = train_data.class_to_idx\\n \\\"\\\"\\\" ============================================================================================================================ \\\"\\\"\\\"\\\"\\n\\n print('model:', model_name, '- hidden layers:', n_hidden, '- epochs:', n_epoch, '- lr:', lr)\\n print(f\\\"Run time: {(time.time() - start)/60:.3f} min\\\")\\n return model\\n\\n# Define function to save checkpoint\\ndef save_checkpoint(model, path):\\n checkpoint = {'c_input': model.classifier.n_in,\\n 'c_hidden': model.classifier.n_hidden,\\n 'c_out': model.classifier.n_out,\\n 'labelsdict': model.classifier.labelsdict,\\n 'c_lr': model.classifier.lr,\\n 'state_dict': model.state_dict(),\\n 'c_state_dict': model.classifier.state_dict(),\\n 'opti_state_dict': model.classifier.optimizer_state_dict,\\n 'model_name': model.classifier.model_name,\\n 'class_to_idx': model.classifier.class_to_idx\\n }\\n torch.save(checkpoint, path)\\n \\n# Define function to load model\\ndef load_model(path):\\n cp = torch.load(path)\\n \\n # Import pre-trained NN model \\n model = getattr(models, cp['model_name'])(pretrained=True)\\n \\n # Freeze parameters that we don't need to re-train \\n for param in model.parameters():\\n param.requires_grad = False\\n \\n # Make classifier\\n model.classifier = NN_Classifier(input_size=cp['c_input'], output_size=cp['c_out'], \\\\\\n hidden_layers=cp['c_hidden'])\\n \\n # Add model info \\n model.classifier.n_in = cp['c_input']\\n model.classifier.n_hidden = cp['c_hidden']\\n model.classifier.n_out = cp['c_out']\\n model.classifier.labelsdict = cp['labelsdict']\\n model.classifier.lr = cp['c_lr']\\n model.classifier.optimizer_state_dict = cp['opti_state_dict']\\n model.classifier.model_name = cp['model_name']\\n model.classifier.class_to_idx = cp['class_to_idx']\\n model.load_state_dict(cp['state_dict'])\\n \\n return model\",\n \"def _objective(self, params, model_ID, model_dict, X, y, **kwargs):\\n model = model_dict['model']\\n param_grid = model_dict['param_grid'].copy()\\n params = params.copy()\\n \\n obj_verbose = max(0,self.verbose-2)\\n \\n type_X = str(type(X))\\n \\n if 'dask' in type_X:\\n X = X.compute()\\n y = y.compute()\\n \\n if obj_verbose>=2:\\n print('params',params)\\n \\n params_transform, model = self._update_model_params(params, \\n model_ID,\\n model, \\n param_grid)\\n type_model = str(type(model))\\n \\n if obj_verbose>=2:\\n print('params_transform',params_transform)\\n if 'sklearn' in type_model or 'xgboost' in type_model:\\n \\n cv_scores = _sklearn_model_selection.cross_val_score(model, X, y,\\n scoring= self.scoring['metric'],\\n cv = self.cv,\\n n_jobs= self.n_jobs,\\n verbose = obj_verbose\\n )\\n\\n else: #using neural net function\\n import tensorflow as _tf\\n #check for kwargs\\n epochs = 100\\n batch_size = 32\\n callbacks = [_tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience =10)]\\n for item in kwargs.items():\\n if 'epochs' in item[0]: \\n epochs = item[1]\\n elif 'batch_size' in item[0]: \\n batch_size = item[1]\\n elif 'callbacks' in item[0]: \\n callbacks = item[1] \\n cv_scores = _NeuralNet.cross_val_score(model,\\n batch_size,\\n epochs,\\n X, y,\\n callbacks,\\n scoring = self.scoring['metric'],\\n cv = self.cv,\\n verbose= obj_verbose)\\n \\n cv_score = _np.mean(cv_scores)\\n \\n if 'sklearn' in type_model or 'xgboost' in type_model:\\n if self.scoring['maximize']==True or self.scoring['metric']==None:\\n cv_score = 1/cv_score \\n else:\\n if self.scoring['maximize']==True and self.scoring['metric']!=None :\\n cv_score = 1/cv_score \\n \\n objective = {'loss': cv_score,\\n 'params': params,\\n 'status': _hyperopt.STATUS_OK,\\n 'eval_time': _time.time()}\\n return objective\",\n \"def precompute(self, features, mode, params):\\n return None\",\n \"def train_step(model, model_0, mu:int, optimizer, train_data, loss_f):\\n \\n total_loss=0\\n \\n for idx, (features,labels) in enumerate(train_data):\\n \\n optimizer.zero_grad()\\n \\n predictions= model(features)\\n \\n loss=loss_f(predictions,labels)\\n loss+=mu/2*difference_models_norm_2(model,model_0)\\n total_loss+=loss\\n \\n loss.backward()\\n optimizer.step()\\n \\n return total_loss/(idx+1)\",\n \"def train_naive(): # add arguments as needed\\n pass\",\n \"def model_loss(inp, fake, real_label, fake_label):\\n \\n \\n Dreal,realcls,R1 = gradpen(inp)\\n [Dfake,fakecls] = D(fake)\\n # 1. Adversarial loss\\n \\n glabel = tf.ones_like(Dfake)#tf.random.uniform((Dfake.shape), 1-LN, 1)\\n dlabelr = tf.ones_like(Dreal)#tf.random.uniform((Dreal.shape), 1-LN, 1)\\n dlabelf = tf.zeros_like(Dfake)#tf.random.uniform((Dfake.shape), 0, LN)\\n \\n \\n \\n # D has no sigmoid activation: \\\"from_logits=True\\\"\\n real_loss = tf.keras.losses.binary_crossentropy(\\n dlabelr, Dreal, from_logits=True)\\n real_loss = tf.reduce_mean(real_loss)\\n \\n fake_loss = tf.keras.losses.binary_crossentropy(\\n dlabelf, Dfake, from_logits=True)\\n fake_loss = tf.reduce_mean(fake_loss)\\n \\n Dadv = 0.5*(real_loss+fake_loss)\\n \\n Gadv = tf.keras.losses.binary_crossentropy(\\n glabel, Dfake, from_logits=True)\\n Gadv = tf.reduce_mean(Gadv)\\n \\n # 2. Classification loss\\n \\n Dcls = tf.keras.losses.binary_crossentropy(real_label, realcls, from_logits=True)\\n Dcls = tf.reduce_mean(Dcls)\\n \\n Gcls = tf.keras.losses.binary_crossentropy(fake_label, fakecls, from_logits=True)\\n Gcls = tf.reduce_mean(Gcls)\\n \\n # 3. Total loss\\n \\n Dloss = Dadv + (GAMMA/2)*R1 + LAMBDA_CLS*Dcls\\n \\n Gloss = Gadv + LAMBDA_CLS*Gcls\\n \\n return (Dloss, Dadv, Dcls, R1), (Gloss, Gadv, Gcls)\",\n \"def createModel(data, eta, epoch, file_name, plot_name, no_of_input=2):\\n logging.info(f\\\"\\\\n\\\\n>>>>>>>>>>Starting training>>>>>>>>>>>>>>>>{file_name}\\\")\\n logging.info(f\\\"eta = {str(eta)} epochs ={str(epoch)}\\\\n\\\")\\n\\n df = pd.DataFrame(data)\\n\\n X,y = prepare_data(df)\\n logging.info(f\\\"X={X}\\\")\\n logging.info(f\\\"Y={y}\\\") \\n\\n model = Perceptron(eta, epoch, no_of_input)\\n\\n model.fit(X, y)\\n\\n model.predict(X)\\n\\n model.total_loss()\\n\\n save_model(model, file_name)\\n\\n \\n logging.info(f\\\">>>>>>>>>>>>>>>>>>>>>>>>>>>>>\\\")\\n\\n if no_of_input == 2:\\n save_plot(df, plot_name, model)\",\n \"def build(self):\\n\\n self.W_AA = self.init([self.n_atom_input_feat, self.n_hidden_AA])\\n self.b_AA = model_ops.zeros(shape=[\\n self.n_hidden_AA,\\n ])\\n\\n self.W_PA = self.init([self.n_pair_input_feat, self.n_hidden_PA])\\n self.b_PA = model_ops.zeros(shape=[\\n self.n_hidden_PA,\\n ])\\n\\n self.W_A = self.init([self.n_hidden_A, self.n_atom_output_feat])\\n self.b_A = model_ops.zeros(shape=[\\n self.n_atom_output_feat,\\n ])\\n\\n self.trainable_weights = [\\n self.W_AA, self.b_AA, self.W_PA, self.b_PA, self.W_A, self.b_A\\n ]\\n if self.update_pair:\\n self.W_AP = self.init([self.n_atom_input_feat * 2, self.n_hidden_AP])\\n self.b_AP = model_ops.zeros(shape=[\\n self.n_hidden_AP,\\n ])\\n\\n self.W_PP = self.init([self.n_pair_input_feat, self.n_hidden_PP])\\n self.b_PP = model_ops.zeros(shape=[\\n self.n_hidden_PP,\\n ])\\n\\n self.W_P = self.init([self.n_hidden_P, self.n_pair_output_feat])\\n self.b_P = model_ops.zeros(shape=[\\n self.n_pair_output_feat,\\n ])\\n\\n self.trainable_weights.extend(\\n [self.W_AP, self.b_AP, self.W_PP, self.b_PP, self.W_P, self.b_P])\",\n \"def __init__(self, ndf, n_layers, original_model, norm_layer, fc_relu_slope, fc_drop_out):\\n super(ModifiedModel_old, self).__init__()\\n if type(norm_layer) == functools.partial: # no need to use bias as BatchNorm2d has affine parameters\\n use_bias = norm_layer.func == nn.InstanceNorm2d\\n else:\\n use_bias = norm_layer == nn.InstanceNorm2d\\n\\n self.features = nn.Sequential(*list(original_model.children())[:-1])\\n self.avg = nn.AdaptiveAvgPool2d((1, 1))\\n\\n sequence = []\\n nf_mult = 1\\n nf_mult_prev = 1\\n for n in range(1, n_layers): # gradually increase the number of filters\\n nf_mult_prev = nf_mult\\n nf_mult = min(2 ** n, 32)\\n sequence += [\\n nn.Linear(in_features=int(ndf/nf_mult_prev), out_features=int(ndf/nf_mult)),\\n # norm_layer(int(ndf/nf_mult)),\\n nn.LeakyReLU(fc_relu_slope, True),\\n nn.Dropout2d(p=fc_drop_out)\\n ]\\n\\n sequence += [nn.Linear(in_features=int(ndf/nf_mult), out_features=1)] # output 1 channel prediction map\\n self.linear_group = nn.Sequential(*sequence)\",\n \"def _build_model(self):\\n\\n with tf.variable_scope(self.name):\\n # adds placeholders, data_normalization and data_noise if desired. Also adds a placeholder for dropout probability\\n self.layer_in_x, self.layer_in_y = self._build_input_layers()\\n\\n # create core multi-layer perceptron\\n mlp_output_dim = 2 * self.ndim_y * self.n_centers + self.n_centers\\n core_network = MLP(\\n name=\\\"core_network\\\",\\n input_layer=self.layer_in_x,\\n output_dim=mlp_output_dim,\\n hidden_sizes=self.hidden_sizes,\\n hidden_nonlinearity=self.hidden_nonlinearity,\\n output_nonlinearity=None,\\n weight_normalization=self.weight_normalization,\\n dropout_ph=self.dropout_ph if self.dropout else None\\n )\\n\\n core_output_layer = core_network.output_layer\\n\\n # slice output of MLP into three equally sized parts for loc, scale and mixture weights\\n slice_layer_locs = L.SliceLayer(core_output_layer, indices=slice(0, self.ndim_y * self.n_centers), axis=-1)\\n slice_layer_scales = L.SliceLayer(core_output_layer, indices=slice(self.ndim_y * self.n_centers, 2 * self.ndim_y * self.n_centers), axis=-1)\\n slice_layer_weights = L.SliceLayer(core_output_layer, indices=slice(2 * self.ndim_y * self.n_centers, mlp_output_dim), axis=-1)\\n\\n # locations mixture components\\n self.reshape_layer_locs = L.ReshapeLayer(slice_layer_locs, (-1, self.n_centers, self.ndim_y))\\n self.locs = L.get_output(self.reshape_layer_locs)\\n\\n # scales of the mixture components\\n reshape_layer_scales = L.ReshapeLayer(slice_layer_scales, (-1, self.n_centers, self.ndim_y))\\n self.softplus_layer_scales = L.NonlinearityLayer(reshape_layer_scales, nonlinearity=tf.nn.softplus)\\n self.scales = L.get_output(self.softplus_layer_scales)\\n\\n # weights of the mixture components\\n self.logits = L.get_output(slice_layer_weights)\\n self.softmax_layer_weights = L.NonlinearityLayer(slice_layer_weights, nonlinearity=tf.nn.softmax)\\n self.weights = L.get_output(self.softmax_layer_weights)\\n\\n # # put mixture components together\\n self.y_input = L.get_output(self.layer_in_y)\\n self.cat = cat = Categorical(logits=self.logits)\\n self.components = components = [MultivariateNormalDiag(loc=loc, scale_diag=scale) for loc, scale\\n in zip(tf.unstack(self.locs, axis=1), tf.unstack( self.scales, axis=1))]\\n self.mixture = mixture = Mixture(cat=cat, components=components, value=tf.zeros_like(self.y_input))\\n\\n # regularization\\n self._add_softmax_entropy_regularization()\\n self._add_l1_l2_regularization(core_network)\\n\\n # tensor to store samples\\n self.samples = mixture.sample() #TODO either use it or remove it\\n\\n # tensor to compute probabilities\\n if self.data_normalization:\\n self.pdf_ = mixture.prob(self.y_input) / tf.reduce_prod(self.std_y_sym)\\n self.log_pdf_ = mixture.log_prob(self.y_input) - tf.reduce_sum(tf.log(self.std_y_sym))\\n else:\\n self.pdf_ = mixture.prob(self.y_input)\\n self.log_pdf_ = mixture.log_prob(self.y_input)\\n\\n # symbolic tensors for getting the unnormalized mixture components\\n if self.data_normalization:\\n self.scales_unnormalized = self.scales * self.std_y_sym\\n self.locs_unnormalized = self.locs * self.std_y_sym + self.mean_y_sym\\n else:\\n self.scales_unnormalized = self.scales\\n self.locs_unnormalized = self.locs\\n\\n # initialize LayersPowered --> provides functions for serializing tf models\\n LayersPowered.__init__(self, [self.softmax_layer_weights, self.softplus_layer_scales, self.reshape_layer_locs,\\n self.layer_in_y])\",\n \"def FNN(ANNSetup, test, train):\\n\\n #ClassWeights = GetClassWeights(train.OutTrue,train.Weights)\\n TrainWeights = GetTrainWeights(train.OutTrue,train.Weights) # Transformation of the Monte Carlo weights for training\\n\\n #tf.debugging.set_log_device_placement(True) #Check if system is running on the correct device\\n\\n #Create the model and pass it the data for Callbacks\\n model = Sequential()\\n model.X_train = train.Events\\n model.Y_train = train.OutTrue\\n model.W_train = train.Weights #Original weights!\\n model.X_test = test.Events\\n model.Y_test = test.OutTrue\\n model.W_test = test.Weights\\n\\n model = BuildModel(ANNSetup,model) # Building the model from the predefinite configuration (FNN.py)\\n\\n Opti = GetOpti(ANNSetup.Optimizer,ANNSetup.LearnRate.Lr) # Set the optimizer\\n lrate = GetLearnRate(ANNSetup.LearnRate,ANNSetup.Epochs) # Set a learning rate schedule\\n Roc = Histories() # Definie history for the AUC results at each training step \\n #Roc = RedHistory()\\n if(lrate == None):\\n Lcallbacks = [Roc]\\n #Lcallbacks = []\\n else:\\n Lcallbacks = [Roc,lrate]\\n #Lcallbacks = [lrate]\\n\\n model.summary()\\n model.compile(optimizer=Opti, loss='binary_crossentropy', metrics=['accuracy'])\\n start = time.clock() # start clock to track training time\\n history = model.fit(train.Events,train.OutTrue, sample_weight=TrainWeights, validation_data=(test.Events, test.OutTrue, test.Weights), epochs=int(ANNSetup.Epochs),\\n batch_size=int(ANNSetup.Batch), verbose=2, callbacks=Lcallbacks) #, callbacks=Lcallbacks , sample_weight=TrainWeights\\n #history = model.fit(train.Events,train.OutTrue,batch_size=4000,epochs=2)\\n end = time.clock()\\n print(\\\"The training took {} seconds\\\".format(end-start))\\n\\n LAuc = Roc.TestAucs\\n LTrainAuc = Roc.TrainAucs\\n print(\\\"Best Test Auc {0:.4f} at Epoch {1}\\\".format(max(LAuc),(LAuc.index(max(LAuc))+1))) #0:.4f\\n print(\\\"Best Train Auc {0:.4f}\\\".format(LTrainAuc[LAuc.index(max(LAuc))]))\\n\\n for i in range(len(LAuc)):\\n print(\\\"Auc at Epoch {0}: {1:.4f} Ov: {2:.3f}\\\".format(i,LAuc[i],1-LAuc[i]/LTrainAuc[i]))\\n\\n model.save(ANNSetup.SavePath)\\n\\n return model, Roc\",\n \"def _augment_model_fn(self, model_fn, batch_axis):\\n\\n def _model_fn(features, labels, mode, config, params):\\n \\\"\\\"\\\"A Estimator `model_fn` for TPUEstimator.\\\"\\\"\\\"\\n with self._ctx.with_mode(mode) as ctx:\\n model_fn_wrapper = _ModelFnWrapper(model_fn, config, params, ctx)\\n\\n if mode != model_fn_lib.ModeKeys.PREDICT:\\n is_export_mode = False\\n else:\\n # For export_savedmodel, input_fn is never passed to Estimator. So, by\\n # checking the self._is_input_fn_invoked bit, we can know, given the\\n # mode == PREDICT, it is the .predict API, not export_savedmodel API.\\n if self._is_input_fn_invoked:\\n is_export_mode = False\\n else:\\n is_export_mode = True\\n\\n # Clear the bit.\\n self._is_input_fn_invoked = None\\n\\n if ctx.is_running_on_cpu(is_export_mode=is_export_mode):\\n logging.info('Running %s on CPU', mode)\\n return model_fn_wrapper.call_without_tpu(\\n features, labels, is_export_mode=is_export_mode)\\n\\n assert labels is None, '`labels` passed to `model_fn` must be `None`.'\\n # TPUEstimator._call_input_fn passes `input_fn` as features to here.\\n assert callable(features), '`input_fn` is not callable.'\\n input_fn = features\\n\\n input_holders = _InputPipeline(input_fn, batch_axis, ctx)\\n enqueue_ops, dequeue_fn, input_hooks, run_infeed_loop_on_coordinator = (\\n input_holders.generate_infeed_enqueue_ops_and_dequeue_fn())\\n\\n graph = ops.get_default_graph()\\n for enqueue_op in enqueue_ops:\\n if isinstance(enqueue_op, list):\\n graph.get_collection_ref(_TPU_ENQUEUE_OPS).extend(enqueue_op)\\n else:\\n graph.add_to_collection(_TPU_ENQUEUE_OPS, enqueue_op)\\n\\n if mode == model_fn_lib.ModeKeys.TRAIN:\\n loss, host_call, scaffold = (\\n _train_on_tpu_system(ctx, model_fn_wrapper, dequeue_fn))\\n host_ops = host_call.create_tpu_hostcall()\\n if host_ops is None:\\n host_ops = []\\n hooks = [\\n TPUInfeedOutfeedSessionHook(\\n ctx,\\n enqueue_ops,\\n host_ops,\\n run_infeed_loop_on_coordinator=(\\n run_infeed_loop_on_coordinator)),\\n ExamplesPerSecondHook(ctx.global_batch_size,\\n output_dir=self.model_dir),\\n InstallSignalHandlerHook(),\\n training.LoggingTensorHook(\\n {\\n 'loss': array_ops.identity(loss),\\n 'step': training.get_global_step()\\n },\\n every_n_secs=30)\\n ] + input_hooks\\n chief_hooks = []\\n if (self._config.save_checkpoints_secs or\\n self._config.save_checkpoints_steps):\\n chief_hooks.append(\\n training.CheckpointSaverHook(\\n self.model_dir,\\n save_secs=self._config.save_checkpoints_secs,\\n save_steps=self._config.save_checkpoints_steps,\\n steps_per_run=self._config.tpu_config.iterations_per_loop,\\n scaffold=scaffold))\\n summary.scalar(model_fn_lib.LOSS_METRIC_KEY, loss)\\n with ops.control_dependencies([loss]):\\n update_ops = _sync_variables_ops()\\n\\n # Validate the TPU training graph to catch basic errors\\n _validate_tpu_training_graph()\\n\\n train_op = control_flow_ops.group(*update_ops)\\n graph.add_to_collection(_TPU_TRAIN_OP, train_op)\\n\\n return model_fn_lib.EstimatorSpec(\\n mode,\\n loss=loss,\\n training_chief_hooks=chief_hooks,\\n training_hooks=hooks,\\n train_op=train_op,\\n scaffold=scaffold)\\n\\n if mode == model_fn_lib.ModeKeys.EVAL:\\n total_loss, host_calls, scaffold = _eval_on_tpu_system(\\n ctx, model_fn_wrapper, dequeue_fn)\\n iterations_per_loop_var = _create_or_get_iterations_per_loop()\\n mean_loss = math_ops.div(total_loss,\\n math_ops.cast(\\n iterations_per_loop_var,\\n dtype=total_loss.dtype))\\n\\n # Creates a dummy metric update_op for all metrics. Estimator expects\\n # all metrics in eval_metric_ops have update_op and calls them one by\\n # one. The real metric update_ops are invoked in a separated thread.\\n # So, here give Estimator the dummy op for all metrics.\\n with ops.control_dependencies([mean_loss]):\\n # After TPU evaluation computation is done (the mean_loss tensor),\\n # reads all variables back from TPU and updates the eval step\\n # counter properly\\n internal_ops_to_run = _sync_variables_ops()\\n internal_ops_to_run.append(\\n _increase_eval_step_op(iterations_per_loop_var))\\n with ops.control_dependencies(internal_ops_to_run):\\n dummy_update_op = control_flow_ops.no_op()\\n\\n host_call_ret = host_calls.create_tpu_hostcall()\\n eval_metric_ops = {}\\n eval_update_ops = []\\n for k, v in host_call_ret['eval_metrics'].items():\\n eval_metric_ops[k] = (v[0], dummy_update_op)\\n eval_update_ops.append(v[1])\\n\\n if 'host_call' not in host_call_ret:\\n host_ops = []\\n else:\\n host_ops = host_call_ret['host_call']\\n hooks = [\\n TPUInfeedOutfeedSessionHook(\\n ctx,\\n enqueue_ops,\\n eval_update_ops + host_ops,\\n run_infeed_loop_on_coordinator=(\\n run_infeed_loop_on_coordinator)),\\n ] + input_hooks\\n\\n return model_fn_lib.EstimatorSpec(\\n mode,\\n loss=mean_loss,\\n evaluation_hooks=hooks,\\n eval_metric_ops=eval_metric_ops,\\n scaffold=scaffold)\\n\\n # Predict\\n assert mode == model_fn_lib.ModeKeys.PREDICT\\n\\n dummy_predict_op, host_calls, scaffold = _predict_on_tpu_system(\\n ctx, model_fn_wrapper, dequeue_fn)\\n with ops.control_dependencies([dummy_predict_op]):\\n internal_ops_to_run = _sync_variables_ops()\\n with ops.control_dependencies(internal_ops_to_run):\\n dummy_predict_op = control_flow_ops.no_op()\\n\\n # In train and evaluation, the main TPU program is passed to monitored\\n # training session to run. Infeed enqueue and outfeed dequeue are\\n # executed in side threads. This is not the configuration for\\n # prediction mode.\\n #\\n # For prediction, the Estimator executes the EstimatorSpec.predictions\\n # directly and yield the element (via generator) to call site. So, the\\n # outfeed based prediction must be passed to MonitoredSession directly.\\n # Other parts of the TPU execution are organized as follows.\\n #\\n # 1. All outfeed based Tensors must be grouped with predictions Tensors\\n # to form a single invocation. This avoid the issue we might trigger\\n # multiple outfeeds incorrectly. To achieve this, `host_call` is\\n # placed in control_dependencies of `stopping_signals`, and\\n # `stopping_signals` is passed into _StoppingPredictHook, which sets\\n # the `stopping_signals` as SessionRunArgs. MonitoredSession merges\\n # all SessionRunArgs with the fetch in session.run together.\\n #\\n # 2. The TPU program (dummy_predict_op) and enqueue_ops (infeed Enqueue)\\n # are grouped together. They will be launched once and only once in\\n # side threads and they quit naturally according to the SAME stopping\\n # condition.\\n enqueue_ops.append(dummy_predict_op)\\n\\n host_call_ret = host_calls.create_tpu_hostcall()\\n if 'host_call' not in host_call_ret:\\n host_ops = []\\n else:\\n host_ops = host_call_ret['host_call']\\n\\n predictions = host_call_ret['predictions']\\n _verify_cross_hosts_transfer_size(\\n predictions, message=(\\n 'The estimated size for TPUEstimatorSpec.predictions is too '\\n 'large.'))\\n signals = host_call_ret['signals']\\n\\n with ops.control_dependencies(host_ops):\\n host_ops = [] # Empty, we do do not need it anymore.\\n scalar_stopping_signal = _StopSignals.as_scalar_stopping_signal(\\n signals)\\n predictions = _PaddingSignals.slice_tensor_or_dict(\\n predictions, signals)\\n\\n hooks = [\\n _StoppingPredictHook(scalar_stopping_signal),\\n TPUInfeedOutfeedSessionHookForPrediction(ctx, enqueue_ops,\\n host_ops),\\n ] + input_hooks\\n\\n return model_fn_lib.EstimatorSpec(\\n mode,\\n prediction_hooks=hooks,\\n predictions=predictions,\\n scaffold=scaffold)\\n\\n return _model_fn\",\n \"def _kmeans_clustering_model_fn(features, labels, mode, params, config):\\n assert labels is None, labels\\n (all_scores, model_predictions, losses,\\n is_initialized, init_op, training_op) = clustering_ops.KMeans(\\n _parse_tensor_or_dict(features),\\n params.get('num_clusters'),\\n initial_clusters=params.get('training_initial_clusters'),\\n distance_metric=params.get('distance_metric'),\\n use_mini_batch=params.get('use_mini_batch'),\\n mini_batch_steps_per_iteration=params.get(\\n 'mini_batch_steps_per_iteration'),\\n random_seed=params.get('random_seed'),\\n kmeans_plus_plus_num_retries=params.get(\\n 'kmeans_plus_plus_num_retries')).training_graph()\\n incr_step = state_ops.assign_add(training_util.get_global_step(), 1)\\n loss = math_ops.reduce_sum(losses, name=KMeansClustering.LOSS_OP_NAME)\\n summary.scalar('loss/raw', loss)\\n training_op = with_dependencies([training_op, incr_step], loss)\\n predictions = {\\n KMeansClustering.ALL_SCORES: all_scores[0],\\n KMeansClustering.CLUSTER_IDX: model_predictions[0],\\n }\\n eval_metric_ops = {KMeansClustering.SCORES: loss}\\n training_hooks = [_InitializeClustersHook(\\n init_op, is_initialized, config.is_chief)]\\n relative_tolerance = params.get('relative_tolerance')\\n if relative_tolerance is not None:\\n training_hooks.append(_LossRelativeChangeHook(relative_tolerance))\\n return ModelFnOps(\\n mode=mode,\\n predictions=predictions,\\n eval_metric_ops=eval_metric_ops,\\n loss=loss,\\n train_op=training_op,\\n training_hooks=training_hooks)\",\n \"def setup_model_loss_criterion(cfg, args, rank, is_cuda):\\r\\n args.distributed_rank = rank\\r\\n cfg.distributed_training.distributed_rank = args.distributed_rank\\r\\n if cfg.distributed_training.distributed_world_size > 1:\\r\\n distributed_utils.distributed_init(cfg)\\r\\n torch.manual_seed(1)\\r\\n model = Model(args.input_size, args.nb_classes)\\r\\n loss_fn = nn.CrossEntropyLoss()\\r\\n if is_cuda:\\r\\n model = model.cuda()\\r\\n loss_fn = loss_fn.cuda()\\r\\n\\r\\n optimizer = optim.sgd.SGD(args, model.parameters())\\r\\n optimizer = optim.FairseqBMUF(\\r\\n cfg=cfg.bmuf,\\r\\n optimizer=optimizer\\r\\n )\\r\\n\\r\\n return model, loss_fn, optimizer\",\n \"def evaluate(cfg: DictConfig):\\n\\n # suppress TensorFlow and DALI warnings\\n suppress_warnings()\\n\\n if cfg.USE_MULTI_GPUS.VALUE:\\n # change number of visible gpus for evaluation\\n set_gpus(cfg.USE_MULTI_GPUS.GPU_IDS)\\n # update batch size according to available gpus\\n data_generator.update_batch_size(cfg)\\n\\n if cfg.OPTIMIZATION.AMP:\\n print(\\\"Enabling Automatic Mixed Precision(AMP) training\\\")\\n policy = mixed_precision.Policy('mixed_float16')\\n mixed_precision.set_global_policy(policy)\\n\\n if cfg.OPTIMIZATION.XLA:\\n print(\\\"Enabling Automatic Mixed Precision(XLA) training\\\")\\n tf.config.optimizer.set_jit(True)\\n\\n # create model\\n strategy = None\\n if cfg.USE_MULTI_GPUS.VALUE:\\n # multi gpu training using tensorflow mirrored strategy\\n strategy = tf.distribute.MirroredStrategy(\\n cross_device_ops=tf.distribute.HierarchicalCopyAllReduce()\\n )\\n print('Number of visible gpu devices: {}'.format(strategy.num_replicas_in_sync))\\n with strategy.scope():\\n optimizer = tf.keras.optimizers.Adam(\\n learning_rate=cfg.HYPER_PARAMETERS.LEARNING_RATE\\n ) # optimizer\\n if cfg.OPTIMIZATION.AMP:\\n optimizer = mixed_precision.LossScaleOptimizer(\\n optimizer,\\n dynamic=True\\n )\\n dice_coef = DiceCoefficient(post_processed=True, classes=cfg.OUTPUT.CLASSES)\\n dice_coef = tf.keras.metrics.MeanMetricWrapper(name=\\\"dice_coef\\\", fn=dice_coef)\\n model = prepare_model(cfg, training=True)\\n else:\\n optimizer = tf.keras.optimizers.Adam(\\n learning_rate=cfg.HYPER_PARAMETERS.LEARNING_RATE\\n ) # optimizer\\n if cfg.OPTIMIZATION.AMP:\\n optimizer = mixed_precision.LossScaleOptimizer(\\n optimizer,\\n dynamic=True\\n )\\n dice_coef = DiceCoefficient(post_processed=True, classes=cfg.OUTPUT.CLASSES)\\n dice_coef = tf.keras.metrics.MeanMetricWrapper(name=\\\"dice_coef\\\", fn=dice_coef)\\n model = prepare_model(cfg, training=True)\\n\\n model.compile(\\n optimizer=optimizer,\\n loss=unet3p_hybrid_loss,\\n metrics=[dice_coef],\\n )\\n\\n # weights model path\\n checkpoint_path = join_paths(\\n cfg.WORK_DIR,\\n cfg.CALLBACKS.MODEL_CHECKPOINT.PATH,\\n f\\\"{cfg.MODEL.WEIGHTS_FILE_NAME}.hdf5\\\"\\n )\\n\\n assert os.path.exists(checkpoint_path), \\\\\\n f\\\"Model weight's file does not exist at \\\\n{checkpoint_path}\\\"\\n\\n # TODO: verify without augment it produces same results\\n # load model weights\\n model.load_weights(checkpoint_path, by_name=True, skip_mismatch=True)\\n model.summary()\\n\\n # data generators\\n val_generator = data_generator.get_data_generator(cfg, \\\"VAL\\\", strategy)\\n validation_steps = data_generator.get_iterations(cfg, mode=\\\"VAL\\\")\\n\\n # evaluation metric\\n evaluation_metric = \\\"dice_coef\\\"\\n if len(model.outputs) > 1:\\n evaluation_metric = f\\\"{model.output_names[0]}_dice_coef\\\"\\n\\n result = model.evaluate(\\n x=val_generator,\\n steps=validation_steps,\\n workers=cfg.DATALOADER_WORKERS,\\n return_dict=True,\\n )\\n\\n # return computed loss, validation accuracy, and it's metric name\\n return result, evaluation_metric\",\n \"def __init__(self, ndf, n_layers, original_model, norm_layer, fc_relu_slope, fc_drop_out):\\n super(ModifiedModel, self).__init__()\\n if type(norm_layer) == functools.partial: # no need to use bias as BatchNorm2d has affine parameters\\n use_bias = norm_layer.func == nn.InstanceNorm2d\\n else:\\n use_bias = norm_layer == nn.InstanceNorm2d\\n\\n self.features = nn.Sequential(*list(original_model.children())[:-1])\\n self.avg = nn.AdaptiveAvgPool2d((1, 1))\\n\\n sequence = []\\n nf_mult = 1\\n nf_mult_prev = 1\\n for n in range(1, n_layers): # gradually increase the number of filters\\n nf_mult_prev = nf_mult\\n nf_mult = min(2 ** n, 32)\\n sequence += [\\n nn.Linear(in_features=int(ndf/nf_mult_prev), out_features=int(ndf/nf_mult)),\\n norm_layer(int(ndf/nf_mult)),\\n nn.LeakyReLU(fc_relu_slope, True),\\n nn.Dropout2d(p=fc_drop_out)\\n ]\\n\\n sequence += [nn.Linear(in_features=int(ndf/nf_mult), out_features=1)] # output 1 channel prediction map\\n self.linear_group = nn.Sequential(*sequence)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6493121","0.64661187","0.63006353","0.6268264","0.6256369","0.62445","0.6237785","0.6226766","0.6207205","0.6190259","0.6169209","0.6139843","0.61165994","0.61126524","0.6089907","0.60873324","0.60776514","0.6052805","0.60448414","0.60442406","0.60207874","0.59972525","0.59861964","0.5977441","0.59644926","0.5961414","0.596123","0.5928357","0.59227926","0.5920253","0.5914829","0.5907494","0.5898885","0.5892374","0.58919924","0.5888736","0.58539826","0.584984","0.58441246","0.58372486","0.58350146","0.5833442","0.5831546","0.5810511","0.5810379","0.5803993","0.57852477","0.57800454","0.5779739","0.5779287","0.5778717","0.5775714","0.5772814","0.57683694","0.5763526","0.57610404","0.5753669","0.57526976","0.5746099","0.57432973","0.5740437","0.5733448","0.5730058","0.5729883","0.57183444","0.5713326","0.57012576","0.56963015","0.56895435","0.568782","0.5675804","0.5675264","0.56723773","0.5671885","0.5670567","0.56573844","0.5652227","0.56503546","0.56431234","0.56378293","0.56371695","0.563603","0.5635466","0.562996","0.56241643","0.5623789","0.56194884","0.56170696","0.56077427","0.5603634","0.5598171","0.5594525","0.5593068","0.559038","0.5589049","0.55881107","0.55872524","0.5584297","0.5584006","0.5583202"],"string":"[\n \"0.6493121\",\n \"0.64661187\",\n \"0.63006353\",\n \"0.6268264\",\n \"0.6256369\",\n \"0.62445\",\n \"0.6237785\",\n \"0.6226766\",\n \"0.6207205\",\n \"0.6190259\",\n \"0.6169209\",\n \"0.6139843\",\n \"0.61165994\",\n \"0.61126524\",\n \"0.6089907\",\n \"0.60873324\",\n \"0.60776514\",\n \"0.6052805\",\n \"0.60448414\",\n \"0.60442406\",\n \"0.60207874\",\n \"0.59972525\",\n \"0.59861964\",\n \"0.5977441\",\n \"0.59644926\",\n \"0.5961414\",\n \"0.596123\",\n \"0.5928357\",\n \"0.59227926\",\n \"0.5920253\",\n \"0.5914829\",\n \"0.5907494\",\n \"0.5898885\",\n \"0.5892374\",\n \"0.58919924\",\n \"0.5888736\",\n \"0.58539826\",\n \"0.584984\",\n \"0.58441246\",\n \"0.58372486\",\n \"0.58350146\",\n \"0.5833442\",\n \"0.5831546\",\n \"0.5810511\",\n \"0.5810379\",\n \"0.5803993\",\n \"0.57852477\",\n \"0.57800454\",\n \"0.5779739\",\n \"0.5779287\",\n \"0.5778717\",\n \"0.5775714\",\n \"0.5772814\",\n \"0.57683694\",\n \"0.5763526\",\n \"0.57610404\",\n \"0.5753669\",\n \"0.57526976\",\n \"0.5746099\",\n \"0.57432973\",\n \"0.5740437\",\n \"0.5733448\",\n \"0.5730058\",\n \"0.5729883\",\n \"0.57183444\",\n \"0.5713326\",\n \"0.57012576\",\n \"0.56963015\",\n \"0.56895435\",\n \"0.568782\",\n \"0.5675804\",\n \"0.5675264\",\n \"0.56723773\",\n \"0.5671885\",\n \"0.5670567\",\n \"0.56573844\",\n \"0.5652227\",\n \"0.56503546\",\n \"0.56431234\",\n \"0.56378293\",\n \"0.56371695\",\n \"0.563603\",\n \"0.5635466\",\n \"0.562996\",\n \"0.56241643\",\n \"0.5623789\",\n \"0.56194884\",\n \"0.56170696\",\n \"0.56077427\",\n \"0.5603634\",\n \"0.5598171\",\n \"0.5594525\",\n \"0.5593068\",\n \"0.559038\",\n \"0.5589049\",\n \"0.55881107\",\n \"0.55872524\",\n \"0.5584297\",\n \"0.5584006\",\n \"0.5583202\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7382619"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81977,"cells":{"query":{"kind":"string","value":"This is a helper function for alignment models for embeddings. This function returns an embedding for features[name] of size params.name_embed_size assuming a vocab size of params.name_vocab_size. features[feature_name] has to be an integer tensor of shape [batch_size, max_sequence_length]."},"document":{"kind":"string","value":"def embed(self, features, feature_name, params):\n with tf.variable_scope(\"%s_embed\" % feature_name):\n embed_matrix = tf.get_variable(\"embedding_matrix\",\n [getattr(params, \"%s_vocab_size\" % feature_name), \n getattr(params, \"%s_embed_size\" % feature_name)])\n return tf.nn.embedding_lookup(embed_matrix, features[feature_name])"},"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 build_embedding_layer(inputs_, vocab_size, embed_size):\n embedding = tf.Variable(tf.random_uniform((vocab_size, embed_size), -1, 1))\n embed = tf.nn.embedding_lookup(embedding, inputs_)\n \n return embed","def embed_features(batch, f_size):\n for f in range(Config.num_feature):\n feature_val = batch[:, f]\n num_cat_value = Config.schema[f]\n\n if f == 0:\n if num_cat_value == 1:\n vector = tf.reshape(feature_val, [-1, 1])\n else:\n vector = tf.nn.embedding_lookup(embed_dict[f], tf.cast(\n feature_val, tf.int32))\n else:\n if num_cat_value == 1:\n vector = tf.concat(1, [vector, tf.reshape(feature_val,\n [-1, 1])])\n else:\n vector = tf.concat(1, [vector, tf.nn.embedding_lookup(\n embed_dict[f], tf.cast(feature_val, tf.int32))])\n\n result = tf.reshape(vector, [-1, 1, f_size])\n\n return result","def _get_embedding_layer(self, input_data, doc_input_data):\n opts = self._options\n word_embedding = tf.Variable(tf.random_uniform((self.vocab_size, opts.embed_dim), -1.0, 1.0))\n embed = []\n\n temp = tf.zeros([opts.batch_size, opts.embed_dim])\n embed_d = []\n for n in range(opts.sentence_sample):\n temp = tf.add(temp, tf.nn.embedding_lookup(word_embedding, doc_input_data[:, n]))\n embed_d.append(temp)\n\n if opts.concat == 'True':\n combined_embed_vector_length = opts.embed_dim * opts.window_size + opts.embed_dim\n for j in range(opts.window_size):\n embed_w = tf.nn.embedding_lookup(word_embedding, input_data[:, j])\n embed.append(embed_w)\n embed.append(embed_d)\n else:\n combined_embed_vector_length = opts.embed_dim\n embed_w = tf.zeros([opts.batch_size, opts.embed_dim])\n for j in range(opts.window_size):\n embed_w += tf.nn.embedding_lookup(word_embedding, input_data[:, j])\n embed_w += embed_d\n embed.append(embed_w)\n\n return tf.concat(embed, 1), word_embedding, combined_embed_vector_length","def get_embed(input_data, vocab_size, embed_dim):\n embedding = tf.Variable(tf.random_uniform((vocab_size,embed_dim), -1, 1))\n embed = tf.nn.embedding_lookup(embedding, input_data)\n #print (\"embed_dim: \",embed_dim) # 向量表达维度为 256\n #print (\"input_data.shape: \",input_data.shape) # (50, 5)\n #print (\"embed.shap: \", embed.shape) # word 的向量表达 ==特征 (50, 5, 256) ==(batch_size, num_step, embed_dim)\n return embed # 返回input的向量表达","def get_embed(input_data, vocab_size, embed_dim):\n embedding = tf.Variable(tf.random_uniform((vocab_size, embed_dim), -1, 1))\n embed = tf.nn.embedding_lookup(embedding, input_data)\n\n return embed","def add_embedding(self):\n ### YOUR CODE HERE (~4-6 lines)\n embeddingTensor = tf.Variable(self.pretrained_embeddings)\n embeddings = tf.nn.embedding_lookup(embeddingTensor, self.input_placeholder)\n embeddings = tf.reshape(embeddings, [-1, self.max_length, Config.n_features * Config.embed_size])\n ### END YOUR CODE\n return embeddings","def model(mtf_features, other_features, params, mesh, variable_dtype, context=None):\n\n x, batch_dim, sequence_dim, embd_dim, vocab_dim, embed_sequence_dim = parse_inputs(mtf_features, other_features)\n\n if is_incremental_inference(context):\n # reshape inputs if in inference mode\n x = mtf.gather(x, context.position - 1, sequence_dim)\n x = mtf.reshape(x, [batch_dim])\n\n use_axial_pos_emb = params[\"axial_pos_emb\"] is not None\n\n if not use_axial_pos_emb:\n # Use standard position encoding\n wpe = mtf.get_variable(mesh, \"wpe\", mtf.Shape([embed_sequence_dim, embd_dim]),\n initializer=tf.random_normal_initializer(stddev=0.01),\n master_dtype=variable_dtype.master_dtype,\n slice_dtype=variable_dtype.slice_dtype,\n activation_dtype=variable_dtype.activation_dtype)\n else:\n wpe = axial_positional_emb(embd_dim, mesh, params, variable_dtype)\n\n # Text encoding\n wte = mtf.get_variable(mesh, \"wte\", mtf.Shape([vocab_dim, embd_dim]),\n initializer=tf.random_normal_initializer(stddev=0.02),\n master_dtype=variable_dtype.master_dtype,\n slice_dtype=variable_dtype.slice_dtype,\n activation_dtype=variable_dtype.activation_dtype)\n\n with tf.variable_scope(\"token_embd\"):\n # Text embedding\n h = mtf.gather(wte, x, vocab_dim)\n if params[\"embed_dropout\"] > 0 and params[\"mode\"] == \"train\":\n h = mtf.dropout(h, rate=params[\"embed_dropout\"], name=\"wte_dropout\")\n\n with tf.variable_scope(\"pos_embd\"):\n # Positional embedding\n position_indices = mtf.range(mesh, sequence_dim, tf.int64) if not is_incremental_inference(context) else (\n context.position - 1)\n pos_emb = mtf.gather(wpe, position_indices, wpe.shape[0])\n if params[\"embed_dropout\"] > 0 and params[\"mode\"] == \"train\":\n pos_emb = mtf.dropout(pos_emb, rate=params[\"embed_dropout\"], name=\"wte_dropout\")\n h += pos_emb\n\n aux_losses = 0 # instantiate auxiliary losses (for MOE models)\n\n for layer in range(params[\"n_layer\"]):\n # attn blocks\n share_parameters = exists(params[\"share_parameters\"]) and params[\"share_parameters\"] == True\n block_scope = f\"h{layer}\" if not share_parameters else \"\"\n\n block_fn = block(params=params, scope=block_scope, layer_num=layer,\n bias=other_features[\"attn_bias\"],\n sequence_dim=sequence_dim,\n memory_length_dim=other_features[\"memory_length_dim\"],\n variable_dtype=variable_dtype,\n context=context)\n\n # If true and in train mode, enable gradient checkpointing\n recompute_grad = params[\"recompute_grad\"] and (params[\"mode\"] == \"train\") == True\n h, loss = block_fn(h) if not recompute_grad else mtf.recompute_grad(block_fn, [h])\n aux_losses += loss\n\n no_weight_tie_emb = params[\"no_weight_tie\"] == True\n if no_weight_tie_emb:\n with tf.variable_scope(\"wte_final_linear\"):\n logits = linear(h, \"linear_out\", vocab_dim, variable_dtype=variable_dtype, params=params)\n else:\n # Layer normalize & affine transform\n h = layer_norm(h, \"ln_f\", variable_dtype=variable_dtype)\n seq_dim = sequence_dim if not is_incremental_inference(context) else mtf.Dimension(\"sequence\", 1)\n with tf.variable_scope(\"wte_final_einsum\"):\n # Equivalent to tf.matmul\n logits = mtf.einsum([h, wte], output_shape=[batch_dim, seq_dim, vocab_dim])\n\n if params[\"mode\"] in [\"train\", \"eval\"]:\n labels = mtf_features[\"labels\"]\n z_loss = params.get(\"z_loss\", 1e-4) # an auxiliary loss used to stabilize mtf xentropy\n\n # Go to full precision for the logits \n logits = mtf.cast(logits, tf.float32)\n\n with tf.variable_scope(\"xentropy_final\"):\n loss_batch = mtf.layers.softmax_cross_entropy_with_logits(logits=logits, targets=labels,\n vocab_dim=logits.shape[-1], z_loss=z_loss)\n\n # For non-autoregressive models (masked language modeling training)\n # Make sure labels with padding tokens are not counted in the loss\n if not params[\"causal\"]:\n padding_id = params.get(\"padding_id\", 0)\n loss_batch = mtf.where(mtf.not_equal(labels, padding_id), loss_batch, mtf.zeros_like(loss_batch))\n\n with tf.variable_scope(\"reduce_mean_final\"):\n loss = mtf.reduce_mean(loss_batch)\n\n loss += aux_losses # Add on auxiliary losses (currently only used for MoE)\n loss /= params[\"num_microbatches\"]\n # Convert to train dtype\n loss = mtf.cast(loss, variable_dtype.slice_dtype)\n else:\n loss = None\n loss_batch = None\n\n # Cast back to checkpoint dtype\n logits = mtf.cast(logits, variable_dtype.master_dtype)\n return logits, loss, loss_batch","def pretrained_embedding_layer(word_to_vec_map, word_to_index):\n \n vocab_size = len(word_to_index) + 1 # adding 1 to fit Keras embedding (requirement)\n any_word = list(word_to_vec_map.keys())[0]\n emb_dim = word_to_vec_map[any_word].shape[0] # define dimensionality of your GloVe word vectors (= 50)\n \n ### START CODE HERE ###\n # Step 1\n # Initialize the embedding matrix as a numpy array of zeros.\n # See instructions above to choose the correct shape.\n emb_matrix = np.zeros((vocab_size, emb_dim))\n \n # Step 2\n # Set each row \"idx\" of the embedding matrix to be \n # the word vector representation of the idx'th word of the vocabulary\n for word, idx in word_to_index.items():\n emb_matrix[idx, :] = word_to_vec_map[word]\n\n # Step 3\n # Define Keras embedding layer with the correct input and output sizes\n # Make it non-trainable.\n embedding_layer = tensorflow.keras.layers.Embedding(input_dim = vocab_size, output_dim = emb_dim, trainable = False)\n ### END CODE HERE ###\n\n # Step 4 (already done for you; please do not modify)\n # Build the embedding layer, it is required before setting the weights of the embedding layer. \n embedding_layer.build((None,)) # Do not modify the \"None\". This line of code is complete as-is.\n \n # Set the weights of the embedding layer to the embedding matrix. Your layer is now pretrained.\n embedding_layer.set_weights([emb_matrix])\n \n return embedding_layer","def embedding_layer(self):\n with tf.name_scope(\"Embedding_Layer\"):\n V_size = len(self.vocab)\n embed_dim = len(self.embed[0]) \n W_embed_ = tf.get_variable(\"W_embed\",shape=[V_size, embed_dim],trainable=False).assign(np.asarray(self.embed))\n W_analogy_embed_ = tf.get_variable(\"W_analogy_embed\",shape=[V_size, embed_dim],trainable=True,initializer=tf.random_uniform_initializer(minval=-1,maxval=1))\n return W_embed_, W_analogy_embed_","def get_embed(input_data, vocab_size, embed_dim):\n # todo 需要编程：\n # 1、构建嵌入矩阵的查找表\n lookup_w = tf.Variable(\n initial_value=tf.random_uniform([vocab_size, embed_dim], -1.0, 1.0)\n )\n # 2、获得嵌入输出\n embed = tf.nn.embedding_lookup(params=lookup_w, ids=input_data)\n # [N, n_steps, embed_size]\n return embed","def embedding(x, vocab_size, dense_size, name=None, reuse=None, multiplier=1.0):\n with tf.variable_scope(\n name, default_name=\"embedding\", values=[x], reuse=reuse):\n embedding_var = tf.get_variable(\"kernel\", [vocab_size, dense_size])\n emb_x = tf.gather(embedding_var, x)\n if multiplier != 1.0:\n emb_x *= multiplier\n return emb_x","def TransformerTokenEmbedding(\n num_embeddings, embedding_dim, padding_idx, freeze_embed=False\n):\n m = nn.Embedding(num_embeddings, embedding_dim, padding_idx=padding_idx)\n nn.init.normal_(m.weight, mean=0, std=embedding_dim ** -0.5)\n nn.init.constant_(m.weight[padding_idx], 0)\n if freeze_embed:\n m.weight.requires_grad = False\n return m","def build_model(allidx,MAX_LENGTH,onlyArg):\n wordidx, labelidx, featuresidx, extraidx=allidx\n posidx, neridx, depidx, distanceidx, chnkidx, wikineridx, dbpedianeridx, subneridx = featuresidx\n\n main_input = Input(shape=(MAX_LENGTH,), name='main_input', dtype='int32')\n inputNodes=[main_input]\n\n w2vmodel=\"../embeddings/Domain-Word2vec.model\"\n\n embedding_matrix,EMBEDDING_DIM,vocabulary_size=prepare.wv_embedded(wordidx,w2vmodel)\n \n x = Embedding(output_dim=EMBEDDING_DIM, weights=[embedding_matrix],input_dim=vocabulary_size, input_length=MAX_LENGTH, mask_zero=False)(main_input)\n numnode=int(EMBEDDING_DIM/2)\n\n # pos embedding\n inputNodes,pos_layer=layers.embedlayer(inputNodes,\"pos_input\",posidx,MAX_LENGTH)\n x=Concatenate()([x,pos_layer])\n numnode+=int(len(posidx)/2)\n\n # ner embedding\n inputNodes,ner_layer=layers.embedlayer(inputNodes,\"ner_input\",neridx,MAX_LENGTH)\n x=Concatenate()([x,ner_layer])\n numnode+=int(len(neridx)/2)\n\n inputNodes,wikiner_layer=layers.embedlayer(inputNodes,\"wikiner_input\",wikineridx,MAX_LENGTH)\n x=Concatenate()([x,wikiner_layer])\n numnode+=int(len(wikineridx)/2)\n\n inputNodes,dbpedianer_layer=layers.embedlayer(inputNodes,\"dbpedianer_input\",dbpedianeridx,MAX_LENGTH)\n x=Concatenate()([x,dbpedianer_layer])\n numnode+=int(len(dbpedianeridx)/2)\n\n # dep embedding\n inputNodes,dep0_layer=layers.embedlayer(inputNodes,\"dep0_input\",depidx,MAX_LENGTH)\n x=Concatenate()([x,dep0_layer])\n numnode+=int(len(depidx)/2)\n\n inputNodes,dep1_layer=layers.embedlayer(inputNodes,\"dep1_input\",depidx,MAX_LENGTH)\n x=Concatenate()([x,dep1_layer])\n numnode+=int(len(depidx)/2)\n\n inputNodes,dep2_layer=layers.embedlayer(inputNodes,\"dep2_input\",depidx,MAX_LENGTH)\n x=Concatenate()([x,dep2_layer])\n numnode+=int(len(depidx)/2)\n\n # chnk embedding\n inputNodes,lvl_layer=layers.embedlayer(inputNodes,\"lvl_input\",distanceidx,MAX_LENGTH)\n x=Concatenate()([x,lvl_layer])\n numnode+=int(len(distanceidx)/2)\n\n inputNodes,chnk_layer=layers.embedlayer(inputNodes,\"chnk_input\",chnkidx,MAX_LENGTH)\n x=Concatenate()([x,chnk_layer])\n numnode+=int(len(chnkidx)/2)\n\n # wikiclass embedding\n inputNodes,subner_layer=layers.embedlayer(inputNodes,\"subner_input\",subneridx,MAX_LENGTH)\n x=Concatenate()([x,subner_layer])\n numnode+=int(len(subneridx)/2)\n\n if onlyArg:\n neartrigger_input = Input(shape=(MAX_LENGTH,), name='neartrigger_input', dtype='int32')\n inputNodes.append(neartrigger_input)\n neartrigger_layer = Embedding(output_dim=EMBEDDING_DIM, weights=[embedding_matrix],input_dim=vocabulary_size, \\\n input_length=MAX_LENGTH, mask_zero=False)(neartrigger_input)\n x=Concatenate()([x,neartrigger_layer])\n numnode+=50\n inputNodes,x,numnode=layers.extralayer(inputNodes,x,numnode,extraidx,featuresidx,MAX_LENGTH)\n\n lstm_out = Bidirectional(LSTM(numnode, dropout=0.2,return_sequences=True))(x)\n numnode=int((numnode+len(labelidx))*2/3)\n\n if onlyArg:\n lstm_out = SeqSelfAttention(attention_activation='tanh', attention_width=5)(lstm_out)\n\n lstm_out = Dropout(0.2)(lstm_out)\n out = Dense(numnode)(lstm_out)\n\n crf = CRF(len(labelidx), sparse_target=False) # CRF layer\n main_output=crf(out)\n loss=crf_loss #crf.loss_function\n acc=[crf_accuracy]\n\n model = Model(inputs=inputNodes, outputs=main_output) \n model.compile(loss=loss,optimizer=Adam(0.001),metrics=acc)\n model.summary()\n\n return model","def pretrained_embedding_layer(model,model2,model3, word_to_index,emb_dim_max):\n words_ignored = []\n vocab_len = len(word_to_index) + 1 \n emb_matrix = np.zeros([vocab_len,emb_dim_max])\n \n print(' Total words would be processed : '+str(vocab_len))\n for word, idx in word_to_index.items():\n if word in model:\n emb_matrix[idx,:200] = model[word]\n emb_matrix[idx,200:] = 0\n if word in model2:\n emb_matrix[idx, :100] = model2[word]\n emb_matrix[idx, 100:] = 0\n if word in model3.keys():\n emb_matrix[idx,:] = model3[word]\n else:\n words_ignored.append(word)\n print(str(len(words_ignored))+\" words ignored\")\n print(emb_matrix.shape) \n \n \n embedding_layer = Embedding(vocab_len,emb_dim_max,trainable = True)\n \n # Build the embedding layer, it is required before setting the weights of the embedding layer. \n embedding_layer.build((None,)) # Do not modify the \"None\". This line of code is complete as-is.\n # Set the weights of the embedding layer to the embedding matrix. Your layer is now pretrained.\n embedding_layer.set_weights([emb_matrix])\n \n return embedding_layer,words_ignored","def pretrained_embedding_layer(word_to_vec_map, word_to_index):\n vocab_len = len(word_to_index) + 1 # adding 1 to fit Keras embedding (requirement)\n emb_dim = word_to_vec_map[\"cucumber\"].shape[0] # define dimensionality of your GloVe word vectors (= 50)\n emb_matrix = np.zeros((vocab_len, emb_dim)) # Initialize the embedding matrix as a numpy array of zeros of shape (vocab_len, dimensions of word vectors = emb_dim)\n for word, index in word_to_index.items(): # Set each row \"index\" of the embedding matrix to be the word vector representation of the \"index\"th word of the vocabulary\n emb_matrix[index, :] = word_to_vec_map[word]\n embedding_layer = Embedding(vocab_len, emb_dim, trainable = False) # Define Keras embedding layer with the correct output/input sizes, make it trainable. Use Embedding(...). Make sure to set trainable=False. \n embedding_layer.build((None,)) # Build the embedding layer, it is required before setting the weights of the embedding layer. Do not modify the \"None\".\n embedding_layer.set_weights([emb_matrix]) # Set the weights of the embedding layer to the embedding matrix. Your layer is now pretrained.\n return embedding_layer","def _embed(self):\n with tf.variable_scope('word_embedding'):\n self.word_embeddings = tf.get_variable(\n 'word_embeddings',\n shape=(self.term_vocab.size(), self.term_vocab.embed_dim),\n initializer=tf.constant_initializer(self.term_vocab.embeddings),\n trainable=True\n )\n self.p_word_emb = tf.nn.embedding_lookup(self.word_embeddings, self.p)\n self.q_word_emb = tf.nn.embedding_lookup(self.word_embeddings, self.q)\n\n with tf.variable_scope('char_embedding'):\n self.char_embeddings = tf.get_variable(\n 'char_embeddings',\n shape=(self.char_vocab.size(), self.char_vocab.embed_dim),\n initializer=tf.constant_initializer(self.char_vocab.embeddings),\n trainable=True\n )\n self.p_char_emb = tf.nn.embedding_lookup(self.char_embeddings, self.p_char) # [batch, seqlen, max_char_num, embedding_size]\n self.q_char_emb = tf.nn.embedding_lookup(self.char_embeddings, self.q_char)\n\n self.p_char_emb = self.cnn_emb(self.p_char_emb, \"p_emb\")\n self.q_char_emb = self.cnn_emb(self.q_char_emb, \"q_emb\")\n '''\n self.p_char_emb = tf.reshape(self.p_char_emb, [-1, self.max_char_num, self.emb_size])\n self.q_char_emb = tf.reshape(self.q_char_emb, [-1, self.max_char_num, self.emb_size])\n\n self.p_char_emb = cnn_layer.conv(self.p_char_emb, self.emb_size,\n bias=True, activation=tf.nn.relu, kernel_size=5, name=\"char_conv\", reuse=None)\n self.q_char_emb = cnn_layer.conv(self.q_char_emb, self.emb_size,\n bias=True, activation=tf.nn.relu, kernel_size=5, name=\"char_conv\", reuse=True)\n\n self.p_char_emb = tf.reduce_max(self.p_char_emb, axis=1) # [batch*seqlen, 1, emb_size]\n self.q_char_emb = tf.reduce_max(self.q_char_emb, axis=1)\n\n batch_size = tf.shape(self.p_word_emb)[0]\n self.p_char_emb = tf.reshape(self.p_char_emb, [batch_size, -1, self.emb_size])\n self.q_char_emb = tf.reshape(self.q_char_emb, [batch_size, -1, self.emb_size])\n\n self.p_char_emb = tf.nn.dropout(self.p_char_emb, 0.95)\n self.q_char_emb = tf.nn.dropout(self.q_char_emb, 0.95)\n '''\n self.p_emb = tf.concat([self.p_word_emb, self.p_char_emb], -1)\n self.q_emb = tf.concat([self.q_word_emb, self.q_char_emb], -1)","def _embed(self):\n with tf.variable_scope('word_embedding'):\n self.pretrained_word_mat = tf.get_variable(\"word_emb_mat\",\n [self.vocab.word_size() - 2, self.vocab.word_embed_dim],\n dtype=tf.float32,\n initializer=tf.constant_initializer(\n self.vocab.word_embeddings[2:],\n dtype=tf.float32),\n trainable=False)\n self.word_pad_unk_mat = tf.get_variable(\"word_unk_pad\",\n [2, self.pretrained_word_mat.get_shape()[1]],\n dtype=tf.float32,\n initializer=tf.constant_initializer(\n self.vocab.word_embeddings[:2],\n dtype=tf.float32),\n trainable=True)\n\n self.word_mat = tf.concat([self.word_pad_unk_mat, self.pretrained_word_mat], axis=0)\n self.p_emb = tf.nn.embedding_lookup(self.word_mat, self.p)\n self.q_emb = tf.nn.embedding_lookup(self.word_mat, self.q)","def add_embedding(self):\n #with tf.variable_scope(\"RNN\", reuse = tf.AUTO_REUSE):\n embeddings = tf.get_variable(\"embeddings\", initializer = self.pretrained_embeddings,trainable=True)\n inputs = self.input_placeholder\n inputs = tf.reshape(inputs, [self.config.batch_size, -1 , self.config.n_features])\n embeddings = tf.nn.embedding_lookup(embeddings, self.input_placeholder)\n embeddings = tf.reshape(embeddings, [self.config.batch_size, -1, self.config.n_features* self.config.embed_size])\n embeddings = tf.cast(embeddings, tf.float32)\n return embeddings","def embedding_layer(n_categories, embedding_dim, name=None):\n\n input_tensor = Input(shape=(1,))\n x = Embedding(n_categories, embedding_dim, name=name)(input_tensor)\n x = Reshape(target_shape=(embedding_dim,))(x)\n\n return input_tensor, x","def load_embed(file_name, vocab_size):\n\n with tf.io.gfile.Open(file_name, 'r') as embed_file:\n vocab = []\n embeds = []\n depth = -1\n for index, line in enumerate(embed_file):\n if vocab_size > 0 and index >= vocab_size:\n break\n line = line.strip()\n tokens = line.strip().split(' ')\n word = tokens[0]\n vocab.append(word)\n if depth == -1:\n embed = [float(token) for token in tokens[1:]]\n else:\n embed = [float(token) for token in tokens[-depth:]]\n d = len(embed)\n if depth == -1:\n depth = d\n if d != depth:\n raise ValueError('Inconsistent embedding sizes')\n embeds.append(embed)\n\n embeds = np.stack(embeds)\n\n return vocab, embeds, depth","def keras_model_fn(_, config):\n\n f = open(config[\"embeddings_path\"],encoding='utf8')\n glove = f.readlines()[:config[\"embeddings_dictionary_size\"]]\n f.close()\n\n embedding_matrix = np.zeros((config[\"embeddings_dictionary_size\"], config[\"embeddings_vector_size\"]))\n for i in range(config[\"embeddings_dictionary_size\"]):\n if len(glove[i].split()[1:]) != config[\"embeddings_vector_size\"]:\n continue\n embedding_matrix[i] = np.asarray(glove[i].split()[1:], dtype='float32')\n\n cnn_model = tf.keras.Sequential()\n cnn_model.add(layers.Embedding(weights=[embedding_matrix],\n input_dim=config['embeddings_dictionary_size'],\n output_dim=config['embeddings_vector_size'],\n input_length=config['padding_size']))\n cnn_model.add(layers.Conv1D(filters=100,kernel_size=2,padding='valid',activation='relu',strides=1))\n cnn_model.add(layers.GlobalMaxPooling1D())\n cnn_model.add(layers.Dense(100, activation='relu'))\n cnn_model.add(layers.Dense(1, activation = 'sigmoid'))\n cnn_model.compile(loss='binary_crossentropy',\n optimizer='adam',\n metrics=['accuracy'])\n\n return cnn_model","def embedding(inputs,\n vocab_dim,\n embedding_dim,\n reuse,\n validate_indices=False,\n w_init=tf.random_uniform_initializer(-1., 1.),\n trainable=True,\n normalize=False,\n vocab_freqs=None,\n name=\"Embedding\"):\n\n input_shape = util.get_input_shape(inputs)\n assert len(input_shape) == 2, \"Input Tensor shape must be 2-D\"\n\n with tf.variable_scope(name, reuse=reuse):\n with tf.device('/cpu:0'):\n W = tf.get_variable(\n \"W\", shape=[vocab_dim, embedding_dim], initializer=w_init, trainable=trainable)\n if normalize:\n assert vocab_freqs is not None\n vocab_freqs = tf.constant(vocab_freqs, dtype=tf.float32, shape=(vocab_dim, 1))\n W = _normalize(W, vocab_freqs)\n\n output = tf.cast(inputs, tf.int32)\n output = tf.nn.embedding_lookup(W, output, validate_indices=validate_indices)\n\n shape = [-1] + output.get_shape().as_list()[1:3] + [1]\n # seq_length = util.retrieve_seq_length(tf.reshape(inputs, shape))\n\n return output","def build_word_embeddings(self):\n if self.mode == \"encode\":\n # Word embeddings are fed from an external vocabulary which has possibly\n # been expanded (see vocabulary_expansion.py).\n encode_emb1 = tf.placeholder(tf.float32, (\n None, None, self.config.word_embedding_dim), \"encode_emb1\")\n # No sequences to decode.\n encode_emb2 = tf.placeholder(tf.float32, (\n None, None, self.config.word_embedding_dim), \"encode_emb2\")\n elif self.mode == \"test\":\n encode_emb1 = tf.placeholder(tf.float32, (\n None, None, self.config.word_embedding_dim), \"encode_emb1\")\n # No sequences to decode.\n encode_emb2 = tf.placeholder(tf.float32, (\n None, None, self.config.word_embedding_dim), \"encode_emb2\")\n else:\n word_emb = tf.get_variable(\n name=\"word_embedding\",\n shape=[self.config.vocab_size, self.config.word_embedding_dim],\n initializer=self.uniform_initializer)\n\n encode_emb1 = tf.nn.embedding_lookup(word_emb, self.encode_ids1)\n encode_emb2 = tf.nn.embedding_lookup(word_emb, self.encode_ids2)\n\n\n self.encode_emb1 = encode_emb1\n self.encode_emb2 = encode_emb2","def call(self, x, *args, **kwargs):\n with tf.name_scope(\"embedding\"):\n # fills out of bound values with padding symbol\n out_bound_mask = tf.cast(x > (self.vocab_size - 1), dtype=tf.int32)\n x *= 1 - out_bound_mask\n x += out_bound_mask * tf.cast(self.pad_sym, dtype=tf.int32)\n\n embeddings = tf.gather(self.shared_weights, x)\n if self.embed_scale:\n # Scale embedding by the sqrt of the hidden size\n embeddings *= self.hidden_size ** 0.5\n\n if self.mask_paddings:\n # Create binary array of size [batch_size, length]\n # where 1 = padding, 0 = not padding\n padding = get_padding(x, padding_value=self.pad_sym)\n\n # Set all padding embedding values to 0\n # embeddings *= tf.expand_dims(1 - padding, -1)\n embeddings *= tf.cast(tf.expand_dims(1.0 - padding, -1), dtype=embeddings.dtype)\n return embeddings","def embedding(org_input):\n # Create the embedding list\n for f in range(Config.num_feature):\n num_cat_value = Config.schema[f]\n\n if num_cat_value == 1:\n pass\n elif num_cat_value > 1:\n embed_dict[f] = tf.get_variable(\n name=\"embed_\" + str(f),\n shape=[num_cat_value, Config.embed_size[f]],\n trainable=True)\n else:\n raise ValueError(\"Schema values should be positive integers!\")\n\n # Create embedded inputs\n f_size = np.sum(Config.embed_size)\n embedded_input = embed_events(org_input, f_size)\n\n return embedded_input","def anime_embedding_model(anime_index, tag_index, embedding_size=50, classification=False):\n\n # Both inputs are 1-dimensional\n anime = Input(name='anime', shape=[1])\n tag = Input(name='tag', shape=[1])\n\n # Embedding the anime (shape will be (None, 1, 50))\n anime_embedding = Embedding(name='anime_embedding',\n input_dim=len(anime_index),\n output_dim=embedding_size)(anime)\n\n # Embedding the tag (shape will be (None, 1, 50))\n tag_embedding = Embedding(name='tag_embedding',\n input_dim=len(tag_index),\n output_dim=embedding_size)(tag)\n\n # Merge the layers with a dot product along the second axis (shape will be (None, 1, 1))\n merged = Dot(name='dot_product', normalize=True, axes=2)([anime_embedding, tag_embedding])\n\n # Reshape to be a single number (shape will be (None, 1))\n merged = Reshape(target_shape=[1])(merged)\n\n # If classifcation, add extra layer and loss function is binary cross entropy\n if classification:\n merged = Dense(1, activation='sigmoid')(merged)\n model = Model(inputs=[anime, tag], outputs=merged)\n model.compile(optimizer='Adam', loss='binary_crossentropy', metrics=['accuracy'])\n\n # Otherwise loss function is mean squared error\n else:\n model = Model(inputs=[anime, tag], outputs=merged)\n model.compile(optimizer='Adam', loss='mse')\n\n return model","def add_embedding(self, prefix=''):\n with tf.variable_scope(prefix + 'embed'):\n if self.cfg.fix_emb:\n assert (hasattr(self.cfg, 'W_emb'))\n W_emb = pkl.load(open(self.cfg.W_emb_path, 'rb'))\n W = tf.get_variable('W', initializer= W_emb, trainable=True)\n print(\"iniitalize word embedding finished\")\n else:\n weightInit = tf.random_uniform_initializer(-0.001, 0.001)\n vocab = pkl.load(open(self.cfg.vocab_path, 'rb'))\n W = tf.get_variable('W', [len(vocab), self.cfg.emb_size], initializer=weightInit)\n if hasattr(self.cfg, 'relu_w') and self.cfg.relu_w:\n W = tf.nn.relu(W)\n return W","def embed_word(self):\n return self.emb.get_keras_embedding(dropout = self.emb_dropout,\n trainable = self.trainable_emb,\n input_length = self.sent_maxlen)","def embeddings_layer(x, Wemb, dim_proj):\n\n n_words = x.shape[0]\n n_max_letters_in_word = x.shape[1]\n n_batch = x.shape[2]\n\n dist = Wemb[x.flatten()].reshape([n_words, n_max_letters_in_word, n_batch, dim_proj])\n return dist","def embed_word(self):\n return self.emb.get_keras_embedding(trainable = self.trainable_emb,\n input_length = self.sent_maxlen)","def model_extract_document_embedding(self):\n input_ids = tf.keras.layers.Input(shape=(self.maxlen,), dtype=tf.int32, name=\"ids\")\n attention_mask = tf.keras.layers.Input(shape=(self.maxlen,), dtype=tf.int32, name=\"att\")\n token = tf.keras.layers.Input(shape=(self.maxlen,), dtype=tf.int32, name=\"tok\")\n\n # Embedding :\n if self.method_embedding == 'CamemBERT':\n Camembert_model = transformers.TFCamembertModel.from_pretrained(\"jplu/tf-camembert-base\")\n x = Camembert_model(input_ids, attention_mask=attention_mask, token_type_ids=token)\n elif self.method_embedding == 'FlauBERT':\n # lr = 0.00001\n Flaubert_model = transformers.TFFlaubertModel.from_pretrained(\"jplu/tf-flaubert-base-uncased\")\n x = Flaubert_model(input_ids, attention_mask=attention_mask, token_type_ids=token)\n elif self.method_embedding == 'XLM-RoBERTa':\n # lr = 0.00001\n XLMRoBERTa_model = transformers.TFXLMRobertaModel.from_pretrained(\"jplu/tf-xlm-roberta-base\")\n x = XLMRoBERTa_model(input_ids, attention_mask=attention_mask, token_type_ids=token)\n elif self.method_embedding == 'RoBERTa':\n # Experience Test path weights :\n PATH = '/kaggle/input/tf-roberta/'\n config = transformers.RobertaConfig.from_pretrained(PATH + 'config-roberta-base.json')\n Roberta_model = transformers.TFRobertaModel.from_pretrained(PATH + 'pretrained-roberta-base.h5',\n config=config)\n # Sinon :\n # Roberta_model = transformers.TFRobertaModel.from_pretrained('roberta-base')\n x = Roberta_model(input_ids, attention_mask=attention_mask, token_type_ids=token)\n elif self.method_embedding == 'BERT':\n BERT_model = transformers.TFBertModel.from_pretrained('bert-base-uncased')\n x = BERT_model(input_ids, attention_mask=attention_mask, token_type_ids=token)\n else:\n logger.critical(\"unknown embedding method name : '{}'\".format(self.method_embedding))\n\n # word vectors shape : (None, maxlen, 768)\n x = x[0]\n cls_token = x[:, 0, :]\n\n model = tf.keras.models.Model(inputs=[input_ids, attention_mask, token], outputs=cls_token)\n return model","def embedding_table(inputs, vocab_size, embed_size, zero_pad=False,\n trainable=True, scope=\"embedding\", reuse=None):\n with tf.variable_scope(scope, reuse=reuse):\n embed_table = tf.get_variable('embedding_table',\n shape=[vocab_size, embed_size],\n initializer=_init,\n trainable=trainable,\n dtype=tf.float32)\n if zero_pad:\n embed_table = tf.concat((tf.zeros(shape=[1, embed_size]), embed_table[1:, :]),\n axis=0)\n\n return tf.nn.embedding_lookup(embed_table, inputs)","def load_embeddings(config, name, vocab, training_generator, validation_generator):\n\n # Pickle embeddings should be AGNOSTIC to the name. This is because each pickled embedding is specific to the dataset and transformer.\n # Applies down the road when/if we attempt active learning\n data_name = config['train_file'].split('/')[-1][:-4] # retrieve file name without the extension\n train_embed_pkl_f = os.path.join(config['cache'], data_name + '_' + config['embedding_type'] + '_training_embeddings.p')\n valid_embed_pkl_f = os.path.join(config['cache'], data_name + '_' + config['embedding_type'] + '_validation_embeddings.p')\n \n \n if os.path.exists(train_embed_pkl_f):\n with open( train_embed_pkl_f, 'rb') as cache:\n train_embeddings = pickle.load(cache)\n\n with open(valid_embed_pkl_f, 'rb') as cache:\n valid_embeddings = pickle.load(cache)\n else:\n # get embeddings from scratch\n tokenizer = AutoTokenizer.from_pretrained(vocab)\n embedding_model = AbstractBert(vocab) \n\n if torch.cuda.device_count() > 1:\n print(\"GPUs Available: \", torch.cuda.device_count())\n embedding_model = torch.nn.DataParallel(embedding_model, device_ids=[0, 1, 2])\n \n use_cuda = torch.cuda.is_available()\n device = torch.device(\"cuda:0\" if use_cuda else \"cpu\")\n\n embedding_model.eval().to(device)\n\n logger.info(' Getting BERT/ROBERTA embeddings...')\n\n train_embeddings = _get_bert_embeddings(training_generator, embedding_model, config[\"metadata\"])\n valid_embeddings = _get_bert_embeddings(validation_generator, embedding_model, config[\"metadata\"])\n\n # save embeddings\n pickle.dump(train_embeddings, open(train_embed_pkl_f, 'wb'))\n pickle.dump(valid_embeddings, open(valid_embed_pkl_f, 'wb'))\n\n logger.info(' Saved full BERT/ROBERTA embeddings.')\n\n embedding_shape = train_embeddings['embeddings'][1].shape[0]\n\n return embedding_shape, train_embeddings, valid_embeddings","def _build(self, ids):\n # Construct embeddings.\n if self._existing_vocab is None:\n if self.EMBEDDINGS not in self._initializers:\n self._initializers[self.EMBEDDINGS] = basic.create_linear_initializer(\n self._vocab_size)\n self._embeddings = tf.get_variable(\n \"embeddings\",\n shape=[self._vocab_size, self._embed_dim],\n dtype=tf.float32,\n initializer=self._initializers[self.EMBEDDINGS],\n partitioner=self._partitioners.get(self.EMBEDDINGS, None),\n regularizer=self._regularizers.get(self.EMBEDDINGS, None),\n trainable=self._trainable)\n else:\n self._embeddings = tf.get_variable(\n \"embeddings\",\n dtype=tf.float32,\n initializer=self._existing_vocab,\n regularizer=self._regularizers.get(self.EMBEDDINGS, None),\n trainable=self._trainable)\n\n # Lookup embeddings\n return tf.nn.embedding_lookup(\n self._embeddings, ids, name=\"embedding_lookup\")","def add_word_embeddings_op(self):\n with tf.variable_scope(\"words\"):\n if self.config.embeddings is None:\n self.logger.info(\"WARNING: randomly initializing word vectors\")\n _word_embeddings = tf.get_variable(\n name=\"_word_embeddings\",\n dtype=tf.float32,\n shape=[self.config.nwords, self.config.dim_word])\n else:\n _word_embeddings = tf.Variable(\n self.config.embeddings,\n name=\"_word_embeddings\",\n dtype=tf.float32,\n trainable=self.config.train_embeddings)\n\n word_embeddings = tf.nn.embedding_lookup(_word_embeddings,\n self.word_ids, name=\"word_embeddings\")\n\n with tf.variable_scope(\"chars\"):\n if self.config.use_chars:\n # get char embeddings matrix\n _char_embeddings = tf.get_variable(\n name=\"_char_embeddings\",\n dtype=tf.float32,\n shape=[self.config.nchars, self.config.dim_char])\n char_embeddings = tf.nn.embedding_lookup(_char_embeddings,\n self.char_ids, name=\"char_embeddings\")\n\n # put the time dimension on axis=1\n s = tf.shape(char_embeddings)\n char_embeddings = tf.reshape(char_embeddings,\n shape=[s[0]*s[1], s[-2], self.config.dim_char])\n word_lengths = tf.reshape(self.word_lengths, shape=[s[0]*s[1]])\n\n # bi lstm on chars\n cell_fw = tf.contrib.rnn.LSTMCell(self.config.hidden_size_char,\n state_is_tuple=True)\n cell_bw = tf.contrib.rnn.LSTMCell(self.config.hidden_size_char,\n state_is_tuple=True)\n _output = tf.nn.bidirectional_dynamic_rnn(\n cell_fw, cell_bw, char_embeddings,\n sequence_length=word_lengths, dtype=tf.float32)\n\n # read and concat output\n _, ((_, output_fw), (_, output_bw)) = _output\n output = tf.concat([output_fw, output_bw], axis=-1)\n\n # shape = (batch size, max sentence length, char hidden size)\n output = tf.reshape(output,\n shape=[s[0], s[1], 2*self.config.hidden_size_char])\n word_embeddings = tf.concat([word_embeddings, output], axis=-1)\n\n self.word_embeddings = tf.nn.dropout(word_embeddings, self.dropout)","def create_embedding(num_symbol, embedding_size, embedding_name):\n return tf.Variable(tf.random_uniform([num_symbol, embedding_size], -0.1, 0.1, tf.float32), name=embedding_name, trainable=True)","def get_embedding(self, task_embedding, layer_id):\n layer_id_tensor = torch.tensor([layer_id], dtype=torch.long, device=self.device)\n layer_embedding = self.layer_id_embeddings(layer_id_tensor)\n layer_embedding = layer_embedding.view(-1)\n segment_id = torch.tensor([0, 1], dtype=torch.long, device=self.device)\n embeddings = torch.cat([task_embedding.view(1, -1), layer_embedding.view(1, -1)], axis=0)\n embeddings += self.token_type_embeddings(segment_id)\n embeddings = self.task_hypernet(embeddings.view(-1))\n if self.unique_hyper_net_layer_norm:\n embeddings = self.LayerNorm(embeddings)\n return embeddings","def generate_embedding(inputs, input_shape: list, embedding_args: dict, embedding_rank: int = 1, **kwargs):\n if len(kwargs) > 0:\n print(\"WARNING:kgcnn: Unknown embedding kwargs {0}. Will be reserved for future versions.\".format(kwargs))\n\n if len(input_shape) == embedding_rank:\n n = ks.layers.Embedding(**embedding_args)(inputs)\n else:\n n = inputs\n return n","def __init__(self,\n vocab_size=None,\n embed_dim=None,\n existing_vocab=None,\n initializers=None,\n partitioners=None,\n regularizers=None,\n trainable=True,\n custom_getter=None,\n name=\"embed\"):\n if vocab_size is None and existing_vocab is None:\n raise ValueError(\"Must provide on of vocab_size or existing_vocab.\")\n\n if existing_vocab is not None and not all(\n x is None for x in [vocab_size, embed_dim, initializers, partitioners]):\n raise ValueError(\"If existing_vocab is provided, none of vocab_size, \"\n \"embedding_dim, initializers, or partitioners is \"\n \"needed.\")\n\n super(Embed, self).__init__(custom_getter=custom_getter, name=name)\n self._existing_vocab = None\n if existing_vocab is None:\n self._vocab_size = vocab_size\n self._embed_dim = embed_dim or _embedding_dim(self._vocab_size)\n else:\n self._existing_vocab = tf.convert_to_tensor(\n existing_vocab, dtype=tf.float32)\n existing_vocab_shape = self._existing_vocab.get_shape().with_rank(2)\n existing_vocab_shape.assert_is_fully_defined()\n self._vocab_size, self._embed_dim = existing_vocab_shape.as_list()\n\n self._initializers = util.check_initializers(\n initializers, self.POSSIBLE_INITIALIZER_KEYS)\n self._partitioners = util.check_partitioners(\n partitioners, self.POSSIBLE_INITIALIZER_KEYS)\n self._regularizers = util.check_regularizers(\n regularizers, self.POSSIBLE_INITIALIZER_KEYS)\n self._trainable = trainable","def word_embeddings(self, feed_seq_batch):\n # compute seq_length\n self.feed_per_seq_length = self.get_per_seq_length(feed_seq_batch)\n\n # compute embedding\n with tf.variable_scope(\"word_embedding\"):\n seq_embedding = tf.get_variable(\n name=\"seq_embedding\",\n shape=[self.config.vocab_size, self.config.embed_dim],\n initializer=self.initializer)\n word_embeddings = tf.nn.embedding_lookup(seq_embedding,\n feed_seq_batch)\n if self.train_mode:\n word_embeddings = tf.nn.dropout(\n word_embeddings, keep_prob=self.feed_general_droprate)\n word_embeddings = tf.nn.tanh(word_embeddings)\n\n return word_embeddings","def _add_pre_trained_embedding(self):\n\n if self.embedding_type['type'] == 'glove':\n self.logging.info('use pre-trained glove word2vec')\n # a. load pre trained glove\n GLOVE_DIR = '../data/glove_pretrained/glove.6B'\n glove_suffix_name = 'glove.6B.' + str(self.embedding_size) + 'd.txt'\n import os\n import numpy as np\n\n embeddings_index = {}\n f = open(os.path.join(GLOVE_DIR, glove_suffix_name)) # 'glove.6B.100d.txt'))\n for line in f:\n values = line.split()\n word = values[0]\n coefs = np.asarray(values[1:], dtype='float32')\n embeddings_index[word] = coefs\n f.close()\n\n self.logging.info('')\n self.logging.info('Found %s word vectors.' % len(embeddings_index))\n\n # b. compute embedding matrix\n embedding_matrix = np.zeros((len(self.word_index) + 1, self.embedding_size))\n cnt = 0\n for word, i in self.word_index.items():\n embedding_vector = embeddings_index.get(word)\n if embedding_vector is not None:\n embedding_matrix[i] = embedding_vector # words not found in embedding index will be all-zeros.\n else:\n # self.logging.info('token in train missing in word2vec: ' + str(word))\n cnt += 1\n self.logging.info('total tokens missing: ' + str(cnt) + ' / ' + str(len(self.word_index)))\n\n # c. build embedding layer\n from keras.layers import Embedding\n embedding_layer = Embedding(len(self.word_index) + 1,\n self.embedding_size,\n weights=[embedding_matrix],\n input_length=self.maxlen,\n trainable=False)\n\n elif self.embedding_type['type'] == 'gensim':\n self.logging.info('use pre-trained gensim word2vec')\n\n import gzip\n import gensim\n from keras.layers import Embedding\n import numpy as np\n\n # fname = '../data/word2vec_pretrained/motors/d_300_k_712904_w_6_e_60_v_motors'\n # fname = '../data/word2vec_pretrained/fashion/d_300_k_1341062_w_6_e_70_v_fashion'\n\n self.logging.info('load word2vec path: ' + str(self.embedding_type['path']))\n model = gensim.models.Word2Vec.load(self.embedding_type['path'])\n pretrained_weights = model.wv.syn0\n vocab_size, vector_dim = pretrained_weights.shape\n\n method = 3\n if method == 1:\n self.logging.info('word2vec attempt to fit into embedding layer - middle complex')\n # convert the wv word vectors into a numpy matrix that is suitable for insertion\n # into our TensorFlow and Keras models\n\n embedding_matrix = np.zeros((len(model.wv.vocab), vector_dim))\n for i in range(len(model.wv.vocab)):\n embedding_vector = model.wv[model.wv.index2word[i]]\n if embedding_vector is not None:\n embedding_matrix[i] = embedding_vector\n\n embedding_layer = Embedding(input_dim=embedding_matrix.shape[0],\n output_dim=embedding_matrix.shape[1],\n # input_length=self.maxlen,\n weights=[embedding_matrix],\n trainable=False)\n elif method == 2:\n self.logging.info('word2vec simple embedding matching - simple complex')\n embedding_layer = Embedding(input_dim=vocab_size,\n output_dim=vector_dim,\n input_length=self.maxlen,\n weights=[pretrained_weights],\n trainable=False)\n elif method == 3:\n\n self.logging.info('word2vec match using word_index from keras tokenizer - as used in glove match above')\n # b. compute embedding matrix\n\n # sd = 1 / np.sqrt(len(self.word_index) + 1)\n # embedding_matrix = np.random.normal(0, scale=sd, size=(len(self.word_index) + 1, self.embedding_size))\n\n embedding_matrix = np.zeros((len(self.word_index) + 1, self.embedding_size))\n cnt = 0\n for word, i in self.word_index.items():\n if word in model.wv:\n embedding_vector = model.wv[word]\n embedding_matrix[i] = embedding_vector\n else:\n # self.logging.info('token in train missing in word2vec: ' + str(word))\n cnt += 1\n self.logging.info('total tokens missing: ' + str(cnt))\n\n\n # c. build embedding layer\n from keras.layers import Embedding\n embedding_layer = Embedding(len(self.word_index) + 1,\n self.embedding_size,\n weights=[embedding_matrix],\n input_length=self.maxlen,\n trainable=False)\n else:\n raise ValueError('unknown method value')\n\n else:\n raise ValueError('unknown embedding type')\n self.logging.info('create glove pre-trained embedding: ' + str(self.embedding_size))\n return embedding_layer","def forward(self, features: EmbeddedFeatures):\n assert len(features.token_embeddings.shape) == 3 and features.token_embeddings.shape[0] == 2, \\\n \"Input must have 2 embeddings\"\n\n # [x, z]\n x = features.token_embeddings[0].to(torch.float)\n y = features.token_embeddings[1].to(torch.float)\n\n # [z, x] @ [x, z] = [z, z]\n attention = torch.mm(x.T, y)\n\n # [z, z]\n softmax_x = F.softmax(attention, dim = 1) # By row\n softmax_y = F.softmax(attention, dim = 0) # By column\n\n # [z, z]\n weighted_x = (softmax_x * torch.sum(y, dim = 0))[:x.shape[0]]\n weighted_y = (softmax_y * torch.sum(x, dim = 0))[:y.shape[0]]\n\n # [x]\n pooled = self.pooling(features)\n pooled_x, pooled_y = pooled.token_embeddings[0], pooled.token_embeddings[1]\n\n features.token_embeddings = torch.stack([weighted_x, weighted_y])\n\n pooled = self.pooling(features)\n pooled_weighted_x, pooled_weighted_y = pooled.token_embeddings[0], pooled.token_embeddings[1]\n\n # [3 * x]\n concatenated_x = torch.cat([pooled_x, pooled_weighted_x, pooled_x - pooled_weighted_x])\n concatenated_y = torch.cat([pooled_y, pooled_weighted_y, pooled_y - pooled_weighted_y])\n\n # [9 * x]\n result = torch.cat([concatenated_x, concatenated_y, torch.abs(concatenated_x - concatenated_y)])\n\n return result","def build_seq_embeddings(self):\n with tf.variable_scope(\"seq_embedding\"), tf.device(\"/cpu:0\"):\n embedding_map = tf.get_variable(\n name=\"map\",\n shape=[self.config.vocab_size, self.config.word_embedding_size],\n initializer=self.initializer)\n \n # We need to store the normalized lookup table for efficient mapping of embedding vectors to closest words\n self.normed_embedding_map = tf.nn.l2_normalize(embedding_map, dim=1)\n \n seq_embeddings = tf.nn.embedding_lookup(embedding_map, self.input_seqs) \n # seq_embeddings has the shape (batch_size, sequence_length, sentence_length, embedding_size)\n # meaning, for each index in input_seqs (with shape (batch_size, sequence_length, sentence_length)) it stores an embedding vector\n\n #print('Shape seq_embeddings: ' + str(seq_embeddings.get_shape()))\n\n self.seq_embeddings = seq_embeddings","def build_embeddings(opt, word_dict, for_encoder='src'):\n if for_encoder=='src':\n embedding_dim = opt.src_word_vec_size #512\n elif for_encoder=='tgt':\n embedding_dim = opt.tgt_word_vec_size\n elif for_encoder=='structure':\n embedding_dim = 64\n\n word_padding_idx = word_dict.stoi[Constants.PAD_WORD]\n num_word_embeddings = len(word_dict)\n \n if for_encoder=='src' or for_encoder=='tgt':\n\n return Embeddings(word_vec_size=embedding_dim,\n position_encoding=opt.position_encoding,\n dropout=opt.dropout,\n word_padding_idx=word_padding_idx,\n word_vocab_size=num_word_embeddings,\n sparse=opt.optim == \"sparseadam\")\n elif for_encoder=='structure':\n return Embeddings(word_vec_size=embedding_dim,\n position_encoding=False,\n dropout=opt.dropout,\n word_padding_idx=word_padding_idx,\n word_vocab_size=num_word_embeddings,\n sparse=opt.optim == \"sparseadam\")","def get_model_bicond_sepembed(batch_size, max_seq_length, input_size, hidden_size, target_size,\n vocab_size, pretrain, tanhOrSoftmax, dropout):\n\n # batch_size x max_seq_length\n inputs = tf.placeholder(tf.int32, [batch_size, max_seq_length])\n inputs_cond = tf.placeholder(tf.int32, [batch_size, max_seq_length])\n\n cont_train = True\n if pretrain == \"pre\": # continue training embeddings or not. Currently works better to continue training them.\n cont_train = False\n embedding_matrix = tf.Variable(tf.random_uniform([vocab_size, input_size], -0.1, 0.1), # input_size is embeddings size\n name=\"embedding_matrix\", trainable=cont_train)\n embedding_matrix_cond = tf.Variable(tf.random_uniform([vocab_size, input_size], -0.1, 0.1),\n name=\"embedding_matrix\", trainable=cont_train)\n\n\n # batch_size x max_seq_length x input_size\n embedded_inputs = tf.nn.embedding_lookup(embedding_matrix, inputs)\n embedded_inputs_cond = tf.nn.embedding_lookup(embedding_matrix_cond, inputs_cond)\n\n\n # [batch_size x inputs_size] with max_seq_length elements\n # fixme: possibly inefficient\n # inputs_list[0]: batch_size x input[0] <-- word vector of the first word\n inputs_list = [tf.squeeze(x) for x in\n tf.split(1, max_seq_length, embedded_inputs)]\n inputs_cond_list = [tf.squeeze(x) for x in\n tf.split(1, max_seq_length, embedded_inputs_cond)]\n\n drop_prob = None\n if dropout:\n drop_prob = 0.1\n lstm_encoder = Encoder(rnn_cell.BasicLSTMCell, input_size, hidden_size, drop_prob, drop_prob)\n\n start_state = tf.zeros([batch_size, lstm_encoder.state_size])\n\n ### FORWARD\n\n # [h_i], [h_i, c_i] <-- LSTM\n # [h_i], [h_i] <-- RNN\n fw_outputs, fw_states = lstm_encoder(inputs_list, start_state, \"LSTM\")\n\n # running a second LSTM conditioned on the last state of the first\n fw_outputs_cond, fw_states_cond = lstm_encoder(inputs_cond_list, fw_states[-1],\n \"LSTMcond\")\n\n fw_outputs_fin = fw_outputs_cond[-1]\n\n ### BACKWARD\n bw_outputs, bw_states = lstm_encoder(inputs_list[::-1], start_state, \"LSTM_bw\")\n bw_outputs_cond, bw_states_cond = lstm_encoder(inputs_cond_list[::-1], bw_states[-1],\n \"LSTMcond_bw\")\n bw_outputs_fin = bw_outputs_cond[-1]\n\n outputs_fin = tf.concat(1, [fw_outputs_fin, bw_outputs_fin])\n\n\n if tanhOrSoftmax == \"tanh\":\n model = Projector(target_size, non_linearity=tf.nn.tanh, bias=True)(outputs_fin) # tf.nn.softmax\n else:\n model = Projector(target_size, non_linearity=tf.nn.softmax, bias=True)(outputs_fin) # tf.nn.softmax\n\n return model, [inputs, inputs_cond]","def _use_embeddings(self, word):\n if word == \"@PAD@\":\n return torch.zeros(self.embeddings_dim)\n else:\n return self.embeddings[word]","def resize_token_embeddings(self, new_num_tokens=None):\n base_model = getattr(self, self.base_model_prefix, self) # get the base model if needed\n model_embeds = base_model._resize_token_embeddings(new_num_tokens)\n if new_num_tokens is None:\n return model_embeds\n\n # Update base model and current model config\n self.config.vocab_size = new_num_tokens\n base_model.vocab_size = new_num_tokens\n\n # Tie weights again if needed\n if hasattr(self, \"tie_weights\"):\n self.tie_weights()\n\n return model_embeds","def test_embedding_matrix_shape(self):\n num_embeddings = 10\n features = 5\n embed = layers.Embed(num_embeddings=num_embeddings, features=features)\n inputs = np.expand_dims(np.arange(features, dtype=np.int64), 1)\n variables = embed.init(jax.random.PRNGKey(0), inputs)\n embedding_matrix = variables['params']['embedding']\n self.assertEqual((num_embeddings, features), embedding_matrix.shape)","def generate_embedding_matrix(self):\n # get all the embeddings\n all_embs = np.stack(list(self.embeddings.values()))\n\n # mean and standard deviation of the embedding values\n emb_mean, emb_std = all_embs.mean(), all_embs.std()\n\n # Find the number of words the the train set\n word_index = self.tokenizer.word_index\n rows = min(self.max_features, len(word_index))\n\n # create embeddings for each word by sampling from a normal distribtion\n # with parameters calculated above.\n embedding_matrix = np.random.normal(emb_mean, emb_std, (rows + 1, self.embed_size))\n\n for word, i in word_index.items():\n # TODO: replace this with stop words and frequency instead\n if i >= self.max_features:\n continue\n\n embedding_vector = self.embeddings.get(word)\n\n # if word is found in the embeddings used\n if embedding_vector is not None:\n # replace row of embeddings matrix with trained embeddings vector\n embedding_matrix[i] = embedding_vector\n\n return embedding_matrix","def sn_embedding(x, number_classes, embedding_size, training=True,\n name='snembedding'):\n with tf.variable_scope(name):\n embedding_map = tf.get_variable(\n name='embedding_map',\n shape=[number_classes, embedding_size],\n initializer=tf.keras.initializers.VarianceScaling(\n scale=1.0, mode='fan_avg', distribution='uniform'))\n embedding_map_bar_transpose = tfgan.features.spectral_normalize(\n tf.transpose(a=embedding_map),\n training=training,\n equality_constrained=False)\n embedding_map_bar = tf.transpose(a=embedding_map_bar_transpose)\n return tf.nn.embedding_lookup(params=embedding_map_bar, ids=x)","def build_input_embed(self, n_input, t_input):\n n_embed_matrix = tf.Variable(tf.random_uniform(\n [self.num_ntoken, self.n_embed_dim], minval=-0.05, maxval=0.05), name='n_embed_matrix')\n t_embed_matrix = tf.Variable(tf.random_uniform(\n [self.num_ttoken, self.t_embed_dim], minval=-0.05, maxval=0.05), name='t_embed_matrix')\n n_input_embedding = tf.nn.embedding_lookup(n_embed_matrix, n_input)\n t_input_embedding = tf.nn.embedding_lookup(t_embed_matrix, t_input)\n return n_input_embedding, t_input_embedding","def get_pretrained_embeddings(source_vocab,embed_df):\r\n \r\n num_tokens = len(source_vocab)\r\n embedding_dim = embed_df.shape[1]\r\n weights = np.zeros((num_tokens,embedding_dim),dtype=np.float32)\r\n \r\n for idx in range(num_tokens):\r\n token = source_vocab.lookup_index(idx)\r\n if token in embed_df.index:\r\n weights[idx,:] = embed_df.loc[token]\r\n else:\r\n weights[idx,:] = np.random.randn(1,embedding_dim)\r\n \r\n embed_tensor = torch.FloatTensor(weights)\r\n return embed_tensor","def _embed(self):\n batch_size = tf.shape(self.p)[0]\n with tf.variable_scope(\"emb\"):\n with tf.variable_scope(\"char\"):\n pc_emb = tf.reshape(tf.nn.embedding_lookup(\n self.char_embed, self.pc), \n [batch_size * self.max_p_len, self.max_w_len, self.vocab.char_embed_dim])\n qc_emb = tf.reshape(tf.nn.embedding_lookup(\n self.char_embed, self.qc), \n [batch_size * self.max_q_len, self.max_w_len, self.vocab.char_embed_dim])\n cell_fw = tf.contrib.rnn.GRUCell(self.char_hidden_size)\n cell_bw = tf.contrib.rnn.GRUCell(self.char_hidden_size)\n _, (state_fw, state_bw) = tf.nn.bidirectional_dynamic_rnn(\n cell_fw, cell_bw, pc_emb, self.pc_length, dtype=tf.float32)\n pc_emb = tf.concat([state_fw, state_bw], axis=1)\n _, (state_fw, state_bw) = tf.nn.bidirectional_dynamic_rnn(\n cell_fw, cell_bw, qc_emb, self.qc_length, dtype=tf.float32)\n qc_emb = tf.concat([state_fw, state_bw], axis=1)\n pc_emb = tf.reshape(pc_emb, [batch_size, self.max_p_len, 2 * self.char_hidden_size])\n qc_emb = tf.reshape(qc_emb, [batch_size, self.max_q_len, 2 * self.char_hidden_size])\n\n with tf.name_scope(\"word\"):\n p_emb = tf.nn.embedding_lookup(self.word_embed, self.p)\n q_emb = tf.nn.embedding_lookup(self.word_embed, self.q)\n\n with tf.name_scope(\"pos\"):\n p_pos_emb = tf.nn.embedding_lookup(self.pos_embed, self.p_pos)\n q_pos_emb = tf.nn.embedding_lookup(self.pos_embed, self.q_pos)\n \n with tf.name_scope(\"em\"):\n sh = tf.shape(self.p_em)\n resh = [sh[0], sh[1], 1]\n p_em_feat = tf.reshape(tf.cast(self.p_em, dtype=tf.float32), shape=resh)\n\n self.p_emb = tf.concat([p_emb, pc_emb, p_pos_emb, p_em_feat], axis=2)\n self.q_emb = tf.concat([q_emb, qc_emb, q_pos_emb], axis=2)","def incorporate_embeddings(self, x):\n all_embedded_data = []\n for embedding_layer_ix, embedding_var in enumerate(self.columns_of_data_to_be_embedded):\n data = x[:, :, embedding_var]\n embedded_data = self.embedding_layers[embedding_layer_ix](data)\n all_embedded_data.append(embedded_data)\n if len(all_embedded_data) > 1: all_embedded_data = Concatenate(axis=2)(all_embedded_data)\n else: all_embedded_data = all_embedded_data[0]\n non_embedded_columns = [col for col in range(x.shape[2]) if col not in self.columns_of_data_to_be_embedded]\n if len(non_embedded_columns) > 0:\n x = tf.gather(x, non_embedded_columns, axis=2)\n x = Concatenate(axis=2)([tf.dtypes.cast(x, float), all_embedded_data])\n else: x = all_embedded_data\n return x","def add_word_embedding_op(self):\n if self.pos:\n print(\"adding pos embeddings\")\n with tf.variable_scope(\"pos\"):\n _pos_embeddings = tf.Variable(self.pos_embeddings,\n name=\"la_pos_embeddings\",\n dtype=tf.float32, trainable=False)\n pos_embeddings = tf.nn.embedding_lookup(_pos_embeddings, self.pos_ids,\n name=\"pos_embeddings\")\n self.pos_vecs = pos_embeddings\n print(\"adding word_embeddings\")\n with tf.variable_scope(\"words\"):\n _word_embeddings = tf.Variable(self.embeddings, name=\"_word_embeddings\",\n dtype=tf.float32, trainable=False)\n word_embeddings = tf.nn.embedding_lookup(_word_embeddings,\n self.word_ids,\n name=\"word_embeddings\")\n if self.use_window:\n print(\"Concatenating word vectors of context words\")\n word_embeddings_sl = tf.nn.embedding_lookup(_word_embeddings,\n self.word_ids_sl,\n name=\"word_embeddings_sl\")\n word_embeddings_sr = tf.nn.embedding_lookup(_word_embeddings,\n self.word_ids_sr,\n name=\"word_embeddings_sr\")\n word_embeddings = tf.concat([word_embeddings_sr, word_embeddings,\n word_embeddings_sl], axis=-1)\n if self.use_char_embeddings:\n print(\"adding CNN for char embeddings\")\n with tf.variable_scope(\"chars\"):\n _char_embeddings = tf.get_variable(name=\"_char_embeddings\",\n dtype=tf.float32,\n shape=[self.char_count, \n self.c_dim_input])\n char_embeddings = tf.nn.embedding_lookup(_char_embeddings, \n self.char_ids, \n name=\"char_embeddings\")\n s = char_embeddings.shape\n # the shape of our char_embeddings is now (batch_size, max number of words\n # in each sentence, max number of chars in each word, self.c_dim )\n char_filter = tf.get_variable(\"char_filter\", dtype=tf.float32,\n shape=[self.c_filter_width, \n self.c_filter_height,\n self.c_dim_input,\n self.c_dim_output])\n print(\"adding 2d convolution layer\")\n char_conv_layer = tf.nn.conv2d(char_embeddings, char_filter, \n strides=[1, 1, 1, 1], \n padding=\"SAME\")\n char_conv_layer = tf.nn.tanh(char_conv_layer)\n print(\"adding 2d pooling layer\")\n char_conv_layer = tf.layers.max_pooling2d(char_conv_layer, \n 1, \n strides=1)\n char_output = tf.reshape(char_conv_layer, shape=[-1, self.max_len, \n self.max_word_length*\n self.c_dim_output])\n word_embeddings = tf.concat([word_embeddings, char_output], axis=-1)\n if self.pos and self.concat_pos:\n print(\"concatenating pos with word_embeddings\")\n word_embeddings = tf.concat([word_embeddings, pos_embeddings], axis=-1)\n self.word_embeddings = word_embeddings\n if self.use_additional and self.hybrid:\n print(\"using additional embeddings\")\n _word_embeddings_2 = tf.Variable(self.additional_embeddings,\n name=\"two_word_embeddings\",\n dtype=tf.float32, trainable=False)\n word_embeddings_2 = tf.nn.embedding_lookup(_word_embeddings_2,\n self.word_ids,\n name=\"two_word_embeddings\")\n self.word_embeddings_2 = word_embeddings_2","def create_model(self):\n\t\twith tf.name_scope(\"input\"):\n\t\t\tself.user_embedding = tf.get_variable(\"user_embed\", \n\t\t\t\t[self.user_size, self.embed_size], dtype=tf.float32)\n\t\t\tself.item_embedding = tf.get_variable(\"item_embed\", \n\t\t\t\t[self.item_size, self.embed_size], dtype=tf.float32)\n\t\t\tself.user_embed = tf.nn.embedding_lookup(\n\t\t\t\t\t\t\tself.user_embedding, self.user)\n\t\t\tself.item_embed = tf.nn.embedding_lookup(\n\t\t\t\t\t\t\tself.user_embedding, self.item)\n\t\twith tf.name_scope(\"fusion\"):\n\t\t\tself.user_fusion_add = self.user_embed + self.user_feature\n\t\t\tself.item_fusion_add = self.item_embed + self.item_feature\n\n\t\t\tself.user_fusion = tf.layers.dense(inputs=self.user_fusion_add,\n\t\t\t\t\t\t\t\tunits=self.embed_size,\n\t\t\t\t\t\t\t\tactivation=self.activation_func,\n\t\t\t\t\t\t\t\tkernel_regularizer=self.regularizer,\n\t\t\t\t\t\t\t\tname='user_fusion')\n\t\t\tself.item_fusion = tf.layers.dense(inputs=self.item_fusion_add,\n\t\t\t\t\t\t\t\tunits=self.embed_size,\n\t\t\t\t\t\t\t\tactivation=self.activation_func,\n\t\t\t\t\t\t\t\tkernel_regularizer=self.regularizer,\n\t\t\t\t\t\t\t\tname='item_fusion')\n\n\t\twith tf.name_scope(\"attention\"):\n\t\t\tself.feature_all = tf.concat([\n\t\t\t\t\t\tself.user_fusion, self.item_fusion], -1)\n\t\t\tself.att_layer1 = tf.layers.dense(inputs=self.feature_all,\n\t\t\t\t\t\t\t\tunits=1,\n\t\t\t\t\t\t\t\tactivation=self.activation_func,\n\t\t\t\t\t\t\t\tkernel_regularizer=self.regularizer,\n\t\t\t\t\t\t\t\tname='att_layer1')\n\t\t\tself.att_layer2 = tf.layers.dense(inputs=self.att_layer1,\n\t\t\t\t\t\t\t\tunits=self.embed_size,\n\t\t\t\t\t\t\t\tactivation=self.activation_func,\n\t\t\t\t\t\t\t\tkernel_regularizer=self.regularizer,\n\t\t\t\t\t\t\t\tname='att_layer2')\n\t\t\tself.att_weights = tf.nn.softmax(self.att_layer2, \n\t\t\t\t\t\t\t\taxis=-1, name='att_softmax')\n\n\t\twith tf.name_scope(\"prediction\"):\n\t\t\tself.interact = self.att_weights*self.user_fusion*self.item_fusion\n\t\t\tself.interact1 = tf.layers.dense(inputs=self.interact,\n\t\t\t\t\t\t\t\tunits=self.embed_size,\n\t\t\t\t\t\t\t\tactivation=self.activation_func,\n\t\t\t\t\t\t\t\tkernel_regularizer=self.regularizer,\n\t\t\t\t\t\t\t\tname='interact1')\n\t\t\tself.interact1 = tf.nn.dropout(self.interact1, self.dropout)\n\t\t\tself.prediction = tf.layers.dense(inputs=self.interact,\n\t\t\t\t\t\t\t\tunits=1,\n\t\t\t\t\t\t\t\tactivation=None,\n\t\t\t\t\t\t\t\tkernel_regularizer=self.regularizer,\n\t\t\t\t\t\t\t\tname='prediction')\n\t\t\tself.prediction = tf.reshape(self.prediction, [-1])","def _embed_composite_feature(self, features, embedding_layers):\n embedding_list = []\n for i in range(len(embedding_layers)):\n embedding_list.append(embedding_layers[i](features[:, :, i]))\n embedding = tf.add_n(embedding_list)\n return embedding","def load_pretrain_embedding(vocab, embed_size, embedding_path):\n model = KeyedVectors.load_word2vec_format(embedding_path)\n\n print('{} {}'.format(vocab.size(), embed_size))\n for token, id in vocab.token2id.items():\n if token in model:\n print('{} {}'.format(token, ' '.join(map(str, model[token]))))\n else:\n emb = np.random.random((embed_size,)) - 0.5\n print('{} {}'.format(token, ' '.join(map(str, emb))))","def init_word_embed(config):\n embedding_mat_val = np.load(config.wordembed_params)\n with tf.variable_scope('vc'):\n with tf.variable_scope('lstm', reuse=True):\n embedding_mat = tf.get_variable(\"embedding_mat\", [config.num_vocab, config.embed_dim])\n init_we = tf.assign(embedding_mat, embedding_mat_val)\n return [init_we]","def _generate_embeddings(self, config): \n tr_parts = []\n te_parts = []\n all_columns = []\n for comp in self.components:\n tr_tmp, te_tmp, cols = comp.generate(config)\n if cols != None:\n print(tr_tmp.shape,te_tmp.shape)\n tr_parts.append(tr_tmp)\n te_parts.append(te_tmp)\n all_columns += cols\n X_train = np.concatenate(tr_parts, axis=1)\n X_test = np.concatenate(te_parts, axis=1)\n print(\"Concatenated size:\", X_train.shape, X_test.shape)\n self.feature_columns = all_columns\n return X_train, X_test","def embedded(self, word_ids, embedding_tensor, scope=\"embedding\"):\n with tf.variable_scope(scope):\n with tf.device(\"/cpu:0\"):\n inputs = tf.nn.embedding_lookup(embedding_tensor, word_ids)\n return inputs","def gen_embedding(text, model, tokenizer):\n ### Tokenize the texts\n encoded_input = tokenizer(text, padding=True, truncation=True, max_length=512, return_tensors='pt')\n \n ### Encode the tokenized data with model\n with torch.no_grad():\n model_output = model(**encoded_input)\n \n ### Pool the outputs into a single vector\n sentence_embeddings = mean_pooling(model_output, encoded_input['attention_mask'])\n return sentence_embeddings","def add_embeddings(self):\n\n with tf.device('/cpu:0'):\n with tf.variable_scope('Embedding_Layer'):\n embeddings = tf.Variable(self.initial_embeddings,name = 'Embeddings')\n self.input_embeddings = tf.nn.embedding_lookup(embeddings, self.inputs_placeholder) #(N,S,D)\n self.question_embeddings = tf.nn.embedding_lookup(embeddings, self.questions_placeholder) #(N,S,D)","def load_embeddings(embedding_path, embedding_size, embedding_format):\n print(\"Loading word embeddings from {}...\".format(embedding_path))\n\n if embedding_format in ['vec', 'txt']:\n default_embedding = np.zeros(embedding_size)\n embedding_dict = collections.defaultdict(lambda: default_embedding)\n skip_first = embedding_format == \"vec\"\n with open(embedding_path) as f:\n for i, line in enumerate(f.readlines()):\n if skip_first and i == 0:\n continue\n splits = line.split(' ')\n assert len(splits) == embedding_size + 1\n word = splits[0]\n embedding = np.array([float(s) for s in splits[1:]])\n embedding_dict[word] = embedding\n elif embedding_format == 'bin':\n embedding_dict = fasttext.load_model(embedding_path)\n else:\n raise ValueError('Not supported embeddings format {}'.format(embedding_format))\n print(\"Done loading word embeddings.\")\n return embedding_dict","def call(self, inputs):\n unpacked_inputs = tf_utils.unpack_inputs(inputs)\n word_embeddings = unpacked_inputs[0]\n token_type_ids = unpacked_inputs[1]\n input_shape = tf_utils.get_shape_list(word_embeddings, expected_rank=3)\n batch_size = input_shape[0]\n seq_length = input_shape[1]\n width = input_shape[2]\n\n output = word_embeddings\n if self.use_type_embeddings:\n flat_token_type_ids = tf.reshape(token_type_ids, [-1])\n token_type_embeddings = tf.gather(self.type_embeddings,\n flat_token_type_ids)\n token_type_embeddings = tf.reshape(token_type_embeddings,\n [batch_size, seq_length, width])\n output += token_type_embeddings\n\n if self.use_position_embeddings:\n position_embeddings = tf.expand_dims(\n tf.slice(self.position_embeddings, [0, 0], [seq_length, width]),\n axis=0)\n\n output += position_embeddings\n\n output = self.output_layer_norm(output)\n output = self.output_dropout(output)\n\n return output","def call(self, inputs):\n unpacked_inputs = tf_utils.unpack_inputs(inputs)\n word_embeddings = unpacked_inputs[0]\n token_type_ids = unpacked_inputs[1]\n input_shape = tf_utils.get_shape_list(word_embeddings, expected_rank=3)\n batch_size = input_shape[0]\n seq_length = input_shape[1]\n width = input_shape[2]\n\n output = word_embeddings\n if self.use_type_embeddings:\n flat_token_type_ids = tf.reshape(token_type_ids, [-1])\n token_type_embeddings = tf.gather(self.type_embeddings,\n flat_token_type_ids)\n token_type_embeddings = tf.reshape(token_type_embeddings,\n [batch_size, seq_length, width])\n output += token_type_embeddings\n\n if self.use_position_embeddings:\n position_embeddings = tf.expand_dims(\n tf.slice(self.position_embeddings, [0, 0], [seq_length, width]),\n axis=0)\n\n output += position_embeddings\n\n output = self.output_layer_norm(output)\n output = self.output_dropout(output)\n\n return output","def word2vec2embed(word2vec, word2idx):\n\temb_dim = word2vec['the'].shape[0]\n\temb = torch.nn.Embedding(len(word2idx), emb_dim) \n\temb_matrix = []\n\tfor w, idx in word2idx.items():\n\t\tif w in word2vec:\n\t\t\temb_matrix.append(word2vec[w])\n\t\telse:\n\t\t\temb_matrix.append(np.zeros(emb_dim,))\n\temb.weight.data.copy_(torch.from_numpy(np.array(emb_matrix)))\n\treturn emb","def create_embeddings(model_fc, ds, model_name, storage_path, storage_size=1000, parallel=True): \n\n # create folder when doesn't exist yet\n try:\n os.makedirs(storage_path)\n except OSError as e:\n if e.errno != errno.EEXIST:\n raise\n \n print(\"Let's use\", torch.cuda.device_count(), \"GPUs!\")\n feature_extractor = model_fc\n if parallel:\n feature_extractor = nn.DataParallel(model_fc)\n target_dataset = ds\n len_target_dataset = len(target_dataset)\n # save some memory\n\n feature_extractor.eval()\n \n with torch.no_grad():\n device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n print(f\"Moving model to {device}\")\n feature_extractor = feature_extractor.to(device)\n params = {'batch_size': 50,\n 'shuffle': False,\n 'num_workers': 6,\n 'pin_memory': False}\n\n print(f\"Length of dataset is {len_target_dataset}\")\n if (len_target_dataset >= storage_size):\n\n if len_target_dataset % storage_size != 0:\n until_i = (len_target_dataset // storage_size + 1)\n else:\n until_i = (len_target_dataset // storage_size)\n\n for i in range(until_i):\n\n \"\"\"Check if we overshot the entries\"\"\"\n if ((i+1)*storage_size <= len_target_dataset):\n t_dataset = torch.utils.data.Subset(target_dataset, range(i*storage_size, (i+1)*storage_size))\n else:\n remainder = len_target_dataset - i*storage_size\n print(f\"Calculating for remainder: {remainder} because we want to extract {(i+1)*storage_size}\")\n t_dataset = torch.utils.data.Subset(target_dataset, range(i*storage_size, (i*storage_size) + remainder))# use remainder\n\n training_generator = data.DataLoader(t_dataset, **params)\n\n features = torch.Tensor([]).to(device)\n labels = torch.LongTensor([]).to(device)\n\n for local_batch, local_labels in training_generator:\n local_batch = local_batch.to(device)\n local_labels = local_labels.to(device)\n output = feature_extractor(local_batch)\n features = torch.cat([features, output], dim=0)\n labels = torch.cat([labels, local_labels], dim=0)\n\n print(features.size())\n features = features.to(\"cpu\")\n labels = labels.to(\"cpu\")\n\n x = features.detach().numpy()\n y = labels.detach().numpy()\n\n np.savez_compressed(f'{storage_path}/{model_name}_{i}.npz', x=x, y=y)\n\n del features\n del labels\n del local_batch\n del local_labels\n torch.cuda.empty_cache()\n\n if (len_target_dataset < storage_size):\n training_generator = data.DataLoader(target_dataset, **params)\n features = torch.Tensor([]).to(device)\n labels = torch.LongTensor([]).to(device)\n\n for local_batch, local_labels in training_generator:\n local_batch = local_batch.to(device)\n local_labels = local_labels.to(device)\n output = feature_extractor(local_batch)\n features = torch.cat([features, output], dim=0)\n labels = torch.cat([labels, local_labels], dim=0)\n\n print(features.size())\n features = features.to(\"cpu\")\n labels = labels.to(\"cpu\")\n\n x = features.detach().numpy()\n y = labels.detach().numpy()\n\n np.savez_compressed(f'{storage_path}/{model_name}_0.npz', x=x, y=y)\n\n del features\n del labels\n del local_batch\n del local_labels\n torch.cuda.empty_cache()","def embedding_setup(self, embedding, emb_trainable):\n if emb_trainable == True:\n emb_variable = tf.get_variable(\n name=\"embedding_matrix\", shape=embedding.shape,\n initializer = tf.constant_initializer(embedding))\n return emb_variable\n else:\n return embedding","def modify_to_return_embeddings(net, model_name):\n if model_name in [\"vgg_face_dag\", \"vgg_m_face_bn_dag\"]:\n net.fc8 = torch.nn.Sequential()\n else:\n msg = \"{} not yet supported\".format(model_name)\n raise NotImplementedError(msg)\n return net","def target_embedding_fairseq(self):\r\n if self.params[\"embedding.share\"]:\r\n return self.source_embedding_fairseq()\r\n return tf.get_variable(\r\n name=\"W\",\r\n shape=[self.target_vocab_info.total_size, self.params[\"embedding.dim\"]],\r\n initializer=tf.random_normal_initializer(\r\n mean=0.0,\r\n stddev=0.1))","def setup_embeddings(self):\n with vs.variable_scope(\"embeddings\"):\n vec_embeddings = tf.get_variable(\"embeddings\", initializer=self.pretrained_embeddings, trainable=False)\n context_batch_embeddings = tf.nn.embedding_lookup(vec_embeddings, self.context_placeholder)\n question_batch_embeddings = tf.nn.embedding_lookup(vec_embeddings, self.question_placeholder)\n context_embeddings = tf.reshape(context_batch_embeddings,\n (-1, self.max_context_len, self.vocab_dim))\n question_embeddings = tf.reshape(question_batch_embeddings,\n (-1, self.max_question_len, self.vocab_dim))\n return context_embeddings, question_embeddings","def testEmbeddings(self):\n input_data = {\n \"x\":\n constant_op.constant(\n np.array(np.random.random_sample((20)), dtype=np.int32))\n }\n\n class EmbeddingModel(keras.Model):\n\n def __init__(self):\n super(EmbeddingModel, self).__init__()\n self.shared_weights = self.add_weight(\n \"weights\",\n shape=(2000, 300),\n dtype=dtypes.float32,\n initializer=init_ops.random_normal_initializer(\n mean=0.0, stddev=300**(-0.5)))\n\n @def_function.function(input_signature=[\n tensor_spec.TensorSpec(shape=(20), dtype=dtypes.int32)\n ])\n def func(self, x):\n return array_ops.gather(self.shared_weights, x)\n\n model = EmbeddingModel()\n root, output_func = self._freezeModel(model.func)\n self._testConvertedFunction(root, root.f, output_func, input_data)","def output_layer(self, features):\n if self.adaptive_softmax is None:\n # project back to size of vocabulary\n if self.share_input_output_embed:\n return F.linear(features, self.embed_tokens.map_layer.weight)\n else:\n return self.embed_out(features)\n else:\n return features","def _get_appdesc_embeddings(self, features, training):\n # Using GloVe, embed each token then aggregate them.\n appdesc_embeddings = self._word_embedding_layer(\n features['appdesc_token_id'])\n appdesc_embeddings = self._aggregate_text_embedding(\n features['appdesc_token_id'], appdesc_embeddings)\n\n if training:\n appdesc_embeddings = tf.nn.dropout(\n appdesc_embeddings, rate=self._hparams['dropout'])\n\n return appdesc_embeddings","def source_embedding_fairseq(self):\r\n return tf.get_variable(\r\n name=\"W\",\r\n shape=[self.params[\"feature.dim\"], self.params[\"embedding.dim\"]],\r\n initializer=tf.random_normal_initializer(\r\n mean=0.0,\r\n stddev=0.1))","def _add_embedding_layer(model_1, model_2):\n result_layer = torch.nn.Embedding(\n model_1.num_embeddings, model_1.embedding_dim + model_2.embedding_dim\n )\n result_layer.weight = torch.nn.Parameter(\n torch.cat((model_1.weight.data, model_2.weight.data), dim=1)\n )\n return result_layer","def get_embedding(self, model):\n embedding = []\n for node in range(len(self.graph.nodes())):\n embedding.append(list(model[str(node)]))\n embedding = np.array(embedding)\n return embedding","def get_word_embedding(counter, emb_file, emb_size, vocab_size, vec_size, vocab_file):\n print(\"Generating word embedding...\")\n # load word embeddings\n embedding_dict = {}\n with open(emb_file, \"r\", encoding=\"utf-8\") as fh:\n for line in tqdm(fh, total=emb_size):\n array = line.split()\n word = \"\".join(array[0:-vec_size])\n vector = list(map(float, array[-vec_size:]))\n embedding_dict[word] = vector\n\n TRANSLATE = {\n \"-lsb-\": \"[\", \"-rsb-\": \"]\", \"-lrb-\": \"(\", \"-rrb-\": \")\", \"-lcb-\": \"{\",\n \"-rcb-\": \"}\", \"-LSB-\": \"[\", \"-RSB-\": \"]\", \"-LRB-\": \"(\", \"-RRB-\": \")\",\n \"-LCB-\": \"{\", \"-RCB-\": \"}\"\n }\n SPECIAL_TOKENS = [\"<NULL>\", \"<UNK>\", \"<S>\", \"</S>\"]\n words = list(map(lambda x: x[0], sorted(counter.items(), key=lambda x: x[1], reverse=True)))\n words = SPECIAL_TOKENS + words\n if vocab_size > 0:\n words = words[:vocab_size]\n with open(vocab_file, 'w') as f:\n f.write('\\n'.join(words[1:]))\n embedding = np.random.normal(scale=0.1, size=(len(words), vec_size))\n word2idx_dict = {}\n unknown_count = 0\n for i, word in enumerate(words):\n word2idx_dict[word] = i\n if word in TRANSLATE:\n word = TRANSLATE[word]\n done = False\n for w in (word, word.lower(), word.upper(), word.capitalize()):\n if w in embedding_dict:\n embedding[i] = embedding_dict[w]\n done = True\n break\n if not done:\n unknown_count += 1\n return embedding, word2idx_dict, unknown_count","def get_embeddings() -> tuple:\n # Initialize the model loading Universal Sentense Encoder\n # into a KerasLayer from Kaggle dataset file\n model = tf.keras.Sequential(\n [KerasLayer(encoder_path, input_shape=[], dtype=tf.string,\n output_shape=[512], trainable=False),\n # tf.keras.layers.Layer(512, dtype=tf.float16) # To reduce memory footprint\n ]\n )\n\n train_emb = model.predict(data_train['text'])\n print('Train texts converted into embeddings. Shape:', train_emb.shape)\n\n test_emb = model.predict(data_test['text'])\n print('Test texts converted into embeddings. Shape:', test_emb.shape)\n\n return train_emb, test_emb","def _create_tf_embed_fnn(\n self,\n x_in: \"tf.Tensor\",\n layer_sizes: List[int],\n fnn_name: Text,\n embed_name: Text,\n ) -> \"tf.Tensor\":\n\n x = train_utils.create_tf_fnn(\n x_in,\n layer_sizes,\n self.droprate,\n self.C2,\n self._is_training,\n layer_name_suffix=fnn_name,\n )\n return train_utils.create_tf_embed(\n x,\n self.embed_dim,\n self.C2,\n self.similarity_type,\n layer_name_suffix=embed_name,\n )","def get_embedding(num_embeddings, embedding_dim, padding_idx=None):\n half_dim = embedding_dim // 2\n emb = math.log(10000) / (half_dim - 1)\n emb = torch.exp(torch.arange(half_dim, dtype=torch.float) * -emb)\n emb = torch.arange(num_embeddings, dtype=torch.float).unsqueeze(1) * emb.unsqueeze(0)\n emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=1).view(num_embeddings, -1)\n if embedding_dim % 2 == 1:\n emb = torch.cat([emb, torch.zeros(num_embeddings, 1)], dim=1)\n if padding_idx is not None:\n emb[padding_idx, :] = 0\n return emb","def create_embedding_matrix(self):\n self.id2word = dict([(self.vocab[word]['id'], word) for word in self.vocab])\n vocab_size = len(self.vocab)\n result = np.zeros((vocab_size, self.embed_dim))\n unknown_token_set = set()\n\n found_words = 0\n avg = np.zeros(self.embed_dim)\n for _ in range(1, vocab_size): # skip PAD embedding (initialize as zero embedding)\n try:\n result[_] = self.pretrained_embedding[self.id2word[_]]\n avg += result[_]\n found_words += 1\n except:\n unknown_token_set.add(_)\n\n avg /= found_words\n for _ in unknown_token_set:\n result[_] = avg\n self.embedding = result\n return found_words, len(self.id2word)","def concept_embedding(concept_model: ConceptDetectionModel2D):\n return concept_model.to_embedding()","def _get_embedding(self, data):\n embedding_list = [super()._get_embedding(data)]\n context = data['context']\n for i in range(context.shape[1]):\n embedding_list.append(getattr(self, f'context{i}')(context[:, i:i+1]))\n return torch.cat(embedding_list, dim=1)","def create_embedding_from_name(self, name: str):\n assert self.name_field is not None\n kwargs = dict(self.default_args)\n kwargs.pop(self.name_field)\n return self.embedding_cls(name, **kwargs) # type: ignore[call-arg]","def embedding_model(\n n_factors: int = 50,\n window: int = 5,\n min_count: int = 1,\n learning_rate: float = 0.05,\n negative_samples: int = 10,\n negative_exponent: float = 0.75,\n workers: int = 4,\n n_iterations: int = 10,\n batch_size: int = 10000,\n skip_gram: int = 0,\n) -> Word2Vec:\n logger.info(\"Defining Embedding Neural Network model.\")\n model = Word2Vec(\n vector_size=n_factors,\n window=window,\n min_count=min_count,\n alpha=learning_rate,\n negative=negative_samples,\n ns_exponent=negative_exponent,\n workers=workers,\n epochs=n_iterations,\n batch_words=batch_size,\n sg=skip_gram,\n compute_loss=True,\n )\n return model","def _generate_relative_positions_embeddings(length, depth, max_relative_position, name):\n with tf.variable_scope(name):\n relative_positions_matrix = _generate_relative_positions_matrix(\n length, max_relative_position)\n vocab_size = max_relative_position * 2 + 1\n embeddings_table = tf.get_variable(\"embeddings\", [vocab_size, depth])\n embeddings = tf.gather(embeddings_table, relative_positions_matrix)\n return embeddings","def build_model(max_movie_id, max_user_id):\n # the number of dimensions our low dimensional embeddings should have\n dims_of_embedding = 35\n bias = 1\n \n # inputs\n # define an input layer: set the datatype and the the shape of the tensors it takes, the true shape would be (number_of_movies, 1) but number_of_movies is the batch size, and keras ignores the first dimensions (batch_size), so we give a shape (1,)\n movie_inputs = Input(shape=(1,), dtype='int32')\n \n # define an embedding layer with input dimension (max_movie_id+1) and output dimension (dims_of_embedding). This layer takes a positive integer index (movie id) and outputs a tensor of shape (None, 1,dims_of_embedding), where None is the batch dimension. So this actually where the low-dimensional embedding of movies happens\n movie_embedding = Embedding(max_movie_id+1, dims_of_embedding, name=\"movie\")(movie_inputs)\n movie_bis = Embedding(max_movie_id + 1, bias, name=\"moviebias\")(movie_inputs)\n\n # define analogous layers for the users\n user_inputs = Input(shape=(1,), dtype='int32')\n user_embedding = Embedding(max_user_id+1, dims_of_embedding, name=\"user\")(user_inputs)\n user_bis = Embedding(max_user_id + 1, bias, name=\"userbias\")(user_inputs)\n \n # the following layers together basically calculate the dot product of user and movie embedding vectors to predict the corresponding rating\n # the multiply layer multiplies (element-wise) a list of input tensors (all of same shape) and returns a single tensor of the same shape\n output = multiply([movie_embedding, user_embedding])\n # a Dropout layer applies Dropout to the input, which means setting a fraction rate (=0.5) of input units to 0 at each update during training. This helps preventing overfitting.\n output = Dropout(0.5)(output)\n # a Concatente layer concatenates a list of input tensors into a single tensor\n output = concatenate([output, user_bis, movie_bis])\n # a Flatten layer flattens the input\n output = Flatten()(output)\n # just regular densely, connected NN layers, where can define the number of units in the layer (e.g. 10), and the activation function of the units (e.g. 'relu')\n output = Dense(10, activation=\"relu\")(output)\n output = Dense(1)(output)\n\n # define a model with its input(s) and output(s)\n model = Model(inputs=[movie_inputs, user_inputs], outputs=output)\n # prepare the model for training, choose loss, optimizers and potentially metrics\n model.compile(loss='mae', optimizer='adam', metrics=[rmse])\n\n return model","def input_dim(use_word_emb, embedding_dim, word_emb_enc_dim):\n return embedding_dim + use_word_emb * word_emb_enc_dim","def make_embedding(path, words, indices):\n #root = '/'.join(path.split('/')[0:-1])\n #all_paths = [root+'/'+x for x in os.listdir(root)] #'/'.join(path.split('/')[0:-1]))\n #for path in all_paths:\n vec_path = 'data/'+path.split('/')[-1]+'_'+mode\n print(vec_path)\n if os.path.exists(vec_path+'.npy'):\n np_vecs = np.load(vec_path+'.npy')\n else:\n words_len = len(words)\n vecs = []\n if mode == 'word':\n f = load_model('wiki.en.bin')\n for i, w in enumerate(words):\n if mode == 'word':\n vec = f.get_word_vector(w)\n else:\n vec = eye[indices[w]]\n vecs.append(vec) \n if i % 10000 == 0:\n print(\"{} / {}\".format(i, words_len))\n np_vecs = np.asarray(vecs, dtype=np.int8)\n np.save(vec_path, np_vecs)\n return np_vecs","def __init__(self, vocab, embed_size=512, dropout_rate=0.1, max_len=200):\n super(DecoderEmbeddings, self).__init__()\n pad_token_idx = 0 #vocab.tokenizer.ids_to_tokens[0]\n assert vocab.tokenizer.ids_to_tokens[0] == '[PAD]'\n self.embeddings = nn.Embedding(len(vocab.tokenizer.ids_to_tokens), embed_size, padding_idx=pad_token_idx)\n self.positional_encoding = PositionalEncoding(d_model=embed_size, dropout=dropout_rate, max_len=max_len)","def glove_embedding(self, word_index, padded, embedding_matrix, part='q'):\n print(\"*\" * 50, \"Start Glove embedding process\", \"*\" * 50)\n start_time = time()\n\n\n MAX_SEQ_LEN = None\n if part == 'q':\n MAX_SEQ_LEN = self.MAX_Q_SEQ_LEN\n elif part == 'a':\n MAX_SEQ_LEN = self.MAX_A_SEQ_LEN\n else:\n print(f\"Please indicate you want embedding question part or answer part\")\n\n\n input_layer = Input(shape=(MAX_SEQ_LEN,), dtype='int32')\n embedding_layer = Embedding(input_dim = len(word_index) + 1,\n output_dim = self.EMBEDDING_DIM,\n weights=[embedding_matrix],\n input_length=MAX_SEQ_LEN,\n trainable=False)(input_layer)\n # (number of sample, MAX_SEQ_LEN, EMBEDING_DIM)\n model = Model(inputs=input_layer, outputs=embedding_layer)\n model.compile('rmsprop', 'mse')\n output_array = model.predict(padded)\n\n cost_time = round((time() - start_time), 4)\n print(\"*\" * 40, \"End Glove embedding() with {} seconds\".format(cost_time), \"*\" * 40, end='\\n\\n')\n\n return output_array, embedding_layer","def add_positional_embedding_nd(x, max_length, name=None):\n with tf.name_scope(\"add_positional_embedding_nd\"):\n x_shape = x.shape.as_list()\n num_dims = len(x_shape) - 2\n depth = x_shape[-1]\n base_shape = [1] * (num_dims + 1) + [depth]\n base_start = [0] * (num_dims + 2)\n base_size = [-1] + [1] * num_dims + [depth]\n for i in range(num_dims):\n shape = base_shape[:]\n start = base_start[:]\n size = base_size[:]\n shape[i + 1] = max_length\n size[i + 1] = x_shape[i + 1]\n var = tf.get_variable(\n name + \"_%d\" % i,\n shape,\n initializer=tf.random_normal_initializer(0, depth ** -0.5))\n var = var * depth ** 0.5\n x += tf.slice(var, start, size)\n return x","def __init__(self,\n vocab_size,\n embed_dim,\n dropout,\n pretrained,\n embedding=None,\n num_gpus=1,\n default_gpu_id=0,\n regularizer=None,\n random_seed=0,\n trainable=True,\n scope=\"word_feat\"):\n self.vocab_size = vocab_size\n self.embed_dim = embed_dim\n self.dropout = dropout\n self.pretrained = pretrained\n self.embedding = embedding\n self.num_gpus = num_gpus\n self.default_gpu_id = default_gpu_id\n self.regularizer = regularizer\n self.random_seed = random_seed\n self.trainable = trainable\n self.scope = scope\n \n with tf.variable_scope(self.scope, reuse=tf.AUTO_REUSE):\n self.embedding_layer = create_embedding_layer(self.vocab_size, self.embed_dim, self.pretrained,\n self.embedding, self.num_gpus, self.default_gpu_id, None, self.random_seed, self.trainable)\n \n self.dropout_layer = create_dropout_layer(self.dropout, self.num_gpus, self.default_gpu_id, self.random_seed)","def get_embeddings_shape(self):\n raise NotImplementedError","def load_embed_text(embed_file):\n \n emb_dict = dict()\n emb_size = None\n with codecs.getreader(\"utf-8\")(tf.gfile.GFile(embed_file, \"rb\")) as f:\n for line in f:\n tokens = line.strip().split(\" \")\n word = tokens[0]\n vec = list(map(float, tokens[1:]))\n emb_dict[word] = vec\n if emb_size:\n assert emb_size == len(vec), \"All embeddings should be same size\"\n else:\n emb_size = len(vec)\n return emb_dict, emb_size","def model(input_shape, model,model2,model3, word_to_index):\n \n ### START CODE HERE ###\n # Define sentence_indices as the input of the graph.\n # It should be of shape input_shape and dtype 'int32' (as it contains indices, which are integers).\n sentence_indices = Input(input_shape,dtype='int32')\n \n # Create the embedding layer pretrained with GloVe Vectors (≈1 line)\n embedding_layer, ignored_words = pretrained_embedding_layer(model,model2,model3,word_to_index,300)\n \n # Propagate sentence_indices through your embedding layer\n # (See additional hints in the instructions).\n embeddings = embedding_layer(sentence_indices)\n \n # Propagate the embeddings through an LSTM layer with 128-dimensional hidden state\n # The returned output should be a batch of sequences.\n X = LSTM(units=128,input_shape=input_shape,return_sequences=True)(embeddings)\n # Add dropout with a probability of 0.5\n X = Dropout(rate=0.5)(X)\n # Propagate X trough another LSTM layer with 128-dimensional hidden state\n # The returned output should be a single hidden state, not a batch of sequences.\n X = LSTM(units=128,input_shape=input_shape,return_sequences=False)(X)\n # Add dropout with a probability of 0.5\n X = Dropout(rate=0.5)(X)\n # Propagate X through a Dense layer with 5 units\n X = Dense(units=num_classes)(X)\n# X = Dense(6, activation='softmax')\n # Add a softmax activation\n# print(X)\n# print(type(X))\n# print(X.shape)\n# print(sum(X))\n X = Activation('softmax')(X)\n \n # Create Model instance which converts sentence_indices into X.\n model = Model(inputs=sentence_indices,outputs=X)\n \n return model","def create_emb_for_encoder_and_decoder(vocab_size,\n embed_size,\n dtype=tf.float32,\n num_partitions=0,\n scope=None):\n\n if num_partitions <= 1:\n partitioner = None\n else:\n # Note: num_partitions > 1 is required for distributed training due to\n # embedding_lookup tries to colocate single partition-ed embedding variable\n # with lookup ops. This may cause embedding variables being placed on worker\n # jobs.\n partitioner = tf.fixed_size_partitioner(num_partitions)\n\n with tf.variable_scope(\n scope or \"embeddings\", dtype=dtype, partitioner=partitioner) as scope:\n # Share embedding\n embedding_encoder = tf.get_variable(\"shared_embedding\",\n [vocab_size, embed_size], dtype)\n embedding_decoder = embedding_encoder\n\n return embedding_encoder, embedding_decoder","def build_model(vocab_size, embedding_dim, rnn_units, batch_size):\n model=tf.keras.Sequential([\n \n tf.keras.layers.Embedding(vocab_size, embedding_dim, batch_input_shape=[batch_size, None]),\n rnn(rnn_units, return_sequences=True, recurrent_initializer='glorot_uniform', stateful=True),\n tf.keras.layers.Dense(vocab_size)\n \n ])\n \n return model"],"string":"[\n \"def build_embedding_layer(inputs_, vocab_size, embed_size):\\n embedding = tf.Variable(tf.random_uniform((vocab_size, embed_size), -1, 1))\\n embed = tf.nn.embedding_lookup(embedding, inputs_)\\n \\n return embed\",\n \"def embed_features(batch, f_size):\\n for f in range(Config.num_feature):\\n feature_val = batch[:, f]\\n num_cat_value = Config.schema[f]\\n\\n if f == 0:\\n if num_cat_value == 1:\\n vector = tf.reshape(feature_val, [-1, 1])\\n else:\\n vector = tf.nn.embedding_lookup(embed_dict[f], tf.cast(\\n feature_val, tf.int32))\\n else:\\n if num_cat_value == 1:\\n vector = tf.concat(1, [vector, tf.reshape(feature_val,\\n [-1, 1])])\\n else:\\n vector = tf.concat(1, [vector, tf.nn.embedding_lookup(\\n embed_dict[f], tf.cast(feature_val, tf.int32))])\\n\\n result = tf.reshape(vector, [-1, 1, f_size])\\n\\n return result\",\n \"def _get_embedding_layer(self, input_data, doc_input_data):\\n opts = self._options\\n word_embedding = tf.Variable(tf.random_uniform((self.vocab_size, opts.embed_dim), -1.0, 1.0))\\n embed = []\\n\\n temp = tf.zeros([opts.batch_size, opts.embed_dim])\\n embed_d = []\\n for n in range(opts.sentence_sample):\\n temp = tf.add(temp, tf.nn.embedding_lookup(word_embedding, doc_input_data[:, n]))\\n embed_d.append(temp)\\n\\n if opts.concat == 'True':\\n combined_embed_vector_length = opts.embed_dim * opts.window_size + opts.embed_dim\\n for j in range(opts.window_size):\\n embed_w = tf.nn.embedding_lookup(word_embedding, input_data[:, j])\\n embed.append(embed_w)\\n embed.append(embed_d)\\n else:\\n combined_embed_vector_length = opts.embed_dim\\n embed_w = tf.zeros([opts.batch_size, opts.embed_dim])\\n for j in range(opts.window_size):\\n embed_w += tf.nn.embedding_lookup(word_embedding, input_data[:, j])\\n embed_w += embed_d\\n embed.append(embed_w)\\n\\n return tf.concat(embed, 1), word_embedding, combined_embed_vector_length\",\n \"def get_embed(input_data, vocab_size, embed_dim):\\n embedding = tf.Variable(tf.random_uniform((vocab_size,embed_dim), -1, 1))\\n embed = tf.nn.embedding_lookup(embedding, input_data)\\n #print (\\\"embed_dim: \\\",embed_dim) # 向量表达维度为 256\\n #print (\\\"input_data.shape: \\\",input_data.shape) # (50, 5)\\n #print (\\\"embed.shap: \\\", embed.shape) # word 的向量表达 ==特征 (50, 5, 256) ==(batch_size, num_step, embed_dim)\\n return embed # 返回input的向量表达\",\n \"def get_embed(input_data, vocab_size, embed_dim):\\n embedding = tf.Variable(tf.random_uniform((vocab_size, embed_dim), -1, 1))\\n embed = tf.nn.embedding_lookup(embedding, input_data)\\n\\n return embed\",\n \"def add_embedding(self):\\n ### YOUR CODE HERE (~4-6 lines)\\n embeddingTensor = tf.Variable(self.pretrained_embeddings)\\n embeddings = tf.nn.embedding_lookup(embeddingTensor, self.input_placeholder)\\n embeddings = tf.reshape(embeddings, [-1, self.max_length, Config.n_features * Config.embed_size])\\n ### END YOUR CODE\\n return embeddings\",\n \"def model(mtf_features, other_features, params, mesh, variable_dtype, context=None):\\n\\n x, batch_dim, sequence_dim, embd_dim, vocab_dim, embed_sequence_dim = parse_inputs(mtf_features, other_features)\\n\\n if is_incremental_inference(context):\\n # reshape inputs if in inference mode\\n x = mtf.gather(x, context.position - 1, sequence_dim)\\n x = mtf.reshape(x, [batch_dim])\\n\\n use_axial_pos_emb = params[\\\"axial_pos_emb\\\"] is not None\\n\\n if not use_axial_pos_emb:\\n # Use standard position encoding\\n wpe = mtf.get_variable(mesh, \\\"wpe\\\", mtf.Shape([embed_sequence_dim, embd_dim]),\\n initializer=tf.random_normal_initializer(stddev=0.01),\\n master_dtype=variable_dtype.master_dtype,\\n slice_dtype=variable_dtype.slice_dtype,\\n activation_dtype=variable_dtype.activation_dtype)\\n else:\\n wpe = axial_positional_emb(embd_dim, mesh, params, variable_dtype)\\n\\n # Text encoding\\n wte = mtf.get_variable(mesh, \\\"wte\\\", mtf.Shape([vocab_dim, embd_dim]),\\n initializer=tf.random_normal_initializer(stddev=0.02),\\n master_dtype=variable_dtype.master_dtype,\\n slice_dtype=variable_dtype.slice_dtype,\\n activation_dtype=variable_dtype.activation_dtype)\\n\\n with tf.variable_scope(\\\"token_embd\\\"):\\n # Text embedding\\n h = mtf.gather(wte, x, vocab_dim)\\n if params[\\\"embed_dropout\\\"] > 0 and params[\\\"mode\\\"] == \\\"train\\\":\\n h = mtf.dropout(h, rate=params[\\\"embed_dropout\\\"], name=\\\"wte_dropout\\\")\\n\\n with tf.variable_scope(\\\"pos_embd\\\"):\\n # Positional embedding\\n position_indices = mtf.range(mesh, sequence_dim, tf.int64) if not is_incremental_inference(context) else (\\n context.position - 1)\\n pos_emb = mtf.gather(wpe, position_indices, wpe.shape[0])\\n if params[\\\"embed_dropout\\\"] > 0 and params[\\\"mode\\\"] == \\\"train\\\":\\n pos_emb = mtf.dropout(pos_emb, rate=params[\\\"embed_dropout\\\"], name=\\\"wte_dropout\\\")\\n h += pos_emb\\n\\n aux_losses = 0 # instantiate auxiliary losses (for MOE models)\\n\\n for layer in range(params[\\\"n_layer\\\"]):\\n # attn blocks\\n share_parameters = exists(params[\\\"share_parameters\\\"]) and params[\\\"share_parameters\\\"] == True\\n block_scope = f\\\"h{layer}\\\" if not share_parameters else \\\"\\\"\\n\\n block_fn = block(params=params, scope=block_scope, layer_num=layer,\\n bias=other_features[\\\"attn_bias\\\"],\\n sequence_dim=sequence_dim,\\n memory_length_dim=other_features[\\\"memory_length_dim\\\"],\\n variable_dtype=variable_dtype,\\n context=context)\\n\\n # If true and in train mode, enable gradient checkpointing\\n recompute_grad = params[\\\"recompute_grad\\\"] and (params[\\\"mode\\\"] == \\\"train\\\") == True\\n h, loss = block_fn(h) if not recompute_grad else mtf.recompute_grad(block_fn, [h])\\n aux_losses += loss\\n\\n no_weight_tie_emb = params[\\\"no_weight_tie\\\"] == True\\n if no_weight_tie_emb:\\n with tf.variable_scope(\\\"wte_final_linear\\\"):\\n logits = linear(h, \\\"linear_out\\\", vocab_dim, variable_dtype=variable_dtype, params=params)\\n else:\\n # Layer normalize & affine transform\\n h = layer_norm(h, \\\"ln_f\\\", variable_dtype=variable_dtype)\\n seq_dim = sequence_dim if not is_incremental_inference(context) else mtf.Dimension(\\\"sequence\\\", 1)\\n with tf.variable_scope(\\\"wte_final_einsum\\\"):\\n # Equivalent to tf.matmul\\n logits = mtf.einsum([h, wte], output_shape=[batch_dim, seq_dim, vocab_dim])\\n\\n if params[\\\"mode\\\"] in [\\\"train\\\", \\\"eval\\\"]:\\n labels = mtf_features[\\\"labels\\\"]\\n z_loss = params.get(\\\"z_loss\\\", 1e-4) # an auxiliary loss used to stabilize mtf xentropy\\n\\n # Go to full precision for the logits \\n logits = mtf.cast(logits, tf.float32)\\n\\n with tf.variable_scope(\\\"xentropy_final\\\"):\\n loss_batch = mtf.layers.softmax_cross_entropy_with_logits(logits=logits, targets=labels,\\n vocab_dim=logits.shape[-1], z_loss=z_loss)\\n\\n # For non-autoregressive models (masked language modeling training)\\n # Make sure labels with padding tokens are not counted in the loss\\n if not params[\\\"causal\\\"]:\\n padding_id = params.get(\\\"padding_id\\\", 0)\\n loss_batch = mtf.where(mtf.not_equal(labels, padding_id), loss_batch, mtf.zeros_like(loss_batch))\\n\\n with tf.variable_scope(\\\"reduce_mean_final\\\"):\\n loss = mtf.reduce_mean(loss_batch)\\n\\n loss += aux_losses # Add on auxiliary losses (currently only used for MoE)\\n loss /= params[\\\"num_microbatches\\\"]\\n # Convert to train dtype\\n loss = mtf.cast(loss, variable_dtype.slice_dtype)\\n else:\\n loss = None\\n loss_batch = None\\n\\n # Cast back to checkpoint dtype\\n logits = mtf.cast(logits, variable_dtype.master_dtype)\\n return logits, loss, loss_batch\",\n \"def pretrained_embedding_layer(word_to_vec_map, word_to_index):\\n \\n vocab_size = len(word_to_index) + 1 # adding 1 to fit Keras embedding (requirement)\\n any_word = list(word_to_vec_map.keys())[0]\\n emb_dim = word_to_vec_map[any_word].shape[0] # define dimensionality of your GloVe word vectors (= 50)\\n \\n ### START CODE HERE ###\\n # Step 1\\n # Initialize the embedding matrix as a numpy array of zeros.\\n # See instructions above to choose the correct shape.\\n emb_matrix = np.zeros((vocab_size, emb_dim))\\n \\n # Step 2\\n # Set each row \\\"idx\\\" of the embedding matrix to be \\n # the word vector representation of the idx'th word of the vocabulary\\n for word, idx in word_to_index.items():\\n emb_matrix[idx, :] = word_to_vec_map[word]\\n\\n # Step 3\\n # Define Keras embedding layer with the correct input and output sizes\\n # Make it non-trainable.\\n embedding_layer = tensorflow.keras.layers.Embedding(input_dim = vocab_size, output_dim = emb_dim, trainable = False)\\n ### END CODE HERE ###\\n\\n # Step 4 (already done for you; please do not modify)\\n # Build the embedding layer, it is required before setting the weights of the embedding layer. \\n embedding_layer.build((None,)) # Do not modify the \\\"None\\\". This line of code is complete as-is.\\n \\n # Set the weights of the embedding layer to the embedding matrix. Your layer is now pretrained.\\n embedding_layer.set_weights([emb_matrix])\\n \\n return embedding_layer\",\n \"def embedding_layer(self):\\n with tf.name_scope(\\\"Embedding_Layer\\\"):\\n V_size = len(self.vocab)\\n embed_dim = len(self.embed[0]) \\n W_embed_ = tf.get_variable(\\\"W_embed\\\",shape=[V_size, embed_dim],trainable=False).assign(np.asarray(self.embed))\\n W_analogy_embed_ = tf.get_variable(\\\"W_analogy_embed\\\",shape=[V_size, embed_dim],trainable=True,initializer=tf.random_uniform_initializer(minval=-1,maxval=1))\\n return W_embed_, W_analogy_embed_\",\n \"def get_embed(input_data, vocab_size, embed_dim):\\n # todo 需要编程：\\n # 1、构建嵌入矩阵的查找表\\n lookup_w = tf.Variable(\\n initial_value=tf.random_uniform([vocab_size, embed_dim], -1.0, 1.0)\\n )\\n # 2、获得嵌入输出\\n embed = tf.nn.embedding_lookup(params=lookup_w, ids=input_data)\\n # [N, n_steps, embed_size]\\n return embed\",\n \"def embedding(x, vocab_size, dense_size, name=None, reuse=None, multiplier=1.0):\\n with tf.variable_scope(\\n name, default_name=\\\"embedding\\\", values=[x], reuse=reuse):\\n embedding_var = tf.get_variable(\\\"kernel\\\", [vocab_size, dense_size])\\n emb_x = tf.gather(embedding_var, x)\\n if multiplier != 1.0:\\n emb_x *= multiplier\\n return emb_x\",\n \"def TransformerTokenEmbedding(\\n num_embeddings, embedding_dim, padding_idx, freeze_embed=False\\n):\\n m = nn.Embedding(num_embeddings, embedding_dim, padding_idx=padding_idx)\\n nn.init.normal_(m.weight, mean=0, std=embedding_dim ** -0.5)\\n nn.init.constant_(m.weight[padding_idx], 0)\\n if freeze_embed:\\n m.weight.requires_grad = False\\n return m\",\n \"def build_model(allidx,MAX_LENGTH,onlyArg):\\n wordidx, labelidx, featuresidx, extraidx=allidx\\n posidx, neridx, depidx, distanceidx, chnkidx, wikineridx, dbpedianeridx, subneridx = featuresidx\\n\\n main_input = Input(shape=(MAX_LENGTH,), name='main_input', dtype='int32')\\n inputNodes=[main_input]\\n\\n w2vmodel=\\\"../embeddings/Domain-Word2vec.model\\\"\\n\\n embedding_matrix,EMBEDDING_DIM,vocabulary_size=prepare.wv_embedded(wordidx,w2vmodel)\\n \\n x = Embedding(output_dim=EMBEDDING_DIM, weights=[embedding_matrix],input_dim=vocabulary_size, input_length=MAX_LENGTH, mask_zero=False)(main_input)\\n numnode=int(EMBEDDING_DIM/2)\\n\\n # pos embedding\\n inputNodes,pos_layer=layers.embedlayer(inputNodes,\\\"pos_input\\\",posidx,MAX_LENGTH)\\n x=Concatenate()([x,pos_layer])\\n numnode+=int(len(posidx)/2)\\n\\n # ner embedding\\n inputNodes,ner_layer=layers.embedlayer(inputNodes,\\\"ner_input\\\",neridx,MAX_LENGTH)\\n x=Concatenate()([x,ner_layer])\\n numnode+=int(len(neridx)/2)\\n\\n inputNodes,wikiner_layer=layers.embedlayer(inputNodes,\\\"wikiner_input\\\",wikineridx,MAX_LENGTH)\\n x=Concatenate()([x,wikiner_layer])\\n numnode+=int(len(wikineridx)/2)\\n\\n inputNodes,dbpedianer_layer=layers.embedlayer(inputNodes,\\\"dbpedianer_input\\\",dbpedianeridx,MAX_LENGTH)\\n x=Concatenate()([x,dbpedianer_layer])\\n numnode+=int(len(dbpedianeridx)/2)\\n\\n # dep embedding\\n inputNodes,dep0_layer=layers.embedlayer(inputNodes,\\\"dep0_input\\\",depidx,MAX_LENGTH)\\n x=Concatenate()([x,dep0_layer])\\n numnode+=int(len(depidx)/2)\\n\\n inputNodes,dep1_layer=layers.embedlayer(inputNodes,\\\"dep1_input\\\",depidx,MAX_LENGTH)\\n x=Concatenate()([x,dep1_layer])\\n numnode+=int(len(depidx)/2)\\n\\n inputNodes,dep2_layer=layers.embedlayer(inputNodes,\\\"dep2_input\\\",depidx,MAX_LENGTH)\\n x=Concatenate()([x,dep2_layer])\\n numnode+=int(len(depidx)/2)\\n\\n # chnk embedding\\n inputNodes,lvl_layer=layers.embedlayer(inputNodes,\\\"lvl_input\\\",distanceidx,MAX_LENGTH)\\n x=Concatenate()([x,lvl_layer])\\n numnode+=int(len(distanceidx)/2)\\n\\n inputNodes,chnk_layer=layers.embedlayer(inputNodes,\\\"chnk_input\\\",chnkidx,MAX_LENGTH)\\n x=Concatenate()([x,chnk_layer])\\n numnode+=int(len(chnkidx)/2)\\n\\n # wikiclass embedding\\n inputNodes,subner_layer=layers.embedlayer(inputNodes,\\\"subner_input\\\",subneridx,MAX_LENGTH)\\n x=Concatenate()([x,subner_layer])\\n numnode+=int(len(subneridx)/2)\\n\\n if onlyArg:\\n neartrigger_input = Input(shape=(MAX_LENGTH,), name='neartrigger_input', dtype='int32')\\n inputNodes.append(neartrigger_input)\\n neartrigger_layer = Embedding(output_dim=EMBEDDING_DIM, weights=[embedding_matrix],input_dim=vocabulary_size, \\\\\\n input_length=MAX_LENGTH, mask_zero=False)(neartrigger_input)\\n x=Concatenate()([x,neartrigger_layer])\\n numnode+=50\\n inputNodes,x,numnode=layers.extralayer(inputNodes,x,numnode,extraidx,featuresidx,MAX_LENGTH)\\n\\n lstm_out = Bidirectional(LSTM(numnode, dropout=0.2,return_sequences=True))(x)\\n numnode=int((numnode+len(labelidx))*2/3)\\n\\n if onlyArg:\\n lstm_out = SeqSelfAttention(attention_activation='tanh', attention_width=5)(lstm_out)\\n\\n lstm_out = Dropout(0.2)(lstm_out)\\n out = Dense(numnode)(lstm_out)\\n\\n crf = CRF(len(labelidx), sparse_target=False) # CRF layer\\n main_output=crf(out)\\n loss=crf_loss #crf.loss_function\\n acc=[crf_accuracy]\\n\\n model = Model(inputs=inputNodes, outputs=main_output) \\n model.compile(loss=loss,optimizer=Adam(0.001),metrics=acc)\\n model.summary()\\n\\n return model\",\n \"def pretrained_embedding_layer(model,model2,model3, word_to_index,emb_dim_max):\\n words_ignored = []\\n vocab_len = len(word_to_index) + 1 \\n emb_matrix = np.zeros([vocab_len,emb_dim_max])\\n \\n print(' Total words would be processed : '+str(vocab_len))\\n for word, idx in word_to_index.items():\\n if word in model:\\n emb_matrix[idx,:200] = model[word]\\n emb_matrix[idx,200:] = 0\\n if word in model2:\\n emb_matrix[idx, :100] = model2[word]\\n emb_matrix[idx, 100:] = 0\\n if word in model3.keys():\\n emb_matrix[idx,:] = model3[word]\\n else:\\n words_ignored.append(word)\\n print(str(len(words_ignored))+\\\" words ignored\\\")\\n print(emb_matrix.shape) \\n \\n \\n embedding_layer = Embedding(vocab_len,emb_dim_max,trainable = True)\\n \\n # Build the embedding layer, it is required before setting the weights of the embedding layer. \\n embedding_layer.build((None,)) # Do not modify the \\\"None\\\". This line of code is complete as-is.\\n # Set the weights of the embedding layer to the embedding matrix. Your layer is now pretrained.\\n embedding_layer.set_weights([emb_matrix])\\n \\n return embedding_layer,words_ignored\",\n \"def pretrained_embedding_layer(word_to_vec_map, word_to_index):\\n vocab_len = len(word_to_index) + 1 # adding 1 to fit Keras embedding (requirement)\\n emb_dim = word_to_vec_map[\\\"cucumber\\\"].shape[0] # define dimensionality of your GloVe word vectors (= 50)\\n emb_matrix = np.zeros((vocab_len, emb_dim)) # Initialize the embedding matrix as a numpy array of zeros of shape (vocab_len, dimensions of word vectors = emb_dim)\\n for word, index in word_to_index.items(): # Set each row \\\"index\\\" of the embedding matrix to be the word vector representation of the \\\"index\\\"th word of the vocabulary\\n emb_matrix[index, :] = word_to_vec_map[word]\\n embedding_layer = Embedding(vocab_len, emb_dim, trainable = False) # Define Keras embedding layer with the correct output/input sizes, make it trainable. Use Embedding(...). Make sure to set trainable=False. \\n embedding_layer.build((None,)) # Build the embedding layer, it is required before setting the weights of the embedding layer. Do not modify the \\\"None\\\".\\n embedding_layer.set_weights([emb_matrix]) # Set the weights of the embedding layer to the embedding matrix. Your layer is now pretrained.\\n return embedding_layer\",\n \"def _embed(self):\\n with tf.variable_scope('word_embedding'):\\n self.word_embeddings = tf.get_variable(\\n 'word_embeddings',\\n shape=(self.term_vocab.size(), self.term_vocab.embed_dim),\\n initializer=tf.constant_initializer(self.term_vocab.embeddings),\\n trainable=True\\n )\\n self.p_word_emb = tf.nn.embedding_lookup(self.word_embeddings, self.p)\\n self.q_word_emb = tf.nn.embedding_lookup(self.word_embeddings, self.q)\\n\\n with tf.variable_scope('char_embedding'):\\n self.char_embeddings = tf.get_variable(\\n 'char_embeddings',\\n shape=(self.char_vocab.size(), self.char_vocab.embed_dim),\\n initializer=tf.constant_initializer(self.char_vocab.embeddings),\\n trainable=True\\n )\\n self.p_char_emb = tf.nn.embedding_lookup(self.char_embeddings, self.p_char) # [batch, seqlen, max_char_num, embedding_size]\\n self.q_char_emb = tf.nn.embedding_lookup(self.char_embeddings, self.q_char)\\n\\n self.p_char_emb = self.cnn_emb(self.p_char_emb, \\\"p_emb\\\")\\n self.q_char_emb = self.cnn_emb(self.q_char_emb, \\\"q_emb\\\")\\n '''\\n self.p_char_emb = tf.reshape(self.p_char_emb, [-1, self.max_char_num, self.emb_size])\\n self.q_char_emb = tf.reshape(self.q_char_emb, [-1, self.max_char_num, self.emb_size])\\n\\n self.p_char_emb = cnn_layer.conv(self.p_char_emb, self.emb_size,\\n bias=True, activation=tf.nn.relu, kernel_size=5, name=\\\"char_conv\\\", reuse=None)\\n self.q_char_emb = cnn_layer.conv(self.q_char_emb, self.emb_size,\\n bias=True, activation=tf.nn.relu, kernel_size=5, name=\\\"char_conv\\\", reuse=True)\\n\\n self.p_char_emb = tf.reduce_max(self.p_char_emb, axis=1) # [batch*seqlen, 1, emb_size]\\n self.q_char_emb = tf.reduce_max(self.q_char_emb, axis=1)\\n\\n batch_size = tf.shape(self.p_word_emb)[0]\\n self.p_char_emb = tf.reshape(self.p_char_emb, [batch_size, -1, self.emb_size])\\n self.q_char_emb = tf.reshape(self.q_char_emb, [batch_size, -1, self.emb_size])\\n\\n self.p_char_emb = tf.nn.dropout(self.p_char_emb, 0.95)\\n self.q_char_emb = tf.nn.dropout(self.q_char_emb, 0.95)\\n '''\\n self.p_emb = tf.concat([self.p_word_emb, self.p_char_emb], -1)\\n self.q_emb = tf.concat([self.q_word_emb, self.q_char_emb], -1)\",\n \"def _embed(self):\\n with tf.variable_scope('word_embedding'):\\n self.pretrained_word_mat = tf.get_variable(\\\"word_emb_mat\\\",\\n [self.vocab.word_size() - 2, self.vocab.word_embed_dim],\\n dtype=tf.float32,\\n initializer=tf.constant_initializer(\\n self.vocab.word_embeddings[2:],\\n dtype=tf.float32),\\n trainable=False)\\n self.word_pad_unk_mat = tf.get_variable(\\\"word_unk_pad\\\",\\n [2, self.pretrained_word_mat.get_shape()[1]],\\n dtype=tf.float32,\\n initializer=tf.constant_initializer(\\n self.vocab.word_embeddings[:2],\\n dtype=tf.float32),\\n trainable=True)\\n\\n self.word_mat = tf.concat([self.word_pad_unk_mat, self.pretrained_word_mat], axis=0)\\n self.p_emb = tf.nn.embedding_lookup(self.word_mat, self.p)\\n self.q_emb = tf.nn.embedding_lookup(self.word_mat, self.q)\",\n \"def add_embedding(self):\\n #with tf.variable_scope(\\\"RNN\\\", reuse = tf.AUTO_REUSE):\\n embeddings = tf.get_variable(\\\"embeddings\\\", initializer = self.pretrained_embeddings,trainable=True)\\n inputs = self.input_placeholder\\n inputs = tf.reshape(inputs, [self.config.batch_size, -1 , self.config.n_features])\\n embeddings = tf.nn.embedding_lookup(embeddings, self.input_placeholder)\\n embeddings = tf.reshape(embeddings, [self.config.batch_size, -1, self.config.n_features* self.config.embed_size])\\n embeddings = tf.cast(embeddings, tf.float32)\\n return embeddings\",\n \"def embedding_layer(n_categories, embedding_dim, name=None):\\n\\n input_tensor = Input(shape=(1,))\\n x = Embedding(n_categories, embedding_dim, name=name)(input_tensor)\\n x = Reshape(target_shape=(embedding_dim,))(x)\\n\\n return input_tensor, x\",\n \"def load_embed(file_name, vocab_size):\\n\\n with tf.io.gfile.Open(file_name, 'r') as embed_file:\\n vocab = []\\n embeds = []\\n depth = -1\\n for index, line in enumerate(embed_file):\\n if vocab_size > 0 and index >= vocab_size:\\n break\\n line = line.strip()\\n tokens = line.strip().split(' ')\\n word = tokens[0]\\n vocab.append(word)\\n if depth == -1:\\n embed = [float(token) for token in tokens[1:]]\\n else:\\n embed = [float(token) for token in tokens[-depth:]]\\n d = len(embed)\\n if depth == -1:\\n depth = d\\n if d != depth:\\n raise ValueError('Inconsistent embedding sizes')\\n embeds.append(embed)\\n\\n embeds = np.stack(embeds)\\n\\n return vocab, embeds, depth\",\n \"def keras_model_fn(_, config):\\n\\n f = open(config[\\\"embeddings_path\\\"],encoding='utf8')\\n glove = f.readlines()[:config[\\\"embeddings_dictionary_size\\\"]]\\n f.close()\\n\\n embedding_matrix = np.zeros((config[\\\"embeddings_dictionary_size\\\"], config[\\\"embeddings_vector_size\\\"]))\\n for i in range(config[\\\"embeddings_dictionary_size\\\"]):\\n if len(glove[i].split()[1:]) != config[\\\"embeddings_vector_size\\\"]:\\n continue\\n embedding_matrix[i] = np.asarray(glove[i].split()[1:], dtype='float32')\\n\\n cnn_model = tf.keras.Sequential()\\n cnn_model.add(layers.Embedding(weights=[embedding_matrix],\\n input_dim=config['embeddings_dictionary_size'],\\n output_dim=config['embeddings_vector_size'],\\n input_length=config['padding_size']))\\n cnn_model.add(layers.Conv1D(filters=100,kernel_size=2,padding='valid',activation='relu',strides=1))\\n cnn_model.add(layers.GlobalMaxPooling1D())\\n cnn_model.add(layers.Dense(100, activation='relu'))\\n cnn_model.add(layers.Dense(1, activation = 'sigmoid'))\\n cnn_model.compile(loss='binary_crossentropy',\\n optimizer='adam',\\n metrics=['accuracy'])\\n\\n return cnn_model\",\n \"def embedding(inputs,\\n vocab_dim,\\n embedding_dim,\\n reuse,\\n validate_indices=False,\\n w_init=tf.random_uniform_initializer(-1., 1.),\\n trainable=True,\\n normalize=False,\\n vocab_freqs=None,\\n name=\\\"Embedding\\\"):\\n\\n input_shape = util.get_input_shape(inputs)\\n assert len(input_shape) == 2, \\\"Input Tensor shape must be 2-D\\\"\\n\\n with tf.variable_scope(name, reuse=reuse):\\n with tf.device('/cpu:0'):\\n W = tf.get_variable(\\n \\\"W\\\", shape=[vocab_dim, embedding_dim], initializer=w_init, trainable=trainable)\\n if normalize:\\n assert vocab_freqs is not None\\n vocab_freqs = tf.constant(vocab_freqs, dtype=tf.float32, shape=(vocab_dim, 1))\\n W = _normalize(W, vocab_freqs)\\n\\n output = tf.cast(inputs, tf.int32)\\n output = tf.nn.embedding_lookup(W, output, validate_indices=validate_indices)\\n\\n shape = [-1] + output.get_shape().as_list()[1:3] + [1]\\n # seq_length = util.retrieve_seq_length(tf.reshape(inputs, shape))\\n\\n return output\",\n \"def build_word_embeddings(self):\\n if self.mode == \\\"encode\\\":\\n # Word embeddings are fed from an external vocabulary which has possibly\\n # been expanded (see vocabulary_expansion.py).\\n encode_emb1 = tf.placeholder(tf.float32, (\\n None, None, self.config.word_embedding_dim), \\\"encode_emb1\\\")\\n # No sequences to decode.\\n encode_emb2 = tf.placeholder(tf.float32, (\\n None, None, self.config.word_embedding_dim), \\\"encode_emb2\\\")\\n elif self.mode == \\\"test\\\":\\n encode_emb1 = tf.placeholder(tf.float32, (\\n None, None, self.config.word_embedding_dim), \\\"encode_emb1\\\")\\n # No sequences to decode.\\n encode_emb2 = tf.placeholder(tf.float32, (\\n None, None, self.config.word_embedding_dim), \\\"encode_emb2\\\")\\n else:\\n word_emb = tf.get_variable(\\n name=\\\"word_embedding\\\",\\n shape=[self.config.vocab_size, self.config.word_embedding_dim],\\n initializer=self.uniform_initializer)\\n\\n encode_emb1 = tf.nn.embedding_lookup(word_emb, self.encode_ids1)\\n encode_emb2 = tf.nn.embedding_lookup(word_emb, self.encode_ids2)\\n\\n\\n self.encode_emb1 = encode_emb1\\n self.encode_emb2 = encode_emb2\",\n \"def call(self, x, *args, **kwargs):\\n with tf.name_scope(\\\"embedding\\\"):\\n # fills out of bound values with padding symbol\\n out_bound_mask = tf.cast(x > (self.vocab_size - 1), dtype=tf.int32)\\n x *= 1 - out_bound_mask\\n x += out_bound_mask * tf.cast(self.pad_sym, dtype=tf.int32)\\n\\n embeddings = tf.gather(self.shared_weights, x)\\n if self.embed_scale:\\n # Scale embedding by the sqrt of the hidden size\\n embeddings *= self.hidden_size ** 0.5\\n\\n if self.mask_paddings:\\n # Create binary array of size [batch_size, length]\\n # where 1 = padding, 0 = not padding\\n padding = get_padding(x, padding_value=self.pad_sym)\\n\\n # Set all padding embedding values to 0\\n # embeddings *= tf.expand_dims(1 - padding, -1)\\n embeddings *= tf.cast(tf.expand_dims(1.0 - padding, -1), dtype=embeddings.dtype)\\n return embeddings\",\n \"def embedding(org_input):\\n # Create the embedding list\\n for f in range(Config.num_feature):\\n num_cat_value = Config.schema[f]\\n\\n if num_cat_value == 1:\\n pass\\n elif num_cat_value > 1:\\n embed_dict[f] = tf.get_variable(\\n name=\\\"embed_\\\" + str(f),\\n shape=[num_cat_value, Config.embed_size[f]],\\n trainable=True)\\n else:\\n raise ValueError(\\\"Schema values should be positive integers!\\\")\\n\\n # Create embedded inputs\\n f_size = np.sum(Config.embed_size)\\n embedded_input = embed_events(org_input, f_size)\\n\\n return embedded_input\",\n \"def anime_embedding_model(anime_index, tag_index, embedding_size=50, classification=False):\\n\\n # Both inputs are 1-dimensional\\n anime = Input(name='anime', shape=[1])\\n tag = Input(name='tag', shape=[1])\\n\\n # Embedding the anime (shape will be (None, 1, 50))\\n anime_embedding = Embedding(name='anime_embedding',\\n input_dim=len(anime_index),\\n output_dim=embedding_size)(anime)\\n\\n # Embedding the tag (shape will be (None, 1, 50))\\n tag_embedding = Embedding(name='tag_embedding',\\n input_dim=len(tag_index),\\n output_dim=embedding_size)(tag)\\n\\n # Merge the layers with a dot product along the second axis (shape will be (None, 1, 1))\\n merged = Dot(name='dot_product', normalize=True, axes=2)([anime_embedding, tag_embedding])\\n\\n # Reshape to be a single number (shape will be (None, 1))\\n merged = Reshape(target_shape=[1])(merged)\\n\\n # If classifcation, add extra layer and loss function is binary cross entropy\\n if classification:\\n merged = Dense(1, activation='sigmoid')(merged)\\n model = Model(inputs=[anime, tag], outputs=merged)\\n model.compile(optimizer='Adam', loss='binary_crossentropy', metrics=['accuracy'])\\n\\n # Otherwise loss function is mean squared error\\n else:\\n model = Model(inputs=[anime, tag], outputs=merged)\\n model.compile(optimizer='Adam', loss='mse')\\n\\n return model\",\n \"def add_embedding(self, prefix=''):\\n with tf.variable_scope(prefix + 'embed'):\\n if self.cfg.fix_emb:\\n assert (hasattr(self.cfg, 'W_emb'))\\n W_emb = pkl.load(open(self.cfg.W_emb_path, 'rb'))\\n W = tf.get_variable('W', initializer= W_emb, trainable=True)\\n print(\\\"iniitalize word embedding finished\\\")\\n else:\\n weightInit = tf.random_uniform_initializer(-0.001, 0.001)\\n vocab = pkl.load(open(self.cfg.vocab_path, 'rb'))\\n W = tf.get_variable('W', [len(vocab), self.cfg.emb_size], initializer=weightInit)\\n if hasattr(self.cfg, 'relu_w') and self.cfg.relu_w:\\n W = tf.nn.relu(W)\\n return W\",\n \"def embed_word(self):\\n return self.emb.get_keras_embedding(dropout = self.emb_dropout,\\n trainable = self.trainable_emb,\\n input_length = self.sent_maxlen)\",\n \"def embeddings_layer(x, Wemb, dim_proj):\\n\\n n_words = x.shape[0]\\n n_max_letters_in_word = x.shape[1]\\n n_batch = x.shape[2]\\n\\n dist = Wemb[x.flatten()].reshape([n_words, n_max_letters_in_word, n_batch, dim_proj])\\n return dist\",\n \"def embed_word(self):\\n return self.emb.get_keras_embedding(trainable = self.trainable_emb,\\n input_length = self.sent_maxlen)\",\n \"def model_extract_document_embedding(self):\\n input_ids = tf.keras.layers.Input(shape=(self.maxlen,), dtype=tf.int32, name=\\\"ids\\\")\\n attention_mask = tf.keras.layers.Input(shape=(self.maxlen,), dtype=tf.int32, name=\\\"att\\\")\\n token = tf.keras.layers.Input(shape=(self.maxlen,), dtype=tf.int32, name=\\\"tok\\\")\\n\\n # Embedding :\\n if self.method_embedding == 'CamemBERT':\\n Camembert_model = transformers.TFCamembertModel.from_pretrained(\\\"jplu/tf-camembert-base\\\")\\n x = Camembert_model(input_ids, attention_mask=attention_mask, token_type_ids=token)\\n elif self.method_embedding == 'FlauBERT':\\n # lr = 0.00001\\n Flaubert_model = transformers.TFFlaubertModel.from_pretrained(\\\"jplu/tf-flaubert-base-uncased\\\")\\n x = Flaubert_model(input_ids, attention_mask=attention_mask, token_type_ids=token)\\n elif self.method_embedding == 'XLM-RoBERTa':\\n # lr = 0.00001\\n XLMRoBERTa_model = transformers.TFXLMRobertaModel.from_pretrained(\\\"jplu/tf-xlm-roberta-base\\\")\\n x = XLMRoBERTa_model(input_ids, attention_mask=attention_mask, token_type_ids=token)\\n elif self.method_embedding == 'RoBERTa':\\n # Experience Test path weights :\\n PATH = '/kaggle/input/tf-roberta/'\\n config = transformers.RobertaConfig.from_pretrained(PATH + 'config-roberta-base.json')\\n Roberta_model = transformers.TFRobertaModel.from_pretrained(PATH + 'pretrained-roberta-base.h5',\\n config=config)\\n # Sinon :\\n # Roberta_model = transformers.TFRobertaModel.from_pretrained('roberta-base')\\n x = Roberta_model(input_ids, attention_mask=attention_mask, token_type_ids=token)\\n elif self.method_embedding == 'BERT':\\n BERT_model = transformers.TFBertModel.from_pretrained('bert-base-uncased')\\n x = BERT_model(input_ids, attention_mask=attention_mask, token_type_ids=token)\\n else:\\n logger.critical(\\\"unknown embedding method name : '{}'\\\".format(self.method_embedding))\\n\\n # word vectors shape : (None, maxlen, 768)\\n x = x[0]\\n cls_token = x[:, 0, :]\\n\\n model = tf.keras.models.Model(inputs=[input_ids, attention_mask, token], outputs=cls_token)\\n return model\",\n \"def embedding_table(inputs, vocab_size, embed_size, zero_pad=False,\\n trainable=True, scope=\\\"embedding\\\", reuse=None):\\n with tf.variable_scope(scope, reuse=reuse):\\n embed_table = tf.get_variable('embedding_table',\\n shape=[vocab_size, embed_size],\\n initializer=_init,\\n trainable=trainable,\\n dtype=tf.float32)\\n if zero_pad:\\n embed_table = tf.concat((tf.zeros(shape=[1, embed_size]), embed_table[1:, :]),\\n axis=0)\\n\\n return tf.nn.embedding_lookup(embed_table, inputs)\",\n \"def load_embeddings(config, name, vocab, training_generator, validation_generator):\\n\\n # Pickle embeddings should be AGNOSTIC to the name. This is because each pickled embedding is specific to the dataset and transformer.\\n # Applies down the road when/if we attempt active learning\\n data_name = config['train_file'].split('/')[-1][:-4] # retrieve file name without the extension\\n train_embed_pkl_f = os.path.join(config['cache'], data_name + '_' + config['embedding_type'] + '_training_embeddings.p')\\n valid_embed_pkl_f = os.path.join(config['cache'], data_name + '_' + config['embedding_type'] + '_validation_embeddings.p')\\n \\n \\n if os.path.exists(train_embed_pkl_f):\\n with open( train_embed_pkl_f, 'rb') as cache:\\n train_embeddings = pickle.load(cache)\\n\\n with open(valid_embed_pkl_f, 'rb') as cache:\\n valid_embeddings = pickle.load(cache)\\n else:\\n # get embeddings from scratch\\n tokenizer = AutoTokenizer.from_pretrained(vocab)\\n embedding_model = AbstractBert(vocab) \\n\\n if torch.cuda.device_count() > 1:\\n print(\\\"GPUs Available: \\\", torch.cuda.device_count())\\n embedding_model = torch.nn.DataParallel(embedding_model, device_ids=[0, 1, 2])\\n \\n use_cuda = torch.cuda.is_available()\\n device = torch.device(\\\"cuda:0\\\" if use_cuda else \\\"cpu\\\")\\n\\n embedding_model.eval().to(device)\\n\\n logger.info(' Getting BERT/ROBERTA embeddings...')\\n\\n train_embeddings = _get_bert_embeddings(training_generator, embedding_model, config[\\\"metadata\\\"])\\n valid_embeddings = _get_bert_embeddings(validation_generator, embedding_model, config[\\\"metadata\\\"])\\n\\n # save embeddings\\n pickle.dump(train_embeddings, open(train_embed_pkl_f, 'wb'))\\n pickle.dump(valid_embeddings, open(valid_embed_pkl_f, 'wb'))\\n\\n logger.info(' Saved full BERT/ROBERTA embeddings.')\\n\\n embedding_shape = train_embeddings['embeddings'][1].shape[0]\\n\\n return embedding_shape, train_embeddings, valid_embeddings\",\n \"def _build(self, ids):\\n # Construct embeddings.\\n if self._existing_vocab is None:\\n if self.EMBEDDINGS not in self._initializers:\\n self._initializers[self.EMBEDDINGS] = basic.create_linear_initializer(\\n self._vocab_size)\\n self._embeddings = tf.get_variable(\\n \\\"embeddings\\\",\\n shape=[self._vocab_size, self._embed_dim],\\n dtype=tf.float32,\\n initializer=self._initializers[self.EMBEDDINGS],\\n partitioner=self._partitioners.get(self.EMBEDDINGS, None),\\n regularizer=self._regularizers.get(self.EMBEDDINGS, None),\\n trainable=self._trainable)\\n else:\\n self._embeddings = tf.get_variable(\\n \\\"embeddings\\\",\\n dtype=tf.float32,\\n initializer=self._existing_vocab,\\n regularizer=self._regularizers.get(self.EMBEDDINGS, None),\\n trainable=self._trainable)\\n\\n # Lookup embeddings\\n return tf.nn.embedding_lookup(\\n self._embeddings, ids, name=\\\"embedding_lookup\\\")\",\n \"def add_word_embeddings_op(self):\\n with tf.variable_scope(\\\"words\\\"):\\n if self.config.embeddings is None:\\n self.logger.info(\\\"WARNING: randomly initializing word vectors\\\")\\n _word_embeddings = tf.get_variable(\\n name=\\\"_word_embeddings\\\",\\n dtype=tf.float32,\\n shape=[self.config.nwords, self.config.dim_word])\\n else:\\n _word_embeddings = tf.Variable(\\n self.config.embeddings,\\n name=\\\"_word_embeddings\\\",\\n dtype=tf.float32,\\n trainable=self.config.train_embeddings)\\n\\n word_embeddings = tf.nn.embedding_lookup(_word_embeddings,\\n self.word_ids, name=\\\"word_embeddings\\\")\\n\\n with tf.variable_scope(\\\"chars\\\"):\\n if self.config.use_chars:\\n # get char embeddings matrix\\n _char_embeddings = tf.get_variable(\\n name=\\\"_char_embeddings\\\",\\n dtype=tf.float32,\\n shape=[self.config.nchars, self.config.dim_char])\\n char_embeddings = tf.nn.embedding_lookup(_char_embeddings,\\n self.char_ids, name=\\\"char_embeddings\\\")\\n\\n # put the time dimension on axis=1\\n s = tf.shape(char_embeddings)\\n char_embeddings = tf.reshape(char_embeddings,\\n shape=[s[0]*s[1], s[-2], self.config.dim_char])\\n word_lengths = tf.reshape(self.word_lengths, shape=[s[0]*s[1]])\\n\\n # bi lstm on chars\\n cell_fw = tf.contrib.rnn.LSTMCell(self.config.hidden_size_char,\\n state_is_tuple=True)\\n cell_bw = tf.contrib.rnn.LSTMCell(self.config.hidden_size_char,\\n state_is_tuple=True)\\n _output = tf.nn.bidirectional_dynamic_rnn(\\n cell_fw, cell_bw, char_embeddings,\\n sequence_length=word_lengths, dtype=tf.float32)\\n\\n # read and concat output\\n _, ((_, output_fw), (_, output_bw)) = _output\\n output = tf.concat([output_fw, output_bw], axis=-1)\\n\\n # shape = (batch size, max sentence length, char hidden size)\\n output = tf.reshape(output,\\n shape=[s[0], s[1], 2*self.config.hidden_size_char])\\n word_embeddings = tf.concat([word_embeddings, output], axis=-1)\\n\\n self.word_embeddings = tf.nn.dropout(word_embeddings, self.dropout)\",\n \"def create_embedding(num_symbol, embedding_size, embedding_name):\\n return tf.Variable(tf.random_uniform([num_symbol, embedding_size], -0.1, 0.1, tf.float32), name=embedding_name, trainable=True)\",\n \"def get_embedding(self, task_embedding, layer_id):\\n layer_id_tensor = torch.tensor([layer_id], dtype=torch.long, device=self.device)\\n layer_embedding = self.layer_id_embeddings(layer_id_tensor)\\n layer_embedding = layer_embedding.view(-1)\\n segment_id = torch.tensor([0, 1], dtype=torch.long, device=self.device)\\n embeddings = torch.cat([task_embedding.view(1, -1), layer_embedding.view(1, -1)], axis=0)\\n embeddings += self.token_type_embeddings(segment_id)\\n embeddings = self.task_hypernet(embeddings.view(-1))\\n if self.unique_hyper_net_layer_norm:\\n embeddings = self.LayerNorm(embeddings)\\n return embeddings\",\n \"def generate_embedding(inputs, input_shape: list, embedding_args: dict, embedding_rank: int = 1, **kwargs):\\n if len(kwargs) > 0:\\n print(\\\"WARNING:kgcnn: Unknown embedding kwargs {0}. Will be reserved for future versions.\\\".format(kwargs))\\n\\n if len(input_shape) == embedding_rank:\\n n = ks.layers.Embedding(**embedding_args)(inputs)\\n else:\\n n = inputs\\n return n\",\n \"def __init__(self,\\n vocab_size=None,\\n embed_dim=None,\\n existing_vocab=None,\\n initializers=None,\\n partitioners=None,\\n regularizers=None,\\n trainable=True,\\n custom_getter=None,\\n name=\\\"embed\\\"):\\n if vocab_size is None and existing_vocab is None:\\n raise ValueError(\\\"Must provide on of vocab_size or existing_vocab.\\\")\\n\\n if existing_vocab is not None and not all(\\n x is None for x in [vocab_size, embed_dim, initializers, partitioners]):\\n raise ValueError(\\\"If existing_vocab is provided, none of vocab_size, \\\"\\n \\\"embedding_dim, initializers, or partitioners is \\\"\\n \\\"needed.\\\")\\n\\n super(Embed, self).__init__(custom_getter=custom_getter, name=name)\\n self._existing_vocab = None\\n if existing_vocab is None:\\n self._vocab_size = vocab_size\\n self._embed_dim = embed_dim or _embedding_dim(self._vocab_size)\\n else:\\n self._existing_vocab = tf.convert_to_tensor(\\n existing_vocab, dtype=tf.float32)\\n existing_vocab_shape = self._existing_vocab.get_shape().with_rank(2)\\n existing_vocab_shape.assert_is_fully_defined()\\n self._vocab_size, self._embed_dim = existing_vocab_shape.as_list()\\n\\n self._initializers = util.check_initializers(\\n initializers, self.POSSIBLE_INITIALIZER_KEYS)\\n self._partitioners = util.check_partitioners(\\n partitioners, self.POSSIBLE_INITIALIZER_KEYS)\\n self._regularizers = util.check_regularizers(\\n regularizers, self.POSSIBLE_INITIALIZER_KEYS)\\n self._trainable = trainable\",\n \"def word_embeddings(self, feed_seq_batch):\\n # compute seq_length\\n self.feed_per_seq_length = self.get_per_seq_length(feed_seq_batch)\\n\\n # compute embedding\\n with tf.variable_scope(\\\"word_embedding\\\"):\\n seq_embedding = tf.get_variable(\\n name=\\\"seq_embedding\\\",\\n shape=[self.config.vocab_size, self.config.embed_dim],\\n initializer=self.initializer)\\n word_embeddings = tf.nn.embedding_lookup(seq_embedding,\\n feed_seq_batch)\\n if self.train_mode:\\n word_embeddings = tf.nn.dropout(\\n word_embeddings, keep_prob=self.feed_general_droprate)\\n word_embeddings = tf.nn.tanh(word_embeddings)\\n\\n return word_embeddings\",\n \"def _add_pre_trained_embedding(self):\\n\\n if self.embedding_type['type'] == 'glove':\\n self.logging.info('use pre-trained glove word2vec')\\n # a. load pre trained glove\\n GLOVE_DIR = '../data/glove_pretrained/glove.6B'\\n glove_suffix_name = 'glove.6B.' + str(self.embedding_size) + 'd.txt'\\n import os\\n import numpy as np\\n\\n embeddings_index = {}\\n f = open(os.path.join(GLOVE_DIR, glove_suffix_name)) # 'glove.6B.100d.txt'))\\n for line in f:\\n values = line.split()\\n word = values[0]\\n coefs = np.asarray(values[1:], dtype='float32')\\n embeddings_index[word] = coefs\\n f.close()\\n\\n self.logging.info('')\\n self.logging.info('Found %s word vectors.' % len(embeddings_index))\\n\\n # b. compute embedding matrix\\n embedding_matrix = np.zeros((len(self.word_index) + 1, self.embedding_size))\\n cnt = 0\\n for word, i in self.word_index.items():\\n embedding_vector = embeddings_index.get(word)\\n if embedding_vector is not None:\\n embedding_matrix[i] = embedding_vector # words not found in embedding index will be all-zeros.\\n else:\\n # self.logging.info('token in train missing in word2vec: ' + str(word))\\n cnt += 1\\n self.logging.info('total tokens missing: ' + str(cnt) + ' / ' + str(len(self.word_index)))\\n\\n # c. build embedding layer\\n from keras.layers import Embedding\\n embedding_layer = Embedding(len(self.word_index) + 1,\\n self.embedding_size,\\n weights=[embedding_matrix],\\n input_length=self.maxlen,\\n trainable=False)\\n\\n elif self.embedding_type['type'] == 'gensim':\\n self.logging.info('use pre-trained gensim word2vec')\\n\\n import gzip\\n import gensim\\n from keras.layers import Embedding\\n import numpy as np\\n\\n # fname = '../data/word2vec_pretrained/motors/d_300_k_712904_w_6_e_60_v_motors'\\n # fname = '../data/word2vec_pretrained/fashion/d_300_k_1341062_w_6_e_70_v_fashion'\\n\\n self.logging.info('load word2vec path: ' + str(self.embedding_type['path']))\\n model = gensim.models.Word2Vec.load(self.embedding_type['path'])\\n pretrained_weights = model.wv.syn0\\n vocab_size, vector_dim = pretrained_weights.shape\\n\\n method = 3\\n if method == 1:\\n self.logging.info('word2vec attempt to fit into embedding layer - middle complex')\\n # convert the wv word vectors into a numpy matrix that is suitable for insertion\\n # into our TensorFlow and Keras models\\n\\n embedding_matrix = np.zeros((len(model.wv.vocab), vector_dim))\\n for i in range(len(model.wv.vocab)):\\n embedding_vector = model.wv[model.wv.index2word[i]]\\n if embedding_vector is not None:\\n embedding_matrix[i] = embedding_vector\\n\\n embedding_layer = Embedding(input_dim=embedding_matrix.shape[0],\\n output_dim=embedding_matrix.shape[1],\\n # input_length=self.maxlen,\\n weights=[embedding_matrix],\\n trainable=False)\\n elif method == 2:\\n self.logging.info('word2vec simple embedding matching - simple complex')\\n embedding_layer = Embedding(input_dim=vocab_size,\\n output_dim=vector_dim,\\n input_length=self.maxlen,\\n weights=[pretrained_weights],\\n trainable=False)\\n elif method == 3:\\n\\n self.logging.info('word2vec match using word_index from keras tokenizer - as used in glove match above')\\n # b. compute embedding matrix\\n\\n # sd = 1 / np.sqrt(len(self.word_index) + 1)\\n # embedding_matrix = np.random.normal(0, scale=sd, size=(len(self.word_index) + 1, self.embedding_size))\\n\\n embedding_matrix = np.zeros((len(self.word_index) + 1, self.embedding_size))\\n cnt = 0\\n for word, i in self.word_index.items():\\n if word in model.wv:\\n embedding_vector = model.wv[word]\\n embedding_matrix[i] = embedding_vector\\n else:\\n # self.logging.info('token in train missing in word2vec: ' + str(word))\\n cnt += 1\\n self.logging.info('total tokens missing: ' + str(cnt))\\n\\n\\n # c. build embedding layer\\n from keras.layers import Embedding\\n embedding_layer = Embedding(len(self.word_index) + 1,\\n self.embedding_size,\\n weights=[embedding_matrix],\\n input_length=self.maxlen,\\n trainable=False)\\n else:\\n raise ValueError('unknown method value')\\n\\n else:\\n raise ValueError('unknown embedding type')\\n self.logging.info('create glove pre-trained embedding: ' + str(self.embedding_size))\\n return embedding_layer\",\n \"def forward(self, features: EmbeddedFeatures):\\n assert len(features.token_embeddings.shape) == 3 and features.token_embeddings.shape[0] == 2, \\\\\\n \\\"Input must have 2 embeddings\\\"\\n\\n # [x, z]\\n x = features.token_embeddings[0].to(torch.float)\\n y = features.token_embeddings[1].to(torch.float)\\n\\n # [z, x] @ [x, z] = [z, z]\\n attention = torch.mm(x.T, y)\\n\\n # [z, z]\\n softmax_x = F.softmax(attention, dim = 1) # By row\\n softmax_y = F.softmax(attention, dim = 0) # By column\\n\\n # [z, z]\\n weighted_x = (softmax_x * torch.sum(y, dim = 0))[:x.shape[0]]\\n weighted_y = (softmax_y * torch.sum(x, dim = 0))[:y.shape[0]]\\n\\n # [x]\\n pooled = self.pooling(features)\\n pooled_x, pooled_y = pooled.token_embeddings[0], pooled.token_embeddings[1]\\n\\n features.token_embeddings = torch.stack([weighted_x, weighted_y])\\n\\n pooled = self.pooling(features)\\n pooled_weighted_x, pooled_weighted_y = pooled.token_embeddings[0], pooled.token_embeddings[1]\\n\\n # [3 * x]\\n concatenated_x = torch.cat([pooled_x, pooled_weighted_x, pooled_x - pooled_weighted_x])\\n concatenated_y = torch.cat([pooled_y, pooled_weighted_y, pooled_y - pooled_weighted_y])\\n\\n # [9 * x]\\n result = torch.cat([concatenated_x, concatenated_y, torch.abs(concatenated_x - concatenated_y)])\\n\\n return result\",\n \"def build_seq_embeddings(self):\\n with tf.variable_scope(\\\"seq_embedding\\\"), tf.device(\\\"/cpu:0\\\"):\\n embedding_map = tf.get_variable(\\n name=\\\"map\\\",\\n shape=[self.config.vocab_size, self.config.word_embedding_size],\\n initializer=self.initializer)\\n \\n # We need to store the normalized lookup table for efficient mapping of embedding vectors to closest words\\n self.normed_embedding_map = tf.nn.l2_normalize(embedding_map, dim=1)\\n \\n seq_embeddings = tf.nn.embedding_lookup(embedding_map, self.input_seqs) \\n # seq_embeddings has the shape (batch_size, sequence_length, sentence_length, embedding_size)\\n # meaning, for each index in input_seqs (with shape (batch_size, sequence_length, sentence_length)) it stores an embedding vector\\n\\n #print('Shape seq_embeddings: ' + str(seq_embeddings.get_shape()))\\n\\n self.seq_embeddings = seq_embeddings\",\n \"def build_embeddings(opt, word_dict, for_encoder='src'):\\n if for_encoder=='src':\\n embedding_dim = opt.src_word_vec_size #512\\n elif for_encoder=='tgt':\\n embedding_dim = opt.tgt_word_vec_size\\n elif for_encoder=='structure':\\n embedding_dim = 64\\n\\n word_padding_idx = word_dict.stoi[Constants.PAD_WORD]\\n num_word_embeddings = len(word_dict)\\n \\n if for_encoder=='src' or for_encoder=='tgt':\\n\\n return Embeddings(word_vec_size=embedding_dim,\\n position_encoding=opt.position_encoding,\\n dropout=opt.dropout,\\n word_padding_idx=word_padding_idx,\\n word_vocab_size=num_word_embeddings,\\n sparse=opt.optim == \\\"sparseadam\\\")\\n elif for_encoder=='structure':\\n return Embeddings(word_vec_size=embedding_dim,\\n position_encoding=False,\\n dropout=opt.dropout,\\n word_padding_idx=word_padding_idx,\\n word_vocab_size=num_word_embeddings,\\n sparse=opt.optim == \\\"sparseadam\\\")\",\n \"def get_model_bicond_sepembed(batch_size, max_seq_length, input_size, hidden_size, target_size,\\n vocab_size, pretrain, tanhOrSoftmax, dropout):\\n\\n # batch_size x max_seq_length\\n inputs = tf.placeholder(tf.int32, [batch_size, max_seq_length])\\n inputs_cond = tf.placeholder(tf.int32, [batch_size, max_seq_length])\\n\\n cont_train = True\\n if pretrain == \\\"pre\\\": # continue training embeddings or not. Currently works better to continue training them.\\n cont_train = False\\n embedding_matrix = tf.Variable(tf.random_uniform([vocab_size, input_size], -0.1, 0.1), # input_size is embeddings size\\n name=\\\"embedding_matrix\\\", trainable=cont_train)\\n embedding_matrix_cond = tf.Variable(tf.random_uniform([vocab_size, input_size], -0.1, 0.1),\\n name=\\\"embedding_matrix\\\", trainable=cont_train)\\n\\n\\n # batch_size x max_seq_length x input_size\\n embedded_inputs = tf.nn.embedding_lookup(embedding_matrix, inputs)\\n embedded_inputs_cond = tf.nn.embedding_lookup(embedding_matrix_cond, inputs_cond)\\n\\n\\n # [batch_size x inputs_size] with max_seq_length elements\\n # fixme: possibly inefficient\\n # inputs_list[0]: batch_size x input[0] <-- word vector of the first word\\n inputs_list = [tf.squeeze(x) for x in\\n tf.split(1, max_seq_length, embedded_inputs)]\\n inputs_cond_list = [tf.squeeze(x) for x in\\n tf.split(1, max_seq_length, embedded_inputs_cond)]\\n\\n drop_prob = None\\n if dropout:\\n drop_prob = 0.1\\n lstm_encoder = Encoder(rnn_cell.BasicLSTMCell, input_size, hidden_size, drop_prob, drop_prob)\\n\\n start_state = tf.zeros([batch_size, lstm_encoder.state_size])\\n\\n ### FORWARD\\n\\n # [h_i], [h_i, c_i] <-- LSTM\\n # [h_i], [h_i] <-- RNN\\n fw_outputs, fw_states = lstm_encoder(inputs_list, start_state, \\\"LSTM\\\")\\n\\n # running a second LSTM conditioned on the last state of the first\\n fw_outputs_cond, fw_states_cond = lstm_encoder(inputs_cond_list, fw_states[-1],\\n \\\"LSTMcond\\\")\\n\\n fw_outputs_fin = fw_outputs_cond[-1]\\n\\n ### BACKWARD\\n bw_outputs, bw_states = lstm_encoder(inputs_list[::-1], start_state, \\\"LSTM_bw\\\")\\n bw_outputs_cond, bw_states_cond = lstm_encoder(inputs_cond_list[::-1], bw_states[-1],\\n \\\"LSTMcond_bw\\\")\\n bw_outputs_fin = bw_outputs_cond[-1]\\n\\n outputs_fin = tf.concat(1, [fw_outputs_fin, bw_outputs_fin])\\n\\n\\n if tanhOrSoftmax == \\\"tanh\\\":\\n model = Projector(target_size, non_linearity=tf.nn.tanh, bias=True)(outputs_fin) # tf.nn.softmax\\n else:\\n model = Projector(target_size, non_linearity=tf.nn.softmax, bias=True)(outputs_fin) # tf.nn.softmax\\n\\n return model, [inputs, inputs_cond]\",\n \"def _use_embeddings(self, word):\\n if word == \\\"@PAD@\\\":\\n return torch.zeros(self.embeddings_dim)\\n else:\\n return self.embeddings[word]\",\n \"def resize_token_embeddings(self, new_num_tokens=None):\\n base_model = getattr(self, self.base_model_prefix, self) # get the base model if needed\\n model_embeds = base_model._resize_token_embeddings(new_num_tokens)\\n if new_num_tokens is None:\\n return model_embeds\\n\\n # Update base model and current model config\\n self.config.vocab_size = new_num_tokens\\n base_model.vocab_size = new_num_tokens\\n\\n # Tie weights again if needed\\n if hasattr(self, \\\"tie_weights\\\"):\\n self.tie_weights()\\n\\n return model_embeds\",\n \"def test_embedding_matrix_shape(self):\\n num_embeddings = 10\\n features = 5\\n embed = layers.Embed(num_embeddings=num_embeddings, features=features)\\n inputs = np.expand_dims(np.arange(features, dtype=np.int64), 1)\\n variables = embed.init(jax.random.PRNGKey(0), inputs)\\n embedding_matrix = variables['params']['embedding']\\n self.assertEqual((num_embeddings, features), embedding_matrix.shape)\",\n \"def generate_embedding_matrix(self):\\n # get all the embeddings\\n all_embs = np.stack(list(self.embeddings.values()))\\n\\n # mean and standard deviation of the embedding values\\n emb_mean, emb_std = all_embs.mean(), all_embs.std()\\n\\n # Find the number of words the the train set\\n word_index = self.tokenizer.word_index\\n rows = min(self.max_features, len(word_index))\\n\\n # create embeddings for each word by sampling from a normal distribtion\\n # with parameters calculated above.\\n embedding_matrix = np.random.normal(emb_mean, emb_std, (rows + 1, self.embed_size))\\n\\n for word, i in word_index.items():\\n # TODO: replace this with stop words and frequency instead\\n if i >= self.max_features:\\n continue\\n\\n embedding_vector = self.embeddings.get(word)\\n\\n # if word is found in the embeddings used\\n if embedding_vector is not None:\\n # replace row of embeddings matrix with trained embeddings vector\\n embedding_matrix[i] = embedding_vector\\n\\n return embedding_matrix\",\n \"def sn_embedding(x, number_classes, embedding_size, training=True,\\n name='snembedding'):\\n with tf.variable_scope(name):\\n embedding_map = tf.get_variable(\\n name='embedding_map',\\n shape=[number_classes, embedding_size],\\n initializer=tf.keras.initializers.VarianceScaling(\\n scale=1.0, mode='fan_avg', distribution='uniform'))\\n embedding_map_bar_transpose = tfgan.features.spectral_normalize(\\n tf.transpose(a=embedding_map),\\n training=training,\\n equality_constrained=False)\\n embedding_map_bar = tf.transpose(a=embedding_map_bar_transpose)\\n return tf.nn.embedding_lookup(params=embedding_map_bar, ids=x)\",\n \"def build_input_embed(self, n_input, t_input):\\n n_embed_matrix = tf.Variable(tf.random_uniform(\\n [self.num_ntoken, self.n_embed_dim], minval=-0.05, maxval=0.05), name='n_embed_matrix')\\n t_embed_matrix = tf.Variable(tf.random_uniform(\\n [self.num_ttoken, self.t_embed_dim], minval=-0.05, maxval=0.05), name='t_embed_matrix')\\n n_input_embedding = tf.nn.embedding_lookup(n_embed_matrix, n_input)\\n t_input_embedding = tf.nn.embedding_lookup(t_embed_matrix, t_input)\\n return n_input_embedding, t_input_embedding\",\n \"def get_pretrained_embeddings(source_vocab,embed_df):\\r\\n \\r\\n num_tokens = len(source_vocab)\\r\\n embedding_dim = embed_df.shape[1]\\r\\n weights = np.zeros((num_tokens,embedding_dim),dtype=np.float32)\\r\\n \\r\\n for idx in range(num_tokens):\\r\\n token = source_vocab.lookup_index(idx)\\r\\n if token in embed_df.index:\\r\\n weights[idx,:] = embed_df.loc[token]\\r\\n else:\\r\\n weights[idx,:] = np.random.randn(1,embedding_dim)\\r\\n \\r\\n embed_tensor = torch.FloatTensor(weights)\\r\\n return embed_tensor\",\n \"def _embed(self):\\n batch_size = tf.shape(self.p)[0]\\n with tf.variable_scope(\\\"emb\\\"):\\n with tf.variable_scope(\\\"char\\\"):\\n pc_emb = tf.reshape(tf.nn.embedding_lookup(\\n self.char_embed, self.pc), \\n [batch_size * self.max_p_len, self.max_w_len, self.vocab.char_embed_dim])\\n qc_emb = tf.reshape(tf.nn.embedding_lookup(\\n self.char_embed, self.qc), \\n [batch_size * self.max_q_len, self.max_w_len, self.vocab.char_embed_dim])\\n cell_fw = tf.contrib.rnn.GRUCell(self.char_hidden_size)\\n cell_bw = tf.contrib.rnn.GRUCell(self.char_hidden_size)\\n _, (state_fw, state_bw) = tf.nn.bidirectional_dynamic_rnn(\\n cell_fw, cell_bw, pc_emb, self.pc_length, dtype=tf.float32)\\n pc_emb = tf.concat([state_fw, state_bw], axis=1)\\n _, (state_fw, state_bw) = tf.nn.bidirectional_dynamic_rnn(\\n cell_fw, cell_bw, qc_emb, self.qc_length, dtype=tf.float32)\\n qc_emb = tf.concat([state_fw, state_bw], axis=1)\\n pc_emb = tf.reshape(pc_emb, [batch_size, self.max_p_len, 2 * self.char_hidden_size])\\n qc_emb = tf.reshape(qc_emb, [batch_size, self.max_q_len, 2 * self.char_hidden_size])\\n\\n with tf.name_scope(\\\"word\\\"):\\n p_emb = tf.nn.embedding_lookup(self.word_embed, self.p)\\n q_emb = tf.nn.embedding_lookup(self.word_embed, self.q)\\n\\n with tf.name_scope(\\\"pos\\\"):\\n p_pos_emb = tf.nn.embedding_lookup(self.pos_embed, self.p_pos)\\n q_pos_emb = tf.nn.embedding_lookup(self.pos_embed, self.q_pos)\\n \\n with tf.name_scope(\\\"em\\\"):\\n sh = tf.shape(self.p_em)\\n resh = [sh[0], sh[1], 1]\\n p_em_feat = tf.reshape(tf.cast(self.p_em, dtype=tf.float32), shape=resh)\\n\\n self.p_emb = tf.concat([p_emb, pc_emb, p_pos_emb, p_em_feat], axis=2)\\n self.q_emb = tf.concat([q_emb, qc_emb, q_pos_emb], axis=2)\",\n \"def incorporate_embeddings(self, x):\\n all_embedded_data = []\\n for embedding_layer_ix, embedding_var in enumerate(self.columns_of_data_to_be_embedded):\\n data = x[:, :, embedding_var]\\n embedded_data = self.embedding_layers[embedding_layer_ix](data)\\n all_embedded_data.append(embedded_data)\\n if len(all_embedded_data) > 1: all_embedded_data = Concatenate(axis=2)(all_embedded_data)\\n else: all_embedded_data = all_embedded_data[0]\\n non_embedded_columns = [col for col in range(x.shape[2]) if col not in self.columns_of_data_to_be_embedded]\\n if len(non_embedded_columns) > 0:\\n x = tf.gather(x, non_embedded_columns, axis=2)\\n x = Concatenate(axis=2)([tf.dtypes.cast(x, float), all_embedded_data])\\n else: x = all_embedded_data\\n return x\",\n \"def add_word_embedding_op(self):\\n if self.pos:\\n print(\\\"adding pos embeddings\\\")\\n with tf.variable_scope(\\\"pos\\\"):\\n _pos_embeddings = tf.Variable(self.pos_embeddings,\\n name=\\\"la_pos_embeddings\\\",\\n dtype=tf.float32, trainable=False)\\n pos_embeddings = tf.nn.embedding_lookup(_pos_embeddings, self.pos_ids,\\n name=\\\"pos_embeddings\\\")\\n self.pos_vecs = pos_embeddings\\n print(\\\"adding word_embeddings\\\")\\n with tf.variable_scope(\\\"words\\\"):\\n _word_embeddings = tf.Variable(self.embeddings, name=\\\"_word_embeddings\\\",\\n dtype=tf.float32, trainable=False)\\n word_embeddings = tf.nn.embedding_lookup(_word_embeddings,\\n self.word_ids,\\n name=\\\"word_embeddings\\\")\\n if self.use_window:\\n print(\\\"Concatenating word vectors of context words\\\")\\n word_embeddings_sl = tf.nn.embedding_lookup(_word_embeddings,\\n self.word_ids_sl,\\n name=\\\"word_embeddings_sl\\\")\\n word_embeddings_sr = tf.nn.embedding_lookup(_word_embeddings,\\n self.word_ids_sr,\\n name=\\\"word_embeddings_sr\\\")\\n word_embeddings = tf.concat([word_embeddings_sr, word_embeddings,\\n word_embeddings_sl], axis=-1)\\n if self.use_char_embeddings:\\n print(\\\"adding CNN for char embeddings\\\")\\n with tf.variable_scope(\\\"chars\\\"):\\n _char_embeddings = tf.get_variable(name=\\\"_char_embeddings\\\",\\n dtype=tf.float32,\\n shape=[self.char_count, \\n self.c_dim_input])\\n char_embeddings = tf.nn.embedding_lookup(_char_embeddings, \\n self.char_ids, \\n name=\\\"char_embeddings\\\")\\n s = char_embeddings.shape\\n # the shape of our char_embeddings is now (batch_size, max number of words\\n # in each sentence, max number of chars in each word, self.c_dim )\\n char_filter = tf.get_variable(\\\"char_filter\\\", dtype=tf.float32,\\n shape=[self.c_filter_width, \\n self.c_filter_height,\\n self.c_dim_input,\\n self.c_dim_output])\\n print(\\\"adding 2d convolution layer\\\")\\n char_conv_layer = tf.nn.conv2d(char_embeddings, char_filter, \\n strides=[1, 1, 1, 1], \\n padding=\\\"SAME\\\")\\n char_conv_layer = tf.nn.tanh(char_conv_layer)\\n print(\\\"adding 2d pooling layer\\\")\\n char_conv_layer = tf.layers.max_pooling2d(char_conv_layer, \\n 1, \\n strides=1)\\n char_output = tf.reshape(char_conv_layer, shape=[-1, self.max_len, \\n self.max_word_length*\\n self.c_dim_output])\\n word_embeddings = tf.concat([word_embeddings, char_output], axis=-1)\\n if self.pos and self.concat_pos:\\n print(\\\"concatenating pos with word_embeddings\\\")\\n word_embeddings = tf.concat([word_embeddings, pos_embeddings], axis=-1)\\n self.word_embeddings = word_embeddings\\n if self.use_additional and self.hybrid:\\n print(\\\"using additional embeddings\\\")\\n _word_embeddings_2 = tf.Variable(self.additional_embeddings,\\n name=\\\"two_word_embeddings\\\",\\n dtype=tf.float32, trainable=False)\\n word_embeddings_2 = tf.nn.embedding_lookup(_word_embeddings_2,\\n self.word_ids,\\n name=\\\"two_word_embeddings\\\")\\n self.word_embeddings_2 = word_embeddings_2\",\n \"def create_model(self):\\n\\t\\twith tf.name_scope(\\\"input\\\"):\\n\\t\\t\\tself.user_embedding = tf.get_variable(\\\"user_embed\\\", \\n\\t\\t\\t\\t[self.user_size, self.embed_size], dtype=tf.float32)\\n\\t\\t\\tself.item_embedding = tf.get_variable(\\\"item_embed\\\", \\n\\t\\t\\t\\t[self.item_size, self.embed_size], dtype=tf.float32)\\n\\t\\t\\tself.user_embed = tf.nn.embedding_lookup(\\n\\t\\t\\t\\t\\t\\t\\tself.user_embedding, self.user)\\n\\t\\t\\tself.item_embed = tf.nn.embedding_lookup(\\n\\t\\t\\t\\t\\t\\t\\tself.user_embedding, self.item)\\n\\t\\twith tf.name_scope(\\\"fusion\\\"):\\n\\t\\t\\tself.user_fusion_add = self.user_embed + self.user_feature\\n\\t\\t\\tself.item_fusion_add = self.item_embed + self.item_feature\\n\\n\\t\\t\\tself.user_fusion = tf.layers.dense(inputs=self.user_fusion_add,\\n\\t\\t\\t\\t\\t\\t\\t\\tunits=self.embed_size,\\n\\t\\t\\t\\t\\t\\t\\t\\tactivation=self.activation_func,\\n\\t\\t\\t\\t\\t\\t\\t\\tkernel_regularizer=self.regularizer,\\n\\t\\t\\t\\t\\t\\t\\t\\tname='user_fusion')\\n\\t\\t\\tself.item_fusion = tf.layers.dense(inputs=self.item_fusion_add,\\n\\t\\t\\t\\t\\t\\t\\t\\tunits=self.embed_size,\\n\\t\\t\\t\\t\\t\\t\\t\\tactivation=self.activation_func,\\n\\t\\t\\t\\t\\t\\t\\t\\tkernel_regularizer=self.regularizer,\\n\\t\\t\\t\\t\\t\\t\\t\\tname='item_fusion')\\n\\n\\t\\twith tf.name_scope(\\\"attention\\\"):\\n\\t\\t\\tself.feature_all = tf.concat([\\n\\t\\t\\t\\t\\t\\tself.user_fusion, self.item_fusion], -1)\\n\\t\\t\\tself.att_layer1 = tf.layers.dense(inputs=self.feature_all,\\n\\t\\t\\t\\t\\t\\t\\t\\tunits=1,\\n\\t\\t\\t\\t\\t\\t\\t\\tactivation=self.activation_func,\\n\\t\\t\\t\\t\\t\\t\\t\\tkernel_regularizer=self.regularizer,\\n\\t\\t\\t\\t\\t\\t\\t\\tname='att_layer1')\\n\\t\\t\\tself.att_layer2 = tf.layers.dense(inputs=self.att_layer1,\\n\\t\\t\\t\\t\\t\\t\\t\\tunits=self.embed_size,\\n\\t\\t\\t\\t\\t\\t\\t\\tactivation=self.activation_func,\\n\\t\\t\\t\\t\\t\\t\\t\\tkernel_regularizer=self.regularizer,\\n\\t\\t\\t\\t\\t\\t\\t\\tname='att_layer2')\\n\\t\\t\\tself.att_weights = tf.nn.softmax(self.att_layer2, \\n\\t\\t\\t\\t\\t\\t\\t\\taxis=-1, name='att_softmax')\\n\\n\\t\\twith tf.name_scope(\\\"prediction\\\"):\\n\\t\\t\\tself.interact = self.att_weights*self.user_fusion*self.item_fusion\\n\\t\\t\\tself.interact1 = tf.layers.dense(inputs=self.interact,\\n\\t\\t\\t\\t\\t\\t\\t\\tunits=self.embed_size,\\n\\t\\t\\t\\t\\t\\t\\t\\tactivation=self.activation_func,\\n\\t\\t\\t\\t\\t\\t\\t\\tkernel_regularizer=self.regularizer,\\n\\t\\t\\t\\t\\t\\t\\t\\tname='interact1')\\n\\t\\t\\tself.interact1 = tf.nn.dropout(self.interact1, self.dropout)\\n\\t\\t\\tself.prediction = tf.layers.dense(inputs=self.interact,\\n\\t\\t\\t\\t\\t\\t\\t\\tunits=1,\\n\\t\\t\\t\\t\\t\\t\\t\\tactivation=None,\\n\\t\\t\\t\\t\\t\\t\\t\\tkernel_regularizer=self.regularizer,\\n\\t\\t\\t\\t\\t\\t\\t\\tname='prediction')\\n\\t\\t\\tself.prediction = tf.reshape(self.prediction, [-1])\",\n \"def _embed_composite_feature(self, features, embedding_layers):\\n embedding_list = []\\n for i in range(len(embedding_layers)):\\n embedding_list.append(embedding_layers[i](features[:, :, i]))\\n embedding = tf.add_n(embedding_list)\\n return embedding\",\n \"def load_pretrain_embedding(vocab, embed_size, embedding_path):\\n model = KeyedVectors.load_word2vec_format(embedding_path)\\n\\n print('{} {}'.format(vocab.size(), embed_size))\\n for token, id in vocab.token2id.items():\\n if token in model:\\n print('{} {}'.format(token, ' '.join(map(str, model[token]))))\\n else:\\n emb = np.random.random((embed_size,)) - 0.5\\n print('{} {}'.format(token, ' '.join(map(str, emb))))\",\n \"def init_word_embed(config):\\n embedding_mat_val = np.load(config.wordembed_params)\\n with tf.variable_scope('vc'):\\n with tf.variable_scope('lstm', reuse=True):\\n embedding_mat = tf.get_variable(\\\"embedding_mat\\\", [config.num_vocab, config.embed_dim])\\n init_we = tf.assign(embedding_mat, embedding_mat_val)\\n return [init_we]\",\n \"def _generate_embeddings(self, config): \\n tr_parts = []\\n te_parts = []\\n all_columns = []\\n for comp in self.components:\\n tr_tmp, te_tmp, cols = comp.generate(config)\\n if cols != None:\\n print(tr_tmp.shape,te_tmp.shape)\\n tr_parts.append(tr_tmp)\\n te_parts.append(te_tmp)\\n all_columns += cols\\n X_train = np.concatenate(tr_parts, axis=1)\\n X_test = np.concatenate(te_parts, axis=1)\\n print(\\\"Concatenated size:\\\", X_train.shape, X_test.shape)\\n self.feature_columns = all_columns\\n return X_train, X_test\",\n \"def embedded(self, word_ids, embedding_tensor, scope=\\\"embedding\\\"):\\n with tf.variable_scope(scope):\\n with tf.device(\\\"/cpu:0\\\"):\\n inputs = tf.nn.embedding_lookup(embedding_tensor, word_ids)\\n return inputs\",\n \"def gen_embedding(text, model, tokenizer):\\n ### Tokenize the texts\\n encoded_input = tokenizer(text, padding=True, truncation=True, max_length=512, return_tensors='pt')\\n \\n ### Encode the tokenized data with model\\n with torch.no_grad():\\n model_output = model(**encoded_input)\\n \\n ### Pool the outputs into a single vector\\n sentence_embeddings = mean_pooling(model_output, encoded_input['attention_mask'])\\n return sentence_embeddings\",\n \"def add_embeddings(self):\\n\\n with tf.device('/cpu:0'):\\n with tf.variable_scope('Embedding_Layer'):\\n embeddings = tf.Variable(self.initial_embeddings,name = 'Embeddings')\\n self.input_embeddings = tf.nn.embedding_lookup(embeddings, self.inputs_placeholder) #(N,S,D)\\n self.question_embeddings = tf.nn.embedding_lookup(embeddings, self.questions_placeholder) #(N,S,D)\",\n \"def load_embeddings(embedding_path, embedding_size, embedding_format):\\n print(\\\"Loading word embeddings from {}...\\\".format(embedding_path))\\n\\n if embedding_format in ['vec', 'txt']:\\n default_embedding = np.zeros(embedding_size)\\n embedding_dict = collections.defaultdict(lambda: default_embedding)\\n skip_first = embedding_format == \\\"vec\\\"\\n with open(embedding_path) as f:\\n for i, line in enumerate(f.readlines()):\\n if skip_first and i == 0:\\n continue\\n splits = line.split(' ')\\n assert len(splits) == embedding_size + 1\\n word = splits[0]\\n embedding = np.array([float(s) for s in splits[1:]])\\n embedding_dict[word] = embedding\\n elif embedding_format == 'bin':\\n embedding_dict = fasttext.load_model(embedding_path)\\n else:\\n raise ValueError('Not supported embeddings format {}'.format(embedding_format))\\n print(\\\"Done loading word embeddings.\\\")\\n return embedding_dict\",\n \"def call(self, inputs):\\n unpacked_inputs = tf_utils.unpack_inputs(inputs)\\n word_embeddings = unpacked_inputs[0]\\n token_type_ids = unpacked_inputs[1]\\n input_shape = tf_utils.get_shape_list(word_embeddings, expected_rank=3)\\n batch_size = input_shape[0]\\n seq_length = input_shape[1]\\n width = input_shape[2]\\n\\n output = word_embeddings\\n if self.use_type_embeddings:\\n flat_token_type_ids = tf.reshape(token_type_ids, [-1])\\n token_type_embeddings = tf.gather(self.type_embeddings,\\n flat_token_type_ids)\\n token_type_embeddings = tf.reshape(token_type_embeddings,\\n [batch_size, seq_length, width])\\n output += token_type_embeddings\\n\\n if self.use_position_embeddings:\\n position_embeddings = tf.expand_dims(\\n tf.slice(self.position_embeddings, [0, 0], [seq_length, width]),\\n axis=0)\\n\\n output += position_embeddings\\n\\n output = self.output_layer_norm(output)\\n output = self.output_dropout(output)\\n\\n return output\",\n \"def call(self, inputs):\\n unpacked_inputs = tf_utils.unpack_inputs(inputs)\\n word_embeddings = unpacked_inputs[0]\\n token_type_ids = unpacked_inputs[1]\\n input_shape = tf_utils.get_shape_list(word_embeddings, expected_rank=3)\\n batch_size = input_shape[0]\\n seq_length = input_shape[1]\\n width = input_shape[2]\\n\\n output = word_embeddings\\n if self.use_type_embeddings:\\n flat_token_type_ids = tf.reshape(token_type_ids, [-1])\\n token_type_embeddings = tf.gather(self.type_embeddings,\\n flat_token_type_ids)\\n token_type_embeddings = tf.reshape(token_type_embeddings,\\n [batch_size, seq_length, width])\\n output += token_type_embeddings\\n\\n if self.use_position_embeddings:\\n position_embeddings = tf.expand_dims(\\n tf.slice(self.position_embeddings, [0, 0], [seq_length, width]),\\n axis=0)\\n\\n output += position_embeddings\\n\\n output = self.output_layer_norm(output)\\n output = self.output_dropout(output)\\n\\n return output\",\n \"def word2vec2embed(word2vec, word2idx):\\n\\temb_dim = word2vec['the'].shape[0]\\n\\temb = torch.nn.Embedding(len(word2idx), emb_dim) \\n\\temb_matrix = []\\n\\tfor w, idx in word2idx.items():\\n\\t\\tif w in word2vec:\\n\\t\\t\\temb_matrix.append(word2vec[w])\\n\\t\\telse:\\n\\t\\t\\temb_matrix.append(np.zeros(emb_dim,))\\n\\temb.weight.data.copy_(torch.from_numpy(np.array(emb_matrix)))\\n\\treturn emb\",\n \"def create_embeddings(model_fc, ds, model_name, storage_path, storage_size=1000, parallel=True): \\n\\n # create folder when doesn't exist yet\\n try:\\n os.makedirs(storage_path)\\n except OSError as e:\\n if e.errno != errno.EEXIST:\\n raise\\n \\n print(\\\"Let's use\\\", torch.cuda.device_count(), \\\"GPUs!\\\")\\n feature_extractor = model_fc\\n if parallel:\\n feature_extractor = nn.DataParallel(model_fc)\\n target_dataset = ds\\n len_target_dataset = len(target_dataset)\\n # save some memory\\n\\n feature_extractor.eval()\\n \\n with torch.no_grad():\\n device = torch.device(\\\"cuda:0\\\" if torch.cuda.is_available() else \\\"cpu\\\")\\n print(f\\\"Moving model to {device}\\\")\\n feature_extractor = feature_extractor.to(device)\\n params = {'batch_size': 50,\\n 'shuffle': False,\\n 'num_workers': 6,\\n 'pin_memory': False}\\n\\n print(f\\\"Length of dataset is {len_target_dataset}\\\")\\n if (len_target_dataset >= storage_size):\\n\\n if len_target_dataset % storage_size != 0:\\n until_i = (len_target_dataset // storage_size + 1)\\n else:\\n until_i = (len_target_dataset // storage_size)\\n\\n for i in range(until_i):\\n\\n \\\"\\\"\\\"Check if we overshot the entries\\\"\\\"\\\"\\n if ((i+1)*storage_size <= len_target_dataset):\\n t_dataset = torch.utils.data.Subset(target_dataset, range(i*storage_size, (i+1)*storage_size))\\n else:\\n remainder = len_target_dataset - i*storage_size\\n print(f\\\"Calculating for remainder: {remainder} because we want to extract {(i+1)*storage_size}\\\")\\n t_dataset = torch.utils.data.Subset(target_dataset, range(i*storage_size, (i*storage_size) + remainder))# use remainder\\n\\n training_generator = data.DataLoader(t_dataset, **params)\\n\\n features = torch.Tensor([]).to(device)\\n labels = torch.LongTensor([]).to(device)\\n\\n for local_batch, local_labels in training_generator:\\n local_batch = local_batch.to(device)\\n local_labels = local_labels.to(device)\\n output = feature_extractor(local_batch)\\n features = torch.cat([features, output], dim=0)\\n labels = torch.cat([labels, local_labels], dim=0)\\n\\n print(features.size())\\n features = features.to(\\\"cpu\\\")\\n labels = labels.to(\\\"cpu\\\")\\n\\n x = features.detach().numpy()\\n y = labels.detach().numpy()\\n\\n np.savez_compressed(f'{storage_path}/{model_name}_{i}.npz', x=x, y=y)\\n\\n del features\\n del labels\\n del local_batch\\n del local_labels\\n torch.cuda.empty_cache()\\n\\n if (len_target_dataset < storage_size):\\n training_generator = data.DataLoader(target_dataset, **params)\\n features = torch.Tensor([]).to(device)\\n labels = torch.LongTensor([]).to(device)\\n\\n for local_batch, local_labels in training_generator:\\n local_batch = local_batch.to(device)\\n local_labels = local_labels.to(device)\\n output = feature_extractor(local_batch)\\n features = torch.cat([features, output], dim=0)\\n labels = torch.cat([labels, local_labels], dim=0)\\n\\n print(features.size())\\n features = features.to(\\\"cpu\\\")\\n labels = labels.to(\\\"cpu\\\")\\n\\n x = features.detach().numpy()\\n y = labels.detach().numpy()\\n\\n np.savez_compressed(f'{storage_path}/{model_name}_0.npz', x=x, y=y)\\n\\n del features\\n del labels\\n del local_batch\\n del local_labels\\n torch.cuda.empty_cache()\",\n \"def embedding_setup(self, embedding, emb_trainable):\\n if emb_trainable == True:\\n emb_variable = tf.get_variable(\\n name=\\\"embedding_matrix\\\", shape=embedding.shape,\\n initializer = tf.constant_initializer(embedding))\\n return emb_variable\\n else:\\n return embedding\",\n \"def modify_to_return_embeddings(net, model_name):\\n if model_name in [\\\"vgg_face_dag\\\", \\\"vgg_m_face_bn_dag\\\"]:\\n net.fc8 = torch.nn.Sequential()\\n else:\\n msg = \\\"{} not yet supported\\\".format(model_name)\\n raise NotImplementedError(msg)\\n return net\",\n \"def target_embedding_fairseq(self):\\r\\n if self.params[\\\"embedding.share\\\"]:\\r\\n return self.source_embedding_fairseq()\\r\\n return tf.get_variable(\\r\\n name=\\\"W\\\",\\r\\n shape=[self.target_vocab_info.total_size, self.params[\\\"embedding.dim\\\"]],\\r\\n initializer=tf.random_normal_initializer(\\r\\n mean=0.0,\\r\\n stddev=0.1))\",\n \"def setup_embeddings(self):\\n with vs.variable_scope(\\\"embeddings\\\"):\\n vec_embeddings = tf.get_variable(\\\"embeddings\\\", initializer=self.pretrained_embeddings, trainable=False)\\n context_batch_embeddings = tf.nn.embedding_lookup(vec_embeddings, self.context_placeholder)\\n question_batch_embeddings = tf.nn.embedding_lookup(vec_embeddings, self.question_placeholder)\\n context_embeddings = tf.reshape(context_batch_embeddings,\\n (-1, self.max_context_len, self.vocab_dim))\\n question_embeddings = tf.reshape(question_batch_embeddings,\\n (-1, self.max_question_len, self.vocab_dim))\\n return context_embeddings, question_embeddings\",\n \"def testEmbeddings(self):\\n input_data = {\\n \\\"x\\\":\\n constant_op.constant(\\n np.array(np.random.random_sample((20)), dtype=np.int32))\\n }\\n\\n class EmbeddingModel(keras.Model):\\n\\n def __init__(self):\\n super(EmbeddingModel, self).__init__()\\n self.shared_weights = self.add_weight(\\n \\\"weights\\\",\\n shape=(2000, 300),\\n dtype=dtypes.float32,\\n initializer=init_ops.random_normal_initializer(\\n mean=0.0, stddev=300**(-0.5)))\\n\\n @def_function.function(input_signature=[\\n tensor_spec.TensorSpec(shape=(20), dtype=dtypes.int32)\\n ])\\n def func(self, x):\\n return array_ops.gather(self.shared_weights, x)\\n\\n model = EmbeddingModel()\\n root, output_func = self._freezeModel(model.func)\\n self._testConvertedFunction(root, root.f, output_func, input_data)\",\n \"def output_layer(self, features):\\n if self.adaptive_softmax is None:\\n # project back to size of vocabulary\\n if self.share_input_output_embed:\\n return F.linear(features, self.embed_tokens.map_layer.weight)\\n else:\\n return self.embed_out(features)\\n else:\\n return features\",\n \"def _get_appdesc_embeddings(self, features, training):\\n # Using GloVe, embed each token then aggregate them.\\n appdesc_embeddings = self._word_embedding_layer(\\n features['appdesc_token_id'])\\n appdesc_embeddings = self._aggregate_text_embedding(\\n features['appdesc_token_id'], appdesc_embeddings)\\n\\n if training:\\n appdesc_embeddings = tf.nn.dropout(\\n appdesc_embeddings, rate=self._hparams['dropout'])\\n\\n return appdesc_embeddings\",\n \"def source_embedding_fairseq(self):\\r\\n return tf.get_variable(\\r\\n name=\\\"W\\\",\\r\\n shape=[self.params[\\\"feature.dim\\\"], self.params[\\\"embedding.dim\\\"]],\\r\\n initializer=tf.random_normal_initializer(\\r\\n mean=0.0,\\r\\n stddev=0.1))\",\n \"def _add_embedding_layer(model_1, model_2):\\n result_layer = torch.nn.Embedding(\\n model_1.num_embeddings, model_1.embedding_dim + model_2.embedding_dim\\n )\\n result_layer.weight = torch.nn.Parameter(\\n torch.cat((model_1.weight.data, model_2.weight.data), dim=1)\\n )\\n return result_layer\",\n \"def get_embedding(self, model):\\n embedding = []\\n for node in range(len(self.graph.nodes())):\\n embedding.append(list(model[str(node)]))\\n embedding = np.array(embedding)\\n return embedding\",\n \"def get_word_embedding(counter, emb_file, emb_size, vocab_size, vec_size, vocab_file):\\n print(\\\"Generating word embedding...\\\")\\n # load word embeddings\\n embedding_dict = {}\\n with open(emb_file, \\\"r\\\", encoding=\\\"utf-8\\\") as fh:\\n for line in tqdm(fh, total=emb_size):\\n array = line.split()\\n word = \\\"\\\".join(array[0:-vec_size])\\n vector = list(map(float, array[-vec_size:]))\\n embedding_dict[word] = vector\\n\\n TRANSLATE = {\\n \\\"-lsb-\\\": \\\"[\\\", \\\"-rsb-\\\": \\\"]\\\", \\\"-lrb-\\\": \\\"(\\\", \\\"-rrb-\\\": \\\")\\\", \\\"-lcb-\\\": \\\"{\\\",\\n \\\"-rcb-\\\": \\\"}\\\", \\\"-LSB-\\\": \\\"[\\\", \\\"-RSB-\\\": \\\"]\\\", \\\"-LRB-\\\": \\\"(\\\", \\\"-RRB-\\\": \\\")\\\",\\n \\\"-LCB-\\\": \\\"{\\\", \\\"-RCB-\\\": \\\"}\\\"\\n }\\n SPECIAL_TOKENS = [\\\"<NULL>\\\", \\\"<UNK>\\\", \\\"<S>\\\", \\\"</S>\\\"]\\n words = list(map(lambda x: x[0], sorted(counter.items(), key=lambda x: x[1], reverse=True)))\\n words = SPECIAL_TOKENS + words\\n if vocab_size > 0:\\n words = words[:vocab_size]\\n with open(vocab_file, 'w') as f:\\n f.write('\\\\n'.join(words[1:]))\\n embedding = np.random.normal(scale=0.1, size=(len(words), vec_size))\\n word2idx_dict = {}\\n unknown_count = 0\\n for i, word in enumerate(words):\\n word2idx_dict[word] = i\\n if word in TRANSLATE:\\n word = TRANSLATE[word]\\n done = False\\n for w in (word, word.lower(), word.upper(), word.capitalize()):\\n if w in embedding_dict:\\n embedding[i] = embedding_dict[w]\\n done = True\\n break\\n if not done:\\n unknown_count += 1\\n return embedding, word2idx_dict, unknown_count\",\n \"def get_embeddings() -> tuple:\\n # Initialize the model loading Universal Sentense Encoder\\n # into a KerasLayer from Kaggle dataset file\\n model = tf.keras.Sequential(\\n [KerasLayer(encoder_path, input_shape=[], dtype=tf.string,\\n output_shape=[512], trainable=False),\\n # tf.keras.layers.Layer(512, dtype=tf.float16) # To reduce memory footprint\\n ]\\n )\\n\\n train_emb = model.predict(data_train['text'])\\n print('Train texts converted into embeddings. Shape:', train_emb.shape)\\n\\n test_emb = model.predict(data_test['text'])\\n print('Test texts converted into embeddings. Shape:', test_emb.shape)\\n\\n return train_emb, test_emb\",\n \"def _create_tf_embed_fnn(\\n self,\\n x_in: \\\"tf.Tensor\\\",\\n layer_sizes: List[int],\\n fnn_name: Text,\\n embed_name: Text,\\n ) -> \\\"tf.Tensor\\\":\\n\\n x = train_utils.create_tf_fnn(\\n x_in,\\n layer_sizes,\\n self.droprate,\\n self.C2,\\n self._is_training,\\n layer_name_suffix=fnn_name,\\n )\\n return train_utils.create_tf_embed(\\n x,\\n self.embed_dim,\\n self.C2,\\n self.similarity_type,\\n layer_name_suffix=embed_name,\\n )\",\n \"def get_embedding(num_embeddings, embedding_dim, padding_idx=None):\\n half_dim = embedding_dim // 2\\n emb = math.log(10000) / (half_dim - 1)\\n emb = torch.exp(torch.arange(half_dim, dtype=torch.float) * -emb)\\n emb = torch.arange(num_embeddings, dtype=torch.float).unsqueeze(1) * emb.unsqueeze(0)\\n emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=1).view(num_embeddings, -1)\\n if embedding_dim % 2 == 1:\\n emb = torch.cat([emb, torch.zeros(num_embeddings, 1)], dim=1)\\n if padding_idx is not None:\\n emb[padding_idx, :] = 0\\n return emb\",\n \"def create_embedding_matrix(self):\\n self.id2word = dict([(self.vocab[word]['id'], word) for word in self.vocab])\\n vocab_size = len(self.vocab)\\n result = np.zeros((vocab_size, self.embed_dim))\\n unknown_token_set = set()\\n\\n found_words = 0\\n avg = np.zeros(self.embed_dim)\\n for _ in range(1, vocab_size): # skip PAD embedding (initialize as zero embedding)\\n try:\\n result[_] = self.pretrained_embedding[self.id2word[_]]\\n avg += result[_]\\n found_words += 1\\n except:\\n unknown_token_set.add(_)\\n\\n avg /= found_words\\n for _ in unknown_token_set:\\n result[_] = avg\\n self.embedding = result\\n return found_words, len(self.id2word)\",\n \"def concept_embedding(concept_model: ConceptDetectionModel2D):\\n return concept_model.to_embedding()\",\n \"def _get_embedding(self, data):\\n embedding_list = [super()._get_embedding(data)]\\n context = data['context']\\n for i in range(context.shape[1]):\\n embedding_list.append(getattr(self, f'context{i}')(context[:, i:i+1]))\\n return torch.cat(embedding_list, dim=1)\",\n \"def create_embedding_from_name(self, name: str):\\n assert self.name_field is not None\\n kwargs = dict(self.default_args)\\n kwargs.pop(self.name_field)\\n return self.embedding_cls(name, **kwargs) # type: ignore[call-arg]\",\n \"def embedding_model(\\n n_factors: int = 50,\\n window: int = 5,\\n min_count: int = 1,\\n learning_rate: float = 0.05,\\n negative_samples: int = 10,\\n negative_exponent: float = 0.75,\\n workers: int = 4,\\n n_iterations: int = 10,\\n batch_size: int = 10000,\\n skip_gram: int = 0,\\n) -> Word2Vec:\\n logger.info(\\\"Defining Embedding Neural Network model.\\\")\\n model = Word2Vec(\\n vector_size=n_factors,\\n window=window,\\n min_count=min_count,\\n alpha=learning_rate,\\n negative=negative_samples,\\n ns_exponent=negative_exponent,\\n workers=workers,\\n epochs=n_iterations,\\n batch_words=batch_size,\\n sg=skip_gram,\\n compute_loss=True,\\n )\\n return model\",\n \"def _generate_relative_positions_embeddings(length, depth, max_relative_position, name):\\n with tf.variable_scope(name):\\n relative_positions_matrix = _generate_relative_positions_matrix(\\n length, max_relative_position)\\n vocab_size = max_relative_position * 2 + 1\\n embeddings_table = tf.get_variable(\\\"embeddings\\\", [vocab_size, depth])\\n embeddings = tf.gather(embeddings_table, relative_positions_matrix)\\n return embeddings\",\n \"def build_model(max_movie_id, max_user_id):\\n # the number of dimensions our low dimensional embeddings should have\\n dims_of_embedding = 35\\n bias = 1\\n \\n # inputs\\n # define an input layer: set the datatype and the the shape of the tensors it takes, the true shape would be (number_of_movies, 1) but number_of_movies is the batch size, and keras ignores the first dimensions (batch_size), so we give a shape (1,)\\n movie_inputs = Input(shape=(1,), dtype='int32')\\n \\n # define an embedding layer with input dimension (max_movie_id+1) and output dimension (dims_of_embedding). This layer takes a positive integer index (movie id) and outputs a tensor of shape (None, 1,dims_of_embedding), where None is the batch dimension. So this actually where the low-dimensional embedding of movies happens\\n movie_embedding = Embedding(max_movie_id+1, dims_of_embedding, name=\\\"movie\\\")(movie_inputs)\\n movie_bis = Embedding(max_movie_id + 1, bias, name=\\\"moviebias\\\")(movie_inputs)\\n\\n # define analogous layers for the users\\n user_inputs = Input(shape=(1,), dtype='int32')\\n user_embedding = Embedding(max_user_id+1, dims_of_embedding, name=\\\"user\\\")(user_inputs)\\n user_bis = Embedding(max_user_id + 1, bias, name=\\\"userbias\\\")(user_inputs)\\n \\n # the following layers together basically calculate the dot product of user and movie embedding vectors to predict the corresponding rating\\n # the multiply layer multiplies (element-wise) a list of input tensors (all of same shape) and returns a single tensor of the same shape\\n output = multiply([movie_embedding, user_embedding])\\n # a Dropout layer applies Dropout to the input, which means setting a fraction rate (=0.5) of input units to 0 at each update during training. This helps preventing overfitting.\\n output = Dropout(0.5)(output)\\n # a Concatente layer concatenates a list of input tensors into a single tensor\\n output = concatenate([output, user_bis, movie_bis])\\n # a Flatten layer flattens the input\\n output = Flatten()(output)\\n # just regular densely, connected NN layers, where can define the number of units in the layer (e.g. 10), and the activation function of the units (e.g. 'relu')\\n output = Dense(10, activation=\\\"relu\\\")(output)\\n output = Dense(1)(output)\\n\\n # define a model with its input(s) and output(s)\\n model = Model(inputs=[movie_inputs, user_inputs], outputs=output)\\n # prepare the model for training, choose loss, optimizers and potentially metrics\\n model.compile(loss='mae', optimizer='adam', metrics=[rmse])\\n\\n return model\",\n \"def input_dim(use_word_emb, embedding_dim, word_emb_enc_dim):\\n return embedding_dim + use_word_emb * word_emb_enc_dim\",\n \"def make_embedding(path, words, indices):\\n #root = '/'.join(path.split('/')[0:-1])\\n #all_paths = [root+'/'+x for x in os.listdir(root)] #'/'.join(path.split('/')[0:-1]))\\n #for path in all_paths:\\n vec_path = 'data/'+path.split('/')[-1]+'_'+mode\\n print(vec_path)\\n if os.path.exists(vec_path+'.npy'):\\n np_vecs = np.load(vec_path+'.npy')\\n else:\\n words_len = len(words)\\n vecs = []\\n if mode == 'word':\\n f = load_model('wiki.en.bin')\\n for i, w in enumerate(words):\\n if mode == 'word':\\n vec = f.get_word_vector(w)\\n else:\\n vec = eye[indices[w]]\\n vecs.append(vec) \\n if i % 10000 == 0:\\n print(\\\"{} / {}\\\".format(i, words_len))\\n np_vecs = np.asarray(vecs, dtype=np.int8)\\n np.save(vec_path, np_vecs)\\n return np_vecs\",\n \"def __init__(self, vocab, embed_size=512, dropout_rate=0.1, max_len=200):\\n super(DecoderEmbeddings, self).__init__()\\n pad_token_idx = 0 #vocab.tokenizer.ids_to_tokens[0]\\n assert vocab.tokenizer.ids_to_tokens[0] == '[PAD]'\\n self.embeddings = nn.Embedding(len(vocab.tokenizer.ids_to_tokens), embed_size, padding_idx=pad_token_idx)\\n self.positional_encoding = PositionalEncoding(d_model=embed_size, dropout=dropout_rate, max_len=max_len)\",\n \"def glove_embedding(self, word_index, padded, embedding_matrix, part='q'):\\n print(\\\"*\\\" * 50, \\\"Start Glove embedding process\\\", \\\"*\\\" * 50)\\n start_time = time()\\n\\n\\n MAX_SEQ_LEN = None\\n if part == 'q':\\n MAX_SEQ_LEN = self.MAX_Q_SEQ_LEN\\n elif part == 'a':\\n MAX_SEQ_LEN = self.MAX_A_SEQ_LEN\\n else:\\n print(f\\\"Please indicate you want embedding question part or answer part\\\")\\n\\n\\n input_layer = Input(shape=(MAX_SEQ_LEN,), dtype='int32')\\n embedding_layer = Embedding(input_dim = len(word_index) + 1,\\n output_dim = self.EMBEDDING_DIM,\\n weights=[embedding_matrix],\\n input_length=MAX_SEQ_LEN,\\n trainable=False)(input_layer)\\n # (number of sample, MAX_SEQ_LEN, EMBEDING_DIM)\\n model = Model(inputs=input_layer, outputs=embedding_layer)\\n model.compile('rmsprop', 'mse')\\n output_array = model.predict(padded)\\n\\n cost_time = round((time() - start_time), 4)\\n print(\\\"*\\\" * 40, \\\"End Glove embedding() with {} seconds\\\".format(cost_time), \\\"*\\\" * 40, end='\\\\n\\\\n')\\n\\n return output_array, embedding_layer\",\n \"def add_positional_embedding_nd(x, max_length, name=None):\\n with tf.name_scope(\\\"add_positional_embedding_nd\\\"):\\n x_shape = x.shape.as_list()\\n num_dims = len(x_shape) - 2\\n depth = x_shape[-1]\\n base_shape = [1] * (num_dims + 1) + [depth]\\n base_start = [0] * (num_dims + 2)\\n base_size = [-1] + [1] * num_dims + [depth]\\n for i in range(num_dims):\\n shape = base_shape[:]\\n start = base_start[:]\\n size = base_size[:]\\n shape[i + 1] = max_length\\n size[i + 1] = x_shape[i + 1]\\n var = tf.get_variable(\\n name + \\\"_%d\\\" % i,\\n shape,\\n initializer=tf.random_normal_initializer(0, depth ** -0.5))\\n var = var * depth ** 0.5\\n x += tf.slice(var, start, size)\\n return x\",\n \"def __init__(self,\\n vocab_size,\\n embed_dim,\\n dropout,\\n pretrained,\\n embedding=None,\\n num_gpus=1,\\n default_gpu_id=0,\\n regularizer=None,\\n random_seed=0,\\n trainable=True,\\n scope=\\\"word_feat\\\"):\\n self.vocab_size = vocab_size\\n self.embed_dim = embed_dim\\n self.dropout = dropout\\n self.pretrained = pretrained\\n self.embedding = embedding\\n self.num_gpus = num_gpus\\n self.default_gpu_id = default_gpu_id\\n self.regularizer = regularizer\\n self.random_seed = random_seed\\n self.trainable = trainable\\n self.scope = scope\\n \\n with tf.variable_scope(self.scope, reuse=tf.AUTO_REUSE):\\n self.embedding_layer = create_embedding_layer(self.vocab_size, self.embed_dim, self.pretrained,\\n self.embedding, self.num_gpus, self.default_gpu_id, None, self.random_seed, self.trainable)\\n \\n self.dropout_layer = create_dropout_layer(self.dropout, self.num_gpus, self.default_gpu_id, self.random_seed)\",\n \"def get_embeddings_shape(self):\\n raise NotImplementedError\",\n \"def load_embed_text(embed_file):\\n \\n emb_dict = dict()\\n emb_size = None\\n with codecs.getreader(\\\"utf-8\\\")(tf.gfile.GFile(embed_file, \\\"rb\\\")) as f:\\n for line in f:\\n tokens = line.strip().split(\\\" \\\")\\n word = tokens[0]\\n vec = list(map(float, tokens[1:]))\\n emb_dict[word] = vec\\n if emb_size:\\n assert emb_size == len(vec), \\\"All embeddings should be same size\\\"\\n else:\\n emb_size = len(vec)\\n return emb_dict, emb_size\",\n \"def model(input_shape, model,model2,model3, word_to_index):\\n \\n ### START CODE HERE ###\\n # Define sentence_indices as the input of the graph.\\n # It should be of shape input_shape and dtype 'int32' (as it contains indices, which are integers).\\n sentence_indices = Input(input_shape,dtype='int32')\\n \\n # Create the embedding layer pretrained with GloVe Vectors (≈1 line)\\n embedding_layer, ignored_words = pretrained_embedding_layer(model,model2,model3,word_to_index,300)\\n \\n # Propagate sentence_indices through your embedding layer\\n # (See additional hints in the instructions).\\n embeddings = embedding_layer(sentence_indices)\\n \\n # Propagate the embeddings through an LSTM layer with 128-dimensional hidden state\\n # The returned output should be a batch of sequences.\\n X = LSTM(units=128,input_shape=input_shape,return_sequences=True)(embeddings)\\n # Add dropout with a probability of 0.5\\n X = Dropout(rate=0.5)(X)\\n # Propagate X trough another LSTM layer with 128-dimensional hidden state\\n # The returned output should be a single hidden state, not a batch of sequences.\\n X = LSTM(units=128,input_shape=input_shape,return_sequences=False)(X)\\n # Add dropout with a probability of 0.5\\n X = Dropout(rate=0.5)(X)\\n # Propagate X through a Dense layer with 5 units\\n X = Dense(units=num_classes)(X)\\n# X = Dense(6, activation='softmax')\\n # Add a softmax activation\\n# print(X)\\n# print(type(X))\\n# print(X.shape)\\n# print(sum(X))\\n X = Activation('softmax')(X)\\n \\n # Create Model instance which converts sentence_indices into X.\\n model = Model(inputs=sentence_indices,outputs=X)\\n \\n return model\",\n \"def create_emb_for_encoder_and_decoder(vocab_size,\\n embed_size,\\n dtype=tf.float32,\\n num_partitions=0,\\n scope=None):\\n\\n if num_partitions <= 1:\\n partitioner = None\\n else:\\n # Note: num_partitions > 1 is required for distributed training due to\\n # embedding_lookup tries to colocate single partition-ed embedding variable\\n # with lookup ops. This may cause embedding variables being placed on worker\\n # jobs.\\n partitioner = tf.fixed_size_partitioner(num_partitions)\\n\\n with tf.variable_scope(\\n scope or \\\"embeddings\\\", dtype=dtype, partitioner=partitioner) as scope:\\n # Share embedding\\n embedding_encoder = tf.get_variable(\\\"shared_embedding\\\",\\n [vocab_size, embed_size], dtype)\\n embedding_decoder = embedding_encoder\\n\\n return embedding_encoder, embedding_decoder\",\n \"def build_model(vocab_size, embedding_dim, rnn_units, batch_size):\\n model=tf.keras.Sequential([\\n \\n tf.keras.layers.Embedding(vocab_size, embedding_dim, batch_input_shape=[batch_size, None]),\\n rnn(rnn_units, return_sequences=True, recurrent_initializer='glorot_uniform', stateful=True),\\n tf.keras.layers.Dense(vocab_size)\\n \\n ])\\n \\n return model\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6896678","0.66577274","0.6655466","0.6557072","0.6546917","0.6513097","0.6508412","0.6499041","0.648341","0.6480802","0.63810956","0.6362331","0.6333119","0.62890506","0.6286926","0.62582594","0.6158827","0.61498016","0.61458313","0.61418664","0.6091481","0.60774696","0.60771805","0.6043846","0.60115665","0.5974747","0.5967657","0.5955242","0.59205365","0.5916446","0.5872842","0.58620703","0.5861673","0.58559066","0.5836872","0.58311117","0.58214575","0.5819402","0.58178824","0.5811679","0.57943624","0.57899517","0.57727844","0.57726306","0.5766327","0.57493454","0.57262456","0.5704142","0.5702284","0.5701845","0.5701163","0.5690808","0.56866044","0.5680313","0.5673181","0.56627715","0.5660982","0.56554705","0.5653437","0.5652565","0.5648006","0.5642785","0.56395614","0.5625847","0.5624295","0.5624295","0.56193286","0.56110495","0.56073576","0.56003976","0.5600152","0.559859","0.5594921","0.5591314","0.55872846","0.5576343","0.5563658","0.55607134","0.55590004","0.5558437","0.55465865","0.55430084","0.5542539","0.5528521","0.5521612","0.55181724","0.55014324","0.5500125","0.5494897","0.5493694","0.54914993","0.54910207","0.5489986","0.54873514","0.54772615","0.54771227","0.5474571","0.5470505","0.5468949","0.5466894"],"string":"[\n \"0.6896678\",\n \"0.66577274\",\n \"0.6655466\",\n \"0.6557072\",\n \"0.6546917\",\n \"0.6513097\",\n \"0.6508412\",\n \"0.6499041\",\n \"0.648341\",\n \"0.6480802\",\n \"0.63810956\",\n \"0.6362331\",\n \"0.6333119\",\n \"0.62890506\",\n \"0.6286926\",\n \"0.62582594\",\n \"0.6158827\",\n \"0.61498016\",\n \"0.61458313\",\n \"0.61418664\",\n \"0.6091481\",\n \"0.60774696\",\n \"0.60771805\",\n \"0.6043846\",\n \"0.60115665\",\n \"0.5974747\",\n \"0.5967657\",\n \"0.5955242\",\n \"0.59205365\",\n \"0.5916446\",\n \"0.5872842\",\n \"0.58620703\",\n \"0.5861673\",\n \"0.58559066\",\n \"0.5836872\",\n \"0.58311117\",\n \"0.58214575\",\n \"0.5819402\",\n \"0.58178824\",\n \"0.5811679\",\n \"0.57943624\",\n \"0.57899517\",\n \"0.57727844\",\n \"0.57726306\",\n \"0.5766327\",\n \"0.57493454\",\n \"0.57262456\",\n \"0.5704142\",\n \"0.5702284\",\n \"0.5701845\",\n \"0.5701163\",\n \"0.5690808\",\n \"0.56866044\",\n \"0.5680313\",\n \"0.5673181\",\n \"0.56627715\",\n \"0.5660982\",\n \"0.56554705\",\n \"0.5653437\",\n \"0.5652565\",\n \"0.5648006\",\n \"0.5642785\",\n \"0.56395614\",\n \"0.5625847\",\n \"0.5624295\",\n \"0.5624295\",\n \"0.56193286\",\n \"0.56110495\",\n \"0.56073576\",\n \"0.56003976\",\n \"0.5600152\",\n \"0.559859\",\n \"0.5594921\",\n \"0.5591314\",\n \"0.55872846\",\n \"0.5576343\",\n \"0.5563658\",\n \"0.55607134\",\n \"0.55590004\",\n \"0.5558437\",\n \"0.55465865\",\n \"0.55430084\",\n \"0.5542539\",\n \"0.5528521\",\n \"0.5521612\",\n \"0.55181724\",\n \"0.55014324\",\n \"0.5500125\",\n \"0.5494897\",\n \"0.5493694\",\n \"0.54914993\",\n \"0.54910207\",\n \"0.5489986\",\n \"0.54873514\",\n \"0.54772615\",\n \"0.54771227\",\n \"0.5474571\",\n \"0.5470505\",\n \"0.5468949\",\n \"0.5466894\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7802241"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81978,"cells":{"query":{"kind":"string","value":"Implemnenting this function can bundle the computation of variables which are used for both decoding (alignment/translation) and training. The return value of that function is passed to compute_loss() etc. as the `precomputed` argumemnt."},"document":{"kind":"string","value":"def precompute(self, features, mode, params):\n return None"},"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 precalculate():\n pass","def precalculate():\n pass","def E_step_precompute(self, model_params, my_suff_stat, my_data):","def pre_forward(self, *args, **kwargs):\n batch_size = args[0].shape[0]\n if not self.instantiated:\n self.hidden_dim = args[0].shape[-1]\n self.instantiate(hidden_dim=self.hidden_dim)\n if self.past_key_reparam is None:\n past_key = self.past_key\n else:\n past_key = self.past_key_reparam\n if self.past_value_reparam is None:\n past_value = self.past_value\n else:\n past_value = self.past_value_reparam\n\n # from IPython import embed\n # embed()\n def expand_batchsize(x):\n x = x.reshape(self.prefix_token_num, self.num_heads, -1).transpose(0,1)\n x = x.unsqueeze(0).expand(batch_size, *x.shape)\n return x\n # from IPython import embe\n\n if 'past_key_value' not in kwargs or kwargs['past_key_value'] is None:\n kwargs['past_key_value'] = (expand_batchsize(past_key), expand_batchsize(past_value))\n\n if 'attention_mask' in kwargs and kwargs['attention_mask'] is not None:\n am = kwargs['attention_mask'] # Should check the format of the attention_mask when moving to a new plm.\n kwargs['attention_mask'] = torch.cat([-torch.zeros((*am.shape[:-1],self.prefix_token_num), dtype = am.dtype,device=am.device), am], dim=-1)\n elif len(args) >1: # attention mask is passed via positional argument\n am = args[1]\n am = torch.cat([-torch.zeros((*am.shape[:-1],self.prefix_token_num), dtype = am.dtype,device=am.device), am], dim=-1)\n args = (args[0], am) + args[2:]\n # from IPython import embed\n # embed(header = \"Herein prefixroberta\")\n return args, kwargs","def pre_forward(self, *args, **kwargs):\n batch_size = args[0].shape[0]\n if not self.instantiated:\n self.hidden_dim = args[0].shape[-1]\n self.instantiate(hidden_dim=self.hidden_dim)\n if self.past_key_reparam is None:\n past_key = self.past_key\n else:\n past_key = self.past_key_reparam\n if self.past_value_reparam is None:\n past_value = self.past_value\n else:\n past_value = self.past_value_reparam\n\n\n def expand_batchsize(x):\n x = x.reshape(self.prefix_token_num, self.num_heads, -1).transpose(0,1)\n x = x.unsqueeze(0).expand(batch_size, *x.shape)\n return x\n # from IPython import embe\n\n if 'past_key_value' not in kwargs or kwargs['past_key_value'] is None:\n kwargs['past_key_value'] = (expand_batchsize(past_key), expand_batchsize(past_value))\n\n if 'attention_mask' in kwargs and kwargs['attention_mask'] is not None:\n am = kwargs['attention_mask'] # Should check the format of the attention_mask when moving to a new plm.\n kwargs['attention_mask'] = torch.cat([-torch.zeros((*am.shape[:-1],self.prefix_token_num), dtype = am.dtype,device=am.device), am], dim=-1)\n elif len(args) >1: # attention mask is passed via positional argument\n am = args[1]\n am = torch.cat([-torch.zeros((*am.shape[:-1],self.prefix_token_num), dtype = am.dtype,device=am.device), am], dim=-1)\n args = (args[0], am) + args[2:]\n # from IPython import embed\n # embed(header = \"Herein prefixroberta\")\n return args, kwargs","def compute_localizations_original(depc, gid_list, config=None):\n\n def _package_to_numpy(key_list, result_list, score):\n temp = [\n [key[0] if isinstance(key, tuple) else result[key] for key in key_list]\n for result in result_list\n ]\n return (\n score,\n np.array([_[0:4] for _ in temp]),\n np.array([_[4] for _ in temp]),\n np.array([_[5] for _ in temp]),\n np.array([_[6] for _ in temp]),\n )\n\n def _combined(gid_list, config_dict_list):\n # Combined list of algorithm configs\n colname_list = ['score', 'bboxes', 'thetas', 'confs', 'classes']\n for gid in gid_list:\n accum_list = []\n for colname in colname_list:\n if colname == 'score':\n accum_value = 0.0\n else:\n len_list = []\n temp_list = []\n for config_dict_ in config_dict_list:\n temp = depc.get_property(\n 'localizations_original', gid, colname, config=config_dict_\n )\n len_list.append(len(temp))\n temp_list.append(temp)\n if colname == 'bboxes':\n accum_value = np.vstack(temp_list)\n else:\n accum_value = np.hstack(temp_list)\n assert len(accum_value) == sum(len_list)\n accum_list.append(accum_value)\n yield tuple(accum_list)\n\n logger.info('[ibs] Preprocess Localizations')\n logger.info('config = {!r}'.format(config))\n # Get controller\n ibs = depc.controller\n ibs.assert_valid_gids(gid_list)\n\n config = dict(config)\n config['sensitivity'] = 0.0\n\n flip = config.get('flip', False)\n if flip:\n assert (\n config['algo'] == 'lightnet'\n ), 'config \"flip\" is only supported by the \"lightnet\" algo'\n\n # Normal computations\n base_key_list = ['xtl', 'ytl', 'width', 'height', 'theta', 'confidence', 'class']\n # Temporary for all detectors\n base_key_list[4] = (0.0,) # Theta\n\n ######################################################################################\n if config['algo'] in ['pydarknet', 'yolo', 'cnn']:\n from wbia.algo.detect import yolo\n\n logger.info('[ibs] detecting using PyDarknet CNN YOLO v1')\n detect_gen = yolo.detect_gid_list(ibs, gid_list, **config)\n ######################################################################################\n elif config['algo'] in ['lightnet']:\n from wbia.algo.detect import lightnet\n\n logger.info('[ibs] detecting using Lightnet CNN YOLO v2')\n detect_gen = lightnet.detect_gid_list(ibs, gid_list, **config)\n elif config['algo'] in ['azure']:\n from wbia.algo.detect import azure\n\n logger.info('[ibs] detecting using Azure CustomVision')\n detect_gen = azure.detect_gid_list(ibs, gid_list, **config)\n ######################################################################################\n elif config['algo'] in ['rf']:\n from wbia.algo.detect import randomforest\n\n logger.info('[ibs] detecting using Random Forests')\n assert config['species'] is not None\n base_key_list[6] = (config['species'],) # class == species\n detect_gen = randomforest.detect_gid_list_with_species(ibs, gid_list, **config)\n ######################################################################################\n elif config['algo'] in ['selective-search']:\n from wbia.algo.detect import selectivesearch\n\n logger.info('[ibs] detecting using Selective Search')\n matlab_command = 'selective_search'\n detect_gen = selectivesearch.detect_gid_list(\n ibs, gid_list, matlab_command=matlab_command, **config\n )\n ######################################################################################\n elif config['algo'] in ['selective-search-rcnn']:\n from wbia.algo.detect import selectivesearch\n\n logger.info('[ibs] detecting using Selective Search (R-CNN)')\n matlab_command = 'selective_search_rcnn'\n detect_gen = selectivesearch.detect_gid_list(\n ibs, gid_list, matlab_command=matlab_command, **config\n )\n ######################################################################################\n # elif config['algo'] in ['fast-rcnn']:\n # from wbia.algo.detect import fasterrcnn\n # logger.info('[ibs] detecting using CNN Fast R-CNN')\n # detect_gen = fasterrcnn.detect_gid_list(ibs, gid_list, **config)\n ######################################################################################\n elif config['algo'] in ['faster-rcnn']:\n from wbia.algo.detect import fasterrcnn\n\n logger.info('[ibs] detecting using CNN Faster R-CNN')\n detect_gen = fasterrcnn.detect_gid_list(ibs, gid_list, **config)\n ######################################################################################\n elif config['algo'] in ['darknet']:\n from wbia.algo.detect import darknet\n\n logger.info('[ibs] detecting using Darknet CNN YOLO')\n detect_gen = darknet.detect_gid_list(ibs, gid_list, **config)\n ######################################################################################\n elif config['algo'] in ['ssd']:\n from wbia.algo.detect import ssd\n\n logger.info('[ibs] detecting using CNN SSD')\n detect_gen = ssd.detect_gid_list(ibs, gid_list, **config)\n # ######################################################################################\n elif config['algo'] in ['_COMBINED']:\n # Combined computations\n config_dict_list = [\n # {'algo': 'selective-search', 'config_filepath': None}, # SS1\n {'algo': 'darknet', 'config_filepath': 'pretrained-tiny-pascal'}, # YOLO1\n {'algo': 'darknet', 'config_filepath': 'pretrained-v2-pascal'}, # YOLO2\n {'algo': 'faster-rcnn', 'config_filepath': 'pretrained-zf-pascal'}, # FRCNN1\n {'algo': 'faster-rcnn', 'config_filepath': 'pretrained-vgg-pascal'}, # FRCNN2\n {'algo': 'ssd', 'config_filepath': 'pretrained-300-pascal'}, # SSD1\n {'algo': 'ssd', 'config_filepath': 'pretrained-512-pascal'}, # SSD1\n {'algo': 'ssd', 'config_filepath': 'pretrained-300-pascal-plus'}, # SSD\n {'algo': 'ssd', 'config_filepath': 'pretrained-512-pascal-plus'}, # SSD4\n ]\n detect_gen = _combined(gid_list, config_dict_list)\n elif config['algo'] in ['tile_aggregation', 'tile_aggregation_quick']:\n from wbia.other.detectfuncs import general_intersection_over_union\n\n include_grid2 = config['algo'] in ['tile_aggregation']\n tid_list = ibs.scout_get_valid_tile_rowids(\n gid_list=gid_list, include_grid2=include_grid2\n )\n\n ancestor_gid_list = ibs.get_tile_ancestor_gids(tid_list)\n bbox_list = ibs.get_tile_bboxes(tid_list)\n size_list = ibs.get_image_sizes(tid_list)\n\n config_filepath = config['config_filepath']\n assert config_filepath in [\n 'variant1',\n 'variant2',\n 'variant2-32',\n 'variant2-64',\n 'variant3-32',\n 'variant3-64',\n 'variant4-32',\n 'variant4-64',\n ]\n\n weight_filepath = config['weight_filepath']\n weight_filepath = weight_filepath.strip().split(';')\n\n assert len(weight_filepath) == 2\n algo_, model_tag_ = weight_filepath\n\n if algo_ in ['densenet+lightnet']:\n model_tag_ = model_tag_.strip().split(',')\n\n assert len(model_tag_) == 4\n wic_model_tag, wic_thresh, weight_filepath, nms_thresh = model_tag_\n wic_thresh = float(wic_thresh)\n nms_thresh = float(nms_thresh)\n wic_confidence_list = ibs.scout_wic_test(\n tid_list, classifier_algo='densenet', model_tag=wic_model_tag\n )\n\n flag_list = [\n wic_confidence >= wic_thresh for wic_confidence in wic_confidence_list\n ]\n tid_list_ = ut.compress(tid_list, flag_list)\n logger.info(\n '%d tiles passed WIC filter out of %d'\n % (\n len(tid_list_),\n len(tid_list),\n )\n )\n\n loc_config = {\n 'grid': False,\n 'algo': 'lightnet',\n 'config_filepath': weight_filepath,\n 'weight_filepath': weight_filepath,\n 'nms': True,\n 'nms_thresh': nms_thresh,\n 'sensitivity': 0.0,\n }\n prediction_list = depc.get_property(\n 'localizations', tid_list_, None, config=loc_config\n )\n prediction_dict = dict(zip(tid_list_, prediction_list))\n else:\n raise ValueError('Only \"densenet+lightnet\" is implemented')\n\n gid_dict = {}\n zipped = list(zip(ancestor_gid_list, tid_list, size_list, bbox_list))\n for ancestor_gid, tid, tile_size, tile_bbox in tqdm.tqdm(zipped):\n prediction = prediction_dict.get(tid, None)\n\n if prediction is None:\n continue\n\n score, bboxes, thetas, confs, classes = prediction\n tile_xtl, tile_ytl, tile_w, tile_h = tile_bbox\n\n if ancestor_gid not in gid_dict:\n gid_dict[ancestor_gid] = {\n 'score': [],\n 'bboxes': [],\n 'thetas': [],\n 'confs': [],\n 'classes': [],\n }\n\n bboxes_ = []\n confs_ = []\n for detect_bbox, detect_conf in zip(bboxes, confs):\n detect_xtl, detect_ytl, detect_w, detect_h = detect_bbox\n detect_xbr = detect_xtl + detect_w\n detect_ybr = detect_ytl + detect_h\n detect_annot = {\n 'xtl': detect_xtl / tile_w,\n 'ytl': detect_ytl / tile_h,\n 'xbr': detect_xbr / tile_w,\n 'ybr': detect_ybr / tile_h,\n 'width': detect_w / tile_w,\n 'height': detect_h / tile_h,\n }\n\n multiplier = None\n if config_filepath in ['variant1']:\n multiplier = 1.0\n elif config_filepath in [\n 'variant2',\n 'variant2-32',\n 'variant2-64',\n 'variant3-32',\n 'variant3-64',\n 'variant4-32',\n 'variant4-64',\n ]:\n margin = (\n 32.0\n if config_filepath\n in ['variant-2', 'variant2-32', 'variant3-32', 'variant4-32']\n else 64.0\n )\n tile_w, tile_h = tile_size\n margin_percent_w = margin / tile_w\n margin_percent_h = margin / tile_h\n xtl = margin_percent_w\n ytl = margin_percent_h\n xbr = 1.0 - margin_percent_w\n ybr = 1.0 - margin_percent_h\n width = xbr - xtl\n height = ybr - ytl\n center = {\n 'xtl': xtl,\n 'ytl': ytl,\n 'xbr': xbr,\n 'ybr': ybr,\n 'width': width,\n 'height': height,\n }\n intersection, union = general_intersection_over_union(\n detect_annot, center, return_components=True\n )\n area = detect_annot['width'] * detect_annot['height']\n overlap = 0.0 if area <= 0 else intersection / area\n assert 0.0 <= overlap and overlap <= 1.0\n\n if config_filepath in ['variant2', 'variant2-32', 'variant2-64']:\n multiplier = overlap\n elif config_filepath in ['variant3-32', 'variant3-64']:\n multiplier = np.sqrt(overlap)\n elif config_filepath in ['variant4-32', 'variant4-64']:\n multiplier = overlap ** overlap\n else:\n raise ValueError\n else:\n raise ValueError\n assert multiplier is not None\n\n bbox_ = (\n tile_xtl + detect_xtl,\n tile_ytl + detect_ytl,\n detect_w,\n detect_h,\n )\n bboxes_.append(bbox_)\n confs_.append(detect_conf * multiplier)\n thetas_ = list(thetas)\n classes_ = list(classes)\n\n gid_dict[ancestor_gid]['score'] += [score]\n gid_dict[ancestor_gid]['bboxes'] += bboxes_\n gid_dict[ancestor_gid]['thetas'] += thetas_\n gid_dict[ancestor_gid]['confs'] += confs_\n gid_dict[ancestor_gid]['classes'] += classes_\n\n detect_gen = []\n for gid in tqdm.tqdm(gid_list):\n if gid in gid_dict:\n score = gid_dict[gid]['score']\n score = sum(score) / len(score) if len(score) > 0 else 0.0\n bboxes = np.array(gid_dict[gid]['bboxes'])\n thetas = np.array(gid_dict[gid]['thetas'])\n confs = np.array(gid_dict[gid]['confs'])\n classes = np.array(gid_dict[gid]['classes'])\n else:\n score = 0.0\n bboxes = np.array([])\n thetas = np.array([])\n confs = np.array([])\n classes = np.array([])\n\n detect = (score, bboxes, thetas, confs, classes)\n detect_gen.append(detect)\n elif config['algo'] in ['scout_detectnet_json', 'scout_faster_rcnn_json']:\n import json\n\n uuid_str_list = list(map(str, ibs.get_image_uuids(gid_list)))\n\n manifest_filepath = join(ibs.dbdir, 'WIC_manifest_output.csv')\n assert config['config_filepath'] in ['variant1']\n json_filepath = join(ibs.dbdir, config['weight_filepath'])\n\n assert exists(manifest_filepath)\n assert exists(json_filepath)\n\n manifest_dict = {}\n with open(manifest_filepath, 'r') as manifest_file:\n manifest_file.readline() # Discard column header row\n manifest_line_list = manifest_file.readlines()\n for manifest_line in manifest_line_list:\n manifest = manifest_line.strip().split(',')\n assert len(manifest) == 2\n manifest_filename, manifest_uuid = manifest\n manifest_dict[manifest_filename] = manifest_uuid\n\n with open(json_filepath, 'r') as json_file:\n json_values = json.load(json_file)\n\n images = json_values.get('images', None)\n annotations = json_values.get('annotations', None)\n\n assert images is not None\n assert annotations is not None\n\n image_dict = {}\n annotation_dict = {}\n for image in images:\n assert 'file_name' in image and 'id' in image, 'Incorrect COCO format'\n image_filename = image['file_name']\n image_id = image['id']\n image_uuid = manifest_dict.get(image_filename, None)\n assert image_uuid is not None\n image_dict[image_id] = image_uuid\n annotation_dict[image_uuid] = []\n\n for annotation in annotations:\n assert 'image_id' in annotation and 'bbox' in annotation\n image_id = annotation['image_id']\n image_uuid = image_dict[image_id]\n assert image_uuid is not None\n annotation_bbox = annotation['bbox']\n assert image_uuid in annotation_dict\n annotation_dict[image_uuid].append(annotation_bbox)\n\n detect_gen = []\n for uuid_str in tqdm.tqdm(uuid_str_list):\n assert uuid_str in annotation_dict\n bbox_list = annotation_dict[uuid_str]\n\n score = 0.0\n bboxes = np.array(bbox_list)\n thetas = np.array([0.0] * len(bbox_list))\n confs = np.array([1.0] * len(bbox_list))\n classes = np.array(['elephant_savanna'] * len(bbox_list))\n\n detect = (score, bboxes, thetas, confs, classes)\n detect_gen.append(detect)\n else:\n raise ValueError(\n 'specified detection algo is not supported in config = {!r}'.format(config)\n )\n\n # yield detections\n for detect in detect_gen:\n if len(detect) == 3:\n gid, gpath, result_list = detect\n score = 0.0\n result = _package_to_numpy(base_key_list, result_list, score)\n else:\n result = detect\n yield result","def compute(self) -> Tensor:\n\n if self.samples:\n return self.average_precisions.float() / self.total\n else:\n # pred_image_indices = torch.cat(self.pred_image_indices, dim=0)\n pred_probs = torch.cat(self.pred_probs, dim=0)\n pred_labels = torch.cat(self.pred_labels, dim=0)\n pred_bboxes = torch.cat(self.pred_bboxes, dim=0)\n\n # target_image_indices = torch.cat(self.target_image_indices, dim=0)\n target_labels = torch.cat(self.target_labels, dim=0)\n target_bboxes = torch.cat(self.target_bboxes, dim=0)\n\n # pred_index = torch.nonzero((pred_labels == 1))\n # pred_probs = pred_probs[pred_index]\n # pred_bboxes = pred_bboxes[pred_index]\n # target_index = torch.nonzero((target_labels == 1))\n # target_bboxes = target_bboxes[target_index]\n\n\n # _, index_sorted = torch.sort(pred_probs)\n # pred_bboxes = pred_bboxes[index_sorted].cpu().detach().numpy()\n # target_bboxes = target_bboxes.cpu().detach().numpy()\n pred_probs = pred_probs.cpu().detach().numpy()\n pred_labels = pred_labels.cpu().detach().numpy()\n pred_bboxes = pred_bboxes.cpu().detach().numpy()\n target_labels = target_labels.cpu().detach().numpy()\n target_bboxes = target_bboxes.cpu().detach().numpy()\n\n pred_probs = pred_probs[pred_labels == 1]\n pred_bboxes = pred_bboxes[pred_labels == 1]\n target_bboxes = target_bboxes[target_labels == 1]\n\n preds_sorted_idx = np.argsort(pred_probs)[::-1]\n pred_bboxes = pred_bboxes[preds_sorted_idx]\n\n x, y = calculate_precision_recall(target_bboxes, pred_bboxes)\n\n if len(x) >= 2:\n return auc(x, y)\n else:\n return 0\n\n # return mean_average_precision(\n # pred_image_indices,\n # pred_probs,\n # pred_labels,\n # pred_bboxes,\n # target_image_indices,\n # target_labels,\n # target_bboxes,\n # self.iou_threshold,\n # self.ap_calculation,\n # )","def precompute_scoring():\n global volume_void_inclusion\n global attract_point_distances\n global perlin_values\n \n volume_void_inclusion = []\n for i,void in enumerate(volumes_void):\n inclusion = gh.PointInBrep(void,points_input,False)\n volume_void_inclusion.append(inclusion)\n \n attract_point_distances = []\n for i,point in enumerate(points_attractor):\n distances = gh.Division(gh.Distance(point,points_input),max_dist)\n attract_point_distances.append(distances)","def _do_compute(self, var_map):\n raise Exception(\"Not implemented. Subclass responsibility\")","def compute_loss(self):","def compute_loss(self, features, mode, params, precomputed):\n raise NotImplementedError(\"Model does not implement loss.\")","def optimize(self):\n \n # converting from batch to local quantities\n if self.dispersion == \"gene-batch\":\n local_dispersion = tf.matmul(self.batch, tf.exp(self.px_r))\n else: \n local_dispersion = tf.exp(self.px_r)\n \n if self.library_mode == \"numeric\":\n local_l_mean = self.library_size_mean\n local_l_var = self.library_size_var\n else:\n local_l_mean = tf.matmul(self.batch, self.library_size_mean)\n local_l_var = tf.matmul(self.batch, self.library_size_var)\n \n \n # VAE loss\n if self.zi:\n recon = log_zinb_positive(self.expression, self.px_rate, local_dispersion, \\\n self.px_dropout)\n else:\n recon = log_nb_positive(self.expression, self.px_rate, local_dispersion)\n \n kl_gauss_z = 0.5 * tf.reduce_sum(\\\n tf.square(self.qz_m) + self.qz_v - tf.log(1e-8 + self.qz_v) - 1, 1)\n\n if self.scalings:\n kl_gauss_l = 0.5 * tf.reduce_sum(\\\n tf.square(self.ql_m - local_l_mean) / local_l_var \\\n + self.ql_v / local_l_var \\\n + tf.log(1e-8 + local_l_var) - tf.log(1e-8 + self.ql_v) - 1, 1)\n \n if self.scalings:\n self.ELBO_gau = tf.reduce_mean(recon - self.kl_scale * kl_gauss_z - kl_gauss_l)\n else:\n self.ELBO_gau = tf.reduce_mean(recon - self.kl_scale * kl_gauss_z)\n \n # MMD loss\n if self.apply_mmd:\n self.mmd = mmd_objective(self.z, self.batch_ind, self.num_batches)\n self.loss = - self.ELBO_gau + self.mmd_scale * self.mmd\n \n else:\n self.loss = - self.ELBO_gau\n \n update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\n optimizer = self.optimize_algo\n with tf.control_dependencies(update_ops):\n self.train_step = optimizer.minimize(self.loss)","def task_metalearn(inp, reuse=True):\n inputa1,inputa2,inputa3, inputb1,inputb2,inputb3, labela, labelb = inp\n print(\"Input a: \" , inputa1)\n task_outputbs, task_lossesb, auto_losses = [], [], []\n auto_loss = None\n\n #One for each. \n\n # This takes in the input and passes out the latent variables.\n temp_in_a_1 = self.encoder(inputa1,self.auto_weights, reuse=reuse)\n #Then transform it back, and take the loss\n temp_out_a_1 = self.decoder(temp_in_a_1,self.auto_weights, reuse=reuse)\n auto_out_a_1 = temp_out_a_1\n\n temp_in_a_2 = self.encoder(inputa2,self.auto_weights, reuse=reuse)\n #Then transform it back, and take the loss\n temp_out_a_2 = self.decoder(temp_in_a_2,self.auto_weights, reuse=reuse)\n auto_out_a_2 = temp_out_a_2\n\n temp_in_a_3 = self.encoder(inputa3,self.auto_weights, reuse=reuse)\n #Then transform it back, and take the loss\n temp_out_a_3 = self.decoder(temp_in_a_3,self.auto_weights, reuse=reuse)\n auto_out_a_3 = temp_out_a_3\n\n # This takes in the input and passes out the latent variables.\n temp_in_b_1 = self.encoder(inputb1,self.auto_weights, reuse=reuse)\n #Then transform it back, and take the loss\n temp_out_b_1 = self.decoder(temp_in_b_1,self.auto_weights, reuse=reuse)\n auto_out_b_1 = temp_out_b_1\n\n temp_in_b_2 = self.encoder(inputb2,self.auto_weights, reuse=reuse)\n #Then transform it back, and take the loss\n temp_out_b_2 = self.decoder(temp_in_b_2,self.auto_weights, reuse=reuse)\n auto_out_b_2 = temp_out_b_2\n\n temp_in_b_3 = self.encoder(inputb3,self.auto_weights, reuse=reuse)\n #Then transform it back, and take the loss\n temp_out_b_3 = self.decoder(temp_in_b_3,self.auto_weights, reuse=reuse)\n auto_out_b_3 = temp_out_b_3\n\n\n #print(\"temp out a: \" , temp_out_a)\n la_1 = self.loss_func(temp_out_a_1,inputa1)\n la_2 = self.loss_func(temp_out_a_2,inputa2)\n la_3 = self.loss_func(temp_out_a_3,inputa3)\n\n lb_1 = self.loss_func(temp_out_b_1,inputb1)\n lb_2 = self.loss_func(temp_out_b_2,inputb2)\n lb_3 = self.loss_func(temp_out_b_3,inputb3)\n\n auto_loss = la_1+la_2+la_3\n\n print(\"Input a1: \" , temp_in_a_1)\n inputa=tf.concat([temp_in_a_1, temp_in_a_2,temp_in_a_3],1)\n inputb=tf.concat([temp_in_b_1, temp_in_b_2,temp_in_b_3],1)\n print(\"Inputa: \" , inputa)\n task_outputa = self.forward(inputa, weights, reuse=reuse) # only reuse on the first iter\n temp_outputa = self.decoder(task_outputa,self.auto_weights,reuse=reuse)\n \n print(\"Task outputa: \" , temp_outputa)\n print(\"Label a: \" , labela)\n task_lossa = self.loss_func(temp_outputa, labela)\n\n grads = tf.gradients(task_lossa, list(weights.values()))\n if FLAGS.stop_grad:\n grads = [tf.stop_gradient(grad) for grad in grads]\n gradients = dict(zip(weights.keys(), grads))\n fast_weights = dict(zip(weights.keys(), [weights[key] - self.update_lr*gradients[key] for key in weights.keys()]))\n output = self.forward(inputb, fast_weights, reuse=True)\n \n temp_outputb = self.decoder(output,self.auto_weights, reuse=True)\n output = temp_outputb\n\n task_outputbs.append(output)\n print(\"Output: \" , output)\n print(\"Labels: \" , labelb)\n task_lossesb.append(self.loss_func(output, labelb))\n print(\"Num updates is: \" , num_updates-1)\n\n for j in range(num_updates - 1):\n loss = self.loss_func(self.decoder(self.forward(inputa, fast_weights, reuse=True),self.auto_weights), labela)\n grads = tf.gradients(loss, list(fast_weights.values()))\n if FLAGS.stop_grad:\n grads = [tf.stop_gradient(grad) for grad in grads]\n gradients = dict(zip(fast_weights.keys(), grads))\n fast_weights = dict(zip(fast_weights.keys(), [fast_weights[key] - self.update_lr*gradients[key] for key in fast_weights.keys()]))\n \n output = self.forward(inputb, fast_weights, reuse=True)\n output = self.decoder(output,self.auto_weights)\n \n task_outputbs.append(output)\n task_lossesb.append(self.loss_func(output, labelb))\n # Task Outputa Direct output, non-decoded (only first step). This is the location (so it is in hyperparameter space)\n # Task_outputbs Output from complete system, for each step (first is after 1st step, 2nd is after next, etc.)\n # task_lossa Loss of difference in first step (decoded)\n # task_lossesb Losses from complete ssystem from each step \n # auto_loss Sum of all auto-encoding loss of a's\n # auto_out_a_1 Auto-encoded a1 output\n # auto_out_a_2 Auto-encoded a2 output\n\n task_output = [temp_outputa, task_outputbs, task_lossa, task_lossesb, auto_loss,auto_out_a_1,auto_out_a_2]\n return task_output","def persistent_training_call(self, inputs, y, branch, enveloppe=None, frozen_common=False):\n # print('using new unet')\n self.train()\n\n # We might want to freeze the hd results to focus on PL.\n out = self.forward(inputs, branch=branch)\n\n # Loss computation TODO : careful with batches !\n if branch == 0:\n target_scale = 1 - y[0, -1, ...]\n else:\n target_scale = y[0, 0, ...]\n weight_loss = self.compute_weight(target=target_scale,\n enveloppe=enveloppe,\n scale_ones=self.score_ones[branch],\n scale_enveloppe=self.wenveloppe)\n\n loss_func = self.branch_losses[branch]\n loss = loss_func(output=out, target=y, weight=weight_loss)\n loss = loss / self.flush_size\n loss.backward()\n\n self.passes += 1\n if self.passes > self.flush_size:\n self.passes = 0\n self.optimizer.step()\n self.optimizer.zero_grad()\n\n return out, loss.item()","def pretrain(args, encoder, classifier, data_loader, optimizer, scheduler):\n\n # setup criterion and optimizer\n # optimizer = optim.Adam(list(encoder.parameters()) + list(classifier.parameters()),\n # lr=param.c_learning_rate)\n\n # set train state for Dropout and BN layers\n encoder.to(DEVICE)\n classifier.to(DEVICE)\n encoder.train()\n classifier.train()\n for epoch in range(args.pre_epochs):\n tr_loss = 0\n nb_tr_examples, nb_tr_steps = 0, 0\n for step, batch in enumerate(tqdm(data_loader, desc=\"Iteration\")):\n batch = tuple(t.to(DEVICE) for t in batch)\n input_ids, visual, acoustic, input_mask, segment_ids, label_ids = batch\n visual = torch.squeeze(visual, 1)\n acoustic = torch.squeeze(acoustic, 1)\n feat = encoder(\n input_ids,\n visual,\n acoustic,\n token_type_ids=segment_ids,\n attention_mask=input_mask,\n labels=None,\n )\n feat.to(DEVICE)\n outputs = classifier(feat)\n outputs.to(DEVICE)\n # logits = outputs[0]\n logits = outputs\n # print(\"mine\", logits.shape, label_ids.shape)\n #print(logits, label_ids)\n\n #loss_fct = MSELoss()\n #loss = loss_fct(logits.view(-1), label_ids.view(-1))\n #print('logits.view(-1) : ' + str(logits.view(-1)) + \"label_ids.view(-1) : \" + str(label_ids.view(-1)) + \"\\n\")\n\n CELoss = nn.CrossEntropyLoss()\n loss = CELoss(logits, label_ids.view(-1).long())\n\n if args.gradient_accumulation_step > 1:\n loss = loss / args.gradient_accumulation_step\n\n loss.backward()\n\n tr_loss += loss.item()\n nb_tr_steps += 1\n if (step + 1) % args.gradient_accumulation_step == 0:\n optimizer.step()\n scheduler.step()\n optimizer.zero_grad()\n print(\"Loss so far: \" +str(tr_loss/nb_tr_steps)+\"\\n\")\n\n # save final model\n # save_model(args, encoder, param.src_encoder_path)\n # save_model(args, classifier, param.src_classifier_path)\n\n return encoder, classifier","def _precompute(self, A):\n return ()","def calculate_vars(self):\n pass","def prepare_emb(self):\n with tf.variable_scope(\"PrepEmb\", reuse=tf.AUTO_REUSE):\n self.src_ten = tf.cast(tf.convert_to_tensor(self.src_ten), tf.float32)\n self.tgt_ten = tf.cast(tf.convert_to_tensor(self.tgt_ten), tf.float32)\n # Mapping\n self.src_ten = tf.matmul(self.src_ten, self.W)\n # Normalization\n self.src_ten = tf.nn.l2_normalize(self.src_ten, axis=1)\n self.tgt_ten = tf.nn.l2_normalize(self.tgt_ten, axis=1)","def compute(self) -> None:\n \n self.model.eval()\n \n with torch.no_grad():\n for (input, target, _) in self.loader:\n\n # self.model = self.model.train(False) # TEST @lacoupe\n output, _ = self.model(input)\n \n output = (output >= 0.5)\n \n for out, tar in zip(output, target):\n \n tar = bool(tar)\n \n if out and tar:\n self.confusion['true_positive'] += 1\n elif not out and not tar:\n self.confusion['true_negative'] += 1\n elif out and not tar:\n self.confusion['false_positive'] += 1\n elif not out and tar:\n self.confusion['false_negative'] += 1\n \n self.accuracy = (self.confusion['true_positive'] + self.confusion['true_negative']) \\\n / sum(list(self.confusion.values()))\n \n if (self.confusion['true_positive'] + self.confusion['false_positive']) == 0.:\n self.precision = 0.\n else:\n self.precision = self.confusion['true_positive'] \\\n / (self.confusion['true_positive'] + self.confusion['false_positive'])\n \n if (self.confusion['true_positive'] + self.confusion['false_negative']) == 0.:\n self.recall = 0.\n else:\n self.recall = self.confusion['true_positive'] \\\n / (self.confusion['true_positive'] + self.confusion['false_negative'])\n \n if (self.precision + self.recall) == 0.:\n self.f1_score = 0.\n else:\n self.f1_score = 2 * self.precision * self.recall / (self.precision + self.recall)","def preprocessing_fn(inputs):\n outputs = {}\n for key in _DENSE_FLOAT_FEATURE_KEYS:\n # Preserve this feature as a dense float, setting nan's to the mean.\n outputs[_transformed_name(key)] = tft.scale_to_z_score(\n _fill_in_missing(inputs[key]))\n\n for key in _VOCAB_FEATURE_KEYS:\n # Build a vocabulary for this feature.\n outputs[_transformed_name(key)] = tft.compute_and_apply_vocabulary(\n _fill_in_missing(inputs[key]),\n top_k=_VOCAB_SIZE,\n num_oov_buckets=_OOV_SIZE)\n\n for key in _BUCKET_FEATURE_KEYS:\n outputs[_transformed_name(key)] = tft.bucketize(\n _fill_in_missing(inputs[key]), _FEATURE_BUCKET_COUNT,\n always_return_num_quantiles=False)\n\n for key in _CATEGORICAL_FEATURE_KEYS:\n outputs[_transformed_name(key)] = _fill_in_missing(inputs[key])\n\n # Was this passenger a big tipper?\n taxi_fare = _fill_in_missing(inputs[_FARE_KEY])\n tips = _fill_in_missing(inputs[_LABEL_KEY])\n outputs[_transformed_name(_LABEL_KEY)] = tf.where(\n tf.is_nan(taxi_fare),\n tf.cast(tf.zeros_like(taxi_fare), tf.int64),\n # Test if the tip was > 20% of the fare.\n tf.cast(\n tf.greater(tips, tf.multiply(taxi_fare, tf.constant(0.2))), tf.int64))\n\n return outputs","def _compute_loss(self, predictions, targets, **params):\n pass","def _compute_loss(self, decoder_output, labels):\n with tf.name_scope(\"compute_loss\"):\n language_logit = decoder_output.logits[0]\n attention_logit = decoder_output.logits[1]\n batch_size = self.params['dataset']['batch_size']\n\n language_losses = self._cross_entropy_sequence_loss(\n logits=language_logit,\n targets=tf.transpose(labels[\"label\"], [1, 0]),\n sequence_length=labels[\"length\"])\n attention_losses = self._cross_entropy_sequence_loss(\n logits=attention_logit,\n targets=tf.transpose(labels[\"label\"], [1, 0]),\n sequence_length=labels[\"length\"])\n\n language_loss = tf.reduce_sum(language_losses) / batch_size\n attention_loss = tf.reduce_sum(attention_losses) / batch_size\n loss = language_loss + attention_loss\n\n return loss","def pre_forward(self, *args, **kwargs):\n batch_size = args[0].shape[0]\n if not self.instantiated:\n self.hidden_dim = args[0].shape[-1]\n self.instantiate(hidden_dim=self.hidden_dim)\n if self.past_key_reparam is None:\n past_key = self.past_key\n else:\n past_key = self.past_key_reparam\n if self.past_value_reparam is None:\n past_value = self.past_value\n else:\n past_value = self.past_value_reparam\n\n def expand_batchsize(x):\n x = x.reshape(self.prefix_token_num, self.num_heads, -1).transpose(0,1)\n x = x.unsqueeze(0).expand(batch_size, *x.shape)\n return x\n\n\n if kwargs['layer_past'] is None:\n kwargs['layer_past'] = (expand_batchsize(past_key), expand_batchsize(past_value))\n if 'attention_mask' in kwargs and kwargs['attention_mask'] is not None:\n am = kwargs['attention_mask'] # Should check the format of the attention_mask when moving to a new plm.\n kwargs['attention_mask'] = torch.cat([-torch.zeros((*am.shape[:-1],self.prefix_token_num), dtype = am.dtype,device=am.device), am], dim=-1)\n return args, kwargs","def inference(self):\r\n\t\tfor partition, loader in self.loaders.items():\r\n\t\t\tavg_loss, (y, y_hat), post, attentions, tags = self.eval_loader(\r\n\t\t\t\tloader)\r\n\t\t\tself.preds[partition] = {\r\n\t\t\t\t'tag': tags,\r\n\t\t\t\t'y': y,\r\n\t\t\t\t'y_hat': y_hat,\r\n\t\t\t\t# 'posteriors': post,\r\n\t\t\t\t# 'attentions': attentions\r\n\t\t\t}","def __compileVariables(self):\n state_variables = []\n state_diffs = []\n networks = []\n frames = []\n vars = []\n\n language = self.language\n\n instansiate_variables = {}\n\n self.obj_vars = self.object_variables()\n for key, var in self.variables.items(): # Grouping the variables\n size = self.size_of_variable(var)\n variable_type = var.type\n if not size or key in self.variables_not_included: # Skip variable\n print('Variable not included:\\tvar: {}'.format(var.label))\n continue\n if var.equation_list and variable_type in ['constant', \"network\"]:\n self.constantEquations.append(*var.equation_list)\n continue\n if variable_type in ['constant', 'frame', 'state']:\n # print(dir(var.units))\n units_pp = var.units.prettyPrint()\n doc_pp = var.doc\n if units_pp:\n units_doc_str = '{}, {}'.format(units_pp, doc_pp)\n else:\n units_doc_str = '{}'.format('Empty', doc_pp)\n instansiate_variables[key] = self.variable_dict(var)\n if var.compiled_index_list: # Index sets need compilation\n string_version = self.matrix_string_zeros(size, prefix = ' ')\n mat = np.zeros(size)\n index = str(var.index_structures) # Convert to string\n rep = self.mod_index[var.index_structures[0]].printable()\n string_w_comments = self.matrix_to_str_w_line_comments(mat, rep,\n prefix = ' ')\n width = 79 - 16 - len(index) - len(var.compiled) # 16 is others\n width2 = 79 - 8 - len(units_pp) - len(doc_pp)\n cons_str = '\\n{0} = {ar}({v: <{msg_box}} {com} {ind}\\n {st} ){v: <{w2}} {com} {udoc}'\n cons_var_str = cons_str.format(var.compiled,\n com = CODE[language][\"comment\"],\n ar = CODE[language][\"list\"],\n st = string_w_comments,\n udoc = units_doc_str,\n ind = index,\n w2 = width2,\n w = width,\n v = '')\n # cons_str = '{0} = {ar}({v: <{msg_box}} {com} {ind}\\n {st})'\n # cons_var_str = cons_str.format(var.compiled,\n # ar = CODE[language]['list'],\n # st = string_w_comments,\n # ind = index,\n # msg_box = width,\n # v = '')\n else:\n string_version = self.matrix_string_zeros(size, prefix = ' ')\n index = 'none'\n width = 79 - 16 - len(index) - len(var.compiled) # 16 is others\n width2 = 79 - 9 - len(units_pp) - len(doc_pp)\n cons_str = '\\n{0} = {array}({val: <{msg_box}} # {ind}\\n {st}\\n ) {h: <{w2}} {com} {udoc}'\n cons_var_str = cons_str.format(var.compiled,\n array = CODE[language][\"list\"],\n com = CODE[language][\"comment\"],\n udoc = units_doc_str,\n st = string_version,\n ind = index,\n w = width,\n w2 = width2,\n h = '',\n val = '')\n if variable_type in ['frame']:\n frames.append(cons_var_str)\n elif variable_type in ['state']:\n if var.label in self.state_variables:\n state_variables.append(cons_var_str)\n else:\n pass\n else:\n vars.append(cons_var_str)\n elif variable_type in [\"network\"]:\n mat = self.populateNetworkVariable(var)\n string_mat = self.matrix_to_string(mat, prefix = ' ')\n index = str(var.index_structures) # Convert to string\n width = 79 - 20 - len(index) - len(var.compiled) # 16 is others\n if width < 1:\n width = 1\n nt_str = '{0} = {array}({val: <{msg_box}} # {ind}\\n {st})'\n netw_var_str = nt_str.format(var.compiled,\n array = CODE[language][\"list\"],\n st = string_mat,\n ind = index,\n w = width,\n val = '')\n networks.append(netw_var_str)\n putData(instansiate_variables, self.variable_instantiate_file)\n return [state_variables, state_diffs, networks, frames, vars]","def rpa_postprocessing(variables):\n return variables","def get_mlperf_model_variables(config_path, init_checkpoint):\n # Load saved model configuration\n bert_config = modeling.BertConfig.from_json_file(config_path)\n seq_length = bert_config.max_position_embeddings\n tf_variables = {}\n max_predictions_per_seq = 76\n\n # Generate BERT TF model and initiate variable update from checkpoint\n graph = tf.Graph()\n sess = tf.Session(graph=graph)\n with graph.as_default():\n input_ids = tf.zeros((4, seq_length), dtype=tf.int32)\n input_mask = tf.zeros((4, seq_length), dtype=tf.int32)\n segment_ids = tf.zeros((4, seq_length), dtype=tf.int32)\n masked_lm_positions = tf.zeros((4, max_predictions_per_seq), dtype=tf.int32)\n masked_lm_ids = tf.zeros((4, max_predictions_per_seq), dtype=tf.int32)\n masked_lm_weights = tf.zeros((4, max_predictions_per_seq), dtype=tf.float32)\n next_sentence_labels = tf.zeros((4), dtype=tf.int32)\n tf_model = modeling.BertModel(\n config=bert_config,\n is_training=True,\n input_ids=input_ids,\n input_mask=input_mask,\n token_type_ids=segment_ids,\n use_one_hot_embeddings=True)\n (masked_lm_loss, _,\n _) = get_masked_lm_output(bert_config, tf_model.get_sequence_output(),\n tf_model.get_embedding_table(),\n masked_lm_positions, masked_lm_ids,\n masked_lm_weights)\n\n (next_sentence_loss, _,\n _) = get_next_sentence_output(bert_config, tf_model.get_pooled_output(),\n next_sentence_labels)\n _ = masked_lm_loss + next_sentence_loss\n\n tvars = tf.trainable_variables()\n (assignment_map,\n _) = modeling.get_assignment_map_from_checkpoint(tvars, init_checkpoint)\n tf.compat.v1.train.init_from_checkpoint(init_checkpoint, assignment_map)\n sess.run(tf.initializers.global_variables())\n tvars_vals = sess.run(tvars)\n for var, val in zip(tvars, tvars_vals):\n tf_variables[var.name[:-2]] = val\n\n tf_config = bert_config.__dict__\n\n return tf_config, tf_variables, tf_model","def pre_forward(self, *args, **kwargs):\n\n batch_size = kwargs['hidden_states'].shape[0]\n if not self.instantiated:\n self.hidden_dim = kwargs['hidden_states'].shape[-1]\n self.instantiate(hidden_dim=self.hidden_dim)\n if self.past_key_reparam is None:\n past_key = self.past_key\n else:\n past_key = self.past_key_reparam\n if self.past_value_reparam is None:\n past_value = self.past_value\n else:\n past_value = self.past_value_reparam\n\n # from IPython import embed\n # embed()\n def expand_batchsize(x):\n x = x.reshape(self.prefix_token_num, self.num_heads, -1).transpose(0,1)\n x = x.unsqueeze(0).expand(batch_size, *x.shape)\n return x\n # from IPython import embe\n\n if 'past_key_value' not in kwargs or kwargs['past_key_value'] is None:\n kwargs['past_key_value'] = (expand_batchsize(past_key), expand_batchsize(past_value))\n\n if 'attention_mask' in kwargs and kwargs['attention_mask'] is not None:\n am = kwargs['attention_mask'] # Should check the format of the attention_mask when moving to a new plm.\n kwargs['attention_mask'] = torch.cat([-torch.zeros((*am.shape[:-1],self.prefix_token_num), dtype = am.dtype,device=am.device), am], dim=-1)\n return args, kwargs","def _decode_train(self):\n\n # the basic idea is, we use golden sketch during train and in order to copy from source\n # we given true mask of decoder to generate right copy weights\n state = {'encoder': self.concated_encoder_output}\n\n def transformer_concated_decoder_internal(inputs, memory, bias, mem_bias, params, state=None, scope=None,\n reuse=False):\n return transformer_decoder(inputs, memory, bias, mem_bias, params, state, scope, reuse)\n\n self.final_logits = self._decode_func(\n self.tgt_seq, self.tgt_len, self.target_embeddings, self.decoder_weights,\n self.final_enc_attn_bias, 'train', state, self.vocab_size, use_copy=True,\n expand_source_ids_oo=self.concat_src_ids_oo,\n max_out_oovs=self.max_out_oovs, src_mask=self.concat_src_mask,\n decoder_fn=transformer_concated_decoder_internal,\n scope='final_decoder')","def calc_pck0(\n target_batch_keys,\n target_keys_pred,\n batch_assignments_gt,\n src_key_num_gt,\n image_scale,\n alpha=0.1,\n):\n batch_keys_gt = torch.bmm(batch_assignments_gt, target_batch_keys[:, :, :2])\n pck = pure_pck(target_keys_pred, batch_keys_gt, src_key_num_gt, image_scale, alpha)\n return pck, target_keys_pred, batch_keys_gt","def compute_objectives(self, predictions, batch, stage):\n (p_ctc, p_seq, asr_p_seq, mt_p_seq, wav_lens, hyps,) = predictions\n\n ids = batch.id\n\n tokens_eos, tokens_eos_lens = batch.tokens_eos\n transcription_eos, transcription_eos_lens = batch.transcription_eos\n transcription_tokens, transcription_lens = batch.transcription_tokens\n\n # loss for different tasks\n # asr loss = ctc_weight * ctc loss + (1 - ctc_weight) * asr attention loss\n # mt loss = mt attention loss\n # st loss =\n # (1 - asr_weight - mt_weight) * st attention loss +\n # asr_weight * asr loss +\n # mt_weight * mt loss\n attention_loss = 0\n asr_ctc_loss = 0\n asr_attention_loss = 0\n mt_loss = 0\n\n # st attention loss\n attention_loss = self.hparams.seq_cost(\n p_seq, tokens_eos, length=tokens_eos_lens,\n )\n\n # asr attention loss\n if self.hparams.ctc_weight < 1 and self.hparams.asr_weight > 0:\n asr_attention_loss = self.hparams.seq_cost(\n asr_p_seq, transcription_eos, length=transcription_eos_lens,\n )\n\n # asr ctc loss\n if self.hparams.ctc_weight > 0 and self.hparams.asr_weight > 0:\n asr_ctc_loss = self.hparams.ctc_cost(\n p_ctc, transcription_tokens, wav_lens, transcription_lens,\n )\n\n # mt attention loss\n if self.hparams.mt_weight > 0:\n mt_loss = self.hparams.seq_cost(\n mt_p_seq, tokens_eos, length=tokens_eos_lens,\n )\n\n asr_loss = (self.hparams.ctc_weight * asr_ctc_loss) + (\n 1 - self.hparams.ctc_weight\n ) * asr_attention_loss\n loss = (\n (1 - self.hparams.asr_weight - self.hparams.mt_weight)\n * attention_loss\n + self.hparams.asr_weight * asr_loss\n + self.hparams.mt_weight * mt_loss\n )\n\n if stage != sb.Stage.TRAIN:\n current_epoch = self.hparams.epoch_counter.current\n valid_search_interval = self.hparams.valid_search_interval\n\n if stage == sb.Stage.TEST:\n # 4 references bleu score\n predictions = [\n en_detoeknizer.detokenize(\n hparams[\"tokenizer\"].decode_ids(utt_seq).split(\" \")\n )\n for utt_seq in hyps\n ]\n\n four_references = [\n batch.translation_0,\n batch.translation_1,\n batch.translation_2,\n batch.translation_3,\n ]\n\n targets = []\n for reference in four_references:\n detokenized_translation = [\n en_detoeknizer.detokenize(translation.split(\" \"))\n for translation in reference\n ]\n targets.append(detokenized_translation)\n\n self.bleu_metric.append(ids, predictions, targets)\n elif (\n current_epoch % valid_search_interval == 0\n and stage == sb.Stage.VALID\n ):\n predictions = [\n en_detoeknizer.detokenize(\n hparams[\"tokenizer\"].decode_ids(utt_seq).split(\" \")\n )\n for utt_seq in hyps\n ]\n\n targets = [\n en_detoeknizer.detokenize(translation.split(\" \"))\n for translation in batch.translation_0\n ]\n self.bleu_metric.append(ids, predictions, [targets])\n\n # compute the accuracy of the one-step-forward prediction\n self.acc_metric.append(p_seq, tokens_eos, tokens_eos_lens)\n\n return loss","def validate(args, val_loader, encoder, decoder, criterion):\n decoder.eval() # eval mode (no dropout or batchnorm)\n if encoder is not None:\n encoder.eval()\n\n batch_time = AverageMeter()\n losses = AverageMeter()\n top5accs = AverageMeter()\n\n start = time.time()\n\n references = list() # references (true captions) for calculating BLEU-4 score\n hypotheses = list() # hypotheses (predictions)\n\n # explicitly disable gradient calculation to avoid CUDA memory error\n with torch.no_grad():\n # Batches\n for i, (imgs, caps, caplens, allcaps) in enumerate(val_loader):\n\n # Move to device, if available\n imgs = imgs.to(device)\n caps = caps.to(device)\n caplens = caplens.to(device)\n\n # Forward prop.\n if encoder is not None:\n imgs = encoder(imgs)\n scores, caps_sorted, decode_lengths, alphas, sort_ind = decoder(imgs, caps, caplens)\n\n # Since we decoded starting with <start>, the targets are all words after <start>, up to <end>\n targets = caps_sorted[:, 1:]\n\n # Remove timesteps that we didn't decode at, or are pads\n # pack_padded_sequence is an easy trick to do this\n scores_copy = scores.clone()\n scores = pack_padded_sequence(scores, decode_lengths, batch_first=True).data\n targets = pack_padded_sequence(targets, decode_lengths, batch_first=True).data\n\n # Calculate loss\n loss = criterion(scores, targets)\n\n # Add doubly stochastic attention regularization\n if args.decoder_mode == \"lstm\":\n loss += args.alpha_c * ((1. - alphas.sum(dim=1)) ** 2).mean()\n elif args.decoder_mode == \"transformer\":\n dec_alphas = alphas[\"dec_enc_attns\"]\n alpha_trans_c = args.alpha_c / (args.n_heads * args.decoder_layers)\n for layer in range(args.decoder_layers): # args.decoder_layers = len(dec_alphas)\n cur_layer_alphas = dec_alphas[layer] # [batch_size, n_heads, 52, 196]\n for h in range(args.n_heads):\n cur_head_alpha = cur_layer_alphas[:, h, :, :]\n loss += alpha_trans_c * ((1. - cur_head_alpha.sum(dim=1)) ** 2).mean()\n\n # Keep track of metrics\n losses.update(loss.item(), sum(decode_lengths))\n top5 = accuracy(scores, targets, 5)\n top5accs.update(top5, sum(decode_lengths))\n batch_time.update(time.time() - start)\n start = time.time()\n\n # Store references (true captions), and hypothesis (prediction) for each image\n # If for n images, we have n hypotheses, and references a, b, c... for each image, we need -\n # references = [[ref1a, ref1b, ref1c], [ref2a, ref2b], ...], hypotheses = [hyp1, hyp2, ...]\n\n # References\n allcaps = allcaps[sort_ind] # because images were sorted in the decoder\n for j in range(allcaps.shape[0]):\n img_caps = allcaps[j].tolist()\n img_captions = list(\n map(lambda c: [w for w in c if w not in {word_map['<start>'], word_map['<pad>']}],\n img_caps)) # remove <start> and pads\n references.append(img_captions)\n\n # Hypotheses\n _, preds = torch.max(scores_copy, dim=2)\n preds = preds.tolist()\n temp_preds = list()\n for j, p in enumerate(preds):\n temp_preds.append(preds[j][:decode_lengths[j]]) # remove pads\n preds = temp_preds\n hypotheses.extend(preds)\n\n assert len(references) == len(hypotheses)\n\n # Calculate BLEU-1~4 scores\n # metrics = {}\n # weights = (1.0 / 1.0,)\n # metrics[\"bleu1\"] = corpus_bleu(references, hypotheses, weights)\n # weights = (1.0/2.0, 1.0/2.0,)\n # metrics[\"bleu2\"] = corpus_bleu(references, hypotheses, weights)\n # weights = (1.0 / 3.0, 1.0 / 3.0, 1.0 / 3.0,)\n # metrics[\"bleu3\"] = corpus_bleu(references, hypotheses, weights)\n # metrics[\"bleu4\"] = corpus_bleu(references, hypotheses)\n\n # Calculate BLEU1~4, METEOR, ROUGE_L, CIDEr scores\n metrics = get_eval_score(references, hypotheses)\n\n print(\"EVA LOSS: {} TOP-5 Accuracy {} BLEU-1 {} BLEU2 {} BLEU3 {} BLEU-4 {} METEOR {} ROUGE_L {} CIDEr {}\".format\n (losses.avg, top5accs.avg, metrics[\"Bleu_1\"], metrics[\"Bleu_2\"], metrics[\"Bleu_3\"], metrics[\"Bleu_4\"],\n metrics[\"METEOR\"], metrics[\"ROUGE_L\"], metrics[\"CIDEr\"]))\n\n return metrics","def _eval_acc(self, data_loader, model,\n loss_fn: Callable = None):\n soft_to_hard_fn, soft_to_hard_fn_kwargs = _validate_soft_to_hard_args(self.soft_to_hard_fn,\n self.soft_to_hard_fn_kwargs)\n\n n_correct = defaultdict(int)\n n_total = defaultdict(int)\n model.eval()\n\n # INPUT: batch of text data + label (batch is gathered with similar lengths with bucket iterator)\n total_val_loss = 0.\n\n prediction_list_correct = defaultdict(int)\n prediction_list_total = defaultdict(int)\n pred_labels_lst = []\n orig_labels_lst = []\n orig_words_lst = []\n sep_token = self.tokenizer.sep_token\n pad_token = self.tokenizer.pad_token\n cls_token = self.tokenizer.cls_token\n\n with torch.no_grad():\n for batch_idx, (input_ids, attention_mask, labels, label_mask) in enumerate(data_loader):\n\n input_ids = input_ids.to(self.device)\n attention_mask = attention_mask.to(self.device)\n labels = labels.to(self.device)\n label_mask = label_mask.to(self.device)\n\n # logits = model.predict(input_ids, input_mask=attention_mask)\n\n # preds: batch size , sequence len, nfeatures\n # labels: batch size, sequence len\n\n # Compute loss and predictions\n batch_train_loss, logits = model(input_ids,\n attention_mask=attention_mask,\n labels=labels)\n\n predictions = torch.argmax(logits, dim=2)\n\n for batch in range(label_mask.shape[0]):\n orig_words = self.tokenizer.decode(input_ids.data[batch]).split(' ')\n mask = label_mask.data[batch]\n preds = predictions.data[batch]\n lab = labels.data[batch]\n\n temp_labels = []\n temp_preds = []\n temp_words = []\n\n for i, m in enumerate(mask):\n if m == 1:\n temp_labels.append(self.id2label[lab[i].item()])\n temp_preds.append(self.id2label[preds[i].item()])\n\n for w in orig_words:\n if w in [sep_token, pad_token, cls_token]:\n continue\n temp_words.append(w)\n\n pred_labels_lst.append(temp_preds)\n orig_labels_lst.append(temp_labels)\n orig_words_lst.append(temp_words)\n\n batch_loss = batch_train_loss.item()\n total_val_loss += batch_loss\n\n running_acc, n_total, n_correct = _running_eval_acc(logits, labels, label_mask,\n n_total=n_total,\n n_correct=n_correct,\n soft_to_hard_fn=soft_to_hard_fn,\n soft_to_hard_fn_kwargs=soft_to_hard_fn_kwargs)\n\n if (loss_fn is not None and np.isnan(batch_loss)) or np.isnan(running_acc):\n # TODO: update to get the actual input text from tokenizer\n _save_nandata(input_ids, predictions, labels, batch_train_loss, batch_loss,\n running_acc, n_total, n_correct, model)\n\n eval_list = []\n\n for orig_w, oril, prel in zip(orig_words_lst, orig_labels_lst, pred_labels_lst):\n\n for ot, ol, pl in zip(orig_w, oril, prel):\n if ot in [self.pad_token, self.cls_token, self.sep_token]:\n continue\n eval_list.append(f\"{ot} {ol} {pl}\\n\")\n eval_list.append(\"\\n\")\n\n counts = conlleval.evaluate(eval_list)\n report = conlleval.report_notprint(counts)\n for line in report:\n logger.info(line.strip())\n\n for k in prediction_list_total.keys():\n logger.info('Acc: {} = {}%'.format(k, 0 if prediction_list_total[k] == 0 else (float(\n prediction_list_correct[k]) / float(prediction_list_total[k])) * 100))\n\n overall, by_type = conlleval.metrics(counts)\n\n total_val_loss /= float(len(data_loader))\n\n return running_acc, n_total, n_correct, total_val_loss, counts","def _precompute(self):\n N = self.N\n # Store 'N' as used by Gale in N[0] --- this is the total # of\n # occurrences.\n N[0] = sum(N[r] * r for r in range(1, self.max_r + 1))\n self.Z = Z = averaging_transform.transform(N, self.max_r) # Z[r] = Z_r\n self.b, self.a = self._regress(Z) # 'a' and 'b' as used in (Gale); a\n # is intercept and b is slope.\n assert self.b < -1, (\"Log-linear slope > -1 (%f); SGT not applicable\" %\n self.b)\n # Find the transition point between linear Good-Turing estimate and the\n # Turing estimate.\n self.linear_cutoff = self._find_cutoff()\n self.norm_constant = self._find_norm_constant()","def pre_compute(self, e_list):\n\t\tpass","def _calc_loss(args, loss_function, local_q_vector, local_ctx_vectors, local_caption_vectors, local_positive_idxs,\n local_hard_negatives_idxs: list = None, experiment=None\n ):\n distributed_world_size = 1 # args.distributed_world_size or 1\n if distributed_world_size > 1:\n # TODO: Add local_caption_vectors\n q_vector_to_send = torch.empty_like(local_q_vector).cpu().copy_(local_q_vector).detach_()\n ctx_vector_to_send = torch.empty_like(local_ctx_vectors).cpu().copy_(local_ctx_vectors).detach_()\n\n global_question_ctx_vectors = all_gather_list(\n [q_vector_to_send, ctx_vector_to_send, local_positive_idxs, local_hard_negatives_idxs],\n max_size=args.global_loss_buf_sz)\n\n global_q_vector = []\n global_ctxs_vector = []\n\n # ctxs_per_question = local_ctx_vectors.size(0)\n positive_idx_per_question = []\n hard_negatives_per_question = []\n\n total_ctxs = 0\n\n for i, item in enumerate(global_question_ctx_vectors):\n q_vector, ctx_vectors, positive_idx, hard_negatives_idxs = item\n\n if i != args.local_rank:\n global_q_vector.append(q_vector.to(local_q_vector.device))\n global_ctxs_vector.append(ctx_vectors.to(local_q_vector.device))\n positive_idx_per_question.extend([v + total_ctxs for v in positive_idx])\n hard_negatives_per_question.extend([[v + total_ctxs for v in l] for l in hard_negatives_idxs])\n else:\n global_q_vector.append(local_q_vector)\n global_ctxs_vector.append(local_ctx_vectors)\n positive_idx_per_question.extend([v + total_ctxs for v in local_positive_idxs])\n hard_negatives_per_question.extend([[v + total_ctxs for v in l] for l in local_hard_negatives_idxs])\n total_ctxs += ctx_vectors.size(0)\n\n global_q_vector = torch.cat(global_q_vector, dim=0)\n global_ctxs_vector = torch.cat(global_ctxs_vector, dim=0)\n\n else:\n global_q_vector = local_q_vector\n global_ctxs_vector = local_ctx_vectors\n global_caption_vector = local_caption_vectors\n positive_idx_per_question = local_positive_idxs\n hard_negatives_per_question = local_hard_negatives_idxs\n\n loss, is_correct, scores = loss_function.calc(global_q_vector, global_ctxs_vector, global_caption_vector,\n positive_idx_per_question, hard_negatives_per_question,\n args.caption_score_weight, experiment)\n\n return loss, is_correct, scores","def precomp_sim_tables(self):\n self.sim_precomp = {}\n\n if self.sim_method == 'emb_jointspace':\n\n for gram in ['s','r','o']:\n\n vocab_gram = self.vocab[gram]\n V = len(vocab_gram)\n self.sim_precomp[gram] = np.zeros((V,V))\n\n for v_target in range(V):\n\n word_target = vocab_gram.idx2word[v_target]\n query_target = self.queries_unigrams(word_target, gram)\n embedding_target = self.language_nets[self.gram_id[gram]](query_target)\n\n\n for v_source in range(V):\n\n word_source = vocab_gram.idx2word[v_source]\n query_source = self.queries_unigrams(word_source, gram)\n embedding_source = self.language_nets[self.gram_id[gram]](query_source)\n\n self.sim_precomp[gram][v_target, v_source] = torch.mul(embedding_target, embedding_source).sum().data[0]\n\n\n elif self.sim_method == 'emb_word2vec':\n\n for gram in ['s','r','o']:\n\n vocab_gram = self.vocab[gram]\n V = len(vocab_gram)\n self.sim_precomp[gram] = np.zeros((V,V))\n\n for v_target in range(V):\n\n embedding_target = self.word_embeddings[self.idx_to_vocab[gram][v_target].data[0]]\n embedding_target = embedding_target / np.linalg.norm(embedding_target)\n\n for v_source in range(V):\n\n embedding_source = self.word_embeddings[self.idx_to_vocab[gram][v_source].data[0]]\n embedding_source = embedding_source / np.linalg.norm(embedding_source)\n\n self.sim_precomp[gram][v_target, v_source] = np.sum(embedding_target*embedding_source)","def _build_preprocessing(self):\n\n # For now, do nothing\n pass","def preprocess(self):\n\n mm_magcoord.add_aacgm_coordinates(self)\n mm_magcoord.add_quasi_dipole_coordinates(self)\n mm_sc.calculate_ecef_velocity(self)\n mm_sc.add_ram_pointing_sc_attitude_vectors(self)\n\n return","def forward(\n self, inp: torch.Tensor, ucb_alpha: Optional[float] = None\n ) -> Dict[str, torch.Tensor]:\n\n mlp_out = self.deep_represent_layers(inp)\n # preprocess by DeepRepresent module before fed to LinUCB layer\n # trainer needs pred_label and mlp_out to update parameters\n\n # append a column of ones to features for LinUCB intercept/bias\n mlp_out_with_ones = torch.cat(\n (\n torch.ones(mlp_out.shape[:-1], device=mlp_out.device).unsqueeze(-1),\n mlp_out,\n ),\n -1,\n )\n\n if ucb_alpha is None:\n ucb_alpha = self.ucb_alpha\n\n if not self.nn_e2e:\n pred_label = torch.matmul(mlp_out_with_ones, self.coefs)\n else:\n pred_label = self.linear_layer(mlp_out_with_ones).squeeze(-1)\n\n if ucb_alpha != 0:\n pred_sigma = torch.sqrt(\n batch_quadratic_form(mlp_out_with_ones, self.inv_avg_A)\n / torch.clamp(self.sum_weight, min=0.00001)\n )\n ucb = pred_label + ucb_alpha * pred_sigma\n else:\n pred_sigma = torch.zeros_like(pred_label)\n ucb = pred_label\n return {\n \"pred_label\": pred_label,\n \"pred_sigma\": pred_sigma,\n \"ucb\": ucb,\n \"mlp_out_with_ones\": mlp_out_with_ones,\n }","def predict(self, first_preprocessed_inputs,second_preprocessed_inputs,third_preprocessed_inputs):\r\n pass","def get_loss_fn():\n return reconstruction","def mag_postprocessing(variables):\n return variables","def loss(self, X, y=None):\n\n # In dev testing, the loss fnc stops at \"scores\" , unfollowed by \"softmax\" probability prediction.\n # In real testing, \"self.predict()\" needs to be implemented in Solver() class.\n \n if y is None:\n for bn_param in self.bn_params:\n bn_param[\"mode\"] = \"test\"\n\n\n W1, b1 = self.params['W1'], self.params['b1']\n gamma1, beta1 = self.params[\"sbnGamma1\"], self.params[\"sbnBeta1\"]\n bn_param1 = self.bn_params[0]\n\n W2, b2 = self.params['W2'], self.params['b2']\n gamma2, beta2 = self.params[\"sbnGamma2\"], self.params[\"sbnBeta2\"]\n bn_param2 = self.bn_params[1]\n\n W3, b3 = self.params['W3'], self.params['b3']\n gamma3, beta3 = self.params[\"bnGamma3\"], self.params[\"bnBeta3\"]\n bn_param3 = self.bn_params[2]\n\n W4, b4 = self.params['W4'], self.params['b4']\n \n # pass conv_param to the forward pass for the convolutional layer\n conv_param = self.conv_param\n\n # pass pool_param to the forward pass for the max-pooling layer\n pool_param = self.maxpool_params\n\n ############################################################################\n # TODO: Implement the forward pass for the three-layer convolutional net, #\n # computing the class scores for X and storing them in the scores #\n # variable. #\n ############################################################################\n \n scores = None \n cache = {}\n # def conv_sbn_relu_forward(x, w, b, gamma, beta, conv_param, bn_param): return out, cache;\n out, cache[\"layer1\"] = layer_utils.conv_sbn_relu_forward(X, W1, b1, gamma1, beta1, conv_param, bn_param1) \n out, cache[\"layer2\"] = layer_utils.conv_sbn_relu_forward(out, W2, b2, gamma2, beta2, conv_param, bn_param2)\n\n # def max_pool_forward_fast(x, pool_param): return out, cache;\n out, cache[\"maxpool\"] = fast_layers.max_pool_forward_fast(out, pool_param)\n\n # def affine_bn_relu_forward(x, w, b, gamma, beta, bn_param): return out, cache;\n \n out, cache[\"layer3\"] = layer_utils.affine_bn_relu_forward(out, W3, b3, gamma3, beta3, bn_param3)\n\n # def affine_forward(x, w, b): return out, cache;\n scores, cache[\"layer4\"] = layers.affine_forward(out, W4, b4)\n\n\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n \n if y is None:\n return scores\n \n ############################################################################\n # TODO: Implement the backward pass for the three-layer convolutional net, #\n # storing the loss and gradients in the loss and grads variables. Compute #\n # data loss using softmax, and make sure that grads[k] holds the gradients #\n # for self.params[k]. Don't forget to add L2 regularization! #\n ############################################################################\n \n loss, grads = 0, {}\n\n # def softmax_loss(x, y): return loss, dscore;\n loss, dscores = layers.softmax_loss(scores, y)\n loss += 0.5 * self.reg * (np.sum(W1 * W1) + np.sum(W2 * W2) + np.sum(W3 * W3) + np.sum(W4 * W4))\n\n # def affine_backward(dout, cache): return dx, dw, db;\n dout, dW4, db4 = layers.affine_backward(dscores, cache[\"layer4\"]) \n\n # def affine_bn_relu_backward(dout, cache): return dx, dw, db, dgamma, dbeta;\n dout, dW3, db3, dgamma3, dbeta3 = layer_utils.affine_bn_relu_backward(dout, cache[\"layer3\"])\n\n # print cache[\"layer3\"]\n\n # def max_pool_backward_fast(dout, cache): return max_pool_backward_im2col(dout, real_cache);\n # def max_pool_backward_im2col(dout, cache): return dx;\n dout = fast_layers.max_pool_backward_fast(dout, cache[\"maxpool\"])\n\n # def conv_sbn_relu_backward(dout, cache): return dx, dw, db, dgamma, dbeta;\n dout, dW2, db2, dgamma2, dbeta2 = layer_utils.conv_sbn_relu_backward(dout, cache[\"layer2\"])\n _, dW1, db1, dgamma1, dbeta1 = layer_utils.conv_sbn_relu_backward(dout, cache[\"layer1\"])\n\n # reg\n grads['W4'], grads['b4'] = dW4 + self.reg * W4, db4\n \n grads['W3'], grads['b3'] = dW3 + self.reg * W3, db3\n grads[\"bnGamma3\"], grads[\"bnBeta3\"] = dgamma3, dbeta3\n\n grads['W2'], grads['b2'] = dW2 + self.reg * W2, db2\n grads[\"sbnGamma2\"], grads[\"sbnBeta2\"] = dgamma2, dbeta2\n\n grads['W1'], grads['b1'] = dW1 + self.reg * W1, db1\n grads[\"sbnGamma1\"], grads[\"sbnBeta1\"] = dgamma1, dbeta1\n\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n \n return loss, grads","def step(x, encoder, decoder, optimizer, loss):\n trainable_variables = encoder.trainable_variables + decoder.trainable_variables\n with tf.GradientTape() as tape:\n tape.watch(trainable_variables)\n lo = loss(x, encoder, decoder)\n minimize_loss = - lo\n grads = tape.gradient(minimize_loss, trainable_variables)\n optimizer.apply_gradients(zip(grads, trainable_variables))\n return lo","def compile(self):\n\n target_values = T.fmatrix('target_values')\n\n train_output = lasagne.layers.get_output(self.l_out)\n\n pred_output = lasagne.layers.get_output(self.l_out, deterministic=True)\n\n reg = lasagne.regularization.regularize_layer_params(self.l_out, lasagne.regularization.l2)\n\n train_cost = self.cost_function(train_output,target_values).mean() + reg * 0.01\n \n real_cost = self.cost_function(pred_output, target_values).mean() + reg * 0.01\n\n # Retrieve all parameters from the network\n all_params = lasagne.layers.get_all_params(self.l_out,trainable=True)\n\n self.logger.info(\"Computing updates...\")\n updates = self.update_function(train_cost, all_params, LEARNING_RATE)\n\n \n self.logger.info(\"Compiling functions ...\")\n\n # compile Theano GPU functions for training and computing train_cost\n self._train = theano.function([self.in_layer.input_var, self.i_mask.input_var, target_values], train_cost, \n updates=updates, allow_input_downcast=True)\n\n self._compute_cost = theano.function([self.in_layer.input_var, self.i_mask.input_var, target_values], real_cost, \n allow_input_downcast=True)\n\n self.label = theano.function([self.in_layer.input_var, self.i_mask.input_var],pred_output,allow_input_downcast=True)\n \n self._compiled = True","def preprocess(self, first_inputs,second_inputs,third_inputs):\r\n pass","def compute_attention(self, decoder_state, forward_encoder_states, backward_encoder_states):\r\n\r\n\t\tassert len(forward_encoder_states) == len(backward_encoder_states)\r\n\t\tmax_encoding_len = len(forward_encoder_states)\r\n\t\toutput_states=[]\r\n\t\tfor i in range(max_encoding_len):\r\n\t\t\tstate = np.concatenate([forward_encoder_states[i]['h'], backward_encoder_states[i]['h']])\r\n\t\t\toutput_states.append(state)\r\n\r\n\t\ttiled_outputs = np.concatenate(output_states, 1)\r\n\t\ttiled_decoder = np.tile(decoder_state['h'], (1, max_encoding_len))\r\n\r\n\t\talpha = np.zeros((len(output_states), 1))\r\n\t\tfor i in range(max_encoding_len):\r\n\t\t\talpha[i] = np.matmul(self.attentionV.transpose(), np.tanh(np.matmul(self.memoryLayer, output_states[i]) + np.matmul(self.queryLayer, decoder_state['h'])))\r\n\t\talpha = softmax(alpha)\r\n\r\n\t\tu = np.zeros(output_states[0].shape)\r\n\t\tfor i in range(max_encoding_len):\r\n\t\t\tu += alpha[i, 0] * output_states[i]\r\n\t\ta = np.matmul(self.attentonLayer, np.concatenate([decoder_state['h'], u]))\r\n\r\n\t\treturn a, alpha","def __call__(self, initial_state, previous_alignments):\n with tf.variable_scope(None, \"rnn_score_attention\", [initial_state]):\n score, final_state = rnn_score(initial_state, self._keys, self._cell, self._memory_sequence_length)\n alignments = self._probability_fn(score, previous_alignments)\n return alignments, final_state","def get_param_computation(self, keep_backpack_buffers):\n param_computation_V_t_V = self._param_computation_V_t_V\n param_computation_V_t_g_n = self._param_computation_V_t_g_n\n param_computation_V_n_t_V = self._param_computation_V_n_t_V\n param_computation_memory_cleanup = partial(\n self._param_computation_memory_cleanup,\n keep_backpack_buffers=keep_backpack_buffers,\n )\n\n compute_gammas = self._compute_gammas\n compute_lambdas = self._compute_lambdas\n\n def param_computation(self, param):\n \"\"\"Compute dot products for a parameter used in directional derivatives.\n\n Args:\n self (ParameterGroupsHook): Group hook to which this function will be\n bound.\n param (torch.Tensor): Parameter of a neural net.\n\n Returns:\n dict: Dictionary with results of the different dot products. Has key\n ``\"V_t_g_n\"``.\n \"\"\"\n result = {}\n\n result[\"V_t_V\"] = param_computation_V_t_V(param)\n\n if compute_gammas:\n result[\"V_t_g_n\"] = param_computation_V_t_g_n(param)\n if compute_lambdas:\n result[\"V_n_t_V\"] = param_computation_V_n_t_V(param)\n\n param_computation_memory_cleanup(param)\n\n return result\n\n return param_computation","def __prepare_parameter__(self, in_args):\n if self.__use_remote_sparse_updater__():\n self.__gradient_machine__.prefetch(in_args)\n self.__parameter_updater__.getParametersRemote()","def preprocess(self):","def pre_forward(self, *args, **kwargs):\n batch_size = args[0].shape[0]\n seq_len = args[0].shape[-2]\n if not self.instantiated:\n self.hidden_dim = args[0].shape[-1]\n self.instantiate(hidden_dim=self.hidden_dim)\n if self.past_key_reparam is None:\n past_key = self.past_key\n else:\n past_key = self.past_key_reparam\n if self.past_value_reparam is None:\n past_value = self.past_value\n else:\n past_value = self.past_value_reparam\n\n\n def expand_batchsize(x):\n x = x.reshape(self.prefix_token_num, self.num_heads, -1).transpose(0,1)\n x = x.unsqueeze(0).expand(batch_size, *x.shape)\n return x\n\n if 'position_bias' in kwargs and kwargs['position_bias'] is not None:\n if kwargs['position_bias'].shape[-1] != seq_len + self.prefix_token_num: # Then the position_bias should be re-calculated\n kwargs['position_bias'] = None\n if kwargs['past_key_value'] is None:\n kwargs['past_key_value'] = (expand_batchsize(past_key), expand_batchsize(past_value))\n\n past_key_len = kwargs['past_key_value'][0].shape[-2]\n\n if 'mask' in kwargs and kwargs['mask'] is not None:\n mask_len = kwargs['mask'].shape[-1]\n if past_key_len + seq_len == mask_len + self.prefix_token_num:\n\n am = kwargs['mask'] # Should check the format of the attention_mask when moving to a new plm.\n kwargs['mask'] = torch.cat([-torch.zeros((*am.shape[:-1],self.prefix_token_num), dtype = am.dtype,device=am.device), am], dim=-1)\n return args, kwargs","def calc_pck(\n target_batch_keys,\n batch_assignments,\n batch_assignments_gt,\n src_key_num_gt,\n image_scale,\n alpha=0.1,\n):\n\n batch_keys_pred = torch.bmm(batch_assignments, target_batch_keys[:, :, :2])\n return calc_pck0(\n target_batch_keys,\n batch_keys_pred,\n batch_assignments_gt,\n src_key_num_gt,\n image_scale,\n alpha,\n )","def preprocess(self, latent_codes, **kwargs):\n raise NotImplementedError(f'Should be implemented in derived class!')","def compute_loss(self, *args, **kwargs):\n raise NotImplementedError","def compile(self, optimizer, lr):\n \n #clip_morm = 0.1\n self.loss_f = None\n with self.graph.as_default():\n \n tvars = tf.trainable_variables()\n ft_vars = [v for v in tvars if \"_fe\" in v.name] \n lab_vars = [v for v in tvars if \"_dc\" not in v.name]\n dom_vars = [v for v in tvars if \"_lp\" not in v.name]\n\n print()\n print(\" ft updates:\", ft_vars)\n print(\"96x3 updates:\", lab_vars)\n print(\" 1x3 updates:\", dom_vars)\n print()\n\n # `tf.nn.softmax_cross_entropy_with_logits` is deprcated.\n # https://www.tensorflow.org/api_docs/python/tf/nn/softmax_cross_entropy_with_logits\n self.loss = tf.nn.softmax_cross_entropy_with_logits_v2(labels=self.labels, logits=self.output, name='cross_entropy')\n self.loss_adv = tf.nn.softmax_cross_entropy_with_logits_v2(labels=self.labels_adv, logits=self.output_adv, name='cross_entropy_adv')\n \n #grads_and_vars = optimizer.compute_gradients(loss, var_list=tf_vars)\n #clipped_grads_and_vars = [(tf.clip_by_norm(grad, clip_norm=clip_norm), var) for grad, var in grads_and_vars]\n \n self.loss_fe = - lam * self.loss_adv\n # `tf.control_dependencies` is necessary if `tf.layers.batch_normalization` is in the model\n # https://www.tensorflow.org/api_docs/python/tf/layers/batch_normalization\n self.train_step_adv = optimizer(lr).minimize(self.loss_fe, name='minimize_fe', var_list=ft_vars)\n self.train_step = optimizer(lr).minimize(self.loss, name='minimize', var_list=lab_vars)\n self.train_step_adv = optimizer(lr).minimize(self.loss_adv, name='minimize_adv', var_list=dom_vars)\n\n # Initialize all `tf.Variable`.\n self.session.run(tf.global_variables_initializer())","def compute_loss(self, obs, returns):","def evaluate(args):\n dataset_param_filepath = os.path.join(args.model, 'dataset.params')\n dataset_params = putils.load_params(dataset_param_filepath)\n source_vocab_filepath = os.path.join(args.model, 'source.vocab')\n source_vocab = Vocab(vocab_filepath=source_vocab_filepath)\n target_vocab_filepath = os.path.join(args.model, 'target.vocab')\n target_vocab = Vocab(vocab_filepath=target_vocab_filepath)\n model_params_filepath = os.path.join(args.model, 'model.params')\n model_params = putils.load_params(model_params_filepath)\n checkpoint_filepath = os.path.join(args.model, 'checkpoint.tar')\n if not torch.cuda.is_available() and model_params['cuda']:\n logger.info('Loading a GPU-trained model on CPU')\n checkpoint = torch.load(checkpoint_filepath,\n map_location=const.DEVICE)\n elif torch.cuda.is_available() and model_params['cuda']:\n logger.info('Loading a GPU-trained model on GPU')\n checkpoint = torch.load(checkpoint_filepath)\n elif torch.cuda.is_available() and not model_params['cuda']:\n logger.info('Loading a CPU-trained model on GPU')\n checkpoint = torch.load(checkpoint_filepath,\n map_location='cuda:0')\n else:\n logger.info('Loading a CPU-trained model on CPU')\n checkpoint = torch.load(checkpoint_filepath)\n encoder = Encoder(model_type=checkpoint['encoder']['model_type'],\n input_size=checkpoint['encoder']['input_size'],\n hidden_size=checkpoint['encoder']['hidden_size'],\n num_layers=checkpoint['encoder']['num_layers'],\n nonlinearity=checkpoint['encoder']['nonlinearity'],\n bias=checkpoint['encoder']['bias'],\n dropout=checkpoint['encoder']['dropout'],\n bidirectional=checkpoint['encoder']['bidirectional'])\n if checkpoint['with_attention']:\n decoder = Attention(model_type=checkpoint['decoder']['model_type'],\n hidden_size=checkpoint['decoder']['hidden_size'],\n output_size=checkpoint['decoder']['output_size'],\n max_seq_len=dataset_params['max_seq_len'],\n num_layers=checkpoint['decoder']['num_layers'],\n nonlinearity=checkpoint['decoder']['nonlinearity'],\n bias=checkpoint['decoder']['bias'],\n dropout=checkpoint['decoder']['dropout'],\n bidirectional=checkpoint['decoder']['bidirectional'])\n else:\n decoder = Decoder(model_type=checkpoint['decoder']['model_type'],\n hidden_size=checkpoint['decoder']['hidden_size'],\n output_size=checkpoint['decoder']['output_size'],\n num_layers=checkpoint['decoder']['num_layers'],\n nonlinearity=checkpoint['decoder']['nonlinearity'],\n bias=checkpoint['decoder']['bias'],\n dropout=checkpoint['decoder']['dropout'],\n bidirectional=checkpoint['decoder']['bidirectional'])\n encoder.load_state_dict(checkpoint['encoder_state_dict'])\n decoder.load_state_dict(checkpoint['decoder_state_dict'])\n if torch.cuda.is_available():\n encoder.to(const.DEVICE)\n decoder.to(const.DEVICE)\n encoder.eval()\n decoder.eval()\n indexes = putils.index_dataset(\n args.data, source_vocab.item2idx, target_vocab.item2idx,\n dataset_params['is_character_based'], dataset_params['max_seq_len'],\n dataset_params['is_reversed'])\n if args.random > 0:\n random.shuffle(indexes)\n for seq_num in range(args.random):\n seq = indexes[seq_num]\n print('-'*80)\n print('>', ' '.join([source_vocab.idx2item[idx]\n for idx in seq[0]]))\n print('=', ' '.join([target_vocab.idx2item[idx]\n for idx in seq[1]]))\n # TODO: add support for OOV\n predicted_idx, _ = _decode(seq[0], encoder, decoder,\n checkpoint['with_attention'],\n dataset_params['max_seq_len'])\n print('<', ' '.join([target_vocab.idx2item[idx]\n for idx in predicted_idx]))\n else:\n _evaluate(indexes, encoder, decoder, target_vocab, checkpoint,\n dataset_params)","def compute_loss(self, **kwargs):\n raise NotImplementedError","def _precompute_lossfun_inputs(self, float_dtype, device):\n num_samples = 100000\n # Normally distributed inputs.\n x = float_dtype(np.random.normal(size=num_samples))\n\n # Uniformly distributed values in (-16, 3), quantized to the nearest 0.1\n # to ensure that we hit the special cases at 0, 2.\n alpha = float_dtype(\n np.round(np.random.uniform(-16, 3, num_samples) * 10) / 10.0\n )\n # Push the sampled alphas at the extents of the range to +/- infinity, so\n # that we probe those cases too.\n alpha[alpha == 3.0] = float_dtype(float(\"inf\"))\n alpha[alpha == -16.0] = -float_dtype(float(\"inf\"))\n\n # Random log-normally distributed values in approx (1e-5, 100000):\n scale = float_dtype(np.exp(np.random.normal(size=num_samples) * 4.0) + 1e-5)\n\n # Compute the loss and its derivative with respect to all three inputs.\n var_x = torch.autograd.Variable(\n torch.tensor(x, device=device), requires_grad=True\n )\n var_alpha = torch.autograd.Variable(\n torch.tensor(alpha, device=device), requires_grad=True\n )\n var_scale = torch.autograd.Variable(\n torch.tensor(scale, device=device), requires_grad=True\n )\n loss = general.lossfun(var_x, var_alpha, var_scale)\n sum_loss = torch.sum(loss)\n sum_loss.backward()\n d_x = var_x.grad.cpu().detach().numpy()\n d_alpha = var_alpha.grad.cpu().detach().numpy()\n d_scale = var_scale.grad.cpu().detach().numpy()\n loss = loss.cpu().detach().numpy()\n return (num_samples, loss, x, alpha, scale, d_x, d_alpha, d_scale)","def evaluate(args):\n dataset_param_filepath = os.path.join(args.model, 'dataset.params')\n dataset_params = putils.load_params(dataset_param_filepath)\n left_vocab_filepath = os.path.join(args.model, 'left.vocab')\n left_vocab = Vocab(vocab_filepath=left_vocab_filepath)\n right_vocab_filepath = os.path.join(args.model, 'right.vocab')\n right_vocab = Vocab(vocab_filepath=right_vocab_filepath)\n model_params_filepath = os.path.join(args.model, 'model.params')\n model_params = putils.load_params(model_params_filepath)\n checkpoint_filepath = os.path.join(args.model, 'checkpoint.tar')\n if not torch.cuda.is_available() and model_params['cuda']:\n logger.info('Loading a GPU-trained model on CPU')\n checkpoint = torch.load(checkpoint_filepath,\n map_location=const.DEVICE)\n elif torch.cuda.is_available() and model_params['cuda']:\n logger.info('Loading a GPU-trained model on GPU')\n checkpoint = torch.load(checkpoint_filepath)\n elif torch.cuda.is_available() and not model_params['cuda']:\n logger.info('Loading a CPU-trained model on GPU')\n checkpoint = torch.load(checkpoint_filepath,\n map_location='cuda:0')\n else:\n logger.info('Loading a CPU-trained model on CPU')\n checkpoint = torch.load(checkpoint_filepath)\n if checkpoint['encoder']['model_type'] == 'transformer':\n encoder = TEncoder(input_size=checkpoint['encoder']['input_size'],\n hidden_size=checkpoint['encoder']['hidden_size'],\n num_layers=checkpoint['encoder']['num_layers'],\n dropout=checkpoint['encoder']['dropout'],\n num_attention_heads=checkpoint['encoder']['num_attention_heads'])\n else:\n encoder = Encoder(model_type=checkpoint['encoder']['model_type'],\n input_size=checkpoint['encoder']['input_size'],\n hidden_size=checkpoint['encoder']['hidden_size'],\n num_layers=checkpoint['encoder']['num_layers'],\n nonlinearity=checkpoint['encoder']['nonlinearity'],\n bias=checkpoint['encoder']['bias'],\n dropout=checkpoint['encoder']['dropout'],\n bidirectional=checkpoint['encoder']['bidirectional'])\n if checkpoint['decoder']['model_type'] == 'transformer':\n decoder = TDecoder(hidden_size=checkpoint['decoder']['hidden_size'],\n output_size=checkpoint['decoder']['output_size'],\n num_layers=checkpoint['decoder']['num_layers'],\n dropout=checkpoint['decoder']['dropout'],\n num_attention_heads=checkpoint['decoder']['num_attention_heads'])\n elif checkpoint['decoder']['with_attention']:\n decoder = Attention(hidden_size=checkpoint['decoder']['hidden_size'],\n output_size=checkpoint['decoder']['output_size'],\n max_seq_len=dataset_params['max_seq_len'],\n num_layers=checkpoint['decoder']['num_layers'],\n nonlinearity=checkpoint['decoder']['nonlinearity'],\n bias=checkpoint['decoder']['bias'],\n dropout=checkpoint['decoder']['dropout'])\n else:\n decoder = Decoder(model_type=checkpoint['decoder']['model_type'],\n hidden_size=checkpoint['decoder']['hidden_size'],\n output_size=checkpoint['decoder']['output_size'],\n num_layers=checkpoint['decoder']['num_layers'],\n nonlinearity=checkpoint['decoder']['nonlinearity'],\n bias=checkpoint['decoder']['bias'],\n dropout=checkpoint['decoder']['dropout'])\n encoder.load_state_dict(checkpoint['encoder_state_dict'])\n decoder.load_state_dict(checkpoint['decoder_state_dict'])\n if torch.cuda.is_available():\n encoder.to(const.DEVICE)\n decoder.to(const.DEVICE)\n encoder.eval()\n decoder.eval()\n pairs = putils.convert_to_seq_pairs(args.data)\n indexed_pairs = putils.index_pairs(pairs, left_vocab.char2idx,\n right_vocab.char2idx)\n if dataset_params['reverse']:\n indexed_pairs = [(y, x) for x, y in indexed_pairs]\n source_vocab = right_vocab\n target_vocab = left_vocab\n else:\n source_vocab = left_vocab\n target_vocab = right_vocab\n if args.random > 0:\n random.shuffle(indexed_pairs)\n for seq_num in range(args.random):\n seq = indexed_pairs[seq_num]\n print('-'*80)\n input_str = ' '.join(\n ''.join([source_vocab.idx2char[idx] for idx in seq[0] if idx\n not in [const.SOS_IDX, const.EOS_IDX]])\n .split(const.SEP))\n gold_str = ' '.join(\n ''.join([target_vocab.idx2char[idx] for idx in seq[1] if idx\n not in [const.SOS_IDX, const.EOS_IDX]])\n .split(const.SEP))\n predicted_idxx = decode(seq[0], args.itemize, encoder, decoder,\n dataset_params['max_seq_len'])\n pred_str = ' '.join(\n ''.join([target_vocab.idx2char[idx] for idx in predicted_idxx\n if idx not in [const.SOS_IDX, const.EOS_IDX]])\n .split(const.SEP))\n print('>', input_str)\n print('=', gold_str)\n print('<', pred_str)\n else:\n _evaluate(indexed_pairs, args.itemize, encoder, decoder,\n target_vocab.idx2char, dataset_params['max_seq_len'])","def local_2(args):\n cache_list = args[\"cache\"]\n input_list = args[\"input\"]\n\n X = pd.read_json(cache_list[\"covariates\"], orient='split')\n y = pd.read_json(cache_list[\"dependents\"], orient='split')\n biased_X = sm.add_constant(X.values)\n\n avg_beta_vector = input_list[\"avg_beta_vector\"]\n mean_y_global = input_list[\"mean_y_global\"]\n\n SSE_local, SST_local, varX_matrix_local = [], [], []\n for index, column in enumerate(y.columns):\n curr_y = y[column]\n\n X_, y_ = ignore_nans(biased_X, curr_y)\n\n SSE_local.append(reg.sum_squared_error(X_, y_, avg_beta_vector[index]))\n SST_local.append(\n np.sum(np.square(np.subtract(y_, mean_y_global[index]))))\n\n varX_matrix_local.append(np.dot(X_.T, X_).tolist())\n\n output_dict = {\n \"SSE_local\": SSE_local,\n \"SST_local\": SST_local,\n \"varX_matrix_local\": varX_matrix_local,\n \"computation_phase\": 'local_2'\n }\n\n cache_dict = {}\n\n computation_output = {\"output\": output_dict, \"cache\": cache_dict}\n\n return json.dumps(computation_output)","def _mer_compute(errors: Tensor, total: Tensor) ->Tensor:\n return errors / total","def compute(self, pred, target):\n pass","def call(self, query_input, source_input, bias, training, cache=None,\n decode_loop_step=None):\n # Linearly project the query, key and value using different learned\n # projections. Splitting heads is automatically done during the linear\n # projections --> [batch_size, length, num_heads, dim_per_head].\n query = self.query_dense_layer(query_input)\n key = self.key_dense_layer(source_input)\n value = self.value_dense_layer(source_input)\n\n if cache is not None:\n # Combine cached keys and values with new keys and values.\n if decode_loop_step is not None:\n cache_k_shape = cache[\"k\"].shape.as_list()\n indices = tf.reshape(\n tf.one_hot(decode_loop_step, cache_k_shape[1], dtype=key.dtype),\n [1, cache_k_shape[1], 1, 1])\n key = cache[\"k\"] + key * indices\n cache_v_shape = cache[\"v\"].shape.as_list()\n indices = tf.reshape(\n tf.one_hot(decode_loop_step, cache_v_shape[1], dtype=value.dtype),\n [1, cache_v_shape[1], 1, 1])\n value = cache[\"v\"] + value * indices\n else:\n key = tf.concat([tf.cast(cache[\"k\"], key.dtype), key], axis=1)\n value = tf.concat([tf.cast(cache[\"v\"], value.dtype), value], axis=1)\n\n # Update cache\n cache[\"k\"] = key\n cache[\"v\"] = value\n\n # Scale query to prevent the dot product between query and key from growing\n # too large.\n depth = (self.hidden_size // self.num_heads)\n query *= depth ** -0.5\n\n # Calculate dot product attention\n logits = tf.einsum(\"BTNH,BFNH->BNFT\", key, query)\n logits += bias\n # Note that softmax internally performs math operations using float32\n # for numeric stability. When training with float16, we keep the input\n # and output in float16 for better performance.\n weights = tf.nn.softmax(logits, name=\"attention_weights\")\n if training:\n weights = tf.nn.dropout(weights, rate=self.attention_dropout)\n attention_output = tf.einsum(\"BNFT,BTNH->BFNH\", weights, value)\n\n # Run the outputs through another linear projection layer. Recombining heads\n # is automatically done --> [batch_size, length, hidden_size]\n attention_output = self.output_dense_layer(attention_output)\n return attention_output","def inference_preprocess(self):\n return","def postprocess(self, prediction_dict, preprocessed_dict=None, use_trimap=True):\r\n pred_images = None\r\n gt_images = None\r\n gt_fg = None\r\n gt_bg = None\r\n if (not preprocessed_dict is None):\r\n gt_fg = preprocessed_dict.get('images_fg')\r\n gt_bg = preprocessed_dict.get('images_bg')\r\n gt_images = preprocessed_dict.get('images')\r\n\r\n pred_trimap = prediction_dict.get('pred_trimap')\r\n alpha_matte_r = prediction_dict.get('alpha_matte_r')\r\n alpha_matte_p = prediction_dict.get('alpha_matte_p')\r\n\r\n threshold = tf.fill(tf.shape(alpha_matte_p), 0.9)\r\n bool_great = tf.math.greater(alpha_matte_p, threshold)\r\n zeros = tf.fill(tf.shape(alpha_matte_p), 0.0)\r\n ones = tf.fill(tf.shape(alpha_matte_p), 1.0)\r\n alpha_matte_p_discrete = tf.where(bool_great, ones, zeros)\r\n if (not preprocessed_dict is None):\r\n pred_images = tf.multiply(alpha_matte_p_discrete, gt_fg) + tf.multiply(1 - alpha_matte_p_discrete, gt_bg)\r\n\r\n postprocessed_dict = {'pred_trimap': (pred_trimap * 255.),\r\n 'alpha_matte_r': (alpha_matte_r * 255.),\r\n 'alpha_matte_p': (alpha_matte_p * 255.),\r\n 'alpha_matte_p_discrete': (alpha_matte_p_discrete * 255.),\r\n 'pred_image': pred_images,\r\n 'gt_images': gt_images}\r\n if (preprocessed_dict is None):\r\n postprocessed_dict = {'pred_trimap': (pred_trimap * 255.),\r\n 'alpha_matte_r': (alpha_matte_r * 255.),\r\n 'alpha_matte_p': (alpha_matte_p * 255.),\r\n 'alpha_matte_p_discrete': (alpha_matte_p_discrete * 255.)\r\n }\r\n return postprocessed_dict","def forward(self, enc_states, enc_len, dec_states):\n\n if self.keys is None:\n\n self.keys = self.key_linear(enc_states)\n self.values = self.value_linear(enc_states)\n self.mask = length_to_mask(\n enc_len, max_len=enc_states.size(1), device=enc_states.device\n ).unsqueeze(2)\n\n query = self.query_linear(dec_states).unsqueeze(2)\n scores = torch.matmul(self.keys, query) / self.scaling\n scores = scores.masked_fill(self.mask == 0, -np.inf)\n normalized_scores = scores.softmax(1).transpose(1, 2)\n out = torch.matmul(normalized_scores, self.values).squeeze(1)\n return out, normalized_scores","def _bleu_score_update(preds: Sequence[str], target: Sequence[Sequence[str]], numerator: Tensor, denominator: Tensor, preds_len: Tensor, target_len: Tensor, n_gram: int=4, tokenizer: Callable[[str], Sequence[str]]=_tokenize_fn) ->Tuple[Tensor, Tensor]:\n target_: Sequence[Sequence[Sequence[str]]] = [[(tokenizer(line) if line else []) for line in t] for t in target]\n preds_: Sequence[Sequence[str]] = [(tokenizer(line) if line else []) for line in preds]\n for pred, targets in zip(preds_, target_):\n preds_len += len(pred)\n target_len_list = [len(tgt) for tgt in targets]\n target_len_diff = [abs(len(pred) - x) for x in target_len_list]\n target_len += target_len_list[target_len_diff.index(min(target_len_diff))]\n preds_counter: Counter = _count_ngram(pred, n_gram)\n target_counter: Counter = Counter()\n for tgt in targets:\n target_counter |= _count_ngram(tgt, n_gram)\n ngram_counter_clip = preds_counter & target_counter\n for counter_clip in ngram_counter_clip:\n numerator[len(counter_clip) - 1] += ngram_counter_clip[counter_clip]\n for counter in preds_counter:\n denominator[len(counter) - 1] += preds_counter[counter]\n return preds_len, target_len","def compute(self, inputs, outputs):\n\n # Add new variables to dictionnary\n cpacs = CPACS(Rt.modules[-1].cpacs_out)\n\n update_dict(cpacs.tixi, Rt.optim_var_dict)\n\n # Save the whole aeromap if needed\n if Rt.use_aeromap:\n update_am_dict(cpacs, Rt.aeromap_uid, Rt.am_dict)\n\n for obj in Rt.objective:\n var_list = split(\"[+*/-]\", obj)\n for v in var_list:\n if not v.isdigit() and v != \"\":\n exec('{} = inputs[\"{}\"]'.format(v, v))\n result = eval(obj)\n\n if Rt.minmax == \"min\":\n outputs[\"Objective function \" + obj] = result\n else:\n outputs[\"Objective function \" + obj] = -result","def _aux_forward(self, F, pred1, pred2, label, **kwargs):\n loss1 = super(MixSoftmaxCrossEntropyLoss, self). \\\n hybrid_forward(F, pred1, label, **kwargs)\n loss2 = super(MixSoftmaxCrossEntropyLoss, self). \\\n hybrid_forward(F, pred2, label, **kwargs)\n return loss1 + self.aux_weight * loss2","def forward(self, encoder_output, encoded_captions, caption_lengths):\n \n batch_size = encoder_output.size(0)\n encoder_dim = encoder_output.size(-1)\n \n # Flatten image\n encoder_output = encoder_output.view(batch_size, -1, encoder_dim)\n \n #print(encoder_output.size())\n \n num_pixels = encoder_output.size(1)\n \n # Embedding\n embeddings = self.embedding(encoded_captions).type(torch.FloatTensor).to(device)\n #print(embeddings.size())\n \n #initial_states\n h, c = self.init_hidden_states(encoder_output)\n #print(h.size(), c.size())\n\n # Create tensors to hold word predicion scores and alphas\n predictions = torch.zeros(batch_size, max(caption_lengths), self.vocab_size) #.to(device)\n \n #print('prediction_length', predictions.size())\n alphas = torch.zeros(batch_size, max(caption_lengths), num_pixels) #.to(device)\n #print('alphas', alphas.size())\n # At each time-step, decode by\n # attention-weighing the encoder's output based on the decoder's previous hidden state output\n # then generate a new word in the decoder with the previous word and the attention weighted encoding\n for t in range(max(caption_lengths)):\n batch_size_t = sum([l > t for l in caption_lengths])\n att, alpha = self.attention(encoder_output[:batch_size_t],\n h[:batch_size_t])\n gate = self.sigmoid(self.f_beta(h[:batch_size_t])) # gating scalar, (batch_size_t, encoder_dim)\n att = gate * att\n h, c = self.decode_step(\n torch.cat([embeddings[:batch_size_t, t, :], att], dim=1),\n (h[:batch_size_t], c[:batch_size_t])) # (batch_size_t, decoder_dim)\n #preds = self.fc(self.dropout(h)) # (batch_size_t, vocab_size)\n \n h_embedded = self.linear_h(h)\n att_embedded = self.linear_z(att)\n preds = self.linear_o(self.dropout(embeddings[:batch_size_t, t, :] + h_embedded + att_embedded))\n \n predictions[:batch_size_t, t, :] = preds\n alphas[:batch_size_t, t, :] = alpha\n \n #print(predictions.size()) \n return predictions, alphas","def calculate_loss(estimated_separation, true_separation, mask, true_latents, estimated_mix, true_mix, args):\n stats = torch.zeros(7)\n sdr = sdr_objective(estimated_separation, true_separation, mask)\n stats[:4] = sdr\n total_loss = -sdr.sum()\n reconstruction_sdr = sdr_objective(estimated_mix, true_mix).mean() if args.reconstruction_loss_weight > 0 else 0.0\n stats[4] = reconstruction_sdr\n total_loss += -args.reconstruction_loss_weight * reconstruction_sdr\n if args.similarity_loss_weight > 0.0 or args.dissimilarity_loss_weight > 0.0:\n mask = mask.squeeze(-1)\n true_latents = true_latents * mask.unsqueeze(-1).unsqueeze(-1)\n true_latents = true_latents.transpose(0, 1)\n dissimilarity = dissimilarity_loss(true_latents, mask) if args.dissimilarity_loss_weight > 0.0 else 0.0\n stats[5] = dissimilarity\n total_loss += args.dissimilarity_loss_weight * dissimilarity\n similarity = similarity_loss(true_latents, mask) if args.similarity_loss_weight > 0.0 else 0.0\n stats[6] = similarity\n total_loss += -args.similarity_loss_weight * similarity\n return total_loss, stats","def calculate_loss(self, word_inputs, feature_inputs, word_seq_lengths, char_inputs, char_seq_lengths, \\\r\n char_seq_recover, batch_label, mask, vfeature_input, v_modal_label, t_modal_label, v_mask, alpha=0):\r\n outs, textual_clf_outputs, visual_clf_outputs = self._get_lstm_features(word_inputs, feature_inputs,\r\n word_seq_lengths, char_inputs,\r\n char_seq_lengths, char_seq_recover,\r\n vfeature_input, v_mask, alpha)\r\n batch_size = word_inputs.size(0)\r\n seq_len = word_inputs.size(1)\r\n # crf\r\n ner_loss = self.crf.neg_log_likelihood_loss(outs, mask, batch_label)\r\n scores, tag_seq = self.crf._viterbi_decode(outs, mask) # batch,\r\n if self.average_batch:\r\n ner_loss = ner_loss / batch_size\r\n\r\n # modal clf loss\r\n # visual_clf_outputs: (obj*b, 2) mask (b, obj) ->\r\n visual_loss = self.modal_clf_loss(visual_clf_outputs, v_modal_label)\r\n textual_loss = self.modal_clf_loss(textual_clf_outputs, t_modal_label)\r\n\r\n total_loss = self.ner_loss_lambda * ner_loss + self.v_loss_lambda * visual_loss \\\r\n + self.t_loss_lambda * textual_loss\r\n\r\n return total_loss, \\\r\n self.ner_loss_lambda * ner_loss, \\\r\n self.t_loss_lambda * textual_loss, \\\r\n self.v_loss_lambda * visual_loss, \\\r\n tag_seq, textual_clf_outputs, visual_clf_outputs","def optimization_step(self):\n \n if \"CSS\" in self.algorithm:\n \n input_dict = {self.x: self.train_inputs[self.minibatch_set,:]}\n \n var_list = [self.x_tilda, self.minibatch_set]\n \n if (self.num_samples > 0) and (not self.mixture):\n \n if ((self.mf_steps > 0) and self.alpha >0) or\\\n self.gibbs_steps > 0: \n \n var_list.append(self.sampler_theta)\n \n elif \"CD\" in self.algorithm:\n \n input_dict = {self.x : self.train_inputs[self.minibatch_set,:]} \n \n var_list = [self.minibatch_set]\n \n var_list.append(self.learning_rate)\n \n if self.use_momentum:\n \n var_list.append(self.momentum)\n \n output_vars = [self.pseudo_cost]\n \n if self.report_p_tilda:\n \n output_vars.append(self.p_tilda)\n \n else:\n \n output_vars.append(theano.shared(0))\n \n opt_step = theano.function(inputs = var_list,\n outputs = output_vars,\n updates = self.updates,\n givens = input_dict,\n on_unused_input='warn')\n \n return opt_step","def preprocessing_fn(inputs):\n outputs = {}\n\n # This function is the entry point for your feature engineering with\n # TensorFlow Transform, using the TFX Transform component. In this example\n # the feature engineering is very simple, only applying z-score scaling.\n for key in Features.FEATURE_KEYS:\n outputs[transformed_name(key)] = tft.scale_to_z_score(inputs[key])\n\n # inputs[key]\n\n # tft.scale_to_z_score(inputs[key])\n\n # Do not apply label transformation as it will result in wrong evaluation.\n outputs[transformed_name(\n Features.LABEL_KEY)] = inputs[Features.LABEL_KEY]\n\n return outputs","def forward(self, encoder_outputs, decoder_h, previous_attention=None, mode=\"soft\"):\n if mode not in [\"soft\", \"hard\"]:\n raise ValueError(\"Invalid forward mode {} for attention; \\\n accept only soft and hard mode\".format(mode))\n\n if mode == \"soft\":\n\n #alpha_rec = cuda_benchmark(super().soft_recursive, encoder_outputs, decoder_h, previous_attention)\n #alpha = cuda_benchmark(super().soft, encoder_outputs, decoder_h, previous_attention)\n #alpha_rec = super().soft_recursive(encoder_outputs, decoder_h, previous_attention)\n alpha = super()(encoder_outputs, decoder_h, previous_attention, mode=\"soft\")\n # sum_of_alpha = torch.sum(alpha, dim=-1)\n # assert torch.allclose(sum_of_alpha, alpha.new_ones(alpha.size(0)),\n # atol=1e-3,\n # rtol=1e-3), \"{}\".format(sum_of_alpha)\n chunk_energy = self.chunk_energy(encoder_outputs, decoder_h)\n beta = self.my_soft(alpha, chunk_energy)\n return alpha, beta\n\n elif mode == \"hard\":\n monotonic_attention = super()(encoder_outputs, decoder_h,\n previous_attention, mode=\"hard\")\n chunk_energy = self.chunk_energy(encoder_outputs, decoder_h)\n masked_energy = self.hard(\n monotonic_attention, chunk_energy)\n chunkwise_attention = self.softmax(masked_energy)\n chunkwise_attention.masked_fill_(\n chunkwise_attention != chunkwise_attention,\n 0) # a trick to replace nan value with 0\n return monotonic_attention, chunkwise_attention","def prepare_vars_and_flows(self):\n\n # clear previously populated vars dictionary\n self.vars.clear()\n\n # calculate vars and flows sequentially\n self.calculate_scaleup_vars()\n self.calculate_vars()\n self.calculate_flows()","def forward(self,pad_pred:torch.Tensor, pad_targets:torch.Tensor, ylen, ctc_out, hlens): # , ylen, encoder_output, hlens\n batch_size,maxlen,_ = pad_pred.size()\n self.loss = self.criterion(pad_pred.view(batch_size*maxlen,-1),pad_targets.view(-1))\n ppl = self.compute_perplexity(self.loss.item())\n self.loss *= (np.mean([ len(x[x!=self.ignore_label]) for x in pad_targets]) - 1)\n\n ## Try to add CTC loss.\n ylen_tensor = torch.LongTensor([length for length in ylen])\n hlens_tensor = torch.LongTensor([length for length in hlens])\n ctc_pad_targets = torch.clone(pad_targets)\n ctc_pad_targets[ctc_pad_targets==-1] = 0\n self.loss = 0.9 * self.loss + 0.1 * \\\n self.ctc(ctc_out.permute(1, 0, 2).log_softmax(-1), \n ctc_pad_targets, hlens_tensor, ylen_tensor)\n\n if self.training:\n return self.loss,self.compute_accuracy(pad_pred,pad_targets),None\n else:\n return self.loss,self.compute_accuracy(pad_pred,pad_targets),self.compute_wer(pad_pred,pad_targets)","def post_build_args(self, args):\n # Default reconstruction loss multipliers\n if args.rec_mults == 'auto':\n dims = self.model.dims\n corrupt_mult = 1 / (1 - args.corrupt.get('uniform', 0.0))\n args.rec_mults = {m : ((1.0 / dims[m]) / len(args.modalities)\n * corrupt_mult)\n for m in args.modalities}\n return args","def __call__(self, query, batch_size, previous_alignments):\n with variable_scope.variable_scope(None, \"custom_attention\", [query]):\n line_scores = _luong_score(query, self._keys, self._scale)\n word_scores = _luong_word_score(query, self._word_values, self._scale, self._alignments_size, self._hierarchy, batch_size)\n \n line_alignments = self._soft_weight*self._probability_fn(line_scores)\n word_alignments = self._soft_weight*self._probability_fn(word_scores)\n\n if self._hierarchy:\n temp_word_alignments = tf.transpose(word_alignments, [0,2,1])\n temp_line_alignments = tf.expand_dims(line_alignments, 1)\n hier_alignments = math_ops.multiply(temp_word_alignments, temp_line_alignments)\n hier_alignments = tf.transpose(hier_alignments, [0,2,1])\n else:\n shape = word_scores.get_shape().as_list()[-1]\n word_scores = tf.reshape(word_scores, [self._batch_size, -1])\n word_alignments = self._probability_fn(word_scores)\n word_alignments = tf.reshape(word_alignments, tf.stack([self._batch_size, -1, shape]))\n hier_alignments = word_alignments\n #[batch_size x memory_size x sentence_size]\n hier_alignments = tf.reshape(hier_alignments, [self._batch_size, -1])\n return line_alignments, word_alignments, hier_alignments","def adapt(args, src_encoder, tgt_encoder, discriminator,\n src_classifier, src_data_loader, tgt_data_train_loader, tgt_data_all_loader):\n\n # set train state for Dropout and BN layers\n src_encoder.eval()\n src_classifier.eval()\n tgt_encoder.train()\n discriminator.train()\n\n # setup criterion and optimizer\n BCELoss = nn.BCELoss()\n KLDivLoss = nn.KLDivLoss(reduction='batchmean')\n optimizer_G = optim.Adam(tgt_encoder.parameters(), lr=param.d_learning_rate)\n optimizer_D = optim.Adam(discriminator.parameters(), lr=param.d_learning_rate)\n len_data_loader = min(len(src_data_loader), len(tgt_data_train_loader))\n \n for epoch in range(args.num_epochs):\n # zip source and target data pair\n data_zip = enumerate(zip(src_data_loader, tgt_data_train_loader))\n print(\"Loader lengths: \", len(src_data_loader), len(tgt_data_train_loader))\n d_l = []\n g_l = []\n kd_l = []\n accu = []\n for step, (batch1, batch2) in data_zip:\n batch1 = tuple(t.to(DEVICE) for t in batch1)\n batch2 = tuple(t.to(DEVICE) for t in batch2)\n src_input_ids, src_visual, src_acoustic, src_input_mask, src_segment_ids, src_label_ids = batch1 \n tgt_input_ids, tgt_visual, tgt_acoustic, tgt_input_mask, tgt_segment_ids, tgt_label_ids = batch2\n\n src_visual = torch.squeeze(src_visual, 1)\n src_acoustic = torch.squeeze(src_acoustic, 1)\n # zero gradients for optimizer\n optimizer_D.zero_grad()\n\n # extract and concat features\n with torch.no_grad():\n feat_src = src_encoder(src_input_ids,\n src_visual,\n src_acoustic,\n token_type_ids=src_segment_ids,\n attention_mask=src_input_mask,\n labels=None,)\n\n feat_src_tgt = tgt_encoder(src_input_ids,\n src_visual,\n src_acoustic,\n token_type_ids=src_segment_ids,\n attention_mask=src_input_mask,\n labels=None,)\n feat_tgt = tgt_encoder(tgt_input_ids,\n tgt_visual,\n tgt_acoustic,\n token_type_ids=tgt_segment_ids,\n attention_mask=tgt_input_mask,\n labels=None,)\n\n feat_concat = torch.cat((feat_src_tgt, feat_tgt), 0)\n # print(\"Checking dims\", feat_src_tgt.shape, feat_tgt.shape, feat_concat.shape)\n\n # predict on discriminator\n pred_concat = discriminator(feat_concat.detach())\n pred_concat.to(DEVICE)\n\n # prepare real and fake label\n label_src = make_cuda(torch.ones(feat_src_tgt.size(0))).unsqueeze(1)\n label_tgt = make_cuda(torch.zeros(feat_tgt.size(0))).unsqueeze(1)\n label_concat = torch.cat((label_src, label_tgt), 0)\n\n # compute loss for discriminator\n dis_loss = BCELoss(pred_concat, label_concat)\n dis_loss.backward()\n\n for p in discriminator.parameters():\n p.data.clamp_(-args.clip_value, args.clip_value)\n # optimize discriminator\n optimizer_D.step()\n # print(\"pred_concat : \" + str(pred_concat) + \"\\n\")\n pred_cls = (pred_concat>0.5).float()\n # pred_cls = torch.squeeze(pred_concat.max(1)[1])\n # print(\"pred_cls : \" + str(pred_cls) + \"\\n\")\n # print(\"label Concat: \" + str(label_concat) + \"\\n\")\n acc = (pred_cls == label_concat).float().mean()\n\n # zero gradients for optimizer\n optimizer_G.zero_grad()\n T = args.temperature\n\n # predict on discriminator\n pred_tgt = discriminator(feat_tgt)\n\n # logits for KL-divergence\n with torch.no_grad():\n src_prob = F.softmax(src_classifier(feat_src) / T, dim=-1)\n tgt_prob = F.log_softmax(src_classifier(feat_src_tgt) / T, dim=-1)\n kd_loss = KLDivLoss(tgt_prob, src_prob.detach()) * T * T\n\n # compute loss for target encoder\n label_src_n = make_cuda(torch.ones(feat_tgt.size(0))).unsqueeze(1)\n # print(\"Checking dims 2:\", feat_tgt.shape, pred_tgt.shape, label_src.shape)\n gen_loss = BCELoss(pred_tgt, label_src_n)\n loss_tgt = args.alpha * gen_loss + args.beta * kd_loss\n loss_tgt.backward()\n accu.append(acc.item())\n g_l.append(gen_loss.item())\n d_l.append(dis_loss.item())\n kd_l.append(kd_loss.item())\n torch.nn.utils.clip_grad_norm_(tgt_encoder.parameters(), args.max_grad_norm)\n # optimize target encoder\n optimizer_G.step()\n\n if (step + 1) % args.log_step == 0:\n print(\"Epoch [%.2d/%.2d] Step [%.3d/%.3d]: \"\n \"acc=%.4f g_loss=%.4f d_loss=%.4f kd_loss=%.4f\"\n % (epoch + 1,\n args.num_epochs,\n step + 1,\n len_data_loader,\n torch.tensor(accu).mean(),\n torch.tensor(g_l).mean(),\n torch.tensor(d_l).mean(),\n torch.tensor(kd_l).mean()))\n\n evaluate(args, tgt_encoder, src_classifier, tgt_data_all_loader)\n\n return tgt_encoder","def recoding_func(self, input_var: Tensor, hidden: HiddenDict, out: Tensor, device: Device,\n **additional: Dict) -> RecurrentOutput:\n target_idx = additional.get(\"target_idx\", None)\n\n # Estimate uncertainty of those same predictions\n delta = self.get_surprisal(out, target_idx)\n\n # Calculate gradient of uncertainty w.r.t. hidden states and make step\n new_out_dist, new_hidden = self.recode_activations(hidden, out, delta, device, **additional)\n\n return new_out_dist, new_hidden","def make_optimizer(self, train_var_filter):\n # According from the prototxt in Caffe implement, learning rate must multiply by 10.0 in pyramid module\n fc_list = ['conv5_3_pool1_conv', 'conv5_3_pool2_conv', 'conv5_3_pool3_conv', 'conv5_3_pool6_conv', 'conv6',\n 'conv5_4']\n all_trainable = [v for v in tf.trainable_variables() if\n ('beta' not in v.name and 'gamma' not in v.name) or True]\n fc_trainable = [v for v in all_trainable if v.name.split('/')[0] in fc_list]\n conv_trainable = [v for v in all_trainable if v.name.split('/')[0] not in fc_list] # lr * 1.0\n fc_w_trainable = [v for v in fc_trainable if 'weights' in v.name] # lr * 10.0\n fc_b_trainable = [v for v in fc_trainable if 'biases' in v.name] # lr * 20.0\n assert (len(all_trainable) == len(fc_trainable) + len(conv_trainable))\n assert (len(fc_trainable) == len(fc_w_trainable) + len(fc_b_trainable))\n\n with tf.control_dependencies(self.update_ops):\n opt_conv = tf.train.MomentumOptimizer(self.lr_op, self.momentum)\n opt_fc_w = tf.train.MomentumOptimizer(self.lr_op * 10.0, self.momentum)\n opt_fc_b = tf.train.MomentumOptimizer(self.lr_op * 20.0, self.momentum)\n\n grads = tf.gradients(self.loss, conv_trainable + fc_w_trainable + fc_b_trainable)\n grads_conv = grads[:len(conv_trainable)]\n grads_fc_w = grads[len(conv_trainable): (len(conv_trainable) + len(fc_w_trainable))]\n grads_fc_b = grads[(len(conv_trainable) + len(fc_w_trainable)):]\n\n train_op_conv = opt_conv.apply_gradients(zip(grads_conv, conv_trainable), global_step=self.global_step)\n train_op_fc_w = opt_fc_w.apply_gradients(zip(grads_fc_w, fc_w_trainable))\n train_op_fc_b = opt_fc_b.apply_gradients(zip(grads_fc_b, fc_b_trainable))\n\n self.optimizer = tf.group(train_op_conv, train_op_fc_w, train_op_fc_b)","def preprocessing(train_raw_, test_raw_):\n \n undef = np.float64(-999.0)\n pred_dict = {'s':'1','b':'0', '?':'-1'}\n # drop 1st column (Id) and also 1st row with column names (\"[1:,\") \n train_raw = train_raw_[1:, :]\n test_raw = test_raw_[1:, :] \n \n # Change s(signal) and b(background) for s:1 and b:0, and change '?' for -1\n train_raw[:,1] = np.vectorize(pred_dict.get)(train_raw[:,1].astype(str))\n test_raw[:,1] = np.vectorize(pred_dict.get)(test_raw[:,1].astype(str))\n \n # Divide the dataset in four according to PRI_jet_num feature and cast to float\n train_data_jets = divide_dataset_by_jet(train_raw)\n test_data_jets = divide_dataset_by_jet(test_raw)\n \n # Remove columns with nan values or with standard deviation of 0\n test_data_jets, train_data_jets = clean_features(test_data_jets, train_data_jets, undef)\n \n # Standardize train and test sets to have mean=0 and std=1\n train_data_jets, test_data_jets = standardize(train_data_jets, test_data_jets)\n \n # Replace remaining undefined values by mean, median or zero\n train_data_mean, train_data_median, train_data_null = replace_nan(train_data_jets)\n test_data_mean, test_data_median, test_data_null = replace_nan(test_data_jets)\n \n return train_data_mean, train_data_median, train_data_null, test_data_mean, test_data_median, test_data_null","def _bleu_score_compute(preds_len: Tensor, target_len: Tensor, numerator: Tensor, denominator: Tensor, n_gram: int, weights: Sequence[float], smooth: bool) ->Tensor:\n device = numerator.device\n if min(numerator) == 0.0:\n return tensor(0.0, device=device)\n if smooth:\n precision_scores = torch.div(torch.add(numerator, torch.ones(n_gram, device=device)), torch.add(denominator, torch.ones(n_gram, device=device)))\n precision_scores[0] = numerator[0] / denominator[0]\n else:\n precision_scores = numerator / denominator\n log_precision_scores = tensor(weights, device=device) * torch.log(precision_scores)\n geometric_mean = torch.exp(torch.sum(log_precision_scores))\n brevity_penalty = tensor(1.0, device=device) if preds_len > target_len else torch.exp(1 - target_len / preds_len)\n bleu = brevity_penalty * geometric_mean\n return bleu","def loss(self, X, y=None):\n W1, b1 = self.params['W1'], self.params['b1']\n W2, b2 = self.params['W2'], self.params['b2']\n W3, b3 = self.params['W3'], self.params['b3']\n \n # pass conv_param to the forward pass for the convolutional layer\n filter_size = W1.shape[2]\n conv_param = {'stride': 1, 'pad': (filter_size - 1) / 2}\n\n # pass pool_param to the forward pass for the max-pooling layer\n pool_param = {'pool_height': 2, 'pool_width': 2, 'stride': 2}\n\n ############################################################################\n # TODO: Implement the forward pass for the three-layer convolutional net, #\n # computing the class scores for X and storing them in the scores #\n # variable. #\n ############################################################################\n \n scores = None \n cache = {}\n # def conv_relu_pool_forward(x, w, b, conv_param, pool_param): return out, cache;\n out, cache['layer1'] = layer_utils.conv_relu_pool_forward(X, W1, b1, conv_param, pool_param) \n # def affine_relu_forward(x, w, b): return out, cache;\n out, cache['layer2'] = layer_utils.affine_relu_forward(out, W2, b2)\n # def affine_forward(x, w, b): return out, cache;\n scores, cache['layer3'] = layers.affine_forward(out, W3, b3)\n\n\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n \n if y is None:\n return scores\n \n ############################################################################\n # TODO: Implement the backward pass for the three-layer convolutional net, #\n # storing the loss and gradients in the loss and grads variables. Compute #\n # data loss using softmax, and make sure that grads[k] holds the gradients #\n # for self.params[k]. Don't forget to add L2 regularization! #\n ############################################################################\n \n loss, grads = 0, {}\n\n # def softmax_loss(x, y): return loss, dscore;\n loss, dscores = layers.softmax_loss(scores, y)\n loss += 0.5 * self.reg * (np.sum(W1 * W1) + np.sum(W2 * W2) + np.sum(W3 * W3))\n\n # def affine_backward(dout, cache): return dx, dw, db;\n dout, dW3, db3 = layers.affine_backward(dscores, cache['layer3']) \n # def affine_relu_backward(dout, cache): return dx, dw, db;\n dout, dW2, db2 = layer_utils.affine_relu_backward(dout, cache['layer2'])\n # def conv_relu_pool_backward(dout, cache): return dx, dw, db;\n dout, dW1, db1 = layer_utils.conv_relu_pool_backward(dout, cache['layer1'])\n\n # reg\n grads['W3'], grads['b3'] = dW3 + self.reg * W3, db3\n grads['W2'], grads['b2'] = dW2 + self.reg * W2, db2\n grads['W1'], grads['b1'] = dW1 + self.reg * W1, db1\n\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n \n return loss, grads","def calculate_scaleup_vars(self):\n\n for label, fn in self.scaleup_fns.items():\n self.vars[label] = fn(self.time)","def compute_backsubstitution(self, length: int, dim: int, layer_gradient_manager=None):\n if self.args.cpu:\n self.lb = torch.zeros(length, dim)\n else:\n self.lb = torch.zeros(length, dim).cuda()\n self.ub = self.lb.clone()\n self.final_lw = self.final_uw = None\n self.final_lb = self.final_ub = None\n\n original_layers = self.layers[:] # We keep a copy, because layers might get modified during the backsubstitution with jacobian\n for layer in self.layers[::-1]:\n if layer.lw is not None:\n layer.backward(layer_gradient_manager)\n # print(\"Controller has grad: \", self.lb.requires_grad)\n self.layers = original_layers # We restore the original layers","def evaluate(net, dmanager, partition): \n def accuracy(outputs, labels, phrases, dmanager):\n correct = 0\n total = 0\n misclassified = []\n for (i, output) in enumerate(outputs):\n total += 1\n if labels[i] == output.argmax():\n correct += 1\n else:\n misclassified.append((phrases[i], \n dmanager.tag(output.argmax().item()),\n dmanager.tag(labels[i].item())))\n return correct, total, misclassified\n val_loader = dmanager.batched_loader(partition, 128)\n total_val_loss = 0\n correct = 0\n total = 0\n misclassified = []\n loss = torch.nn.CrossEntropyLoss() \n for data in val_loader:\n raw_inputs = [dmanager.vectorize(p) for p in data['phrase']]\n raw_labels = [dmanager.tag_index(c) for c in data['tag']]\n inputs = []\n labels = []\n for (inp, label) in zip(raw_inputs, raw_labels):\n if inp is not None:\n inputs.append(inp)\n labels.append(label) \n inputs = torch.Tensor(inputs)\n labels = torch.LongTensor([dmanager.tag_index(c) for \n c in data['tag']])\n val_outputs = net(inputs) \n val_loss_size = loss(val_outputs, labels)\n correct_inc, total_inc, misclassified_inc = accuracy(val_outputs, \n labels, \n data['phrase'], \n dmanager)\n correct += correct_inc\n total += total_inc\n misclassified += misclassified_inc\n total_val_loss += val_loss_size.data.item()\n return correct/total, misclassified","def compute_loss(model, loader, loss_fn, optimizer=None):\n\n total_loss = 0.0\n count_batches = 0\n for x_, y_, qm_, db_mask, blink_mask in loader:\n batch_loss_list = []\n xbatch_list = []\n for mask in [db_mask, blink_mask]:\n idxes = get_idxes_from_mask(mask)\n x_pick, y_pick, qm_pick = x_[idxes], y_[idxes], qm_[idxes]\n y_pos_idxes = torch.nonzero(y_pick.squeeze(), as_tuple=False).reshape(1, -1)[0]\n y_neg_idxes = torch.nonzero(~y_pick.squeeze().bool(), as_tuple=False).reshape(1, -1)[0]\n\n if (len(y_pos_idxes) == 0) or (len(y_neg_idxes) == 0):\n xbatch_list.append(torch.tensor([]))\n continue\n elif len(x_pick) <= 1:\n xbatch_list.append(torch.tensor([]))\n continue\n elif len(y_pos_idxes) == 1:\n y_pos_idx = y_pos_idxes[0]\n else: # len(y_pos_idxes) > 1:\n # TODO: I am just always using the first positive example for now\n # rand_idx = random.choice(list(range(len(y_pos_idxes))))\n # print(y_pos_idxes)\n rand_idx = 0\n y_pos_idx = y_pos_idxes[rand_idx]\n\n batch_length = 1 + len(y_neg_idxes)\n batch_feature_len = x_.shape[1]\n x_batch = torch.zeros(batch_length, batch_feature_len)\n x_batch[:-1:, :] = x_pick[y_neg_idxes]\n x_batch[-1, :] = x_pick[y_pos_idx] # put positive to the end\n xbatch_list.append(x_batch)\n # print(y_pos_idx, len(y_neg_idxes))\n # print(\"batch\", x_batch.shape)\n\n if (len(xbatch_list[0]) == 0) and (len(xbatch_list[1]) == 0):\n # skip if both batches are []\n # print(\"hitting cases without any examples [SHOULD BE WRONG]\")\n continue\n elif (len(xbatch_list[0]) == 0) or (len(xbatch_list[1]) == 0):\n # continue # TODO: testing whether improvements made if we only use cases where there are sources from both\n yhat = model(xbatch_list[0], xbatch_list[1])\n extended_batch_length = len(yhat) - 1\n yhat_neg = yhat[:-1]\n yhat_pos = yhat[-1].repeat(extended_batch_length, 1)\n loss = loss_fn(yhat_pos, yhat_neg, torch.ones((len(yhat) - 1), 1).to(device))\n batch_loss_list.append(loss)\n total_loss += loss.item() * extended_batch_length\n count_batches += 1\n else:\n # get yhats for both BLINK and DB batches\n # print(len(xbatch_list[0]), len(xbatch_list[1]))\n # print((xbatch_list[0], xbatch_list[1]))\n yhat = model(xbatch_list[0], xbatch_list[1])\n extended_batch_length = len(yhat) - 2\n yhat_neg = torch.zeros(extended_batch_length, 1)\n yhat_neg[:len(xbatch_list[0])-1] = yhat[:len(xbatch_list[0])-1]\n yhat_neg[len(xbatch_list[0])-1:] = yhat[len(xbatch_list[0]):-1]\n for idx in [len(xbatch_list[0]), -1]:\n yhat_pos = yhat[idx].repeat(extended_batch_length, 1)\n loss = loss_fn(yhat_pos, yhat_neg, torch.ones(extended_batch_length, 1).to(device))\n batch_loss_list.append(loss)\n total_loss += loss.item() * extended_batch_length\n count_batches += 1\n\n # update every question-mention\n if batch_loss_list and optimizer:\n (sum(batch_loss_list)/len(batch_loss_list)).backward()\n optimizer.step()\n\n avg_loss = total_loss / count_batches\n\n return avg_loss, batch_length","def init_trainers(self, args):\n self.actors_cur = [None for _ in range(self.num_agents)]\n self.critics_cur = [None for _ in range(self.num_agents)]\n self.actors_tar = [None for _ in range(self.num_agents)]\n self.critics_tar = [None for _ in range(self.num_agents)]\n self.optimizers_c = [None for _ in range(self.num_agents)]\n self.optimizers_a = [None for _ in range(self.num_agents)]\n input_size_global = sum(self.obs_shape_n) + sum(self.action_shape_n)\n\n if args.restore == True: # restore the model\n game_step = int(args.old_model_name.split('_')[-1][:-1])\n for idx in range(self.num_agents):\n self.actors_cur[idx] = torch.load(args.old_model_name+'a_c_{}.pt'.format(idx))\n self.actors_tar[idx] = torch.load(args.old_model_name+'a_t_{}.pt'.format(idx))\n self.critics_cur[idx] = torch.load(args.old_model_name+'c_c_{}.pt'.format(idx))\n self.critics_tar[idx] = torch.load(args.old_model_name+'c_t_{}.pt'.format(idx))\n self.optimizers_a[idx] = optim.Adam(self.actors_cur[idx].parameters(), args.lr_a)\n self.optimizers_c[idx] = optim.Adam(self.critics_cur[idx].parameters(), args.lr_c)\n self.var = self.var - (game_step-args.learning_start_episode*args.per_episode_max_len)*args.var_discount\n self.var = self.min_var if self.var < self.min_var else self.var\n old_data = {'game_step':game_step, 'episode_gone_old':int(game_step/args.per_episode_max_len)}\n\n # Note: if you need load old model, there should be a procedure for juding if the trainers[idx] is None\n for i in range(self.num_agents):\n self.actors_cur[i] = actor_agent(self.obs_shape_n[i], self.action_shape_n[i], \\\n args).to(args.device)\n self.critics_cur[i] = critic_agent(sum(self.obs_shape_n), sum(self.action_shape_n), \\\n args).to(args.device)\n self.actors_tar[i] = actor_agent(self.obs_shape_n[i], self.action_shape_n[i], \\\n args).to(args.device)\n self.critics_tar[i] = critic_agent(sum(self.obs_shape_n), sum(self.action_shape_n), \\\n args).to(args.device)\n self.optimizers_a[i] = optim.Adam(self.actors_cur[i].parameters(), args.lr_a)\n self.optimizers_c[i] = optim.Adam(self.critics_cur[i].parameters(), args.lr_c)\n\n # return the old data, no need to update the trainers\n if args.restore == True: return old_data\n\n self.actors_tar = self.update_trainers(self.actors_cur, self.actors_tar, 1.0) # update the target par using the cur\n self.critics_tar = self.update_trainers(self.critics_cur, self.critics_tar, 1.0) # update the target par using the cur","def _bleu_score_compute(\n preds_len: Tensor,\n target_len: Tensor,\n numerator: Tensor,\n denominator: Tensor,\n n_gram: int,\n weights: Sequence[float],\n smooth: bool,\n) -> Tensor:\n device = numerator.device\n if min(numerator) == 0.0:\n return tensor(0.0, device=device)\n\n if smooth:\n precision_scores = torch.div(\n torch.add(numerator, torch.ones(n_gram, device=device)),\n torch.add(denominator, torch.ones(n_gram, device=device)),\n )\n precision_scores[0] = numerator[0] / denominator[0]\n else:\n precision_scores = numerator / denominator\n\n log_precision_scores = tensor(weights, device=device) * torch.log(precision_scores)\n geometric_mean = torch.exp(torch.sum(log_precision_scores))\n brevity_penalty = tensor(1.0, device=device) if preds_len > target_len else torch.exp(1 - (target_len / preds_len))\n return brevity_penalty * geometric_mean","def initialize_cache(inputs, outputs, programs, max_decode_len, config):\n target_shape = (programs.shape[0], max_decode_len)\n initial_variables = models.ProgramTransformer(config).init(\n jax.random.PRNGKey(0),\n jnp.ones(inputs.shape, config.dtype),\n jnp.ones(outputs.shape, config.dtype),\n jnp.ones(target_shape, config.dtype))\n return initial_variables['cache']","def get_pca_embeddings(config, name, training_embedding: dict, validation_embedding: dict):\n\n data_name = config['train_file'].split('/')[-1][:-4] # retrieve file name without the extension\n train_pca_pkl_f = os.path.join(config['pca_cache'], data_name + '_' + config['embedding_type'] + '_training_embeddings.p')\n valid_pca_pkl_f = os.path.join(config['pca_cache'], data_name + '_' + config['embedding_type'] + '_validation_embeddings.p')\n\n if os.path.exists(train_pca_pkl_f):\n logger.info(\" Loading PCA-embeddings from cache \")\n with open(train_pca_pkl_f , 'rb') as cache:\n train_embeddings = pickle.load(cache)\n\n with open(valid_pca_pkl_f, 'rb') as cache:\n valid_embeddings = pickle.load(cache)\n else:\n logger.info(' Standardizing ')\n \n ss = StandardScaler()\n train_embed_ss = ss.fit_transform(training_embedding['embeddings'])\n valid_embed_ss = ss.transform(validation_embedding['embeddings'])\n\n # Dimension reduction: PCA or UMAP (?)\n logger.info(' Doing PCA...')\n pca_model = decomposition.PCA(n_components = 0.90) # this can be a parameter down the road, but for debugging it's fine\n train_reduc = pca_model.fit_transform(train_embed_ss)\n val_reduc = pca_model.transform(valid_embed_ss)\n\n \n training_embedding['embeddings'] = train_reduc\n validation_embedding['embeddings'] = val_reduc\n\n train_embeddings = training_embedding.copy()\n valid_embeddings = validation_embedding.copy()\n\n # save embeddings\n pickle.dump(train_embeddings, open(train_pca_pkl_f, 'wb'))\n pickle.dump(valid_embeddings, open(valid_pca_pkl_f, 'wb'))\n\n embedding_shape = len(train_embeddings['embeddings'][0])\n\n return embedding_shape, train_embeddings, valid_embeddings","def fisher_precalc(\n self,\n cbl,\n cls_input,\n cls_debias=None,\n likelihood=False,\n windows=False,\n ):\n num_maps = self.num_maps\n pol_dim = 3 if self.pol else 1\n dim1 = pol_dim * num_maps\n\n comps = [\"cmb\"]\n if \"fg_tt\" in cbl:\n comps += [\"fg\"]\n if \"res_tt\" in cbl or \"res_ee\" in cbl:\n comps += [\"res\"]\n\n specs = list(cls_input)\n\n if likelihood:\n Dmat_obs_b = OrderedDict()\n Dmat_obs = None\n dSdqb = None\n Mmat = None\n Mmat_mix = None\n else:\n if windows:\n Dmat_obs = None\n Mmat = OrderedDict()\n Mmat_mix = OrderedDict() if self.pol else None\n mll = getattr(self, \"mll\", None)\n if mll is None:\n mll = self.kernel_precalc()\n else:\n Dmat_obs = OrderedDict()\n Mmat = None\n Mmat_mix = None\n Dmat_obs_b = None\n dSdqb = OrderedDict()\n\n for xname, (m0, m1) in self.map_pairs.items():\n # transfer function doesn't have all the crosses\n if xname not in cls_input[specs[0]]:\n continue\n\n if likelihood:\n Dmat_obs_b[xname] = OrderedDict()\n elif windows:\n Mmat[xname] = OrderedDict()\n if self.pol:\n Mmat_mix[xname] = OrderedDict()\n else:\n Dmat_obs[xname] = OrderedDict()\n\n for spec in specs:\n if likelihood:\n # without bias subtraction for likelihood\n Dmat_obs_b[xname][spec] = cls_input[spec][xname]\n elif windows:\n Mmat[xname][spec] = mll[spec][xname]\n if spec in [\"ee\", \"bb\"]:\n mspec = \"bb\" if spec == \"ee\" else \"ee\"\n Mmat_mix[xname][spec] = mll[\"{}_mix\".format(mspec)][xname]\n else:\n if cls_debias is not None:\n Dmat_obs[xname][spec] = (\n cls_input[spec][xname] - cls_debias[spec][xname]\n )\n else:\n Dmat_obs[xname][spec] = cls_input[spec][xname]\n\n if likelihood:\n continue\n\n for comp in comps:\n for spec in specs:\n stag = \"{}_{}\".format(comp, spec)\n if stag not in cbl:\n continue\n if xname not in cbl[stag]:\n continue\n\n dSdqb.setdefault(comp, OrderedDict()).setdefault(\n xname, OrderedDict()\n ).setdefault(spec, OrderedDict())\n dSdqb[comp][xname][spec][spec] = cbl[stag][xname]\n\n if spec in [\"ee\", \"bb\"]:\n if stag + \"_mix\" not in cbl:\n continue\n mspec = \"bb\" if spec == \"ee\" else \"ee\"\n mix_cbl = cbl[stag + \"_mix\"][xname]\n dSdqb[comp][xname][spec][mspec] = mix_cbl\n\n if comp == \"fg\":\n # add delta beta bin for spectral index\n dSdqb.setdefault(\"delta_beta\", OrderedDict()).setdefault(\n xname, OrderedDict()\n )\n for spec in specs:\n # this will be filled in in fisher_calc\n dSdqb[\"delta_beta\"][xname][spec] = OrderedDict()\n\n return Dmat_obs, Dmat_obs_b, dSdqb, Mmat, Mmat_mix","def _create_preprocess_fn(\n num_epochs: int,\n batch_size: int,\n merge_case: bool,\n shuffle_buffer_size: int = emnist_dataset.MAX_CLIENT_DATASET_SIZE,\n use_cache: bool = True,\n use_prefetch: bool = True,\n) -> Callable[[tf.data.Dataset], tf.data.Dataset]:\n @tf.function\n def merge_mapping(elem):\n original_label_to_merged_label = tf.constant([\n 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,\n 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,\n 12, 38, 39, 40, 41, 42, 18, 19, 20, 21, 22, 43, 24, 25, 44, 45, 28, 46,\n 30, 31, 32, 33, 34, 35\n ])\n return collections.OrderedDict(\n label=original_label_to_merged_label[elem['label']],\n pixels=elem['pixels'])\n\n base_preprocess_fn = emnist_dataset.create_preprocess_fn(\n num_epochs=num_epochs,\n batch_size=batch_size,\n shuffle_buffer_size=shuffle_buffer_size)\n\n def preprocess_fn(dataset: tf.data.Dataset):\n if merge_case:\n dataset = dataset.map(merge_mapping)\n if use_cache:\n dataset = dataset.cache()\n dataset = base_preprocess_fn(dataset)\n if use_prefetch:\n dataset = dataset.prefetch(tf.data.AUTOTUNE)\n\n return dataset\n\n return preprocess_fn # pytype: disable=bad-return-type","def param_computation(self, param):\n result = {}\n\n result[\"V_t_V\"] = param_computation_V_t_V(param)\n\n if compute_gammas:\n result[\"V_t_g_n\"] = param_computation_V_t_g_n(param)\n if compute_lambdas:\n result[\"V_n_t_V\"] = param_computation_V_n_t_V(param)\n\n param_computation_memory_cleanup(param)\n\n return result","def call_preprocessing(self, train_mains, train_appliances):\n return train_mains, train_appliances"],"string":"[\n \"def precalculate():\\n pass\",\n \"def precalculate():\\n pass\",\n \"def E_step_precompute(self, model_params, my_suff_stat, my_data):\",\n \"def pre_forward(self, *args, **kwargs):\\n batch_size = args[0].shape[0]\\n if not self.instantiated:\\n self.hidden_dim = args[0].shape[-1]\\n self.instantiate(hidden_dim=self.hidden_dim)\\n if self.past_key_reparam is None:\\n past_key = self.past_key\\n else:\\n past_key = self.past_key_reparam\\n if self.past_value_reparam is None:\\n past_value = self.past_value\\n else:\\n past_value = self.past_value_reparam\\n\\n # from IPython import embed\\n # embed()\\n def expand_batchsize(x):\\n x = x.reshape(self.prefix_token_num, self.num_heads, -1).transpose(0,1)\\n x = x.unsqueeze(0).expand(batch_size, *x.shape)\\n return x\\n # from IPython import embe\\n\\n if 'past_key_value' not in kwargs or kwargs['past_key_value'] is None:\\n kwargs['past_key_value'] = (expand_batchsize(past_key), expand_batchsize(past_value))\\n\\n if 'attention_mask' in kwargs and kwargs['attention_mask'] is not None:\\n am = kwargs['attention_mask'] # Should check the format of the attention_mask when moving to a new plm.\\n kwargs['attention_mask'] = torch.cat([-torch.zeros((*am.shape[:-1],self.prefix_token_num), dtype = am.dtype,device=am.device), am], dim=-1)\\n elif len(args) >1: # attention mask is passed via positional argument\\n am = args[1]\\n am = torch.cat([-torch.zeros((*am.shape[:-1],self.prefix_token_num), dtype = am.dtype,device=am.device), am], dim=-1)\\n args = (args[0], am) + args[2:]\\n # from IPython import embed\\n # embed(header = \\\"Herein prefixroberta\\\")\\n return args, kwargs\",\n \"def pre_forward(self, *args, **kwargs):\\n batch_size = args[0].shape[0]\\n if not self.instantiated:\\n self.hidden_dim = args[0].shape[-1]\\n self.instantiate(hidden_dim=self.hidden_dim)\\n if self.past_key_reparam is None:\\n past_key = self.past_key\\n else:\\n past_key = self.past_key_reparam\\n if self.past_value_reparam is None:\\n past_value = self.past_value\\n else:\\n past_value = self.past_value_reparam\\n\\n\\n def expand_batchsize(x):\\n x = x.reshape(self.prefix_token_num, self.num_heads, -1).transpose(0,1)\\n x = x.unsqueeze(0).expand(batch_size, *x.shape)\\n return x\\n # from IPython import embe\\n\\n if 'past_key_value' not in kwargs or kwargs['past_key_value'] is None:\\n kwargs['past_key_value'] = (expand_batchsize(past_key), expand_batchsize(past_value))\\n\\n if 'attention_mask' in kwargs and kwargs['attention_mask'] is not None:\\n am = kwargs['attention_mask'] # Should check the format of the attention_mask when moving to a new plm.\\n kwargs['attention_mask'] = torch.cat([-torch.zeros((*am.shape[:-1],self.prefix_token_num), dtype = am.dtype,device=am.device), am], dim=-1)\\n elif len(args) >1: # attention mask is passed via positional argument\\n am = args[1]\\n am = torch.cat([-torch.zeros((*am.shape[:-1],self.prefix_token_num), dtype = am.dtype,device=am.device), am], dim=-1)\\n args = (args[0], am) + args[2:]\\n # from IPython import embed\\n # embed(header = \\\"Herein prefixroberta\\\")\\n return args, kwargs\",\n \"def compute_localizations_original(depc, gid_list, config=None):\\n\\n def _package_to_numpy(key_list, result_list, score):\\n temp = [\\n [key[0] if isinstance(key, tuple) else result[key] for key in key_list]\\n for result in result_list\\n ]\\n return (\\n score,\\n np.array([_[0:4] for _ in temp]),\\n np.array([_[4] for _ in temp]),\\n np.array([_[5] for _ in temp]),\\n np.array([_[6] for _ in temp]),\\n )\\n\\n def _combined(gid_list, config_dict_list):\\n # Combined list of algorithm configs\\n colname_list = ['score', 'bboxes', 'thetas', 'confs', 'classes']\\n for gid in gid_list:\\n accum_list = []\\n for colname in colname_list:\\n if colname == 'score':\\n accum_value = 0.0\\n else:\\n len_list = []\\n temp_list = []\\n for config_dict_ in config_dict_list:\\n temp = depc.get_property(\\n 'localizations_original', gid, colname, config=config_dict_\\n )\\n len_list.append(len(temp))\\n temp_list.append(temp)\\n if colname == 'bboxes':\\n accum_value = np.vstack(temp_list)\\n else:\\n accum_value = np.hstack(temp_list)\\n assert len(accum_value) == sum(len_list)\\n accum_list.append(accum_value)\\n yield tuple(accum_list)\\n\\n logger.info('[ibs] Preprocess Localizations')\\n logger.info('config = {!r}'.format(config))\\n # Get controller\\n ibs = depc.controller\\n ibs.assert_valid_gids(gid_list)\\n\\n config = dict(config)\\n config['sensitivity'] = 0.0\\n\\n flip = config.get('flip', False)\\n if flip:\\n assert (\\n config['algo'] == 'lightnet'\\n ), 'config \\\"flip\\\" is only supported by the \\\"lightnet\\\" algo'\\n\\n # Normal computations\\n base_key_list = ['xtl', 'ytl', 'width', 'height', 'theta', 'confidence', 'class']\\n # Temporary for all detectors\\n base_key_list[4] = (0.0,) # Theta\\n\\n ######################################################################################\\n if config['algo'] in ['pydarknet', 'yolo', 'cnn']:\\n from wbia.algo.detect import yolo\\n\\n logger.info('[ibs] detecting using PyDarknet CNN YOLO v1')\\n detect_gen = yolo.detect_gid_list(ibs, gid_list, **config)\\n ######################################################################################\\n elif config['algo'] in ['lightnet']:\\n from wbia.algo.detect import lightnet\\n\\n logger.info('[ibs] detecting using Lightnet CNN YOLO v2')\\n detect_gen = lightnet.detect_gid_list(ibs, gid_list, **config)\\n elif config['algo'] in ['azure']:\\n from wbia.algo.detect import azure\\n\\n logger.info('[ibs] detecting using Azure CustomVision')\\n detect_gen = azure.detect_gid_list(ibs, gid_list, **config)\\n ######################################################################################\\n elif config['algo'] in ['rf']:\\n from wbia.algo.detect import randomforest\\n\\n logger.info('[ibs] detecting using Random Forests')\\n assert config['species'] is not None\\n base_key_list[6] = (config['species'],) # class == species\\n detect_gen = randomforest.detect_gid_list_with_species(ibs, gid_list, **config)\\n ######################################################################################\\n elif config['algo'] in ['selective-search']:\\n from wbia.algo.detect import selectivesearch\\n\\n logger.info('[ibs] detecting using Selective Search')\\n matlab_command = 'selective_search'\\n detect_gen = selectivesearch.detect_gid_list(\\n ibs, gid_list, matlab_command=matlab_command, **config\\n )\\n ######################################################################################\\n elif config['algo'] in ['selective-search-rcnn']:\\n from wbia.algo.detect import selectivesearch\\n\\n logger.info('[ibs] detecting using Selective Search (R-CNN)')\\n matlab_command = 'selective_search_rcnn'\\n detect_gen = selectivesearch.detect_gid_list(\\n ibs, gid_list, matlab_command=matlab_command, **config\\n )\\n ######################################################################################\\n # elif config['algo'] in ['fast-rcnn']:\\n # from wbia.algo.detect import fasterrcnn\\n # logger.info('[ibs] detecting using CNN Fast R-CNN')\\n # detect_gen = fasterrcnn.detect_gid_list(ibs, gid_list, **config)\\n ######################################################################################\\n elif config['algo'] in ['faster-rcnn']:\\n from wbia.algo.detect import fasterrcnn\\n\\n logger.info('[ibs] detecting using CNN Faster R-CNN')\\n detect_gen = fasterrcnn.detect_gid_list(ibs, gid_list, **config)\\n ######################################################################################\\n elif config['algo'] in ['darknet']:\\n from wbia.algo.detect import darknet\\n\\n logger.info('[ibs] detecting using Darknet CNN YOLO')\\n detect_gen = darknet.detect_gid_list(ibs, gid_list, **config)\\n ######################################################################################\\n elif config['algo'] in ['ssd']:\\n from wbia.algo.detect import ssd\\n\\n logger.info('[ibs] detecting using CNN SSD')\\n detect_gen = ssd.detect_gid_list(ibs, gid_list, **config)\\n # ######################################################################################\\n elif config['algo'] in ['_COMBINED']:\\n # Combined computations\\n config_dict_list = [\\n # {'algo': 'selective-search', 'config_filepath': None}, # SS1\\n {'algo': 'darknet', 'config_filepath': 'pretrained-tiny-pascal'}, # YOLO1\\n {'algo': 'darknet', 'config_filepath': 'pretrained-v2-pascal'}, # YOLO2\\n {'algo': 'faster-rcnn', 'config_filepath': 'pretrained-zf-pascal'}, # FRCNN1\\n {'algo': 'faster-rcnn', 'config_filepath': 'pretrained-vgg-pascal'}, # FRCNN2\\n {'algo': 'ssd', 'config_filepath': 'pretrained-300-pascal'}, # SSD1\\n {'algo': 'ssd', 'config_filepath': 'pretrained-512-pascal'}, # SSD1\\n {'algo': 'ssd', 'config_filepath': 'pretrained-300-pascal-plus'}, # SSD\\n {'algo': 'ssd', 'config_filepath': 'pretrained-512-pascal-plus'}, # SSD4\\n ]\\n detect_gen = _combined(gid_list, config_dict_list)\\n elif config['algo'] in ['tile_aggregation', 'tile_aggregation_quick']:\\n from wbia.other.detectfuncs import general_intersection_over_union\\n\\n include_grid2 = config['algo'] in ['tile_aggregation']\\n tid_list = ibs.scout_get_valid_tile_rowids(\\n gid_list=gid_list, include_grid2=include_grid2\\n )\\n\\n ancestor_gid_list = ibs.get_tile_ancestor_gids(tid_list)\\n bbox_list = ibs.get_tile_bboxes(tid_list)\\n size_list = ibs.get_image_sizes(tid_list)\\n\\n config_filepath = config['config_filepath']\\n assert config_filepath in [\\n 'variant1',\\n 'variant2',\\n 'variant2-32',\\n 'variant2-64',\\n 'variant3-32',\\n 'variant3-64',\\n 'variant4-32',\\n 'variant4-64',\\n ]\\n\\n weight_filepath = config['weight_filepath']\\n weight_filepath = weight_filepath.strip().split(';')\\n\\n assert len(weight_filepath) == 2\\n algo_, model_tag_ = weight_filepath\\n\\n if algo_ in ['densenet+lightnet']:\\n model_tag_ = model_tag_.strip().split(',')\\n\\n assert len(model_tag_) == 4\\n wic_model_tag, wic_thresh, weight_filepath, nms_thresh = model_tag_\\n wic_thresh = float(wic_thresh)\\n nms_thresh = float(nms_thresh)\\n wic_confidence_list = ibs.scout_wic_test(\\n tid_list, classifier_algo='densenet', model_tag=wic_model_tag\\n )\\n\\n flag_list = [\\n wic_confidence >= wic_thresh for wic_confidence in wic_confidence_list\\n ]\\n tid_list_ = ut.compress(tid_list, flag_list)\\n logger.info(\\n '%d tiles passed WIC filter out of %d'\\n % (\\n len(tid_list_),\\n len(tid_list),\\n )\\n )\\n\\n loc_config = {\\n 'grid': False,\\n 'algo': 'lightnet',\\n 'config_filepath': weight_filepath,\\n 'weight_filepath': weight_filepath,\\n 'nms': True,\\n 'nms_thresh': nms_thresh,\\n 'sensitivity': 0.0,\\n }\\n prediction_list = depc.get_property(\\n 'localizations', tid_list_, None, config=loc_config\\n )\\n prediction_dict = dict(zip(tid_list_, prediction_list))\\n else:\\n raise ValueError('Only \\\"densenet+lightnet\\\" is implemented')\\n\\n gid_dict = {}\\n zipped = list(zip(ancestor_gid_list, tid_list, size_list, bbox_list))\\n for ancestor_gid, tid, tile_size, tile_bbox in tqdm.tqdm(zipped):\\n prediction = prediction_dict.get(tid, None)\\n\\n if prediction is None:\\n continue\\n\\n score, bboxes, thetas, confs, classes = prediction\\n tile_xtl, tile_ytl, tile_w, tile_h = tile_bbox\\n\\n if ancestor_gid not in gid_dict:\\n gid_dict[ancestor_gid] = {\\n 'score': [],\\n 'bboxes': [],\\n 'thetas': [],\\n 'confs': [],\\n 'classes': [],\\n }\\n\\n bboxes_ = []\\n confs_ = []\\n for detect_bbox, detect_conf in zip(bboxes, confs):\\n detect_xtl, detect_ytl, detect_w, detect_h = detect_bbox\\n detect_xbr = detect_xtl + detect_w\\n detect_ybr = detect_ytl + detect_h\\n detect_annot = {\\n 'xtl': detect_xtl / tile_w,\\n 'ytl': detect_ytl / tile_h,\\n 'xbr': detect_xbr / tile_w,\\n 'ybr': detect_ybr / tile_h,\\n 'width': detect_w / tile_w,\\n 'height': detect_h / tile_h,\\n }\\n\\n multiplier = None\\n if config_filepath in ['variant1']:\\n multiplier = 1.0\\n elif config_filepath in [\\n 'variant2',\\n 'variant2-32',\\n 'variant2-64',\\n 'variant3-32',\\n 'variant3-64',\\n 'variant4-32',\\n 'variant4-64',\\n ]:\\n margin = (\\n 32.0\\n if config_filepath\\n in ['variant-2', 'variant2-32', 'variant3-32', 'variant4-32']\\n else 64.0\\n )\\n tile_w, tile_h = tile_size\\n margin_percent_w = margin / tile_w\\n margin_percent_h = margin / tile_h\\n xtl = margin_percent_w\\n ytl = margin_percent_h\\n xbr = 1.0 - margin_percent_w\\n ybr = 1.0 - margin_percent_h\\n width = xbr - xtl\\n height = ybr - ytl\\n center = {\\n 'xtl': xtl,\\n 'ytl': ytl,\\n 'xbr': xbr,\\n 'ybr': ybr,\\n 'width': width,\\n 'height': height,\\n }\\n intersection, union = general_intersection_over_union(\\n detect_annot, center, return_components=True\\n )\\n area = detect_annot['width'] * detect_annot['height']\\n overlap = 0.0 if area <= 0 else intersection / area\\n assert 0.0 <= overlap and overlap <= 1.0\\n\\n if config_filepath in ['variant2', 'variant2-32', 'variant2-64']:\\n multiplier = overlap\\n elif config_filepath in ['variant3-32', 'variant3-64']:\\n multiplier = np.sqrt(overlap)\\n elif config_filepath in ['variant4-32', 'variant4-64']:\\n multiplier = overlap ** overlap\\n else:\\n raise ValueError\\n else:\\n raise ValueError\\n assert multiplier is not None\\n\\n bbox_ = (\\n tile_xtl + detect_xtl,\\n tile_ytl + detect_ytl,\\n detect_w,\\n detect_h,\\n )\\n bboxes_.append(bbox_)\\n confs_.append(detect_conf * multiplier)\\n thetas_ = list(thetas)\\n classes_ = list(classes)\\n\\n gid_dict[ancestor_gid]['score'] += [score]\\n gid_dict[ancestor_gid]['bboxes'] += bboxes_\\n gid_dict[ancestor_gid]['thetas'] += thetas_\\n gid_dict[ancestor_gid]['confs'] += confs_\\n gid_dict[ancestor_gid]['classes'] += classes_\\n\\n detect_gen = []\\n for gid in tqdm.tqdm(gid_list):\\n if gid in gid_dict:\\n score = gid_dict[gid]['score']\\n score = sum(score) / len(score) if len(score) > 0 else 0.0\\n bboxes = np.array(gid_dict[gid]['bboxes'])\\n thetas = np.array(gid_dict[gid]['thetas'])\\n confs = np.array(gid_dict[gid]['confs'])\\n classes = np.array(gid_dict[gid]['classes'])\\n else:\\n score = 0.0\\n bboxes = np.array([])\\n thetas = np.array([])\\n confs = np.array([])\\n classes = np.array([])\\n\\n detect = (score, bboxes, thetas, confs, classes)\\n detect_gen.append(detect)\\n elif config['algo'] in ['scout_detectnet_json', 'scout_faster_rcnn_json']:\\n import json\\n\\n uuid_str_list = list(map(str, ibs.get_image_uuids(gid_list)))\\n\\n manifest_filepath = join(ibs.dbdir, 'WIC_manifest_output.csv')\\n assert config['config_filepath'] in ['variant1']\\n json_filepath = join(ibs.dbdir, config['weight_filepath'])\\n\\n assert exists(manifest_filepath)\\n assert exists(json_filepath)\\n\\n manifest_dict = {}\\n with open(manifest_filepath, 'r') as manifest_file:\\n manifest_file.readline() # Discard column header row\\n manifest_line_list = manifest_file.readlines()\\n for manifest_line in manifest_line_list:\\n manifest = manifest_line.strip().split(',')\\n assert len(manifest) == 2\\n manifest_filename, manifest_uuid = manifest\\n manifest_dict[manifest_filename] = manifest_uuid\\n\\n with open(json_filepath, 'r') as json_file:\\n json_values = json.load(json_file)\\n\\n images = json_values.get('images', None)\\n annotations = json_values.get('annotations', None)\\n\\n assert images is not None\\n assert annotations is not None\\n\\n image_dict = {}\\n annotation_dict = {}\\n for image in images:\\n assert 'file_name' in image and 'id' in image, 'Incorrect COCO format'\\n image_filename = image['file_name']\\n image_id = image['id']\\n image_uuid = manifest_dict.get(image_filename, None)\\n assert image_uuid is not None\\n image_dict[image_id] = image_uuid\\n annotation_dict[image_uuid] = []\\n\\n for annotation in annotations:\\n assert 'image_id' in annotation and 'bbox' in annotation\\n image_id = annotation['image_id']\\n image_uuid = image_dict[image_id]\\n assert image_uuid is not None\\n annotation_bbox = annotation['bbox']\\n assert image_uuid in annotation_dict\\n annotation_dict[image_uuid].append(annotation_bbox)\\n\\n detect_gen = []\\n for uuid_str in tqdm.tqdm(uuid_str_list):\\n assert uuid_str in annotation_dict\\n bbox_list = annotation_dict[uuid_str]\\n\\n score = 0.0\\n bboxes = np.array(bbox_list)\\n thetas = np.array([0.0] * len(bbox_list))\\n confs = np.array([1.0] * len(bbox_list))\\n classes = np.array(['elephant_savanna'] * len(bbox_list))\\n\\n detect = (score, bboxes, thetas, confs, classes)\\n detect_gen.append(detect)\\n else:\\n raise ValueError(\\n 'specified detection algo is not supported in config = {!r}'.format(config)\\n )\\n\\n # yield detections\\n for detect in detect_gen:\\n if len(detect) == 3:\\n gid, gpath, result_list = detect\\n score = 0.0\\n result = _package_to_numpy(base_key_list, result_list, score)\\n else:\\n result = detect\\n yield result\",\n \"def compute(self) -> Tensor:\\n\\n if self.samples:\\n return self.average_precisions.float() / self.total\\n else:\\n # pred_image_indices = torch.cat(self.pred_image_indices, dim=0)\\n pred_probs = torch.cat(self.pred_probs, dim=0)\\n pred_labels = torch.cat(self.pred_labels, dim=0)\\n pred_bboxes = torch.cat(self.pred_bboxes, dim=0)\\n\\n # target_image_indices = torch.cat(self.target_image_indices, dim=0)\\n target_labels = torch.cat(self.target_labels, dim=0)\\n target_bboxes = torch.cat(self.target_bboxes, dim=0)\\n\\n # pred_index = torch.nonzero((pred_labels == 1))\\n # pred_probs = pred_probs[pred_index]\\n # pred_bboxes = pred_bboxes[pred_index]\\n # target_index = torch.nonzero((target_labels == 1))\\n # target_bboxes = target_bboxes[target_index]\\n\\n\\n # _, index_sorted = torch.sort(pred_probs)\\n # pred_bboxes = pred_bboxes[index_sorted].cpu().detach().numpy()\\n # target_bboxes = target_bboxes.cpu().detach().numpy()\\n pred_probs = pred_probs.cpu().detach().numpy()\\n pred_labels = pred_labels.cpu().detach().numpy()\\n pred_bboxes = pred_bboxes.cpu().detach().numpy()\\n target_labels = target_labels.cpu().detach().numpy()\\n target_bboxes = target_bboxes.cpu().detach().numpy()\\n\\n pred_probs = pred_probs[pred_labels == 1]\\n pred_bboxes = pred_bboxes[pred_labels == 1]\\n target_bboxes = target_bboxes[target_labels == 1]\\n\\n preds_sorted_idx = np.argsort(pred_probs)[::-1]\\n pred_bboxes = pred_bboxes[preds_sorted_idx]\\n\\n x, y = calculate_precision_recall(target_bboxes, pred_bboxes)\\n\\n if len(x) >= 2:\\n return auc(x, y)\\n else:\\n return 0\\n\\n # return mean_average_precision(\\n # pred_image_indices,\\n # pred_probs,\\n # pred_labels,\\n # pred_bboxes,\\n # target_image_indices,\\n # target_labels,\\n # target_bboxes,\\n # self.iou_threshold,\\n # self.ap_calculation,\\n # )\",\n \"def precompute_scoring():\\n global volume_void_inclusion\\n global attract_point_distances\\n global perlin_values\\n \\n volume_void_inclusion = []\\n for i,void in enumerate(volumes_void):\\n inclusion = gh.PointInBrep(void,points_input,False)\\n volume_void_inclusion.append(inclusion)\\n \\n attract_point_distances = []\\n for i,point in enumerate(points_attractor):\\n distances = gh.Division(gh.Distance(point,points_input),max_dist)\\n attract_point_distances.append(distances)\",\n \"def _do_compute(self, var_map):\\n raise Exception(\\\"Not implemented. Subclass responsibility\\\")\",\n \"def compute_loss(self):\",\n \"def compute_loss(self, features, mode, params, precomputed):\\n raise NotImplementedError(\\\"Model does not implement loss.\\\")\",\n \"def optimize(self):\\n \\n # converting from batch to local quantities\\n if self.dispersion == \\\"gene-batch\\\":\\n local_dispersion = tf.matmul(self.batch, tf.exp(self.px_r))\\n else: \\n local_dispersion = tf.exp(self.px_r)\\n \\n if self.library_mode == \\\"numeric\\\":\\n local_l_mean = self.library_size_mean\\n local_l_var = self.library_size_var\\n else:\\n local_l_mean = tf.matmul(self.batch, self.library_size_mean)\\n local_l_var = tf.matmul(self.batch, self.library_size_var)\\n \\n \\n # VAE loss\\n if self.zi:\\n recon = log_zinb_positive(self.expression, self.px_rate, local_dispersion, \\\\\\n self.px_dropout)\\n else:\\n recon = log_nb_positive(self.expression, self.px_rate, local_dispersion)\\n \\n kl_gauss_z = 0.5 * tf.reduce_sum(\\\\\\n tf.square(self.qz_m) + self.qz_v - tf.log(1e-8 + self.qz_v) - 1, 1)\\n\\n if self.scalings:\\n kl_gauss_l = 0.5 * tf.reduce_sum(\\\\\\n tf.square(self.ql_m - local_l_mean) / local_l_var \\\\\\n + self.ql_v / local_l_var \\\\\\n + tf.log(1e-8 + local_l_var) - tf.log(1e-8 + self.ql_v) - 1, 1)\\n \\n if self.scalings:\\n self.ELBO_gau = tf.reduce_mean(recon - self.kl_scale * kl_gauss_z - kl_gauss_l)\\n else:\\n self.ELBO_gau = tf.reduce_mean(recon - self.kl_scale * kl_gauss_z)\\n \\n # MMD loss\\n if self.apply_mmd:\\n self.mmd = mmd_objective(self.z, self.batch_ind, self.num_batches)\\n self.loss = - self.ELBO_gau + self.mmd_scale * self.mmd\\n \\n else:\\n self.loss = - self.ELBO_gau\\n \\n update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\\n optimizer = self.optimize_algo\\n with tf.control_dependencies(update_ops):\\n self.train_step = optimizer.minimize(self.loss)\",\n \"def task_metalearn(inp, reuse=True):\\n inputa1,inputa2,inputa3, inputb1,inputb2,inputb3, labela, labelb = inp\\n print(\\\"Input a: \\\" , inputa1)\\n task_outputbs, task_lossesb, auto_losses = [], [], []\\n auto_loss = None\\n\\n #One for each. \\n\\n # This takes in the input and passes out the latent variables.\\n temp_in_a_1 = self.encoder(inputa1,self.auto_weights, reuse=reuse)\\n #Then transform it back, and take the loss\\n temp_out_a_1 = self.decoder(temp_in_a_1,self.auto_weights, reuse=reuse)\\n auto_out_a_1 = temp_out_a_1\\n\\n temp_in_a_2 = self.encoder(inputa2,self.auto_weights, reuse=reuse)\\n #Then transform it back, and take the loss\\n temp_out_a_2 = self.decoder(temp_in_a_2,self.auto_weights, reuse=reuse)\\n auto_out_a_2 = temp_out_a_2\\n\\n temp_in_a_3 = self.encoder(inputa3,self.auto_weights, reuse=reuse)\\n #Then transform it back, and take the loss\\n temp_out_a_3 = self.decoder(temp_in_a_3,self.auto_weights, reuse=reuse)\\n auto_out_a_3 = temp_out_a_3\\n\\n # This takes in the input and passes out the latent variables.\\n temp_in_b_1 = self.encoder(inputb1,self.auto_weights, reuse=reuse)\\n #Then transform it back, and take the loss\\n temp_out_b_1 = self.decoder(temp_in_b_1,self.auto_weights, reuse=reuse)\\n auto_out_b_1 = temp_out_b_1\\n\\n temp_in_b_2 = self.encoder(inputb2,self.auto_weights, reuse=reuse)\\n #Then transform it back, and take the loss\\n temp_out_b_2 = self.decoder(temp_in_b_2,self.auto_weights, reuse=reuse)\\n auto_out_b_2 = temp_out_b_2\\n\\n temp_in_b_3 = self.encoder(inputb3,self.auto_weights, reuse=reuse)\\n #Then transform it back, and take the loss\\n temp_out_b_3 = self.decoder(temp_in_b_3,self.auto_weights, reuse=reuse)\\n auto_out_b_3 = temp_out_b_3\\n\\n\\n #print(\\\"temp out a: \\\" , temp_out_a)\\n la_1 = self.loss_func(temp_out_a_1,inputa1)\\n la_2 = self.loss_func(temp_out_a_2,inputa2)\\n la_3 = self.loss_func(temp_out_a_3,inputa3)\\n\\n lb_1 = self.loss_func(temp_out_b_1,inputb1)\\n lb_2 = self.loss_func(temp_out_b_2,inputb2)\\n lb_3 = self.loss_func(temp_out_b_3,inputb3)\\n\\n auto_loss = la_1+la_2+la_3\\n\\n print(\\\"Input a1: \\\" , temp_in_a_1)\\n inputa=tf.concat([temp_in_a_1, temp_in_a_2,temp_in_a_3],1)\\n inputb=tf.concat([temp_in_b_1, temp_in_b_2,temp_in_b_3],1)\\n print(\\\"Inputa: \\\" , inputa)\\n task_outputa = self.forward(inputa, weights, reuse=reuse) # only reuse on the first iter\\n temp_outputa = self.decoder(task_outputa,self.auto_weights,reuse=reuse)\\n \\n print(\\\"Task outputa: \\\" , temp_outputa)\\n print(\\\"Label a: \\\" , labela)\\n task_lossa = self.loss_func(temp_outputa, labela)\\n\\n grads = tf.gradients(task_lossa, list(weights.values()))\\n if FLAGS.stop_grad:\\n grads = [tf.stop_gradient(grad) for grad in grads]\\n gradients = dict(zip(weights.keys(), grads))\\n fast_weights = dict(zip(weights.keys(), [weights[key] - self.update_lr*gradients[key] for key in weights.keys()]))\\n output = self.forward(inputb, fast_weights, reuse=True)\\n \\n temp_outputb = self.decoder(output,self.auto_weights, reuse=True)\\n output = temp_outputb\\n\\n task_outputbs.append(output)\\n print(\\\"Output: \\\" , output)\\n print(\\\"Labels: \\\" , labelb)\\n task_lossesb.append(self.loss_func(output, labelb))\\n print(\\\"Num updates is: \\\" , num_updates-1)\\n\\n for j in range(num_updates - 1):\\n loss = self.loss_func(self.decoder(self.forward(inputa, fast_weights, reuse=True),self.auto_weights), labela)\\n grads = tf.gradients(loss, list(fast_weights.values()))\\n if FLAGS.stop_grad:\\n grads = [tf.stop_gradient(grad) for grad in grads]\\n gradients = dict(zip(fast_weights.keys(), grads))\\n fast_weights = dict(zip(fast_weights.keys(), [fast_weights[key] - self.update_lr*gradients[key] for key in fast_weights.keys()]))\\n \\n output = self.forward(inputb, fast_weights, reuse=True)\\n output = self.decoder(output,self.auto_weights)\\n \\n task_outputbs.append(output)\\n task_lossesb.append(self.loss_func(output, labelb))\\n # Task Outputa Direct output, non-decoded (only first step). This is the location (so it is in hyperparameter space)\\n # Task_outputbs Output from complete system, for each step (first is after 1st step, 2nd is after next, etc.)\\n # task_lossa Loss of difference in first step (decoded)\\n # task_lossesb Losses from complete ssystem from each step \\n # auto_loss Sum of all auto-encoding loss of a's\\n # auto_out_a_1 Auto-encoded a1 output\\n # auto_out_a_2 Auto-encoded a2 output\\n\\n task_output = [temp_outputa, task_outputbs, task_lossa, task_lossesb, auto_loss,auto_out_a_1,auto_out_a_2]\\n return task_output\",\n \"def persistent_training_call(self, inputs, y, branch, enveloppe=None, frozen_common=False):\\n # print('using new unet')\\n self.train()\\n\\n # We might want to freeze the hd results to focus on PL.\\n out = self.forward(inputs, branch=branch)\\n\\n # Loss computation TODO : careful with batches !\\n if branch == 0:\\n target_scale = 1 - y[0, -1, ...]\\n else:\\n target_scale = y[0, 0, ...]\\n weight_loss = self.compute_weight(target=target_scale,\\n enveloppe=enveloppe,\\n scale_ones=self.score_ones[branch],\\n scale_enveloppe=self.wenveloppe)\\n\\n loss_func = self.branch_losses[branch]\\n loss = loss_func(output=out, target=y, weight=weight_loss)\\n loss = loss / self.flush_size\\n loss.backward()\\n\\n self.passes += 1\\n if self.passes > self.flush_size:\\n self.passes = 0\\n self.optimizer.step()\\n self.optimizer.zero_grad()\\n\\n return out, loss.item()\",\n \"def pretrain(args, encoder, classifier, data_loader, optimizer, scheduler):\\n\\n # setup criterion and optimizer\\n # optimizer = optim.Adam(list(encoder.parameters()) + list(classifier.parameters()),\\n # lr=param.c_learning_rate)\\n\\n # set train state for Dropout and BN layers\\n encoder.to(DEVICE)\\n classifier.to(DEVICE)\\n encoder.train()\\n classifier.train()\\n for epoch in range(args.pre_epochs):\\n tr_loss = 0\\n nb_tr_examples, nb_tr_steps = 0, 0\\n for step, batch in enumerate(tqdm(data_loader, desc=\\\"Iteration\\\")):\\n batch = tuple(t.to(DEVICE) for t in batch)\\n input_ids, visual, acoustic, input_mask, segment_ids, label_ids = batch\\n visual = torch.squeeze(visual, 1)\\n acoustic = torch.squeeze(acoustic, 1)\\n feat = encoder(\\n input_ids,\\n visual,\\n acoustic,\\n token_type_ids=segment_ids,\\n attention_mask=input_mask,\\n labels=None,\\n )\\n feat.to(DEVICE)\\n outputs = classifier(feat)\\n outputs.to(DEVICE)\\n # logits = outputs[0]\\n logits = outputs\\n # print(\\\"mine\\\", logits.shape, label_ids.shape)\\n #print(logits, label_ids)\\n\\n #loss_fct = MSELoss()\\n #loss = loss_fct(logits.view(-1), label_ids.view(-1))\\n #print('logits.view(-1) : ' + str(logits.view(-1)) + \\\"label_ids.view(-1) : \\\" + str(label_ids.view(-1)) + \\\"\\\\n\\\")\\n\\n CELoss = nn.CrossEntropyLoss()\\n loss = CELoss(logits, label_ids.view(-1).long())\\n\\n if args.gradient_accumulation_step > 1:\\n loss = loss / args.gradient_accumulation_step\\n\\n loss.backward()\\n\\n tr_loss += loss.item()\\n nb_tr_steps += 1\\n if (step + 1) % args.gradient_accumulation_step == 0:\\n optimizer.step()\\n scheduler.step()\\n optimizer.zero_grad()\\n print(\\\"Loss so far: \\\" +str(tr_loss/nb_tr_steps)+\\\"\\\\n\\\")\\n\\n # save final model\\n # save_model(args, encoder, param.src_encoder_path)\\n # save_model(args, classifier, param.src_classifier_path)\\n\\n return encoder, classifier\",\n \"def _precompute(self, A):\\n return ()\",\n \"def calculate_vars(self):\\n pass\",\n \"def prepare_emb(self):\\n with tf.variable_scope(\\\"PrepEmb\\\", reuse=tf.AUTO_REUSE):\\n self.src_ten = tf.cast(tf.convert_to_tensor(self.src_ten), tf.float32)\\n self.tgt_ten = tf.cast(tf.convert_to_tensor(self.tgt_ten), tf.float32)\\n # Mapping\\n self.src_ten = tf.matmul(self.src_ten, self.W)\\n # Normalization\\n self.src_ten = tf.nn.l2_normalize(self.src_ten, axis=1)\\n self.tgt_ten = tf.nn.l2_normalize(self.tgt_ten, axis=1)\",\n \"def compute(self) -> None:\\n \\n self.model.eval()\\n \\n with torch.no_grad():\\n for (input, target, _) in self.loader:\\n\\n # self.model = self.model.train(False) # TEST @lacoupe\\n output, _ = self.model(input)\\n \\n output = (output >= 0.5)\\n \\n for out, tar in zip(output, target):\\n \\n tar = bool(tar)\\n \\n if out and tar:\\n self.confusion['true_positive'] += 1\\n elif not out and not tar:\\n self.confusion['true_negative'] += 1\\n elif out and not tar:\\n self.confusion['false_positive'] += 1\\n elif not out and tar:\\n self.confusion['false_negative'] += 1\\n \\n self.accuracy = (self.confusion['true_positive'] + self.confusion['true_negative']) \\\\\\n / sum(list(self.confusion.values()))\\n \\n if (self.confusion['true_positive'] + self.confusion['false_positive']) == 0.:\\n self.precision = 0.\\n else:\\n self.precision = self.confusion['true_positive'] \\\\\\n / (self.confusion['true_positive'] + self.confusion['false_positive'])\\n \\n if (self.confusion['true_positive'] + self.confusion['false_negative']) == 0.:\\n self.recall = 0.\\n else:\\n self.recall = self.confusion['true_positive'] \\\\\\n / (self.confusion['true_positive'] + self.confusion['false_negative'])\\n \\n if (self.precision + self.recall) == 0.:\\n self.f1_score = 0.\\n else:\\n self.f1_score = 2 * self.precision * self.recall / (self.precision + self.recall)\",\n \"def preprocessing_fn(inputs):\\n outputs = {}\\n for key in _DENSE_FLOAT_FEATURE_KEYS:\\n # Preserve this feature as a dense float, setting nan's to the mean.\\n outputs[_transformed_name(key)] = tft.scale_to_z_score(\\n _fill_in_missing(inputs[key]))\\n\\n for key in _VOCAB_FEATURE_KEYS:\\n # Build a vocabulary for this feature.\\n outputs[_transformed_name(key)] = tft.compute_and_apply_vocabulary(\\n _fill_in_missing(inputs[key]),\\n top_k=_VOCAB_SIZE,\\n num_oov_buckets=_OOV_SIZE)\\n\\n for key in _BUCKET_FEATURE_KEYS:\\n outputs[_transformed_name(key)] = tft.bucketize(\\n _fill_in_missing(inputs[key]), _FEATURE_BUCKET_COUNT,\\n always_return_num_quantiles=False)\\n\\n for key in _CATEGORICAL_FEATURE_KEYS:\\n outputs[_transformed_name(key)] = _fill_in_missing(inputs[key])\\n\\n # Was this passenger a big tipper?\\n taxi_fare = _fill_in_missing(inputs[_FARE_KEY])\\n tips = _fill_in_missing(inputs[_LABEL_KEY])\\n outputs[_transformed_name(_LABEL_KEY)] = tf.where(\\n tf.is_nan(taxi_fare),\\n tf.cast(tf.zeros_like(taxi_fare), tf.int64),\\n # Test if the tip was > 20% of the fare.\\n tf.cast(\\n tf.greater(tips, tf.multiply(taxi_fare, tf.constant(0.2))), tf.int64))\\n\\n return outputs\",\n \"def _compute_loss(self, predictions, targets, **params):\\n pass\",\n \"def _compute_loss(self, decoder_output, labels):\\n with tf.name_scope(\\\"compute_loss\\\"):\\n language_logit = decoder_output.logits[0]\\n attention_logit = decoder_output.logits[1]\\n batch_size = self.params['dataset']['batch_size']\\n\\n language_losses = self._cross_entropy_sequence_loss(\\n logits=language_logit,\\n targets=tf.transpose(labels[\\\"label\\\"], [1, 0]),\\n sequence_length=labels[\\\"length\\\"])\\n attention_losses = self._cross_entropy_sequence_loss(\\n logits=attention_logit,\\n targets=tf.transpose(labels[\\\"label\\\"], [1, 0]),\\n sequence_length=labels[\\\"length\\\"])\\n\\n language_loss = tf.reduce_sum(language_losses) / batch_size\\n attention_loss = tf.reduce_sum(attention_losses) / batch_size\\n loss = language_loss + attention_loss\\n\\n return loss\",\n \"def pre_forward(self, *args, **kwargs):\\n batch_size = args[0].shape[0]\\n if not self.instantiated:\\n self.hidden_dim = args[0].shape[-1]\\n self.instantiate(hidden_dim=self.hidden_dim)\\n if self.past_key_reparam is None:\\n past_key = self.past_key\\n else:\\n past_key = self.past_key_reparam\\n if self.past_value_reparam is None:\\n past_value = self.past_value\\n else:\\n past_value = self.past_value_reparam\\n\\n def expand_batchsize(x):\\n x = x.reshape(self.prefix_token_num, self.num_heads, -1).transpose(0,1)\\n x = x.unsqueeze(0).expand(batch_size, *x.shape)\\n return x\\n\\n\\n if kwargs['layer_past'] is None:\\n kwargs['layer_past'] = (expand_batchsize(past_key), expand_batchsize(past_value))\\n if 'attention_mask' in kwargs and kwargs['attention_mask'] is not None:\\n am = kwargs['attention_mask'] # Should check the format of the attention_mask when moving to a new plm.\\n kwargs['attention_mask'] = torch.cat([-torch.zeros((*am.shape[:-1],self.prefix_token_num), dtype = am.dtype,device=am.device), am], dim=-1)\\n return args, kwargs\",\n \"def inference(self):\\r\\n\\t\\tfor partition, loader in self.loaders.items():\\r\\n\\t\\t\\tavg_loss, (y, y_hat), post, attentions, tags = self.eval_loader(\\r\\n\\t\\t\\t\\tloader)\\r\\n\\t\\t\\tself.preds[partition] = {\\r\\n\\t\\t\\t\\t'tag': tags,\\r\\n\\t\\t\\t\\t'y': y,\\r\\n\\t\\t\\t\\t'y_hat': y_hat,\\r\\n\\t\\t\\t\\t# 'posteriors': post,\\r\\n\\t\\t\\t\\t# 'attentions': attentions\\r\\n\\t\\t\\t}\",\n \"def __compileVariables(self):\\n state_variables = []\\n state_diffs = []\\n networks = []\\n frames = []\\n vars = []\\n\\n language = self.language\\n\\n instansiate_variables = {}\\n\\n self.obj_vars = self.object_variables()\\n for key, var in self.variables.items(): # Grouping the variables\\n size = self.size_of_variable(var)\\n variable_type = var.type\\n if not size or key in self.variables_not_included: # Skip variable\\n print('Variable not included:\\\\tvar: {}'.format(var.label))\\n continue\\n if var.equation_list and variable_type in ['constant', \\\"network\\\"]:\\n self.constantEquations.append(*var.equation_list)\\n continue\\n if variable_type in ['constant', 'frame', 'state']:\\n # print(dir(var.units))\\n units_pp = var.units.prettyPrint()\\n doc_pp = var.doc\\n if units_pp:\\n units_doc_str = '{}, {}'.format(units_pp, doc_pp)\\n else:\\n units_doc_str = '{}'.format('Empty', doc_pp)\\n instansiate_variables[key] = self.variable_dict(var)\\n if var.compiled_index_list: # Index sets need compilation\\n string_version = self.matrix_string_zeros(size, prefix = ' ')\\n mat = np.zeros(size)\\n index = str(var.index_structures) # Convert to string\\n rep = self.mod_index[var.index_structures[0]].printable()\\n string_w_comments = self.matrix_to_str_w_line_comments(mat, rep,\\n prefix = ' ')\\n width = 79 - 16 - len(index) - len(var.compiled) # 16 is others\\n width2 = 79 - 8 - len(units_pp) - len(doc_pp)\\n cons_str = '\\\\n{0} = {ar}({v: <{msg_box}} {com} {ind}\\\\n {st} ){v: <{w2}} {com} {udoc}'\\n cons_var_str = cons_str.format(var.compiled,\\n com = CODE[language][\\\"comment\\\"],\\n ar = CODE[language][\\\"list\\\"],\\n st = string_w_comments,\\n udoc = units_doc_str,\\n ind = index,\\n w2 = width2,\\n w = width,\\n v = '')\\n # cons_str = '{0} = {ar}({v: <{msg_box}} {com} {ind}\\\\n {st})'\\n # cons_var_str = cons_str.format(var.compiled,\\n # ar = CODE[language]['list'],\\n # st = string_w_comments,\\n # ind = index,\\n # msg_box = width,\\n # v = '')\\n else:\\n string_version = self.matrix_string_zeros(size, prefix = ' ')\\n index = 'none'\\n width = 79 - 16 - len(index) - len(var.compiled) # 16 is others\\n width2 = 79 - 9 - len(units_pp) - len(doc_pp)\\n cons_str = '\\\\n{0} = {array}({val: <{msg_box}} # {ind}\\\\n {st}\\\\n ) {h: <{w2}} {com} {udoc}'\\n cons_var_str = cons_str.format(var.compiled,\\n array = CODE[language][\\\"list\\\"],\\n com = CODE[language][\\\"comment\\\"],\\n udoc = units_doc_str,\\n st = string_version,\\n ind = index,\\n w = width,\\n w2 = width2,\\n h = '',\\n val = '')\\n if variable_type in ['frame']:\\n frames.append(cons_var_str)\\n elif variable_type in ['state']:\\n if var.label in self.state_variables:\\n state_variables.append(cons_var_str)\\n else:\\n pass\\n else:\\n vars.append(cons_var_str)\\n elif variable_type in [\\\"network\\\"]:\\n mat = self.populateNetworkVariable(var)\\n string_mat = self.matrix_to_string(mat, prefix = ' ')\\n index = str(var.index_structures) # Convert to string\\n width = 79 - 20 - len(index) - len(var.compiled) # 16 is others\\n if width < 1:\\n width = 1\\n nt_str = '{0} = {array}({val: <{msg_box}} # {ind}\\\\n {st})'\\n netw_var_str = nt_str.format(var.compiled,\\n array = CODE[language][\\\"list\\\"],\\n st = string_mat,\\n ind = index,\\n w = width,\\n val = '')\\n networks.append(netw_var_str)\\n putData(instansiate_variables, self.variable_instantiate_file)\\n return [state_variables, state_diffs, networks, frames, vars]\",\n \"def rpa_postprocessing(variables):\\n return variables\",\n \"def get_mlperf_model_variables(config_path, init_checkpoint):\\n # Load saved model configuration\\n bert_config = modeling.BertConfig.from_json_file(config_path)\\n seq_length = bert_config.max_position_embeddings\\n tf_variables = {}\\n max_predictions_per_seq = 76\\n\\n # Generate BERT TF model and initiate variable update from checkpoint\\n graph = tf.Graph()\\n sess = tf.Session(graph=graph)\\n with graph.as_default():\\n input_ids = tf.zeros((4, seq_length), dtype=tf.int32)\\n input_mask = tf.zeros((4, seq_length), dtype=tf.int32)\\n segment_ids = tf.zeros((4, seq_length), dtype=tf.int32)\\n masked_lm_positions = tf.zeros((4, max_predictions_per_seq), dtype=tf.int32)\\n masked_lm_ids = tf.zeros((4, max_predictions_per_seq), dtype=tf.int32)\\n masked_lm_weights = tf.zeros((4, max_predictions_per_seq), dtype=tf.float32)\\n next_sentence_labels = tf.zeros((4), dtype=tf.int32)\\n tf_model = modeling.BertModel(\\n config=bert_config,\\n is_training=True,\\n input_ids=input_ids,\\n input_mask=input_mask,\\n token_type_ids=segment_ids,\\n use_one_hot_embeddings=True)\\n (masked_lm_loss, _,\\n _) = get_masked_lm_output(bert_config, tf_model.get_sequence_output(),\\n tf_model.get_embedding_table(),\\n masked_lm_positions, masked_lm_ids,\\n masked_lm_weights)\\n\\n (next_sentence_loss, _,\\n _) = get_next_sentence_output(bert_config, tf_model.get_pooled_output(),\\n next_sentence_labels)\\n _ = masked_lm_loss + next_sentence_loss\\n\\n tvars = tf.trainable_variables()\\n (assignment_map,\\n _) = modeling.get_assignment_map_from_checkpoint(tvars, init_checkpoint)\\n tf.compat.v1.train.init_from_checkpoint(init_checkpoint, assignment_map)\\n sess.run(tf.initializers.global_variables())\\n tvars_vals = sess.run(tvars)\\n for var, val in zip(tvars, tvars_vals):\\n tf_variables[var.name[:-2]] = val\\n\\n tf_config = bert_config.__dict__\\n\\n return tf_config, tf_variables, tf_model\",\n \"def pre_forward(self, *args, **kwargs):\\n\\n batch_size = kwargs['hidden_states'].shape[0]\\n if not self.instantiated:\\n self.hidden_dim = kwargs['hidden_states'].shape[-1]\\n self.instantiate(hidden_dim=self.hidden_dim)\\n if self.past_key_reparam is None:\\n past_key = self.past_key\\n else:\\n past_key = self.past_key_reparam\\n if self.past_value_reparam is None:\\n past_value = self.past_value\\n else:\\n past_value = self.past_value_reparam\\n\\n # from IPython import embed\\n # embed()\\n def expand_batchsize(x):\\n x = x.reshape(self.prefix_token_num, self.num_heads, -1).transpose(0,1)\\n x = x.unsqueeze(0).expand(batch_size, *x.shape)\\n return x\\n # from IPython import embe\\n\\n if 'past_key_value' not in kwargs or kwargs['past_key_value'] is None:\\n kwargs['past_key_value'] = (expand_batchsize(past_key), expand_batchsize(past_value))\\n\\n if 'attention_mask' in kwargs and kwargs['attention_mask'] is not None:\\n am = kwargs['attention_mask'] # Should check the format of the attention_mask when moving to a new plm.\\n kwargs['attention_mask'] = torch.cat([-torch.zeros((*am.shape[:-1],self.prefix_token_num), dtype = am.dtype,device=am.device), am], dim=-1)\\n return args, kwargs\",\n \"def _decode_train(self):\\n\\n # the basic idea is, we use golden sketch during train and in order to copy from source\\n # we given true mask of decoder to generate right copy weights\\n state = {'encoder': self.concated_encoder_output}\\n\\n def transformer_concated_decoder_internal(inputs, memory, bias, mem_bias, params, state=None, scope=None,\\n reuse=False):\\n return transformer_decoder(inputs, memory, bias, mem_bias, params, state, scope, reuse)\\n\\n self.final_logits = self._decode_func(\\n self.tgt_seq, self.tgt_len, self.target_embeddings, self.decoder_weights,\\n self.final_enc_attn_bias, 'train', state, self.vocab_size, use_copy=True,\\n expand_source_ids_oo=self.concat_src_ids_oo,\\n max_out_oovs=self.max_out_oovs, src_mask=self.concat_src_mask,\\n decoder_fn=transformer_concated_decoder_internal,\\n scope='final_decoder')\",\n \"def calc_pck0(\\n target_batch_keys,\\n target_keys_pred,\\n batch_assignments_gt,\\n src_key_num_gt,\\n image_scale,\\n alpha=0.1,\\n):\\n batch_keys_gt = torch.bmm(batch_assignments_gt, target_batch_keys[:, :, :2])\\n pck = pure_pck(target_keys_pred, batch_keys_gt, src_key_num_gt, image_scale, alpha)\\n return pck, target_keys_pred, batch_keys_gt\",\n \"def compute_objectives(self, predictions, batch, stage):\\n (p_ctc, p_seq, asr_p_seq, mt_p_seq, wav_lens, hyps,) = predictions\\n\\n ids = batch.id\\n\\n tokens_eos, tokens_eos_lens = batch.tokens_eos\\n transcription_eos, transcription_eos_lens = batch.transcription_eos\\n transcription_tokens, transcription_lens = batch.transcription_tokens\\n\\n # loss for different tasks\\n # asr loss = ctc_weight * ctc loss + (1 - ctc_weight) * asr attention loss\\n # mt loss = mt attention loss\\n # st loss =\\n # (1 - asr_weight - mt_weight) * st attention loss +\\n # asr_weight * asr loss +\\n # mt_weight * mt loss\\n attention_loss = 0\\n asr_ctc_loss = 0\\n asr_attention_loss = 0\\n mt_loss = 0\\n\\n # st attention loss\\n attention_loss = self.hparams.seq_cost(\\n p_seq, tokens_eos, length=tokens_eos_lens,\\n )\\n\\n # asr attention loss\\n if self.hparams.ctc_weight < 1 and self.hparams.asr_weight > 0:\\n asr_attention_loss = self.hparams.seq_cost(\\n asr_p_seq, transcription_eos, length=transcription_eos_lens,\\n )\\n\\n # asr ctc loss\\n if self.hparams.ctc_weight > 0 and self.hparams.asr_weight > 0:\\n asr_ctc_loss = self.hparams.ctc_cost(\\n p_ctc, transcription_tokens, wav_lens, transcription_lens,\\n )\\n\\n # mt attention loss\\n if self.hparams.mt_weight > 0:\\n mt_loss = self.hparams.seq_cost(\\n mt_p_seq, tokens_eos, length=tokens_eos_lens,\\n )\\n\\n asr_loss = (self.hparams.ctc_weight * asr_ctc_loss) + (\\n 1 - self.hparams.ctc_weight\\n ) * asr_attention_loss\\n loss = (\\n (1 - self.hparams.asr_weight - self.hparams.mt_weight)\\n * attention_loss\\n + self.hparams.asr_weight * asr_loss\\n + self.hparams.mt_weight * mt_loss\\n )\\n\\n if stage != sb.Stage.TRAIN:\\n current_epoch = self.hparams.epoch_counter.current\\n valid_search_interval = self.hparams.valid_search_interval\\n\\n if stage == sb.Stage.TEST:\\n # 4 references bleu score\\n predictions = [\\n en_detoeknizer.detokenize(\\n hparams[\\\"tokenizer\\\"].decode_ids(utt_seq).split(\\\" \\\")\\n )\\n for utt_seq in hyps\\n ]\\n\\n four_references = [\\n batch.translation_0,\\n batch.translation_1,\\n batch.translation_2,\\n batch.translation_3,\\n ]\\n\\n targets = []\\n for reference in four_references:\\n detokenized_translation = [\\n en_detoeknizer.detokenize(translation.split(\\\" \\\"))\\n for translation in reference\\n ]\\n targets.append(detokenized_translation)\\n\\n self.bleu_metric.append(ids, predictions, targets)\\n elif (\\n current_epoch % valid_search_interval == 0\\n and stage == sb.Stage.VALID\\n ):\\n predictions = [\\n en_detoeknizer.detokenize(\\n hparams[\\\"tokenizer\\\"].decode_ids(utt_seq).split(\\\" \\\")\\n )\\n for utt_seq in hyps\\n ]\\n\\n targets = [\\n en_detoeknizer.detokenize(translation.split(\\\" \\\"))\\n for translation in batch.translation_0\\n ]\\n self.bleu_metric.append(ids, predictions, [targets])\\n\\n # compute the accuracy of the one-step-forward prediction\\n self.acc_metric.append(p_seq, tokens_eos, tokens_eos_lens)\\n\\n return loss\",\n \"def validate(args, val_loader, encoder, decoder, criterion):\\n decoder.eval() # eval mode (no dropout or batchnorm)\\n if encoder is not None:\\n encoder.eval()\\n\\n batch_time = AverageMeter()\\n losses = AverageMeter()\\n top5accs = AverageMeter()\\n\\n start = time.time()\\n\\n references = list() # references (true captions) for calculating BLEU-4 score\\n hypotheses = list() # hypotheses (predictions)\\n\\n # explicitly disable gradient calculation to avoid CUDA memory error\\n with torch.no_grad():\\n # Batches\\n for i, (imgs, caps, caplens, allcaps) in enumerate(val_loader):\\n\\n # Move to device, if available\\n imgs = imgs.to(device)\\n caps = caps.to(device)\\n caplens = caplens.to(device)\\n\\n # Forward prop.\\n if encoder is not None:\\n imgs = encoder(imgs)\\n scores, caps_sorted, decode_lengths, alphas, sort_ind = decoder(imgs, caps, caplens)\\n\\n # Since we decoded starting with <start>, the targets are all words after <start>, up to <end>\\n targets = caps_sorted[:, 1:]\\n\\n # Remove timesteps that we didn't decode at, or are pads\\n # pack_padded_sequence is an easy trick to do this\\n scores_copy = scores.clone()\\n scores = pack_padded_sequence(scores, decode_lengths, batch_first=True).data\\n targets = pack_padded_sequence(targets, decode_lengths, batch_first=True).data\\n\\n # Calculate loss\\n loss = criterion(scores, targets)\\n\\n # Add doubly stochastic attention regularization\\n if args.decoder_mode == \\\"lstm\\\":\\n loss += args.alpha_c * ((1. - alphas.sum(dim=1)) ** 2).mean()\\n elif args.decoder_mode == \\\"transformer\\\":\\n dec_alphas = alphas[\\\"dec_enc_attns\\\"]\\n alpha_trans_c = args.alpha_c / (args.n_heads * args.decoder_layers)\\n for layer in range(args.decoder_layers): # args.decoder_layers = len(dec_alphas)\\n cur_layer_alphas = dec_alphas[layer] # [batch_size, n_heads, 52, 196]\\n for h in range(args.n_heads):\\n cur_head_alpha = cur_layer_alphas[:, h, :, :]\\n loss += alpha_trans_c * ((1. - cur_head_alpha.sum(dim=1)) ** 2).mean()\\n\\n # Keep track of metrics\\n losses.update(loss.item(), sum(decode_lengths))\\n top5 = accuracy(scores, targets, 5)\\n top5accs.update(top5, sum(decode_lengths))\\n batch_time.update(time.time() - start)\\n start = time.time()\\n\\n # Store references (true captions), and hypothesis (prediction) for each image\\n # If for n images, we have n hypotheses, and references a, b, c... for each image, we need -\\n # references = [[ref1a, ref1b, ref1c], [ref2a, ref2b], ...], hypotheses = [hyp1, hyp2, ...]\\n\\n # References\\n allcaps = allcaps[sort_ind] # because images were sorted in the decoder\\n for j in range(allcaps.shape[0]):\\n img_caps = allcaps[j].tolist()\\n img_captions = list(\\n map(lambda c: [w for w in c if w not in {word_map['<start>'], word_map['<pad>']}],\\n img_caps)) # remove <start> and pads\\n references.append(img_captions)\\n\\n # Hypotheses\\n _, preds = torch.max(scores_copy, dim=2)\\n preds = preds.tolist()\\n temp_preds = list()\\n for j, p in enumerate(preds):\\n temp_preds.append(preds[j][:decode_lengths[j]]) # remove pads\\n preds = temp_preds\\n hypotheses.extend(preds)\\n\\n assert len(references) == len(hypotheses)\\n\\n # Calculate BLEU-1~4 scores\\n # metrics = {}\\n # weights = (1.0 / 1.0,)\\n # metrics[\\\"bleu1\\\"] = corpus_bleu(references, hypotheses, weights)\\n # weights = (1.0/2.0, 1.0/2.0,)\\n # metrics[\\\"bleu2\\\"] = corpus_bleu(references, hypotheses, weights)\\n # weights = (1.0 / 3.0, 1.0 / 3.0, 1.0 / 3.0,)\\n # metrics[\\\"bleu3\\\"] = corpus_bleu(references, hypotheses, weights)\\n # metrics[\\\"bleu4\\\"] = corpus_bleu(references, hypotheses)\\n\\n # Calculate BLEU1~4, METEOR, ROUGE_L, CIDEr scores\\n metrics = get_eval_score(references, hypotheses)\\n\\n print(\\\"EVA LOSS: {} TOP-5 Accuracy {} BLEU-1 {} BLEU2 {} BLEU3 {} BLEU-4 {} METEOR {} ROUGE_L {} CIDEr {}\\\".format\\n (losses.avg, top5accs.avg, metrics[\\\"Bleu_1\\\"], metrics[\\\"Bleu_2\\\"], metrics[\\\"Bleu_3\\\"], metrics[\\\"Bleu_4\\\"],\\n metrics[\\\"METEOR\\\"], metrics[\\\"ROUGE_L\\\"], metrics[\\\"CIDEr\\\"]))\\n\\n return metrics\",\n \"def _eval_acc(self, data_loader, model,\\n loss_fn: Callable = None):\\n soft_to_hard_fn, soft_to_hard_fn_kwargs = _validate_soft_to_hard_args(self.soft_to_hard_fn,\\n self.soft_to_hard_fn_kwargs)\\n\\n n_correct = defaultdict(int)\\n n_total = defaultdict(int)\\n model.eval()\\n\\n # INPUT: batch of text data + label (batch is gathered with similar lengths with bucket iterator)\\n total_val_loss = 0.\\n\\n prediction_list_correct = defaultdict(int)\\n prediction_list_total = defaultdict(int)\\n pred_labels_lst = []\\n orig_labels_lst = []\\n orig_words_lst = []\\n sep_token = self.tokenizer.sep_token\\n pad_token = self.tokenizer.pad_token\\n cls_token = self.tokenizer.cls_token\\n\\n with torch.no_grad():\\n for batch_idx, (input_ids, attention_mask, labels, label_mask) in enumerate(data_loader):\\n\\n input_ids = input_ids.to(self.device)\\n attention_mask = attention_mask.to(self.device)\\n labels = labels.to(self.device)\\n label_mask = label_mask.to(self.device)\\n\\n # logits = model.predict(input_ids, input_mask=attention_mask)\\n\\n # preds: batch size , sequence len, nfeatures\\n # labels: batch size, sequence len\\n\\n # Compute loss and predictions\\n batch_train_loss, logits = model(input_ids,\\n attention_mask=attention_mask,\\n labels=labels)\\n\\n predictions = torch.argmax(logits, dim=2)\\n\\n for batch in range(label_mask.shape[0]):\\n orig_words = self.tokenizer.decode(input_ids.data[batch]).split(' ')\\n mask = label_mask.data[batch]\\n preds = predictions.data[batch]\\n lab = labels.data[batch]\\n\\n temp_labels = []\\n temp_preds = []\\n temp_words = []\\n\\n for i, m in enumerate(mask):\\n if m == 1:\\n temp_labels.append(self.id2label[lab[i].item()])\\n temp_preds.append(self.id2label[preds[i].item()])\\n\\n for w in orig_words:\\n if w in [sep_token, pad_token, cls_token]:\\n continue\\n temp_words.append(w)\\n\\n pred_labels_lst.append(temp_preds)\\n orig_labels_lst.append(temp_labels)\\n orig_words_lst.append(temp_words)\\n\\n batch_loss = batch_train_loss.item()\\n total_val_loss += batch_loss\\n\\n running_acc, n_total, n_correct = _running_eval_acc(logits, labels, label_mask,\\n n_total=n_total,\\n n_correct=n_correct,\\n soft_to_hard_fn=soft_to_hard_fn,\\n soft_to_hard_fn_kwargs=soft_to_hard_fn_kwargs)\\n\\n if (loss_fn is not None and np.isnan(batch_loss)) or np.isnan(running_acc):\\n # TODO: update to get the actual input text from tokenizer\\n _save_nandata(input_ids, predictions, labels, batch_train_loss, batch_loss,\\n running_acc, n_total, n_correct, model)\\n\\n eval_list = []\\n\\n for orig_w, oril, prel in zip(orig_words_lst, orig_labels_lst, pred_labels_lst):\\n\\n for ot, ol, pl in zip(orig_w, oril, prel):\\n if ot in [self.pad_token, self.cls_token, self.sep_token]:\\n continue\\n eval_list.append(f\\\"{ot} {ol} {pl}\\\\n\\\")\\n eval_list.append(\\\"\\\\n\\\")\\n\\n counts = conlleval.evaluate(eval_list)\\n report = conlleval.report_notprint(counts)\\n for line in report:\\n logger.info(line.strip())\\n\\n for k in prediction_list_total.keys():\\n logger.info('Acc: {} = {}%'.format(k, 0 if prediction_list_total[k] == 0 else (float(\\n prediction_list_correct[k]) / float(prediction_list_total[k])) * 100))\\n\\n overall, by_type = conlleval.metrics(counts)\\n\\n total_val_loss /= float(len(data_loader))\\n\\n return running_acc, n_total, n_correct, total_val_loss, counts\",\n \"def _precompute(self):\\n N = self.N\\n # Store 'N' as used by Gale in N[0] --- this is the total # of\\n # occurrences.\\n N[0] = sum(N[r] * r for r in range(1, self.max_r + 1))\\n self.Z = Z = averaging_transform.transform(N, self.max_r) # Z[r] = Z_r\\n self.b, self.a = self._regress(Z) # 'a' and 'b' as used in (Gale); a\\n # is intercept and b is slope.\\n assert self.b < -1, (\\\"Log-linear slope > -1 (%f); SGT not applicable\\\" %\\n self.b)\\n # Find the transition point between linear Good-Turing estimate and the\\n # Turing estimate.\\n self.linear_cutoff = self._find_cutoff()\\n self.norm_constant = self._find_norm_constant()\",\n \"def pre_compute(self, e_list):\\n\\t\\tpass\",\n \"def _calc_loss(args, loss_function, local_q_vector, local_ctx_vectors, local_caption_vectors, local_positive_idxs,\\n local_hard_negatives_idxs: list = None, experiment=None\\n ):\\n distributed_world_size = 1 # args.distributed_world_size or 1\\n if distributed_world_size > 1:\\n # TODO: Add local_caption_vectors\\n q_vector_to_send = torch.empty_like(local_q_vector).cpu().copy_(local_q_vector).detach_()\\n ctx_vector_to_send = torch.empty_like(local_ctx_vectors).cpu().copy_(local_ctx_vectors).detach_()\\n\\n global_question_ctx_vectors = all_gather_list(\\n [q_vector_to_send, ctx_vector_to_send, local_positive_idxs, local_hard_negatives_idxs],\\n max_size=args.global_loss_buf_sz)\\n\\n global_q_vector = []\\n global_ctxs_vector = []\\n\\n # ctxs_per_question = local_ctx_vectors.size(0)\\n positive_idx_per_question = []\\n hard_negatives_per_question = []\\n\\n total_ctxs = 0\\n\\n for i, item in enumerate(global_question_ctx_vectors):\\n q_vector, ctx_vectors, positive_idx, hard_negatives_idxs = item\\n\\n if i != args.local_rank:\\n global_q_vector.append(q_vector.to(local_q_vector.device))\\n global_ctxs_vector.append(ctx_vectors.to(local_q_vector.device))\\n positive_idx_per_question.extend([v + total_ctxs for v in positive_idx])\\n hard_negatives_per_question.extend([[v + total_ctxs for v in l] for l in hard_negatives_idxs])\\n else:\\n global_q_vector.append(local_q_vector)\\n global_ctxs_vector.append(local_ctx_vectors)\\n positive_idx_per_question.extend([v + total_ctxs for v in local_positive_idxs])\\n hard_negatives_per_question.extend([[v + total_ctxs for v in l] for l in local_hard_negatives_idxs])\\n total_ctxs += ctx_vectors.size(0)\\n\\n global_q_vector = torch.cat(global_q_vector, dim=0)\\n global_ctxs_vector = torch.cat(global_ctxs_vector, dim=0)\\n\\n else:\\n global_q_vector = local_q_vector\\n global_ctxs_vector = local_ctx_vectors\\n global_caption_vector = local_caption_vectors\\n positive_idx_per_question = local_positive_idxs\\n hard_negatives_per_question = local_hard_negatives_idxs\\n\\n loss, is_correct, scores = loss_function.calc(global_q_vector, global_ctxs_vector, global_caption_vector,\\n positive_idx_per_question, hard_negatives_per_question,\\n args.caption_score_weight, experiment)\\n\\n return loss, is_correct, scores\",\n \"def precomp_sim_tables(self):\\n self.sim_precomp = {}\\n\\n if self.sim_method == 'emb_jointspace':\\n\\n for gram in ['s','r','o']:\\n\\n vocab_gram = self.vocab[gram]\\n V = len(vocab_gram)\\n self.sim_precomp[gram] = np.zeros((V,V))\\n\\n for v_target in range(V):\\n\\n word_target = vocab_gram.idx2word[v_target]\\n query_target = self.queries_unigrams(word_target, gram)\\n embedding_target = self.language_nets[self.gram_id[gram]](query_target)\\n\\n\\n for v_source in range(V):\\n\\n word_source = vocab_gram.idx2word[v_source]\\n query_source = self.queries_unigrams(word_source, gram)\\n embedding_source = self.language_nets[self.gram_id[gram]](query_source)\\n\\n self.sim_precomp[gram][v_target, v_source] = torch.mul(embedding_target, embedding_source).sum().data[0]\\n\\n\\n elif self.sim_method == 'emb_word2vec':\\n\\n for gram in ['s','r','o']:\\n\\n vocab_gram = self.vocab[gram]\\n V = len(vocab_gram)\\n self.sim_precomp[gram] = np.zeros((V,V))\\n\\n for v_target in range(V):\\n\\n embedding_target = self.word_embeddings[self.idx_to_vocab[gram][v_target].data[0]]\\n embedding_target = embedding_target / np.linalg.norm(embedding_target)\\n\\n for v_source in range(V):\\n\\n embedding_source = self.word_embeddings[self.idx_to_vocab[gram][v_source].data[0]]\\n embedding_source = embedding_source / np.linalg.norm(embedding_source)\\n\\n self.sim_precomp[gram][v_target, v_source] = np.sum(embedding_target*embedding_source)\",\n \"def _build_preprocessing(self):\\n\\n # For now, do nothing\\n pass\",\n \"def preprocess(self):\\n\\n mm_magcoord.add_aacgm_coordinates(self)\\n mm_magcoord.add_quasi_dipole_coordinates(self)\\n mm_sc.calculate_ecef_velocity(self)\\n mm_sc.add_ram_pointing_sc_attitude_vectors(self)\\n\\n return\",\n \"def forward(\\n self, inp: torch.Tensor, ucb_alpha: Optional[float] = None\\n ) -> Dict[str, torch.Tensor]:\\n\\n mlp_out = self.deep_represent_layers(inp)\\n # preprocess by DeepRepresent module before fed to LinUCB layer\\n # trainer needs pred_label and mlp_out to update parameters\\n\\n # append a column of ones to features for LinUCB intercept/bias\\n mlp_out_with_ones = torch.cat(\\n (\\n torch.ones(mlp_out.shape[:-1], device=mlp_out.device).unsqueeze(-1),\\n mlp_out,\\n ),\\n -1,\\n )\\n\\n if ucb_alpha is None:\\n ucb_alpha = self.ucb_alpha\\n\\n if not self.nn_e2e:\\n pred_label = torch.matmul(mlp_out_with_ones, self.coefs)\\n else:\\n pred_label = self.linear_layer(mlp_out_with_ones).squeeze(-1)\\n\\n if ucb_alpha != 0:\\n pred_sigma = torch.sqrt(\\n batch_quadratic_form(mlp_out_with_ones, self.inv_avg_A)\\n / torch.clamp(self.sum_weight, min=0.00001)\\n )\\n ucb = pred_label + ucb_alpha * pred_sigma\\n else:\\n pred_sigma = torch.zeros_like(pred_label)\\n ucb = pred_label\\n return {\\n \\\"pred_label\\\": pred_label,\\n \\\"pred_sigma\\\": pred_sigma,\\n \\\"ucb\\\": ucb,\\n \\\"mlp_out_with_ones\\\": mlp_out_with_ones,\\n }\",\n \"def predict(self, first_preprocessed_inputs,second_preprocessed_inputs,third_preprocessed_inputs):\\r\\n pass\",\n \"def get_loss_fn():\\n return reconstruction\",\n \"def mag_postprocessing(variables):\\n return variables\",\n \"def loss(self, X, y=None):\\n\\n # In dev testing, the loss fnc stops at \\\"scores\\\" , unfollowed by \\\"softmax\\\" probability prediction.\\n # In real testing, \\\"self.predict()\\\" needs to be implemented in Solver() class.\\n \\n if y is None:\\n for bn_param in self.bn_params:\\n bn_param[\\\"mode\\\"] = \\\"test\\\"\\n\\n\\n W1, b1 = self.params['W1'], self.params['b1']\\n gamma1, beta1 = self.params[\\\"sbnGamma1\\\"], self.params[\\\"sbnBeta1\\\"]\\n bn_param1 = self.bn_params[0]\\n\\n W2, b2 = self.params['W2'], self.params['b2']\\n gamma2, beta2 = self.params[\\\"sbnGamma2\\\"], self.params[\\\"sbnBeta2\\\"]\\n bn_param2 = self.bn_params[1]\\n\\n W3, b3 = self.params['W3'], self.params['b3']\\n gamma3, beta3 = self.params[\\\"bnGamma3\\\"], self.params[\\\"bnBeta3\\\"]\\n bn_param3 = self.bn_params[2]\\n\\n W4, b4 = self.params['W4'], self.params['b4']\\n \\n # pass conv_param to the forward pass for the convolutional layer\\n conv_param = self.conv_param\\n\\n # pass pool_param to the forward pass for the max-pooling layer\\n pool_param = self.maxpool_params\\n\\n ############################################################################\\n # TODO: Implement the forward pass for the three-layer convolutional net, #\\n # computing the class scores for X and storing them in the scores #\\n # variable. #\\n ############################################################################\\n \\n scores = None \\n cache = {}\\n # def conv_sbn_relu_forward(x, w, b, gamma, beta, conv_param, bn_param): return out, cache;\\n out, cache[\\\"layer1\\\"] = layer_utils.conv_sbn_relu_forward(X, W1, b1, gamma1, beta1, conv_param, bn_param1) \\n out, cache[\\\"layer2\\\"] = layer_utils.conv_sbn_relu_forward(out, W2, b2, gamma2, beta2, conv_param, bn_param2)\\n\\n # def max_pool_forward_fast(x, pool_param): return out, cache;\\n out, cache[\\\"maxpool\\\"] = fast_layers.max_pool_forward_fast(out, pool_param)\\n\\n # def affine_bn_relu_forward(x, w, b, gamma, beta, bn_param): return out, cache;\\n \\n out, cache[\\\"layer3\\\"] = layer_utils.affine_bn_relu_forward(out, W3, b3, gamma3, beta3, bn_param3)\\n\\n # def affine_forward(x, w, b): return out, cache;\\n scores, cache[\\\"layer4\\\"] = layers.affine_forward(out, W4, b4)\\n\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n \\n if y is None:\\n return scores\\n \\n ############################################################################\\n # TODO: Implement the backward pass for the three-layer convolutional net, #\\n # storing the loss and gradients in the loss and grads variables. Compute #\\n # data loss using softmax, and make sure that grads[k] holds the gradients #\\n # for self.params[k]. Don't forget to add L2 regularization! #\\n ############################################################################\\n \\n loss, grads = 0, {}\\n\\n # def softmax_loss(x, y): return loss, dscore;\\n loss, dscores = layers.softmax_loss(scores, y)\\n loss += 0.5 * self.reg * (np.sum(W1 * W1) + np.sum(W2 * W2) + np.sum(W3 * W3) + np.sum(W4 * W4))\\n\\n # def affine_backward(dout, cache): return dx, dw, db;\\n dout, dW4, db4 = layers.affine_backward(dscores, cache[\\\"layer4\\\"]) \\n\\n # def affine_bn_relu_backward(dout, cache): return dx, dw, db, dgamma, dbeta;\\n dout, dW3, db3, dgamma3, dbeta3 = layer_utils.affine_bn_relu_backward(dout, cache[\\\"layer3\\\"])\\n\\n # print cache[\\\"layer3\\\"]\\n\\n # def max_pool_backward_fast(dout, cache): return max_pool_backward_im2col(dout, real_cache);\\n # def max_pool_backward_im2col(dout, cache): return dx;\\n dout = fast_layers.max_pool_backward_fast(dout, cache[\\\"maxpool\\\"])\\n\\n # def conv_sbn_relu_backward(dout, cache): return dx, dw, db, dgamma, dbeta;\\n dout, dW2, db2, dgamma2, dbeta2 = layer_utils.conv_sbn_relu_backward(dout, cache[\\\"layer2\\\"])\\n _, dW1, db1, dgamma1, dbeta1 = layer_utils.conv_sbn_relu_backward(dout, cache[\\\"layer1\\\"])\\n\\n # reg\\n grads['W4'], grads['b4'] = dW4 + self.reg * W4, db4\\n \\n grads['W3'], grads['b3'] = dW3 + self.reg * W3, db3\\n grads[\\\"bnGamma3\\\"], grads[\\\"bnBeta3\\\"] = dgamma3, dbeta3\\n\\n grads['W2'], grads['b2'] = dW2 + self.reg * W2, db2\\n grads[\\\"sbnGamma2\\\"], grads[\\\"sbnBeta2\\\"] = dgamma2, dbeta2\\n\\n grads['W1'], grads['b1'] = dW1 + self.reg * W1, db1\\n grads[\\\"sbnGamma1\\\"], grads[\\\"sbnBeta1\\\"] = dgamma1, dbeta1\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n \\n return loss, grads\",\n \"def step(x, encoder, decoder, optimizer, loss):\\n trainable_variables = encoder.trainable_variables + decoder.trainable_variables\\n with tf.GradientTape() as tape:\\n tape.watch(trainable_variables)\\n lo = loss(x, encoder, decoder)\\n minimize_loss = - lo\\n grads = tape.gradient(minimize_loss, trainable_variables)\\n optimizer.apply_gradients(zip(grads, trainable_variables))\\n return lo\",\n \"def compile(self):\\n\\n target_values = T.fmatrix('target_values')\\n\\n train_output = lasagne.layers.get_output(self.l_out)\\n\\n pred_output = lasagne.layers.get_output(self.l_out, deterministic=True)\\n\\n reg = lasagne.regularization.regularize_layer_params(self.l_out, lasagne.regularization.l2)\\n\\n train_cost = self.cost_function(train_output,target_values).mean() + reg * 0.01\\n \\n real_cost = self.cost_function(pred_output, target_values).mean() + reg * 0.01\\n\\n # Retrieve all parameters from the network\\n all_params = lasagne.layers.get_all_params(self.l_out,trainable=True)\\n\\n self.logger.info(\\\"Computing updates...\\\")\\n updates = self.update_function(train_cost, all_params, LEARNING_RATE)\\n\\n \\n self.logger.info(\\\"Compiling functions ...\\\")\\n\\n # compile Theano GPU functions for training and computing train_cost\\n self._train = theano.function([self.in_layer.input_var, self.i_mask.input_var, target_values], train_cost, \\n updates=updates, allow_input_downcast=True)\\n\\n self._compute_cost = theano.function([self.in_layer.input_var, self.i_mask.input_var, target_values], real_cost, \\n allow_input_downcast=True)\\n\\n self.label = theano.function([self.in_layer.input_var, self.i_mask.input_var],pred_output,allow_input_downcast=True)\\n \\n self._compiled = True\",\n \"def preprocess(self, first_inputs,second_inputs,third_inputs):\\r\\n pass\",\n \"def compute_attention(self, decoder_state, forward_encoder_states, backward_encoder_states):\\r\\n\\r\\n\\t\\tassert len(forward_encoder_states) == len(backward_encoder_states)\\r\\n\\t\\tmax_encoding_len = len(forward_encoder_states)\\r\\n\\t\\toutput_states=[]\\r\\n\\t\\tfor i in range(max_encoding_len):\\r\\n\\t\\t\\tstate = np.concatenate([forward_encoder_states[i]['h'], backward_encoder_states[i]['h']])\\r\\n\\t\\t\\toutput_states.append(state)\\r\\n\\r\\n\\t\\ttiled_outputs = np.concatenate(output_states, 1)\\r\\n\\t\\ttiled_decoder = np.tile(decoder_state['h'], (1, max_encoding_len))\\r\\n\\r\\n\\t\\talpha = np.zeros((len(output_states), 1))\\r\\n\\t\\tfor i in range(max_encoding_len):\\r\\n\\t\\t\\talpha[i] = np.matmul(self.attentionV.transpose(), np.tanh(np.matmul(self.memoryLayer, output_states[i]) + np.matmul(self.queryLayer, decoder_state['h'])))\\r\\n\\t\\talpha = softmax(alpha)\\r\\n\\r\\n\\t\\tu = np.zeros(output_states[0].shape)\\r\\n\\t\\tfor i in range(max_encoding_len):\\r\\n\\t\\t\\tu += alpha[i, 0] * output_states[i]\\r\\n\\t\\ta = np.matmul(self.attentonLayer, np.concatenate([decoder_state['h'], u]))\\r\\n\\r\\n\\t\\treturn a, alpha\",\n \"def __call__(self, initial_state, previous_alignments):\\n with tf.variable_scope(None, \\\"rnn_score_attention\\\", [initial_state]):\\n score, final_state = rnn_score(initial_state, self._keys, self._cell, self._memory_sequence_length)\\n alignments = self._probability_fn(score, previous_alignments)\\n return alignments, final_state\",\n \"def get_param_computation(self, keep_backpack_buffers):\\n param_computation_V_t_V = self._param_computation_V_t_V\\n param_computation_V_t_g_n = self._param_computation_V_t_g_n\\n param_computation_V_n_t_V = self._param_computation_V_n_t_V\\n param_computation_memory_cleanup = partial(\\n self._param_computation_memory_cleanup,\\n keep_backpack_buffers=keep_backpack_buffers,\\n )\\n\\n compute_gammas = self._compute_gammas\\n compute_lambdas = self._compute_lambdas\\n\\n def param_computation(self, param):\\n \\\"\\\"\\\"Compute dot products for a parameter used in directional derivatives.\\n\\n Args:\\n self (ParameterGroupsHook): Group hook to which this function will be\\n bound.\\n param (torch.Tensor): Parameter of a neural net.\\n\\n Returns:\\n dict: Dictionary with results of the different dot products. Has key\\n ``\\\"V_t_g_n\\\"``.\\n \\\"\\\"\\\"\\n result = {}\\n\\n result[\\\"V_t_V\\\"] = param_computation_V_t_V(param)\\n\\n if compute_gammas:\\n result[\\\"V_t_g_n\\\"] = param_computation_V_t_g_n(param)\\n if compute_lambdas:\\n result[\\\"V_n_t_V\\\"] = param_computation_V_n_t_V(param)\\n\\n param_computation_memory_cleanup(param)\\n\\n return result\\n\\n return param_computation\",\n \"def __prepare_parameter__(self, in_args):\\n if self.__use_remote_sparse_updater__():\\n self.__gradient_machine__.prefetch(in_args)\\n self.__parameter_updater__.getParametersRemote()\",\n \"def preprocess(self):\",\n \"def pre_forward(self, *args, **kwargs):\\n batch_size = args[0].shape[0]\\n seq_len = args[0].shape[-2]\\n if not self.instantiated:\\n self.hidden_dim = args[0].shape[-1]\\n self.instantiate(hidden_dim=self.hidden_dim)\\n if self.past_key_reparam is None:\\n past_key = self.past_key\\n else:\\n past_key = self.past_key_reparam\\n if self.past_value_reparam is None:\\n past_value = self.past_value\\n else:\\n past_value = self.past_value_reparam\\n\\n\\n def expand_batchsize(x):\\n x = x.reshape(self.prefix_token_num, self.num_heads, -1).transpose(0,1)\\n x = x.unsqueeze(0).expand(batch_size, *x.shape)\\n return x\\n\\n if 'position_bias' in kwargs and kwargs['position_bias'] is not None:\\n if kwargs['position_bias'].shape[-1] != seq_len + self.prefix_token_num: # Then the position_bias should be re-calculated\\n kwargs['position_bias'] = None\\n if kwargs['past_key_value'] is None:\\n kwargs['past_key_value'] = (expand_batchsize(past_key), expand_batchsize(past_value))\\n\\n past_key_len = kwargs['past_key_value'][0].shape[-2]\\n\\n if 'mask' in kwargs and kwargs['mask'] is not None:\\n mask_len = kwargs['mask'].shape[-1]\\n if past_key_len + seq_len == mask_len + self.prefix_token_num:\\n\\n am = kwargs['mask'] # Should check the format of the attention_mask when moving to a new plm.\\n kwargs['mask'] = torch.cat([-torch.zeros((*am.shape[:-1],self.prefix_token_num), dtype = am.dtype,device=am.device), am], dim=-1)\\n return args, kwargs\",\n \"def calc_pck(\\n target_batch_keys,\\n batch_assignments,\\n batch_assignments_gt,\\n src_key_num_gt,\\n image_scale,\\n alpha=0.1,\\n):\\n\\n batch_keys_pred = torch.bmm(batch_assignments, target_batch_keys[:, :, :2])\\n return calc_pck0(\\n target_batch_keys,\\n batch_keys_pred,\\n batch_assignments_gt,\\n src_key_num_gt,\\n image_scale,\\n alpha,\\n )\",\n \"def preprocess(self, latent_codes, **kwargs):\\n raise NotImplementedError(f'Should be implemented in derived class!')\",\n \"def compute_loss(self, *args, **kwargs):\\n raise NotImplementedError\",\n \"def compile(self, optimizer, lr):\\n \\n #clip_morm = 0.1\\n self.loss_f = None\\n with self.graph.as_default():\\n \\n tvars = tf.trainable_variables()\\n ft_vars = [v for v in tvars if \\\"_fe\\\" in v.name] \\n lab_vars = [v for v in tvars if \\\"_dc\\\" not in v.name]\\n dom_vars = [v for v in tvars if \\\"_lp\\\" not in v.name]\\n\\n print()\\n print(\\\" ft updates:\\\", ft_vars)\\n print(\\\"96x3 updates:\\\", lab_vars)\\n print(\\\" 1x3 updates:\\\", dom_vars)\\n print()\\n\\n # `tf.nn.softmax_cross_entropy_with_logits` is deprcated.\\n # https://www.tensorflow.org/api_docs/python/tf/nn/softmax_cross_entropy_with_logits\\n self.loss = tf.nn.softmax_cross_entropy_with_logits_v2(labels=self.labels, logits=self.output, name='cross_entropy')\\n self.loss_adv = tf.nn.softmax_cross_entropy_with_logits_v2(labels=self.labels_adv, logits=self.output_adv, name='cross_entropy_adv')\\n \\n #grads_and_vars = optimizer.compute_gradients(loss, var_list=tf_vars)\\n #clipped_grads_and_vars = [(tf.clip_by_norm(grad, clip_norm=clip_norm), var) for grad, var in grads_and_vars]\\n \\n self.loss_fe = - lam * self.loss_adv\\n # `tf.control_dependencies` is necessary if `tf.layers.batch_normalization` is in the model\\n # https://www.tensorflow.org/api_docs/python/tf/layers/batch_normalization\\n self.train_step_adv = optimizer(lr).minimize(self.loss_fe, name='minimize_fe', var_list=ft_vars)\\n self.train_step = optimizer(lr).minimize(self.loss, name='minimize', var_list=lab_vars)\\n self.train_step_adv = optimizer(lr).minimize(self.loss_adv, name='minimize_adv', var_list=dom_vars)\\n\\n # Initialize all `tf.Variable`.\\n self.session.run(tf.global_variables_initializer())\",\n \"def compute_loss(self, obs, returns):\",\n \"def evaluate(args):\\n dataset_param_filepath = os.path.join(args.model, 'dataset.params')\\n dataset_params = putils.load_params(dataset_param_filepath)\\n source_vocab_filepath = os.path.join(args.model, 'source.vocab')\\n source_vocab = Vocab(vocab_filepath=source_vocab_filepath)\\n target_vocab_filepath = os.path.join(args.model, 'target.vocab')\\n target_vocab = Vocab(vocab_filepath=target_vocab_filepath)\\n model_params_filepath = os.path.join(args.model, 'model.params')\\n model_params = putils.load_params(model_params_filepath)\\n checkpoint_filepath = os.path.join(args.model, 'checkpoint.tar')\\n if not torch.cuda.is_available() and model_params['cuda']:\\n logger.info('Loading a GPU-trained model on CPU')\\n checkpoint = torch.load(checkpoint_filepath,\\n map_location=const.DEVICE)\\n elif torch.cuda.is_available() and model_params['cuda']:\\n logger.info('Loading a GPU-trained model on GPU')\\n checkpoint = torch.load(checkpoint_filepath)\\n elif torch.cuda.is_available() and not model_params['cuda']:\\n logger.info('Loading a CPU-trained model on GPU')\\n checkpoint = torch.load(checkpoint_filepath,\\n map_location='cuda:0')\\n else:\\n logger.info('Loading a CPU-trained model on CPU')\\n checkpoint = torch.load(checkpoint_filepath)\\n encoder = Encoder(model_type=checkpoint['encoder']['model_type'],\\n input_size=checkpoint['encoder']['input_size'],\\n hidden_size=checkpoint['encoder']['hidden_size'],\\n num_layers=checkpoint['encoder']['num_layers'],\\n nonlinearity=checkpoint['encoder']['nonlinearity'],\\n bias=checkpoint['encoder']['bias'],\\n dropout=checkpoint['encoder']['dropout'],\\n bidirectional=checkpoint['encoder']['bidirectional'])\\n if checkpoint['with_attention']:\\n decoder = Attention(model_type=checkpoint['decoder']['model_type'],\\n hidden_size=checkpoint['decoder']['hidden_size'],\\n output_size=checkpoint['decoder']['output_size'],\\n max_seq_len=dataset_params['max_seq_len'],\\n num_layers=checkpoint['decoder']['num_layers'],\\n nonlinearity=checkpoint['decoder']['nonlinearity'],\\n bias=checkpoint['decoder']['bias'],\\n dropout=checkpoint['decoder']['dropout'],\\n bidirectional=checkpoint['decoder']['bidirectional'])\\n else:\\n decoder = Decoder(model_type=checkpoint['decoder']['model_type'],\\n hidden_size=checkpoint['decoder']['hidden_size'],\\n output_size=checkpoint['decoder']['output_size'],\\n num_layers=checkpoint['decoder']['num_layers'],\\n nonlinearity=checkpoint['decoder']['nonlinearity'],\\n bias=checkpoint['decoder']['bias'],\\n dropout=checkpoint['decoder']['dropout'],\\n bidirectional=checkpoint['decoder']['bidirectional'])\\n encoder.load_state_dict(checkpoint['encoder_state_dict'])\\n decoder.load_state_dict(checkpoint['decoder_state_dict'])\\n if torch.cuda.is_available():\\n encoder.to(const.DEVICE)\\n decoder.to(const.DEVICE)\\n encoder.eval()\\n decoder.eval()\\n indexes = putils.index_dataset(\\n args.data, source_vocab.item2idx, target_vocab.item2idx,\\n dataset_params['is_character_based'], dataset_params['max_seq_len'],\\n dataset_params['is_reversed'])\\n if args.random > 0:\\n random.shuffle(indexes)\\n for seq_num in range(args.random):\\n seq = indexes[seq_num]\\n print('-'*80)\\n print('>', ' '.join([source_vocab.idx2item[idx]\\n for idx in seq[0]]))\\n print('=', ' '.join([target_vocab.idx2item[idx]\\n for idx in seq[1]]))\\n # TODO: add support for OOV\\n predicted_idx, _ = _decode(seq[0], encoder, decoder,\\n checkpoint['with_attention'],\\n dataset_params['max_seq_len'])\\n print('<', ' '.join([target_vocab.idx2item[idx]\\n for idx in predicted_idx]))\\n else:\\n _evaluate(indexes, encoder, decoder, target_vocab, checkpoint,\\n dataset_params)\",\n \"def compute_loss(self, **kwargs):\\n raise NotImplementedError\",\n \"def _precompute_lossfun_inputs(self, float_dtype, device):\\n num_samples = 100000\\n # Normally distributed inputs.\\n x = float_dtype(np.random.normal(size=num_samples))\\n\\n # Uniformly distributed values in (-16, 3), quantized to the nearest 0.1\\n # to ensure that we hit the special cases at 0, 2.\\n alpha = float_dtype(\\n np.round(np.random.uniform(-16, 3, num_samples) * 10) / 10.0\\n )\\n # Push the sampled alphas at the extents of the range to +/- infinity, so\\n # that we probe those cases too.\\n alpha[alpha == 3.0] = float_dtype(float(\\\"inf\\\"))\\n alpha[alpha == -16.0] = -float_dtype(float(\\\"inf\\\"))\\n\\n # Random log-normally distributed values in approx (1e-5, 100000):\\n scale = float_dtype(np.exp(np.random.normal(size=num_samples) * 4.0) + 1e-5)\\n\\n # Compute the loss and its derivative with respect to all three inputs.\\n var_x = torch.autograd.Variable(\\n torch.tensor(x, device=device), requires_grad=True\\n )\\n var_alpha = torch.autograd.Variable(\\n torch.tensor(alpha, device=device), requires_grad=True\\n )\\n var_scale = torch.autograd.Variable(\\n torch.tensor(scale, device=device), requires_grad=True\\n )\\n loss = general.lossfun(var_x, var_alpha, var_scale)\\n sum_loss = torch.sum(loss)\\n sum_loss.backward()\\n d_x = var_x.grad.cpu().detach().numpy()\\n d_alpha = var_alpha.grad.cpu().detach().numpy()\\n d_scale = var_scale.grad.cpu().detach().numpy()\\n loss = loss.cpu().detach().numpy()\\n return (num_samples, loss, x, alpha, scale, d_x, d_alpha, d_scale)\",\n \"def evaluate(args):\\n dataset_param_filepath = os.path.join(args.model, 'dataset.params')\\n dataset_params = putils.load_params(dataset_param_filepath)\\n left_vocab_filepath = os.path.join(args.model, 'left.vocab')\\n left_vocab = Vocab(vocab_filepath=left_vocab_filepath)\\n right_vocab_filepath = os.path.join(args.model, 'right.vocab')\\n right_vocab = Vocab(vocab_filepath=right_vocab_filepath)\\n model_params_filepath = os.path.join(args.model, 'model.params')\\n model_params = putils.load_params(model_params_filepath)\\n checkpoint_filepath = os.path.join(args.model, 'checkpoint.tar')\\n if not torch.cuda.is_available() and model_params['cuda']:\\n logger.info('Loading a GPU-trained model on CPU')\\n checkpoint = torch.load(checkpoint_filepath,\\n map_location=const.DEVICE)\\n elif torch.cuda.is_available() and model_params['cuda']:\\n logger.info('Loading a GPU-trained model on GPU')\\n checkpoint = torch.load(checkpoint_filepath)\\n elif torch.cuda.is_available() and not model_params['cuda']:\\n logger.info('Loading a CPU-trained model on GPU')\\n checkpoint = torch.load(checkpoint_filepath,\\n map_location='cuda:0')\\n else:\\n logger.info('Loading a CPU-trained model on CPU')\\n checkpoint = torch.load(checkpoint_filepath)\\n if checkpoint['encoder']['model_type'] == 'transformer':\\n encoder = TEncoder(input_size=checkpoint['encoder']['input_size'],\\n hidden_size=checkpoint['encoder']['hidden_size'],\\n num_layers=checkpoint['encoder']['num_layers'],\\n dropout=checkpoint['encoder']['dropout'],\\n num_attention_heads=checkpoint['encoder']['num_attention_heads'])\\n else:\\n encoder = Encoder(model_type=checkpoint['encoder']['model_type'],\\n input_size=checkpoint['encoder']['input_size'],\\n hidden_size=checkpoint['encoder']['hidden_size'],\\n num_layers=checkpoint['encoder']['num_layers'],\\n nonlinearity=checkpoint['encoder']['nonlinearity'],\\n bias=checkpoint['encoder']['bias'],\\n dropout=checkpoint['encoder']['dropout'],\\n bidirectional=checkpoint['encoder']['bidirectional'])\\n if checkpoint['decoder']['model_type'] == 'transformer':\\n decoder = TDecoder(hidden_size=checkpoint['decoder']['hidden_size'],\\n output_size=checkpoint['decoder']['output_size'],\\n num_layers=checkpoint['decoder']['num_layers'],\\n dropout=checkpoint['decoder']['dropout'],\\n num_attention_heads=checkpoint['decoder']['num_attention_heads'])\\n elif checkpoint['decoder']['with_attention']:\\n decoder = Attention(hidden_size=checkpoint['decoder']['hidden_size'],\\n output_size=checkpoint['decoder']['output_size'],\\n max_seq_len=dataset_params['max_seq_len'],\\n num_layers=checkpoint['decoder']['num_layers'],\\n nonlinearity=checkpoint['decoder']['nonlinearity'],\\n bias=checkpoint['decoder']['bias'],\\n dropout=checkpoint['decoder']['dropout'])\\n else:\\n decoder = Decoder(model_type=checkpoint['decoder']['model_type'],\\n hidden_size=checkpoint['decoder']['hidden_size'],\\n output_size=checkpoint['decoder']['output_size'],\\n num_layers=checkpoint['decoder']['num_layers'],\\n nonlinearity=checkpoint['decoder']['nonlinearity'],\\n bias=checkpoint['decoder']['bias'],\\n dropout=checkpoint['decoder']['dropout'])\\n encoder.load_state_dict(checkpoint['encoder_state_dict'])\\n decoder.load_state_dict(checkpoint['decoder_state_dict'])\\n if torch.cuda.is_available():\\n encoder.to(const.DEVICE)\\n decoder.to(const.DEVICE)\\n encoder.eval()\\n decoder.eval()\\n pairs = putils.convert_to_seq_pairs(args.data)\\n indexed_pairs = putils.index_pairs(pairs, left_vocab.char2idx,\\n right_vocab.char2idx)\\n if dataset_params['reverse']:\\n indexed_pairs = [(y, x) for x, y in indexed_pairs]\\n source_vocab = right_vocab\\n target_vocab = left_vocab\\n else:\\n source_vocab = left_vocab\\n target_vocab = right_vocab\\n if args.random > 0:\\n random.shuffle(indexed_pairs)\\n for seq_num in range(args.random):\\n seq = indexed_pairs[seq_num]\\n print('-'*80)\\n input_str = ' '.join(\\n ''.join([source_vocab.idx2char[idx] for idx in seq[0] if idx\\n not in [const.SOS_IDX, const.EOS_IDX]])\\n .split(const.SEP))\\n gold_str = ' '.join(\\n ''.join([target_vocab.idx2char[idx] for idx in seq[1] if idx\\n not in [const.SOS_IDX, const.EOS_IDX]])\\n .split(const.SEP))\\n predicted_idxx = decode(seq[0], args.itemize, encoder, decoder,\\n dataset_params['max_seq_len'])\\n pred_str = ' '.join(\\n ''.join([target_vocab.idx2char[idx] for idx in predicted_idxx\\n if idx not in [const.SOS_IDX, const.EOS_IDX]])\\n .split(const.SEP))\\n print('>', input_str)\\n print('=', gold_str)\\n print('<', pred_str)\\n else:\\n _evaluate(indexed_pairs, args.itemize, encoder, decoder,\\n target_vocab.idx2char, dataset_params['max_seq_len'])\",\n \"def local_2(args):\\n cache_list = args[\\\"cache\\\"]\\n input_list = args[\\\"input\\\"]\\n\\n X = pd.read_json(cache_list[\\\"covariates\\\"], orient='split')\\n y = pd.read_json(cache_list[\\\"dependents\\\"], orient='split')\\n biased_X = sm.add_constant(X.values)\\n\\n avg_beta_vector = input_list[\\\"avg_beta_vector\\\"]\\n mean_y_global = input_list[\\\"mean_y_global\\\"]\\n\\n SSE_local, SST_local, varX_matrix_local = [], [], []\\n for index, column in enumerate(y.columns):\\n curr_y = y[column]\\n\\n X_, y_ = ignore_nans(biased_X, curr_y)\\n\\n SSE_local.append(reg.sum_squared_error(X_, y_, avg_beta_vector[index]))\\n SST_local.append(\\n np.sum(np.square(np.subtract(y_, mean_y_global[index]))))\\n\\n varX_matrix_local.append(np.dot(X_.T, X_).tolist())\\n\\n output_dict = {\\n \\\"SSE_local\\\": SSE_local,\\n \\\"SST_local\\\": SST_local,\\n \\\"varX_matrix_local\\\": varX_matrix_local,\\n \\\"computation_phase\\\": 'local_2'\\n }\\n\\n cache_dict = {}\\n\\n computation_output = {\\\"output\\\": output_dict, \\\"cache\\\": cache_dict}\\n\\n return json.dumps(computation_output)\",\n \"def _mer_compute(errors: Tensor, total: Tensor) ->Tensor:\\n return errors / total\",\n \"def compute(self, pred, target):\\n pass\",\n \"def call(self, query_input, source_input, bias, training, cache=None,\\n decode_loop_step=None):\\n # Linearly project the query, key and value using different learned\\n # projections. Splitting heads is automatically done during the linear\\n # projections --> [batch_size, length, num_heads, dim_per_head].\\n query = self.query_dense_layer(query_input)\\n key = self.key_dense_layer(source_input)\\n value = self.value_dense_layer(source_input)\\n\\n if cache is not None:\\n # Combine cached keys and values with new keys and values.\\n if decode_loop_step is not None:\\n cache_k_shape = cache[\\\"k\\\"].shape.as_list()\\n indices = tf.reshape(\\n tf.one_hot(decode_loop_step, cache_k_shape[1], dtype=key.dtype),\\n [1, cache_k_shape[1], 1, 1])\\n key = cache[\\\"k\\\"] + key * indices\\n cache_v_shape = cache[\\\"v\\\"].shape.as_list()\\n indices = tf.reshape(\\n tf.one_hot(decode_loop_step, cache_v_shape[1], dtype=value.dtype),\\n [1, cache_v_shape[1], 1, 1])\\n value = cache[\\\"v\\\"] + value * indices\\n else:\\n key = tf.concat([tf.cast(cache[\\\"k\\\"], key.dtype), key], axis=1)\\n value = tf.concat([tf.cast(cache[\\\"v\\\"], value.dtype), value], axis=1)\\n\\n # Update cache\\n cache[\\\"k\\\"] = key\\n cache[\\\"v\\\"] = value\\n\\n # Scale query to prevent the dot product between query and key from growing\\n # too large.\\n depth = (self.hidden_size // self.num_heads)\\n query *= depth ** -0.5\\n\\n # Calculate dot product attention\\n logits = tf.einsum(\\\"BTNH,BFNH->BNFT\\\", key, query)\\n logits += bias\\n # Note that softmax internally performs math operations using float32\\n # for numeric stability. When training with float16, we keep the input\\n # and output in float16 for better performance.\\n weights = tf.nn.softmax(logits, name=\\\"attention_weights\\\")\\n if training:\\n weights = tf.nn.dropout(weights, rate=self.attention_dropout)\\n attention_output = tf.einsum(\\\"BNFT,BTNH->BFNH\\\", weights, value)\\n\\n # Run the outputs through another linear projection layer. Recombining heads\\n # is automatically done --> [batch_size, length, hidden_size]\\n attention_output = self.output_dense_layer(attention_output)\\n return attention_output\",\n \"def inference_preprocess(self):\\n return\",\n \"def postprocess(self, prediction_dict, preprocessed_dict=None, use_trimap=True):\\r\\n pred_images = None\\r\\n gt_images = None\\r\\n gt_fg = None\\r\\n gt_bg = None\\r\\n if (not preprocessed_dict is None):\\r\\n gt_fg = preprocessed_dict.get('images_fg')\\r\\n gt_bg = preprocessed_dict.get('images_bg')\\r\\n gt_images = preprocessed_dict.get('images')\\r\\n\\r\\n pred_trimap = prediction_dict.get('pred_trimap')\\r\\n alpha_matte_r = prediction_dict.get('alpha_matte_r')\\r\\n alpha_matte_p = prediction_dict.get('alpha_matte_p')\\r\\n\\r\\n threshold = tf.fill(tf.shape(alpha_matte_p), 0.9)\\r\\n bool_great = tf.math.greater(alpha_matte_p, threshold)\\r\\n zeros = tf.fill(tf.shape(alpha_matte_p), 0.0)\\r\\n ones = tf.fill(tf.shape(alpha_matte_p), 1.0)\\r\\n alpha_matte_p_discrete = tf.where(bool_great, ones, zeros)\\r\\n if (not preprocessed_dict is None):\\r\\n pred_images = tf.multiply(alpha_matte_p_discrete, gt_fg) + tf.multiply(1 - alpha_matte_p_discrete, gt_bg)\\r\\n\\r\\n postprocessed_dict = {'pred_trimap': (pred_trimap * 255.),\\r\\n 'alpha_matte_r': (alpha_matte_r * 255.),\\r\\n 'alpha_matte_p': (alpha_matte_p * 255.),\\r\\n 'alpha_matte_p_discrete': (alpha_matte_p_discrete * 255.),\\r\\n 'pred_image': pred_images,\\r\\n 'gt_images': gt_images}\\r\\n if (preprocessed_dict is None):\\r\\n postprocessed_dict = {'pred_trimap': (pred_trimap * 255.),\\r\\n 'alpha_matte_r': (alpha_matte_r * 255.),\\r\\n 'alpha_matte_p': (alpha_matte_p * 255.),\\r\\n 'alpha_matte_p_discrete': (alpha_matte_p_discrete * 255.)\\r\\n }\\r\\n return postprocessed_dict\",\n \"def forward(self, enc_states, enc_len, dec_states):\\n\\n if self.keys is None:\\n\\n self.keys = self.key_linear(enc_states)\\n self.values = self.value_linear(enc_states)\\n self.mask = length_to_mask(\\n enc_len, max_len=enc_states.size(1), device=enc_states.device\\n ).unsqueeze(2)\\n\\n query = self.query_linear(dec_states).unsqueeze(2)\\n scores = torch.matmul(self.keys, query) / self.scaling\\n scores = scores.masked_fill(self.mask == 0, -np.inf)\\n normalized_scores = scores.softmax(1).transpose(1, 2)\\n out = torch.matmul(normalized_scores, self.values).squeeze(1)\\n return out, normalized_scores\",\n \"def _bleu_score_update(preds: Sequence[str], target: Sequence[Sequence[str]], numerator: Tensor, denominator: Tensor, preds_len: Tensor, target_len: Tensor, n_gram: int=4, tokenizer: Callable[[str], Sequence[str]]=_tokenize_fn) ->Tuple[Tensor, Tensor]:\\n target_: Sequence[Sequence[Sequence[str]]] = [[(tokenizer(line) if line else []) for line in t] for t in target]\\n preds_: Sequence[Sequence[str]] = [(tokenizer(line) if line else []) for line in preds]\\n for pred, targets in zip(preds_, target_):\\n preds_len += len(pred)\\n target_len_list = [len(tgt) for tgt in targets]\\n target_len_diff = [abs(len(pred) - x) for x in target_len_list]\\n target_len += target_len_list[target_len_diff.index(min(target_len_diff))]\\n preds_counter: Counter = _count_ngram(pred, n_gram)\\n target_counter: Counter = Counter()\\n for tgt in targets:\\n target_counter |= _count_ngram(tgt, n_gram)\\n ngram_counter_clip = preds_counter & target_counter\\n for counter_clip in ngram_counter_clip:\\n numerator[len(counter_clip) - 1] += ngram_counter_clip[counter_clip]\\n for counter in preds_counter:\\n denominator[len(counter) - 1] += preds_counter[counter]\\n return preds_len, target_len\",\n \"def compute(self, inputs, outputs):\\n\\n # Add new variables to dictionnary\\n cpacs = CPACS(Rt.modules[-1].cpacs_out)\\n\\n update_dict(cpacs.tixi, Rt.optim_var_dict)\\n\\n # Save the whole aeromap if needed\\n if Rt.use_aeromap:\\n update_am_dict(cpacs, Rt.aeromap_uid, Rt.am_dict)\\n\\n for obj in Rt.objective:\\n var_list = split(\\\"[+*/-]\\\", obj)\\n for v in var_list:\\n if not v.isdigit() and v != \\\"\\\":\\n exec('{} = inputs[\\\"{}\\\"]'.format(v, v))\\n result = eval(obj)\\n\\n if Rt.minmax == \\\"min\\\":\\n outputs[\\\"Objective function \\\" + obj] = result\\n else:\\n outputs[\\\"Objective function \\\" + obj] = -result\",\n \"def _aux_forward(self, F, pred1, pred2, label, **kwargs):\\n loss1 = super(MixSoftmaxCrossEntropyLoss, self). \\\\\\n hybrid_forward(F, pred1, label, **kwargs)\\n loss2 = super(MixSoftmaxCrossEntropyLoss, self). \\\\\\n hybrid_forward(F, pred2, label, **kwargs)\\n return loss1 + self.aux_weight * loss2\",\n \"def forward(self, encoder_output, encoded_captions, caption_lengths):\\n \\n batch_size = encoder_output.size(0)\\n encoder_dim = encoder_output.size(-1)\\n \\n # Flatten image\\n encoder_output = encoder_output.view(batch_size, -1, encoder_dim)\\n \\n #print(encoder_output.size())\\n \\n num_pixels = encoder_output.size(1)\\n \\n # Embedding\\n embeddings = self.embedding(encoded_captions).type(torch.FloatTensor).to(device)\\n #print(embeddings.size())\\n \\n #initial_states\\n h, c = self.init_hidden_states(encoder_output)\\n #print(h.size(), c.size())\\n\\n # Create tensors to hold word predicion scores and alphas\\n predictions = torch.zeros(batch_size, max(caption_lengths), self.vocab_size) #.to(device)\\n \\n #print('prediction_length', predictions.size())\\n alphas = torch.zeros(batch_size, max(caption_lengths), num_pixels) #.to(device)\\n #print('alphas', alphas.size())\\n # At each time-step, decode by\\n # attention-weighing the encoder's output based on the decoder's previous hidden state output\\n # then generate a new word in the decoder with the previous word and the attention weighted encoding\\n for t in range(max(caption_lengths)):\\n batch_size_t = sum([l > t for l in caption_lengths])\\n att, alpha = self.attention(encoder_output[:batch_size_t],\\n h[:batch_size_t])\\n gate = self.sigmoid(self.f_beta(h[:batch_size_t])) # gating scalar, (batch_size_t, encoder_dim)\\n att = gate * att\\n h, c = self.decode_step(\\n torch.cat([embeddings[:batch_size_t, t, :], att], dim=1),\\n (h[:batch_size_t], c[:batch_size_t])) # (batch_size_t, decoder_dim)\\n #preds = self.fc(self.dropout(h)) # (batch_size_t, vocab_size)\\n \\n h_embedded = self.linear_h(h)\\n att_embedded = self.linear_z(att)\\n preds = self.linear_o(self.dropout(embeddings[:batch_size_t, t, :] + h_embedded + att_embedded))\\n \\n predictions[:batch_size_t, t, :] = preds\\n alphas[:batch_size_t, t, :] = alpha\\n \\n #print(predictions.size()) \\n return predictions, alphas\",\n \"def calculate_loss(estimated_separation, true_separation, mask, true_latents, estimated_mix, true_mix, args):\\n stats = torch.zeros(7)\\n sdr = sdr_objective(estimated_separation, true_separation, mask)\\n stats[:4] = sdr\\n total_loss = -sdr.sum()\\n reconstruction_sdr = sdr_objective(estimated_mix, true_mix).mean() if args.reconstruction_loss_weight > 0 else 0.0\\n stats[4] = reconstruction_sdr\\n total_loss += -args.reconstruction_loss_weight * reconstruction_sdr\\n if args.similarity_loss_weight > 0.0 or args.dissimilarity_loss_weight > 0.0:\\n mask = mask.squeeze(-1)\\n true_latents = true_latents * mask.unsqueeze(-1).unsqueeze(-1)\\n true_latents = true_latents.transpose(0, 1)\\n dissimilarity = dissimilarity_loss(true_latents, mask) if args.dissimilarity_loss_weight > 0.0 else 0.0\\n stats[5] = dissimilarity\\n total_loss += args.dissimilarity_loss_weight * dissimilarity\\n similarity = similarity_loss(true_latents, mask) if args.similarity_loss_weight > 0.0 else 0.0\\n stats[6] = similarity\\n total_loss += -args.similarity_loss_weight * similarity\\n return total_loss, stats\",\n \"def calculate_loss(self, word_inputs, feature_inputs, word_seq_lengths, char_inputs, char_seq_lengths, \\\\\\r\\n char_seq_recover, batch_label, mask, vfeature_input, v_modal_label, t_modal_label, v_mask, alpha=0):\\r\\n outs, textual_clf_outputs, visual_clf_outputs = self._get_lstm_features(word_inputs, feature_inputs,\\r\\n word_seq_lengths, char_inputs,\\r\\n char_seq_lengths, char_seq_recover,\\r\\n vfeature_input, v_mask, alpha)\\r\\n batch_size = word_inputs.size(0)\\r\\n seq_len = word_inputs.size(1)\\r\\n # crf\\r\\n ner_loss = self.crf.neg_log_likelihood_loss(outs, mask, batch_label)\\r\\n scores, tag_seq = self.crf._viterbi_decode(outs, mask) # batch,\\r\\n if self.average_batch:\\r\\n ner_loss = ner_loss / batch_size\\r\\n\\r\\n # modal clf loss\\r\\n # visual_clf_outputs: (obj*b, 2) mask (b, obj) ->\\r\\n visual_loss = self.modal_clf_loss(visual_clf_outputs, v_modal_label)\\r\\n textual_loss = self.modal_clf_loss(textual_clf_outputs, t_modal_label)\\r\\n\\r\\n total_loss = self.ner_loss_lambda * ner_loss + self.v_loss_lambda * visual_loss \\\\\\r\\n + self.t_loss_lambda * textual_loss\\r\\n\\r\\n return total_loss, \\\\\\r\\n self.ner_loss_lambda * ner_loss, \\\\\\r\\n self.t_loss_lambda * textual_loss, \\\\\\r\\n self.v_loss_lambda * visual_loss, \\\\\\r\\n tag_seq, textual_clf_outputs, visual_clf_outputs\",\n \"def optimization_step(self):\\n \\n if \\\"CSS\\\" in self.algorithm:\\n \\n input_dict = {self.x: self.train_inputs[self.minibatch_set,:]}\\n \\n var_list = [self.x_tilda, self.minibatch_set]\\n \\n if (self.num_samples > 0) and (not self.mixture):\\n \\n if ((self.mf_steps > 0) and self.alpha >0) or\\\\\\n self.gibbs_steps > 0: \\n \\n var_list.append(self.sampler_theta)\\n \\n elif \\\"CD\\\" in self.algorithm:\\n \\n input_dict = {self.x : self.train_inputs[self.minibatch_set,:]} \\n \\n var_list = [self.minibatch_set]\\n \\n var_list.append(self.learning_rate)\\n \\n if self.use_momentum:\\n \\n var_list.append(self.momentum)\\n \\n output_vars = [self.pseudo_cost]\\n \\n if self.report_p_tilda:\\n \\n output_vars.append(self.p_tilda)\\n \\n else:\\n \\n output_vars.append(theano.shared(0))\\n \\n opt_step = theano.function(inputs = var_list,\\n outputs = output_vars,\\n updates = self.updates,\\n givens = input_dict,\\n on_unused_input='warn')\\n \\n return opt_step\",\n \"def preprocessing_fn(inputs):\\n outputs = {}\\n\\n # This function is the entry point for your feature engineering with\\n # TensorFlow Transform, using the TFX Transform component. In this example\\n # the feature engineering is very simple, only applying z-score scaling.\\n for key in Features.FEATURE_KEYS:\\n outputs[transformed_name(key)] = tft.scale_to_z_score(inputs[key])\\n\\n # inputs[key]\\n\\n # tft.scale_to_z_score(inputs[key])\\n\\n # Do not apply label transformation as it will result in wrong evaluation.\\n outputs[transformed_name(\\n Features.LABEL_KEY)] = inputs[Features.LABEL_KEY]\\n\\n return outputs\",\n \"def forward(self, encoder_outputs, decoder_h, previous_attention=None, mode=\\\"soft\\\"):\\n if mode not in [\\\"soft\\\", \\\"hard\\\"]:\\n raise ValueError(\\\"Invalid forward mode {} for attention; \\\\\\n accept only soft and hard mode\\\".format(mode))\\n\\n if mode == \\\"soft\\\":\\n\\n #alpha_rec = cuda_benchmark(super().soft_recursive, encoder_outputs, decoder_h, previous_attention)\\n #alpha = cuda_benchmark(super().soft, encoder_outputs, decoder_h, previous_attention)\\n #alpha_rec = super().soft_recursive(encoder_outputs, decoder_h, previous_attention)\\n alpha = super()(encoder_outputs, decoder_h, previous_attention, mode=\\\"soft\\\")\\n # sum_of_alpha = torch.sum(alpha, dim=-1)\\n # assert torch.allclose(sum_of_alpha, alpha.new_ones(alpha.size(0)),\\n # atol=1e-3,\\n # rtol=1e-3), \\\"{}\\\".format(sum_of_alpha)\\n chunk_energy = self.chunk_energy(encoder_outputs, decoder_h)\\n beta = self.my_soft(alpha, chunk_energy)\\n return alpha, beta\\n\\n elif mode == \\\"hard\\\":\\n monotonic_attention = super()(encoder_outputs, decoder_h,\\n previous_attention, mode=\\\"hard\\\")\\n chunk_energy = self.chunk_energy(encoder_outputs, decoder_h)\\n masked_energy = self.hard(\\n monotonic_attention, chunk_energy)\\n chunkwise_attention = self.softmax(masked_energy)\\n chunkwise_attention.masked_fill_(\\n chunkwise_attention != chunkwise_attention,\\n 0) # a trick to replace nan value with 0\\n return monotonic_attention, chunkwise_attention\",\n \"def prepare_vars_and_flows(self):\\n\\n # clear previously populated vars dictionary\\n self.vars.clear()\\n\\n # calculate vars and flows sequentially\\n self.calculate_scaleup_vars()\\n self.calculate_vars()\\n self.calculate_flows()\",\n \"def forward(self,pad_pred:torch.Tensor, pad_targets:torch.Tensor, ylen, ctc_out, hlens): # , ylen, encoder_output, hlens\\n batch_size,maxlen,_ = pad_pred.size()\\n self.loss = self.criterion(pad_pred.view(batch_size*maxlen,-1),pad_targets.view(-1))\\n ppl = self.compute_perplexity(self.loss.item())\\n self.loss *= (np.mean([ len(x[x!=self.ignore_label]) for x in pad_targets]) - 1)\\n\\n ## Try to add CTC loss.\\n ylen_tensor = torch.LongTensor([length for length in ylen])\\n hlens_tensor = torch.LongTensor([length for length in hlens])\\n ctc_pad_targets = torch.clone(pad_targets)\\n ctc_pad_targets[ctc_pad_targets==-1] = 0\\n self.loss = 0.9 * self.loss + 0.1 * \\\\\\n self.ctc(ctc_out.permute(1, 0, 2).log_softmax(-1), \\n ctc_pad_targets, hlens_tensor, ylen_tensor)\\n\\n if self.training:\\n return self.loss,self.compute_accuracy(pad_pred,pad_targets),None\\n else:\\n return self.loss,self.compute_accuracy(pad_pred,pad_targets),self.compute_wer(pad_pred,pad_targets)\",\n \"def post_build_args(self, args):\\n # Default reconstruction loss multipliers\\n if args.rec_mults == 'auto':\\n dims = self.model.dims\\n corrupt_mult = 1 / (1 - args.corrupt.get('uniform', 0.0))\\n args.rec_mults = {m : ((1.0 / dims[m]) / len(args.modalities)\\n * corrupt_mult)\\n for m in args.modalities}\\n return args\",\n \"def __call__(self, query, batch_size, previous_alignments):\\n with variable_scope.variable_scope(None, \\\"custom_attention\\\", [query]):\\n line_scores = _luong_score(query, self._keys, self._scale)\\n word_scores = _luong_word_score(query, self._word_values, self._scale, self._alignments_size, self._hierarchy, batch_size)\\n \\n line_alignments = self._soft_weight*self._probability_fn(line_scores)\\n word_alignments = self._soft_weight*self._probability_fn(word_scores)\\n\\n if self._hierarchy:\\n temp_word_alignments = tf.transpose(word_alignments, [0,2,1])\\n temp_line_alignments = tf.expand_dims(line_alignments, 1)\\n hier_alignments = math_ops.multiply(temp_word_alignments, temp_line_alignments)\\n hier_alignments = tf.transpose(hier_alignments, [0,2,1])\\n else:\\n shape = word_scores.get_shape().as_list()[-1]\\n word_scores = tf.reshape(word_scores, [self._batch_size, -1])\\n word_alignments = self._probability_fn(word_scores)\\n word_alignments = tf.reshape(word_alignments, tf.stack([self._batch_size, -1, shape]))\\n hier_alignments = word_alignments\\n #[batch_size x memory_size x sentence_size]\\n hier_alignments = tf.reshape(hier_alignments, [self._batch_size, -1])\\n return line_alignments, word_alignments, hier_alignments\",\n \"def adapt(args, src_encoder, tgt_encoder, discriminator,\\n src_classifier, src_data_loader, tgt_data_train_loader, tgt_data_all_loader):\\n\\n # set train state for Dropout and BN layers\\n src_encoder.eval()\\n src_classifier.eval()\\n tgt_encoder.train()\\n discriminator.train()\\n\\n # setup criterion and optimizer\\n BCELoss = nn.BCELoss()\\n KLDivLoss = nn.KLDivLoss(reduction='batchmean')\\n optimizer_G = optim.Adam(tgt_encoder.parameters(), lr=param.d_learning_rate)\\n optimizer_D = optim.Adam(discriminator.parameters(), lr=param.d_learning_rate)\\n len_data_loader = min(len(src_data_loader), len(tgt_data_train_loader))\\n \\n for epoch in range(args.num_epochs):\\n # zip source and target data pair\\n data_zip = enumerate(zip(src_data_loader, tgt_data_train_loader))\\n print(\\\"Loader lengths: \\\", len(src_data_loader), len(tgt_data_train_loader))\\n d_l = []\\n g_l = []\\n kd_l = []\\n accu = []\\n for step, (batch1, batch2) in data_zip:\\n batch1 = tuple(t.to(DEVICE) for t in batch1)\\n batch2 = tuple(t.to(DEVICE) for t in batch2)\\n src_input_ids, src_visual, src_acoustic, src_input_mask, src_segment_ids, src_label_ids = batch1 \\n tgt_input_ids, tgt_visual, tgt_acoustic, tgt_input_mask, tgt_segment_ids, tgt_label_ids = batch2\\n\\n src_visual = torch.squeeze(src_visual, 1)\\n src_acoustic = torch.squeeze(src_acoustic, 1)\\n # zero gradients for optimizer\\n optimizer_D.zero_grad()\\n\\n # extract and concat features\\n with torch.no_grad():\\n feat_src = src_encoder(src_input_ids,\\n src_visual,\\n src_acoustic,\\n token_type_ids=src_segment_ids,\\n attention_mask=src_input_mask,\\n labels=None,)\\n\\n feat_src_tgt = tgt_encoder(src_input_ids,\\n src_visual,\\n src_acoustic,\\n token_type_ids=src_segment_ids,\\n attention_mask=src_input_mask,\\n labels=None,)\\n feat_tgt = tgt_encoder(tgt_input_ids,\\n tgt_visual,\\n tgt_acoustic,\\n token_type_ids=tgt_segment_ids,\\n attention_mask=tgt_input_mask,\\n labels=None,)\\n\\n feat_concat = torch.cat((feat_src_tgt, feat_tgt), 0)\\n # print(\\\"Checking dims\\\", feat_src_tgt.shape, feat_tgt.shape, feat_concat.shape)\\n\\n # predict on discriminator\\n pred_concat = discriminator(feat_concat.detach())\\n pred_concat.to(DEVICE)\\n\\n # prepare real and fake label\\n label_src = make_cuda(torch.ones(feat_src_tgt.size(0))).unsqueeze(1)\\n label_tgt = make_cuda(torch.zeros(feat_tgt.size(0))).unsqueeze(1)\\n label_concat = torch.cat((label_src, label_tgt), 0)\\n\\n # compute loss for discriminator\\n dis_loss = BCELoss(pred_concat, label_concat)\\n dis_loss.backward()\\n\\n for p in discriminator.parameters():\\n p.data.clamp_(-args.clip_value, args.clip_value)\\n # optimize discriminator\\n optimizer_D.step()\\n # print(\\\"pred_concat : \\\" + str(pred_concat) + \\\"\\\\n\\\")\\n pred_cls = (pred_concat>0.5).float()\\n # pred_cls = torch.squeeze(pred_concat.max(1)[1])\\n # print(\\\"pred_cls : \\\" + str(pred_cls) + \\\"\\\\n\\\")\\n # print(\\\"label Concat: \\\" + str(label_concat) + \\\"\\\\n\\\")\\n acc = (pred_cls == label_concat).float().mean()\\n\\n # zero gradients for optimizer\\n optimizer_G.zero_grad()\\n T = args.temperature\\n\\n # predict on discriminator\\n pred_tgt = discriminator(feat_tgt)\\n\\n # logits for KL-divergence\\n with torch.no_grad():\\n src_prob = F.softmax(src_classifier(feat_src) / T, dim=-1)\\n tgt_prob = F.log_softmax(src_classifier(feat_src_tgt) / T, dim=-1)\\n kd_loss = KLDivLoss(tgt_prob, src_prob.detach()) * T * T\\n\\n # compute loss for target encoder\\n label_src_n = make_cuda(torch.ones(feat_tgt.size(0))).unsqueeze(1)\\n # print(\\\"Checking dims 2:\\\", feat_tgt.shape, pred_tgt.shape, label_src.shape)\\n gen_loss = BCELoss(pred_tgt, label_src_n)\\n loss_tgt = args.alpha * gen_loss + args.beta * kd_loss\\n loss_tgt.backward()\\n accu.append(acc.item())\\n g_l.append(gen_loss.item())\\n d_l.append(dis_loss.item())\\n kd_l.append(kd_loss.item())\\n torch.nn.utils.clip_grad_norm_(tgt_encoder.parameters(), args.max_grad_norm)\\n # optimize target encoder\\n optimizer_G.step()\\n\\n if (step + 1) % args.log_step == 0:\\n print(\\\"Epoch [%.2d/%.2d] Step [%.3d/%.3d]: \\\"\\n \\\"acc=%.4f g_loss=%.4f d_loss=%.4f kd_loss=%.4f\\\"\\n % (epoch + 1,\\n args.num_epochs,\\n step + 1,\\n len_data_loader,\\n torch.tensor(accu).mean(),\\n torch.tensor(g_l).mean(),\\n torch.tensor(d_l).mean(),\\n torch.tensor(kd_l).mean()))\\n\\n evaluate(args, tgt_encoder, src_classifier, tgt_data_all_loader)\\n\\n return tgt_encoder\",\n \"def recoding_func(self, input_var: Tensor, hidden: HiddenDict, out: Tensor, device: Device,\\n **additional: Dict) -> RecurrentOutput:\\n target_idx = additional.get(\\\"target_idx\\\", None)\\n\\n # Estimate uncertainty of those same predictions\\n delta = self.get_surprisal(out, target_idx)\\n\\n # Calculate gradient of uncertainty w.r.t. hidden states and make step\\n new_out_dist, new_hidden = self.recode_activations(hidden, out, delta, device, **additional)\\n\\n return new_out_dist, new_hidden\",\n \"def make_optimizer(self, train_var_filter):\\n # According from the prototxt in Caffe implement, learning rate must multiply by 10.0 in pyramid module\\n fc_list = ['conv5_3_pool1_conv', 'conv5_3_pool2_conv', 'conv5_3_pool3_conv', 'conv5_3_pool6_conv', 'conv6',\\n 'conv5_4']\\n all_trainable = [v for v in tf.trainable_variables() if\\n ('beta' not in v.name and 'gamma' not in v.name) or True]\\n fc_trainable = [v for v in all_trainable if v.name.split('/')[0] in fc_list]\\n conv_trainable = [v for v in all_trainable if v.name.split('/')[0] not in fc_list] # lr * 1.0\\n fc_w_trainable = [v for v in fc_trainable if 'weights' in v.name] # lr * 10.0\\n fc_b_trainable = [v for v in fc_trainable if 'biases' in v.name] # lr * 20.0\\n assert (len(all_trainable) == len(fc_trainable) + len(conv_trainable))\\n assert (len(fc_trainable) == len(fc_w_trainable) + len(fc_b_trainable))\\n\\n with tf.control_dependencies(self.update_ops):\\n opt_conv = tf.train.MomentumOptimizer(self.lr_op, self.momentum)\\n opt_fc_w = tf.train.MomentumOptimizer(self.lr_op * 10.0, self.momentum)\\n opt_fc_b = tf.train.MomentumOptimizer(self.lr_op * 20.0, self.momentum)\\n\\n grads = tf.gradients(self.loss, conv_trainable + fc_w_trainable + fc_b_trainable)\\n grads_conv = grads[:len(conv_trainable)]\\n grads_fc_w = grads[len(conv_trainable): (len(conv_trainable) + len(fc_w_trainable))]\\n grads_fc_b = grads[(len(conv_trainable) + len(fc_w_trainable)):]\\n\\n train_op_conv = opt_conv.apply_gradients(zip(grads_conv, conv_trainable), global_step=self.global_step)\\n train_op_fc_w = opt_fc_w.apply_gradients(zip(grads_fc_w, fc_w_trainable))\\n train_op_fc_b = opt_fc_b.apply_gradients(zip(grads_fc_b, fc_b_trainable))\\n\\n self.optimizer = tf.group(train_op_conv, train_op_fc_w, train_op_fc_b)\",\n \"def preprocessing(train_raw_, test_raw_):\\n \\n undef = np.float64(-999.0)\\n pred_dict = {'s':'1','b':'0', '?':'-1'}\\n # drop 1st column (Id) and also 1st row with column names (\\\"[1:,\\\") \\n train_raw = train_raw_[1:, :]\\n test_raw = test_raw_[1:, :] \\n \\n # Change s(signal) and b(background) for s:1 and b:0, and change '?' for -1\\n train_raw[:,1] = np.vectorize(pred_dict.get)(train_raw[:,1].astype(str))\\n test_raw[:,1] = np.vectorize(pred_dict.get)(test_raw[:,1].astype(str))\\n \\n # Divide the dataset in four according to PRI_jet_num feature and cast to float\\n train_data_jets = divide_dataset_by_jet(train_raw)\\n test_data_jets = divide_dataset_by_jet(test_raw)\\n \\n # Remove columns with nan values or with standard deviation of 0\\n test_data_jets, train_data_jets = clean_features(test_data_jets, train_data_jets, undef)\\n \\n # Standardize train and test sets to have mean=0 and std=1\\n train_data_jets, test_data_jets = standardize(train_data_jets, test_data_jets)\\n \\n # Replace remaining undefined values by mean, median or zero\\n train_data_mean, train_data_median, train_data_null = replace_nan(train_data_jets)\\n test_data_mean, test_data_median, test_data_null = replace_nan(test_data_jets)\\n \\n return train_data_mean, train_data_median, train_data_null, test_data_mean, test_data_median, test_data_null\",\n \"def _bleu_score_compute(preds_len: Tensor, target_len: Tensor, numerator: Tensor, denominator: Tensor, n_gram: int, weights: Sequence[float], smooth: bool) ->Tensor:\\n device = numerator.device\\n if min(numerator) == 0.0:\\n return tensor(0.0, device=device)\\n if smooth:\\n precision_scores = torch.div(torch.add(numerator, torch.ones(n_gram, device=device)), torch.add(denominator, torch.ones(n_gram, device=device)))\\n precision_scores[0] = numerator[0] / denominator[0]\\n else:\\n precision_scores = numerator / denominator\\n log_precision_scores = tensor(weights, device=device) * torch.log(precision_scores)\\n geometric_mean = torch.exp(torch.sum(log_precision_scores))\\n brevity_penalty = tensor(1.0, device=device) if preds_len > target_len else torch.exp(1 - target_len / preds_len)\\n bleu = brevity_penalty * geometric_mean\\n return bleu\",\n \"def loss(self, X, y=None):\\n W1, b1 = self.params['W1'], self.params['b1']\\n W2, b2 = self.params['W2'], self.params['b2']\\n W3, b3 = self.params['W3'], self.params['b3']\\n \\n # pass conv_param to the forward pass for the convolutional layer\\n filter_size = W1.shape[2]\\n conv_param = {'stride': 1, 'pad': (filter_size - 1) / 2}\\n\\n # pass pool_param to the forward pass for the max-pooling layer\\n pool_param = {'pool_height': 2, 'pool_width': 2, 'stride': 2}\\n\\n ############################################################################\\n # TODO: Implement the forward pass for the three-layer convolutional net, #\\n # computing the class scores for X and storing them in the scores #\\n # variable. #\\n ############################################################################\\n \\n scores = None \\n cache = {}\\n # def conv_relu_pool_forward(x, w, b, conv_param, pool_param): return out, cache;\\n out, cache['layer1'] = layer_utils.conv_relu_pool_forward(X, W1, b1, conv_param, pool_param) \\n # def affine_relu_forward(x, w, b): return out, cache;\\n out, cache['layer2'] = layer_utils.affine_relu_forward(out, W2, b2)\\n # def affine_forward(x, w, b): return out, cache;\\n scores, cache['layer3'] = layers.affine_forward(out, W3, b3)\\n\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n \\n if y is None:\\n return scores\\n \\n ############################################################################\\n # TODO: Implement the backward pass for the three-layer convolutional net, #\\n # storing the loss and gradients in the loss and grads variables. Compute #\\n # data loss using softmax, and make sure that grads[k] holds the gradients #\\n # for self.params[k]. Don't forget to add L2 regularization! #\\n ############################################################################\\n \\n loss, grads = 0, {}\\n\\n # def softmax_loss(x, y): return loss, dscore;\\n loss, dscores = layers.softmax_loss(scores, y)\\n loss += 0.5 * self.reg * (np.sum(W1 * W1) + np.sum(W2 * W2) + np.sum(W3 * W3))\\n\\n # def affine_backward(dout, cache): return dx, dw, db;\\n dout, dW3, db3 = layers.affine_backward(dscores, cache['layer3']) \\n # def affine_relu_backward(dout, cache): return dx, dw, db;\\n dout, dW2, db2 = layer_utils.affine_relu_backward(dout, cache['layer2'])\\n # def conv_relu_pool_backward(dout, cache): return dx, dw, db;\\n dout, dW1, db1 = layer_utils.conv_relu_pool_backward(dout, cache['layer1'])\\n\\n # reg\\n grads['W3'], grads['b3'] = dW3 + self.reg * W3, db3\\n grads['W2'], grads['b2'] = dW2 + self.reg * W2, db2\\n grads['W1'], grads['b1'] = dW1 + self.reg * W1, db1\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n \\n return loss, grads\",\n \"def calculate_scaleup_vars(self):\\n\\n for label, fn in self.scaleup_fns.items():\\n self.vars[label] = fn(self.time)\",\n \"def compute_backsubstitution(self, length: int, dim: int, layer_gradient_manager=None):\\n if self.args.cpu:\\n self.lb = torch.zeros(length, dim)\\n else:\\n self.lb = torch.zeros(length, dim).cuda()\\n self.ub = self.lb.clone()\\n self.final_lw = self.final_uw = None\\n self.final_lb = self.final_ub = None\\n\\n original_layers = self.layers[:] # We keep a copy, because layers might get modified during the backsubstitution with jacobian\\n for layer in self.layers[::-1]:\\n if layer.lw is not None:\\n layer.backward(layer_gradient_manager)\\n # print(\\\"Controller has grad: \\\", self.lb.requires_grad)\\n self.layers = original_layers # We restore the original layers\",\n \"def evaluate(net, dmanager, partition): \\n def accuracy(outputs, labels, phrases, dmanager):\\n correct = 0\\n total = 0\\n misclassified = []\\n for (i, output) in enumerate(outputs):\\n total += 1\\n if labels[i] == output.argmax():\\n correct += 1\\n else:\\n misclassified.append((phrases[i], \\n dmanager.tag(output.argmax().item()),\\n dmanager.tag(labels[i].item())))\\n return correct, total, misclassified\\n val_loader = dmanager.batched_loader(partition, 128)\\n total_val_loss = 0\\n correct = 0\\n total = 0\\n misclassified = []\\n loss = torch.nn.CrossEntropyLoss() \\n for data in val_loader:\\n raw_inputs = [dmanager.vectorize(p) for p in data['phrase']]\\n raw_labels = [dmanager.tag_index(c) for c in data['tag']]\\n inputs = []\\n labels = []\\n for (inp, label) in zip(raw_inputs, raw_labels):\\n if inp is not None:\\n inputs.append(inp)\\n labels.append(label) \\n inputs = torch.Tensor(inputs)\\n labels = torch.LongTensor([dmanager.tag_index(c) for \\n c in data['tag']])\\n val_outputs = net(inputs) \\n val_loss_size = loss(val_outputs, labels)\\n correct_inc, total_inc, misclassified_inc = accuracy(val_outputs, \\n labels, \\n data['phrase'], \\n dmanager)\\n correct += correct_inc\\n total += total_inc\\n misclassified += misclassified_inc\\n total_val_loss += val_loss_size.data.item()\\n return correct/total, misclassified\",\n \"def compute_loss(model, loader, loss_fn, optimizer=None):\\n\\n total_loss = 0.0\\n count_batches = 0\\n for x_, y_, qm_, db_mask, blink_mask in loader:\\n batch_loss_list = []\\n xbatch_list = []\\n for mask in [db_mask, blink_mask]:\\n idxes = get_idxes_from_mask(mask)\\n x_pick, y_pick, qm_pick = x_[idxes], y_[idxes], qm_[idxes]\\n y_pos_idxes = torch.nonzero(y_pick.squeeze(), as_tuple=False).reshape(1, -1)[0]\\n y_neg_idxes = torch.nonzero(~y_pick.squeeze().bool(), as_tuple=False).reshape(1, -1)[0]\\n\\n if (len(y_pos_idxes) == 0) or (len(y_neg_idxes) == 0):\\n xbatch_list.append(torch.tensor([]))\\n continue\\n elif len(x_pick) <= 1:\\n xbatch_list.append(torch.tensor([]))\\n continue\\n elif len(y_pos_idxes) == 1:\\n y_pos_idx = y_pos_idxes[0]\\n else: # len(y_pos_idxes) > 1:\\n # TODO: I am just always using the first positive example for now\\n # rand_idx = random.choice(list(range(len(y_pos_idxes))))\\n # print(y_pos_idxes)\\n rand_idx = 0\\n y_pos_idx = y_pos_idxes[rand_idx]\\n\\n batch_length = 1 + len(y_neg_idxes)\\n batch_feature_len = x_.shape[1]\\n x_batch = torch.zeros(batch_length, batch_feature_len)\\n x_batch[:-1:, :] = x_pick[y_neg_idxes]\\n x_batch[-1, :] = x_pick[y_pos_idx] # put positive to the end\\n xbatch_list.append(x_batch)\\n # print(y_pos_idx, len(y_neg_idxes))\\n # print(\\\"batch\\\", x_batch.shape)\\n\\n if (len(xbatch_list[0]) == 0) and (len(xbatch_list[1]) == 0):\\n # skip if both batches are []\\n # print(\\\"hitting cases without any examples [SHOULD BE WRONG]\\\")\\n continue\\n elif (len(xbatch_list[0]) == 0) or (len(xbatch_list[1]) == 0):\\n # continue # TODO: testing whether improvements made if we only use cases where there are sources from both\\n yhat = model(xbatch_list[0], xbatch_list[1])\\n extended_batch_length = len(yhat) - 1\\n yhat_neg = yhat[:-1]\\n yhat_pos = yhat[-1].repeat(extended_batch_length, 1)\\n loss = loss_fn(yhat_pos, yhat_neg, torch.ones((len(yhat) - 1), 1).to(device))\\n batch_loss_list.append(loss)\\n total_loss += loss.item() * extended_batch_length\\n count_batches += 1\\n else:\\n # get yhats for both BLINK and DB batches\\n # print(len(xbatch_list[0]), len(xbatch_list[1]))\\n # print((xbatch_list[0], xbatch_list[1]))\\n yhat = model(xbatch_list[0], xbatch_list[1])\\n extended_batch_length = len(yhat) - 2\\n yhat_neg = torch.zeros(extended_batch_length, 1)\\n yhat_neg[:len(xbatch_list[0])-1] = yhat[:len(xbatch_list[0])-1]\\n yhat_neg[len(xbatch_list[0])-1:] = yhat[len(xbatch_list[0]):-1]\\n for idx in [len(xbatch_list[0]), -1]:\\n yhat_pos = yhat[idx].repeat(extended_batch_length, 1)\\n loss = loss_fn(yhat_pos, yhat_neg, torch.ones(extended_batch_length, 1).to(device))\\n batch_loss_list.append(loss)\\n total_loss += loss.item() * extended_batch_length\\n count_batches += 1\\n\\n # update every question-mention\\n if batch_loss_list and optimizer:\\n (sum(batch_loss_list)/len(batch_loss_list)).backward()\\n optimizer.step()\\n\\n avg_loss = total_loss / count_batches\\n\\n return avg_loss, batch_length\",\n \"def init_trainers(self, args):\\n self.actors_cur = [None for _ in range(self.num_agents)]\\n self.critics_cur = [None for _ in range(self.num_agents)]\\n self.actors_tar = [None for _ in range(self.num_agents)]\\n self.critics_tar = [None for _ in range(self.num_agents)]\\n self.optimizers_c = [None for _ in range(self.num_agents)]\\n self.optimizers_a = [None for _ in range(self.num_agents)]\\n input_size_global = sum(self.obs_shape_n) + sum(self.action_shape_n)\\n\\n if args.restore == True: # restore the model\\n game_step = int(args.old_model_name.split('_')[-1][:-1])\\n for idx in range(self.num_agents):\\n self.actors_cur[idx] = torch.load(args.old_model_name+'a_c_{}.pt'.format(idx))\\n self.actors_tar[idx] = torch.load(args.old_model_name+'a_t_{}.pt'.format(idx))\\n self.critics_cur[idx] = torch.load(args.old_model_name+'c_c_{}.pt'.format(idx))\\n self.critics_tar[idx] = torch.load(args.old_model_name+'c_t_{}.pt'.format(idx))\\n self.optimizers_a[idx] = optim.Adam(self.actors_cur[idx].parameters(), args.lr_a)\\n self.optimizers_c[idx] = optim.Adam(self.critics_cur[idx].parameters(), args.lr_c)\\n self.var = self.var - (game_step-args.learning_start_episode*args.per_episode_max_len)*args.var_discount\\n self.var = self.min_var if self.var < self.min_var else self.var\\n old_data = {'game_step':game_step, 'episode_gone_old':int(game_step/args.per_episode_max_len)}\\n\\n # Note: if you need load old model, there should be a procedure for juding if the trainers[idx] is None\\n for i in range(self.num_agents):\\n self.actors_cur[i] = actor_agent(self.obs_shape_n[i], self.action_shape_n[i], \\\\\\n args).to(args.device)\\n self.critics_cur[i] = critic_agent(sum(self.obs_shape_n), sum(self.action_shape_n), \\\\\\n args).to(args.device)\\n self.actors_tar[i] = actor_agent(self.obs_shape_n[i], self.action_shape_n[i], \\\\\\n args).to(args.device)\\n self.critics_tar[i] = critic_agent(sum(self.obs_shape_n), sum(self.action_shape_n), \\\\\\n args).to(args.device)\\n self.optimizers_a[i] = optim.Adam(self.actors_cur[i].parameters(), args.lr_a)\\n self.optimizers_c[i] = optim.Adam(self.critics_cur[i].parameters(), args.lr_c)\\n\\n # return the old data, no need to update the trainers\\n if args.restore == True: return old_data\\n\\n self.actors_tar = self.update_trainers(self.actors_cur, self.actors_tar, 1.0) # update the target par using the cur\\n self.critics_tar = self.update_trainers(self.critics_cur, self.critics_tar, 1.0) # update the target par using the cur\",\n \"def _bleu_score_compute(\\n preds_len: Tensor,\\n target_len: Tensor,\\n numerator: Tensor,\\n denominator: Tensor,\\n n_gram: int,\\n weights: Sequence[float],\\n smooth: bool,\\n) -> Tensor:\\n device = numerator.device\\n if min(numerator) == 0.0:\\n return tensor(0.0, device=device)\\n\\n if smooth:\\n precision_scores = torch.div(\\n torch.add(numerator, torch.ones(n_gram, device=device)),\\n torch.add(denominator, torch.ones(n_gram, device=device)),\\n )\\n precision_scores[0] = numerator[0] / denominator[0]\\n else:\\n precision_scores = numerator / denominator\\n\\n log_precision_scores = tensor(weights, device=device) * torch.log(precision_scores)\\n geometric_mean = torch.exp(torch.sum(log_precision_scores))\\n brevity_penalty = tensor(1.0, device=device) if preds_len > target_len else torch.exp(1 - (target_len / preds_len))\\n return brevity_penalty * geometric_mean\",\n \"def initialize_cache(inputs, outputs, programs, max_decode_len, config):\\n target_shape = (programs.shape[0], max_decode_len)\\n initial_variables = models.ProgramTransformer(config).init(\\n jax.random.PRNGKey(0),\\n jnp.ones(inputs.shape, config.dtype),\\n jnp.ones(outputs.shape, config.dtype),\\n jnp.ones(target_shape, config.dtype))\\n return initial_variables['cache']\",\n \"def get_pca_embeddings(config, name, training_embedding: dict, validation_embedding: dict):\\n\\n data_name = config['train_file'].split('/')[-1][:-4] # retrieve file name without the extension\\n train_pca_pkl_f = os.path.join(config['pca_cache'], data_name + '_' + config['embedding_type'] + '_training_embeddings.p')\\n valid_pca_pkl_f = os.path.join(config['pca_cache'], data_name + '_' + config['embedding_type'] + '_validation_embeddings.p')\\n\\n if os.path.exists(train_pca_pkl_f):\\n logger.info(\\\" Loading PCA-embeddings from cache \\\")\\n with open(train_pca_pkl_f , 'rb') as cache:\\n train_embeddings = pickle.load(cache)\\n\\n with open(valid_pca_pkl_f, 'rb') as cache:\\n valid_embeddings = pickle.load(cache)\\n else:\\n logger.info(' Standardizing ')\\n \\n ss = StandardScaler()\\n train_embed_ss = ss.fit_transform(training_embedding['embeddings'])\\n valid_embed_ss = ss.transform(validation_embedding['embeddings'])\\n\\n # Dimension reduction: PCA or UMAP (?)\\n logger.info(' Doing PCA...')\\n pca_model = decomposition.PCA(n_components = 0.90) # this can be a parameter down the road, but for debugging it's fine\\n train_reduc = pca_model.fit_transform(train_embed_ss)\\n val_reduc = pca_model.transform(valid_embed_ss)\\n\\n \\n training_embedding['embeddings'] = train_reduc\\n validation_embedding['embeddings'] = val_reduc\\n\\n train_embeddings = training_embedding.copy()\\n valid_embeddings = validation_embedding.copy()\\n\\n # save embeddings\\n pickle.dump(train_embeddings, open(train_pca_pkl_f, 'wb'))\\n pickle.dump(valid_embeddings, open(valid_pca_pkl_f, 'wb'))\\n\\n embedding_shape = len(train_embeddings['embeddings'][0])\\n\\n return embedding_shape, train_embeddings, valid_embeddings\",\n \"def fisher_precalc(\\n self,\\n cbl,\\n cls_input,\\n cls_debias=None,\\n likelihood=False,\\n windows=False,\\n ):\\n num_maps = self.num_maps\\n pol_dim = 3 if self.pol else 1\\n dim1 = pol_dim * num_maps\\n\\n comps = [\\\"cmb\\\"]\\n if \\\"fg_tt\\\" in cbl:\\n comps += [\\\"fg\\\"]\\n if \\\"res_tt\\\" in cbl or \\\"res_ee\\\" in cbl:\\n comps += [\\\"res\\\"]\\n\\n specs = list(cls_input)\\n\\n if likelihood:\\n Dmat_obs_b = OrderedDict()\\n Dmat_obs = None\\n dSdqb = None\\n Mmat = None\\n Mmat_mix = None\\n else:\\n if windows:\\n Dmat_obs = None\\n Mmat = OrderedDict()\\n Mmat_mix = OrderedDict() if self.pol else None\\n mll = getattr(self, \\\"mll\\\", None)\\n if mll is None:\\n mll = self.kernel_precalc()\\n else:\\n Dmat_obs = OrderedDict()\\n Mmat = None\\n Mmat_mix = None\\n Dmat_obs_b = None\\n dSdqb = OrderedDict()\\n\\n for xname, (m0, m1) in self.map_pairs.items():\\n # transfer function doesn't have all the crosses\\n if xname not in cls_input[specs[0]]:\\n continue\\n\\n if likelihood:\\n Dmat_obs_b[xname] = OrderedDict()\\n elif windows:\\n Mmat[xname] = OrderedDict()\\n if self.pol:\\n Mmat_mix[xname] = OrderedDict()\\n else:\\n Dmat_obs[xname] = OrderedDict()\\n\\n for spec in specs:\\n if likelihood:\\n # without bias subtraction for likelihood\\n Dmat_obs_b[xname][spec] = cls_input[spec][xname]\\n elif windows:\\n Mmat[xname][spec] = mll[spec][xname]\\n if spec in [\\\"ee\\\", \\\"bb\\\"]:\\n mspec = \\\"bb\\\" if spec == \\\"ee\\\" else \\\"ee\\\"\\n Mmat_mix[xname][spec] = mll[\\\"{}_mix\\\".format(mspec)][xname]\\n else:\\n if cls_debias is not None:\\n Dmat_obs[xname][spec] = (\\n cls_input[spec][xname] - cls_debias[spec][xname]\\n )\\n else:\\n Dmat_obs[xname][spec] = cls_input[spec][xname]\\n\\n if likelihood:\\n continue\\n\\n for comp in comps:\\n for spec in specs:\\n stag = \\\"{}_{}\\\".format(comp, spec)\\n if stag not in cbl:\\n continue\\n if xname not in cbl[stag]:\\n continue\\n\\n dSdqb.setdefault(comp, OrderedDict()).setdefault(\\n xname, OrderedDict()\\n ).setdefault(spec, OrderedDict())\\n dSdqb[comp][xname][spec][spec] = cbl[stag][xname]\\n\\n if spec in [\\\"ee\\\", \\\"bb\\\"]:\\n if stag + \\\"_mix\\\" not in cbl:\\n continue\\n mspec = \\\"bb\\\" if spec == \\\"ee\\\" else \\\"ee\\\"\\n mix_cbl = cbl[stag + \\\"_mix\\\"][xname]\\n dSdqb[comp][xname][spec][mspec] = mix_cbl\\n\\n if comp == \\\"fg\\\":\\n # add delta beta bin for spectral index\\n dSdqb.setdefault(\\\"delta_beta\\\", OrderedDict()).setdefault(\\n xname, OrderedDict()\\n )\\n for spec in specs:\\n # this will be filled in in fisher_calc\\n dSdqb[\\\"delta_beta\\\"][xname][spec] = OrderedDict()\\n\\n return Dmat_obs, Dmat_obs_b, dSdqb, Mmat, Mmat_mix\",\n \"def _create_preprocess_fn(\\n num_epochs: int,\\n batch_size: int,\\n merge_case: bool,\\n shuffle_buffer_size: int = emnist_dataset.MAX_CLIENT_DATASET_SIZE,\\n use_cache: bool = True,\\n use_prefetch: bool = True,\\n) -> Callable[[tf.data.Dataset], tf.data.Dataset]:\\n @tf.function\\n def merge_mapping(elem):\\n original_label_to_merged_label = tf.constant([\\n 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,\\n 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,\\n 12, 38, 39, 40, 41, 42, 18, 19, 20, 21, 22, 43, 24, 25, 44, 45, 28, 46,\\n 30, 31, 32, 33, 34, 35\\n ])\\n return collections.OrderedDict(\\n label=original_label_to_merged_label[elem['label']],\\n pixels=elem['pixels'])\\n\\n base_preprocess_fn = emnist_dataset.create_preprocess_fn(\\n num_epochs=num_epochs,\\n batch_size=batch_size,\\n shuffle_buffer_size=shuffle_buffer_size)\\n\\n def preprocess_fn(dataset: tf.data.Dataset):\\n if merge_case:\\n dataset = dataset.map(merge_mapping)\\n if use_cache:\\n dataset = dataset.cache()\\n dataset = base_preprocess_fn(dataset)\\n if use_prefetch:\\n dataset = dataset.prefetch(tf.data.AUTOTUNE)\\n\\n return dataset\\n\\n return preprocess_fn # pytype: disable=bad-return-type\",\n \"def param_computation(self, param):\\n result = {}\\n\\n result[\\\"V_t_V\\\"] = param_computation_V_t_V(param)\\n\\n if compute_gammas:\\n result[\\\"V_t_g_n\\\"] = param_computation_V_t_g_n(param)\\n if compute_lambdas:\\n result[\\\"V_n_t_V\\\"] = param_computation_V_n_t_V(param)\\n\\n param_computation_memory_cleanup(param)\\n\\n return result\",\n \"def call_preprocessing(self, train_mains, train_appliances):\\n return train_mains, train_appliances\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6046909","0.6046909","0.5747046","0.5558208","0.5538616","0.54545367","0.54432714","0.54280794","0.541424","0.5409307","0.5395517","0.53825015","0.5354495","0.5351136","0.52674043","0.52538127","0.5232878","0.52251","0.52243966","0.5220421","0.5217032","0.5216503","0.5213711","0.52040696","0.5203097","0.5193022","0.51903534","0.51798207","0.51788545","0.516698","0.51528776","0.51478034","0.514637","0.5146093","0.5144303","0.5139056","0.513809","0.51052785","0.50911045","0.5090672","0.5090556","0.5089331","0.50880307","0.50875765","0.5083939","0.50794643","0.5077726","0.50748336","0.5070926","0.50639534","0.50638676","0.5060896","0.5053515","0.50448704","0.5043023","0.5041018","0.5039597","0.5039195","0.50295603","0.5022912","0.5010416","0.4999452","0.49921152","0.49820513","0.49724022","0.49722338","0.49680465","0.49613753","0.49607593","0.49583676","0.49520102","0.4949791","0.4949274","0.4948184","0.493701","0.49353677","0.49285573","0.49231702","0.4922569","0.491854","0.49183333","0.49164942","0.4914811","0.49086487","0.49001694","0.48961848","0.48926473","0.4892468","0.48880684","0.4885936","0.48796827","0.48790434","0.48787048","0.48718083","0.48702174","0.48694715","0.48627898","0.48619038","0.48571825","0.48535126"],"string":"[\n \"0.6046909\",\n \"0.6046909\",\n \"0.5747046\",\n \"0.5558208\",\n \"0.5538616\",\n \"0.54545367\",\n \"0.54432714\",\n \"0.54280794\",\n \"0.541424\",\n \"0.5409307\",\n \"0.5395517\",\n \"0.53825015\",\n \"0.5354495\",\n \"0.5351136\",\n \"0.52674043\",\n \"0.52538127\",\n \"0.5232878\",\n \"0.52251\",\n \"0.52243966\",\n \"0.5220421\",\n \"0.5217032\",\n \"0.5216503\",\n \"0.5213711\",\n \"0.52040696\",\n \"0.5203097\",\n \"0.5193022\",\n \"0.51903534\",\n \"0.51798207\",\n \"0.51788545\",\n \"0.516698\",\n \"0.51528776\",\n \"0.51478034\",\n \"0.514637\",\n \"0.5146093\",\n \"0.5144303\",\n \"0.5139056\",\n \"0.513809\",\n \"0.51052785\",\n \"0.50911045\",\n \"0.5090672\",\n \"0.5090556\",\n \"0.5089331\",\n \"0.50880307\",\n \"0.50875765\",\n \"0.5083939\",\n \"0.50794643\",\n \"0.5077726\",\n \"0.50748336\",\n \"0.5070926\",\n \"0.50639534\",\n \"0.50638676\",\n \"0.5060896\",\n \"0.5053515\",\n \"0.50448704\",\n \"0.5043023\",\n \"0.5041018\",\n \"0.5039597\",\n \"0.5039195\",\n \"0.50295603\",\n \"0.5022912\",\n \"0.5010416\",\n \"0.4999452\",\n \"0.49921152\",\n \"0.49820513\",\n \"0.49724022\",\n \"0.49722338\",\n \"0.49680465\",\n \"0.49613753\",\n \"0.49607593\",\n \"0.49583676\",\n \"0.49520102\",\n \"0.4949791\",\n \"0.4949274\",\n \"0.4948184\",\n \"0.493701\",\n \"0.49353677\",\n \"0.49285573\",\n \"0.49231702\",\n \"0.4922569\",\n \"0.491854\",\n \"0.49183333\",\n \"0.49164942\",\n \"0.4914811\",\n \"0.49086487\",\n \"0.49001694\",\n \"0.48961848\",\n \"0.48926473\",\n \"0.4892468\",\n \"0.48880684\",\n \"0.4885936\",\n \"0.48796827\",\n \"0.48790434\",\n \"0.48787048\",\n \"0.48718083\",\n \"0.48702174\",\n \"0.48694715\",\n \"0.48627898\",\n \"0.48619038\",\n \"0.48571825\",\n \"0.48535126\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5792342"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":81979,"cells":{"query":{"kind":"string","value":"Computes the training loss for the alignment model. For example, you could implement crossentropy loss as loss_num, loss_den = common_utils.padded_cross_entropy( precomputed, features[\"targets\"], params.label_smoothing) loss = loss_num / tf.maximum(1.0, loss_den) return loss assuming that precomputed holds the logits for the targets."},"document":{"kind":"string","value":"def compute_loss(self, features, mode, params, precomputed):\n raise NotImplementedError(\"Model does not implement loss.\")"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def compute_loss(self):\n self.test_logits = self.compute_logits()\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(\n labels=self.data.test_labels, logits=self.test_logits)\n cross_entropy_loss = tf.reduce_mean(loss)\n regularization = tf.reduce_sum(\n tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))\n loss = cross_entropy_loss + self.weight_decay * regularization\n return loss","def _compute_loss(self, predictions, targets, **params):\n pass","def calculate_loss(self, pred, gold, smoothing=False):\n gold = gold.contiguous().view(-1)\n if smoothing:\n epsilon = 0.1\n n_class = pred.size(1)\n one_hot = torch.zeros_like(pred).scatter(1, gold.view(-1, 1), 1)\n one_hot = one_hot * (1 - epsilon) + \\\n (1 - one_hot) * epsilon / (n_class - 1)\n\n log_prb = F.log_softmax(pred, dim=1)\n # create non-padding mask with torch.ne()\n non_pad_mask = gold.ne(self.constants.PAD)\n loss = -(one_hot * log_prb).sum(dim=1)\n # losses are averaged later\n loss = loss.masked_select(non_pad_mask).sum()\n else:\n loss = F.cross_entropy(\n pred, gold, ignore_index=self.constants.PAD, reduction='sum')\n return loss","def lfads_training_loss(params, lfads_hps, key, x_bxt, kl_scale, keep_rate):\n losses = lfads_losses(params, lfads_hps, key, x_bxt, kl_scale, keep_rate)\n return losses['total']","def loss_function(self, train_head, train_tail, train_relation, train_head_corrupted, train_tail_corrupted):\n\n # train_head = tf.nn.l2_normalize(train_head, 1)\n # train_tail = tf.nn.l2_normalize(train_tail, 1)\n # train_head_corrupted = tf.nn.l2_normalize(train_head_corrupted, 1)\n # train_tail_corrupted = tf.nn.l2_normalize(train_tail_corrupted, 1)\n\n # loss = tf.reduce_mean(\n # tf.maximum(self.dict_paras['margin']\n # + self.distance(tf.add(train_head, train_relation), train_tail)\n # - self.distance(tf.add(train_head_corrupted, train_relation), train_tail_corrupted), 0.))\n\n loss = tf.reduce_mean(self.distance(tf.add(train_head, train_relation), train_tail))\n\n return loss","def compute_loss(self):\n def calc_loss(inputs, outputs):\n reconstruction_loss = tf.metrics.binary_crossentropy(\n tf_flat(inputs), tf_flat(outputs))\n reconstruction_loss *= OUT_SIZE * OUT_SIZE\n kl_loss = -0.5 * tf.reduce_sum(1.0 + self.log_sigma - tf.square(\n self.mu) - tf.exp(self.log_sigma), 1)\n return tf.reduce_mean(reconstruction_loss + kl_loss)\n return calc_loss","def calculate_loss(self, word_inputs, feature_inputs, word_seq_lengths, char_inputs, char_seq_lengths, \\\r\n char_seq_recover, batch_label, mask, vfeature_input, v_modal_label, t_modal_label, v_mask, alpha=0):\r\n outs, textual_clf_outputs, visual_clf_outputs = self._get_lstm_features(word_inputs, feature_inputs,\r\n word_seq_lengths, char_inputs,\r\n char_seq_lengths, char_seq_recover,\r\n vfeature_input, v_mask, alpha)\r\n batch_size = word_inputs.size(0)\r\n seq_len = word_inputs.size(1)\r\n # crf\r\n ner_loss = self.crf.neg_log_likelihood_loss(outs, mask, batch_label)\r\n scores, tag_seq = self.crf._viterbi_decode(outs, mask) # batch,\r\n if self.average_batch:\r\n ner_loss = ner_loss / batch_size\r\n\r\n # modal clf loss\r\n # visual_clf_outputs: (obj*b, 2) mask (b, obj) ->\r\n visual_loss = self.modal_clf_loss(visual_clf_outputs, v_modal_label)\r\n textual_loss = self.modal_clf_loss(textual_clf_outputs, t_modal_label)\r\n\r\n total_loss = self.ner_loss_lambda * ner_loss + self.v_loss_lambda * visual_loss \\\r\n + self.t_loss_lambda * textual_loss\r\n\r\n return total_loss, \\\r\n self.ner_loss_lambda * ner_loss, \\\r\n self.t_loss_lambda * textual_loss, \\\r\n self.v_loss_lambda * visual_loss, \\\r\n tag_seq, textual_clf_outputs, visual_clf_outputs","def compute_loss(self):\n self.prototypes = self.compute_prototypes()\n self.test_logits = self.compute_logits()\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(\n labels=self.episode.test_labels, logits=self.test_logits)\n cross_entropy_loss = tf.reduce_mean(loss)\n regularization = tf.reduce_sum(\n tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))\n loss = cross_entropy_loss + self.weight_decay * regularization\n return loss","def loss_fn(params):\n logits = models.ProgramTransformer(config).apply(\n {'params': params},\n inputs,\n outputs,\n programs,\n rngs={'dropout': train_rng})\n loss, weight_sum = compute_weighted_cross_entropy(logits, programs, weights)\n mean_loss = loss / weight_sum\n return mean_loss, logits","def _compute_loss(self, decoder_output, labels):\n with tf.name_scope(\"compute_loss\"):\n language_logit = decoder_output.logits[0]\n attention_logit = decoder_output.logits[1]\n batch_size = self.params['dataset']['batch_size']\n\n language_losses = self._cross_entropy_sequence_loss(\n logits=language_logit,\n targets=tf.transpose(labels[\"label\"], [1, 0]),\n sequence_length=labels[\"length\"])\n attention_losses = self._cross_entropy_sequence_loss(\n logits=attention_logit,\n targets=tf.transpose(labels[\"label\"], [1, 0]),\n sequence_length=labels[\"length\"])\n\n language_loss = tf.reduce_sum(language_losses) / batch_size\n attention_loss = tf.reduce_sum(attention_losses) / batch_size\n loss = language_loss + attention_loss\n\n return loss","def _calc_loss(self, fvs, labels, w, b):\n\n loss = 0.5 * self.lda * (np.linalg.norm(w) ** 2)\n tmp = sum(map(lambda x, y: (x - y) ** 2, fvs.dot(w) + b, labels))\n loss += tmp / fvs.shape[0]\n\n return loss","def compute_loss(self, targets, logits, seq_length):\n\n\t\twith tf.name_scope('evaluate_loss'):\n\t\t\tloss, norm = self.loss_computer(targets, logits, seq_length)\n\t\t\t\n\t\treturn loss, norm","def _compute_loss(self, parameters, inputs, ground_truth):\n predictions = self.network_forward(parameters, inputs)\n loss = np.mean((ground_truth - predictions) ** 2)\n return loss","def _compute_loss(self, parameters, inputs, ground_truth):\n predictions = self.network_forward(parameters, inputs)\n loss = np.mean((ground_truth - predictions) ** 2)\n return loss","def _create_loss_op(self):\n # 1.) The reconstruction loss, which forces the NN towards reconstructing more accurately the\n # given input. This function is configurable, but usually it is the Bernoulli negative log-likelihood.\n if self.cost_function == 'abs':\n reconstr_loss = tf.reduce_sum(tf.abs(self.x_decoded - self.x_in), 1)\n elif self.cost_function in ('mse', 'l2', 'square'):\n reconstr_loss = tf.reduce_sum(tf.squared_difference(self.x_in, self.x_decoded), 1)\n elif self.cost_function in ('xentropy', 'log'):\n reconstr_loss = \\\n -tf.reduce_sum(self.x_in * tf.log(1e-10 + self.x_decoded)\n + (1 - self.x_in) * tf.log(1e-10 + 1 - self.x_decoded),\n 1)\n else:\n raise ValueError(self.cost_function, \"Unknown cost function name!\")\n\n # 2.) The latent loss, which is defined as the Kullback Leibler divergence\n ## between the distribution in latent space induced by the encoder on\n # the data and some prior. This acts as a kind of regularizer.\n # This can be interpreted as the number of \"nats\" required\n # for transmitting the the latent space distribution given\n # the prior.\n latent_loss = -0.5 * tf.reduce_sum(1. + self.z_log_sigma_sq\n - tf.square(self.z_mean)\n - tf.exp(self.z_log_sigma_sq), 1)\n\n self.loss_op = tf.reduce_mean(reconstr_loss + latent_loss) # average over batch\n tf.add_to_collection(\"losses\", self.loss_op)\n\n if self.learning_rate is not None:\n global_step = tf.train.get_or_create_global_step()\n self.train_op = tf.train.AdamOptimizer(learning_rate=self.learning_rate).minimize(\n self.loss_op,\n global_step=global_step,\n var_list=tf.get_collection(self.training_scope) if self.training_scope is not None else None)\n\n tf.add_to_collection(\"train_ops\", self.train_op)\n tf_logging.info(\"Added AdamOptimizer with learning rate: %.8f\" % self.learning_rate)\n\n tf.summary.scalar(\"latent_loss\", tf.reduce_mean(latent_loss))\n tf.summary.scalar(\"reconstruction_loss\", tf.reduce_mean(reconstr_loss))\n tf.summary.scalar(\"vae_loss\", self.loss_op)","def _training_loss(features,\n labels,\n logits,\n loss_fn,\n weight_column_name=None,\n head_name=None):\n with ops.name_scope(None, \"training_loss\",\n tuple(six.itervalues(features)) +\n (labels, logits)) as name:\n loss, weighted_average_loss = _loss(\n loss_fn(logits, labels),\n _weight_tensor(features, weight_column_name),\n name=name)\n # The tag must be same as the tag for eval loss, so the losses will show up\n # in the same graph in tensorboard.\n logging_ops.scalar_summary(\n _summary_key(head_name, \"loss\"), weighted_average_loss)\n return loss","def _compute_loss(self):\n state, action, reward, next_state, done = self.replay_buffer.sample(self.batch_size)\n\n state = torch.FloatTensor(state)\n next_state = torch.FloatTensor(next_state)\n action = torch.LongTensor(action)\n reward = torch.FloatTensor(reward)\n done = torch.FloatTensor(done)\n\n q_values = self.dqn(state)\n q_value = q_values.gather(1, action.unsqueeze(1)).squeeze(1)\n\n next_q_values = self.target_dqn(next_state)\n next_q_value = next_q_values.max(1)[0]\n target = reward + self.discount_factor * next_q_value * (1 - done)\n\n # loss = F.smooth_l1_loss(q_value, target.detach())\n loss = F.mse_loss(q_value, target.detach())\n\n return loss","def loss_fn(self, recons, inputs, mu, log_var, **kwargs):\n# kld_weight = kwargs['M_N'] # Account for the minibatch samples from the dataset\n recons_loss = F.mse_loss(recons, inputs)\n# recons_loss = F.binary_cross_entropy(recons, inputs)\n KLD = torch.mean(-0.5 * torch.sum(1 + log_var - mu**2 - log_var.exp(), dim=1), dim=0)\n loss = recons_loss - KLD\n return loss, recons_loss, KLD","def dnn_loss_calculation(self, labeled_examples, labels):\n predicted_labels, _ = self.DNN(labeled_examples)\n labeled_loss = self.labeled_loss_function(predicted_labels, labels, order=self.settings.labeled_loss_order)\n labeled_loss *= self.settings.labeled_loss_multiplier\n return labeled_loss","def calculate_training_loss(self):\n self.network.train()\n self.training_average_loss = self.calculate_average_loss(self.training_dataloader)","def loss(self, labels, input_data):\n\n pred, out = self.inference(input_data)\n loss = tf.reduce_mean(tf.losses.sparse_softmax_cross_entropy(labels, out), name=\"loss\") + \\\n tf.losses.get_regularization_loss()\n return loss, pred","def calc_loss(predictions, labels):\n return np.mean(np.square(predictions - labels))","def labeled_loss_calculation(self, labeled_examples, labels):\n predicted_labels, _ = self.D(labeled_examples)\n labeled_loss = self.labeled_loss_function(predicted_labels, labels, order=self.settings.labeled_loss_order)\n labeled_loss *= self.settings.labeled_loss_multiplier\n return labeled_loss","def calc_loss(self, outputs, labels):\n information_loss = self.bottleneck.buffer_capacity.mean() # Taking the mean is equivalent of scaling with 1/K\n cross_entropy = F.cross_entropy(outputs, target=labels)\n total = cross_entropy + self.beta * information_loss\n self.ce_loss.append(cross_entropy.cpu().detach().numpy())\n self.info_loss.append(information_loss.cpu().detach().numpy())\n self.total_loss.append(total.cpu().detach().numpy())\n return total","def loss_fn(self, targets, outputs, model):","def loss_function(cls, logits, label, targeted):\n\n if targeted:\n adv_loss = - torch.gather(logits, 1, label)\n else:\n adv_loss = torch.gather(logits, 1, label)\n\n return adv_loss.mean()","def loss(self, features: Tensor, tags: Tensor, masks: Tensor):\n \n features = self.linear(features)\n T = features.size(1)\n masks_ = masks[:, :T].float()\n forward_score = self.forward_algorithm(features, masks_)\n gold_score = self._score(features, tags[:, :T].long(), masks_)\n loss = (forward_score - gold_score).mean()\n return loss","def loss_fn(\n model_config: ml_collections.FrozenConfigDict,\n model_params: Dict[str, Any],\n model_vars: Dict[str, Any], # pylint: disable=unused-argument\n batch: Dict[str, Any],\n deterministic: bool,\n dropout_rng: Optional[Dict[str, Array]] = None,\n ) -> Tuple[float, MetricGroups, Dict[str, Any]]:\n\n batch_size = batch['text_ids'].shape[0]\n loss_helpers, logging_helpers = cls.build_model(model_config).apply( # pylint: disable=unused-variable\n {'params': model_params},\n batch,\n deterministic=deterministic,\n rngs=dropout_rng)\n mention_target_is_masked = batch['mention_target_is_masked']\n mention_target_is_not_masked = 1 - batch['mention_target_is_masked']\n mention_target_ids = batch['mention_target_ids']\n mention_target_ids = mention_target_ids * batch['mention_target_weights']\n\n mlm_logits = loss_helpers['mlm_logits']\n\n mlm_loss, mlm_denom = metric_utils.compute_weighted_cross_entropy(\n mlm_logits, batch['mlm_target_ids'], batch['mlm_target_weights'])\n\n mlm_correct_mask = jnp.equal(\n jnp.argmax(mlm_logits, axis=-1),\n batch['mlm_target_ids']) * batch['mlm_target_weights']\n mlm_acc = mlm_correct_mask.sum()\n mlm_mention_acc = (mlm_correct_mask *\n batch['mlm_target_is_mention']).sum()\n mlm_mention_denom = (batch['mlm_target_weights'] *\n batch['mlm_target_is_mention']).sum()\n mlm_non_mention_acc = (mlm_correct_mask *\n (1 - batch['mlm_target_is_mention'])).sum()\n mlm_non_mention_denom = (batch['mlm_target_weights'] *\n (1 - batch['mlm_target_is_mention'])).sum()\n\n metrics = {\n 'mlm': {\n 'loss': mlm_loss,\n 'acc': mlm_acc,\n 'denominator': mlm_denom,\n },\n 'mlm_mention': {\n 'acc': mlm_mention_acc,\n 'denominator': mlm_mention_denom,\n },\n 'mlm_non_mention': {\n 'acc': mlm_non_mention_acc,\n 'denominator': mlm_non_mention_denom,\n },\n }\n\n if 'intermediate_mention_encodings' in loss_helpers:\n intermediate_target_mention_encodings = jut.matmul_slice(\n loss_helpers['intermediate_mention_encodings'],\n batch['mention_target_indices'])\n else:\n intermediate_target_mention_encodings = loss_helpers[\n 'im_target_mention_encodings']\n\n if model_config.encoder_config.get('no_entity_attention', False):\n (el_im_loss, el_im_metrics,\n (el_im_acc_per_mention,\n el_im_weight_per_mention)) = mention_losses.entity_linking_loss(\n intermediate_target_mention_encodings,\n loss_helpers['entity_embeddings'], mention_target_ids,\n batch['mention_target_weights'], el_score_mode)\n el_im_denom = el_im_metrics['denominator']\n metrics['el_intermediate'] = el_im_metrics\n metrics['el_intermediate_masked'] = {\n 'acc':\n jnp.dot(el_im_acc_per_mention,\n el_im_weight_per_mention * mention_target_is_masked),\n 'denominator':\n jnp.dot(el_im_weight_per_mention, mention_target_is_not_masked),\n }\n metrics['el_intermediate_non_masked'] = {\n 'acc':\n jnp.dot(el_im_acc_per_mention,\n el_im_weight_per_mention * mention_target_is_masked),\n 'denominator':\n jnp.dot(el_im_weight_per_mention, mention_target_is_not_masked),\n }\n else:\n intermediate_entity_attention = loss_helpers[\n 'intermediate_entity_attention']\n\n # Construct targets and ids for intermediate entity linking loss\n intermediate_target_ids = jnp.zeros_like(batch['mention_mask'])\n intermediate_target_ids = intermediate_target_ids.at[\n batch['mention_target_indices']].add(\n mention_target_ids * batch['mention_target_weights'])\n\n intermediate_target_weights = jnp.zeros_like(\n batch['mention_mask'], dtype=intermediate_entity_attention.dtype)\n intermediate_target_weights = intermediate_target_weights.at[\n batch['mention_target_indices']].add(\n batch['mention_target_weights'])\n\n mention_is_masked = jnp.zeros_like(batch['mention_mask'])\n mention_is_masked = mention_is_masked.at[\n batch['mention_target_indices']].add(\n mention_target_is_masked * batch['mention_target_weights'])\n\n el_im_loss, el_im_denom = metric_utils.compute_weighted_cross_entropy(\n intermediate_entity_attention,\n intermediate_target_ids,\n intermediate_target_weights,\n inputs_are_prob=True)\n\n el_im_correct_mask = jnp.equal(\n jnp.argmax(intermediate_entity_attention, axis=-1),\n intermediate_target_ids) * intermediate_target_weights\n el_im_acc = el_im_correct_mask.sum()\n\n el_im_acc, _ = metric_utils.compute_weighted_accuracy(\n intermediate_entity_attention, intermediate_target_ids,\n intermediate_target_weights)\n\n intermediate_entity_cos_sim = loss_helpers[\n 'intermediate_entity_cos_sim'][batch['mention_target_indices'],\n mention_target_ids]\n\n metrics['el_intermediate'] = {\n 'loss':\n el_im_loss,\n 'acc':\n el_im_acc,\n 'cos_sim':\n jnp.dot(intermediate_entity_cos_sim,\n batch['mention_target_weights']),\n 'denominator':\n el_im_denom,\n }\n metrics['el_intermediate_masked'] = {\n 'acc':\n jnp.dot(el_im_correct_mask, mention_is_masked),\n 'denominator':\n jnp.dot(batch['mention_target_weights'],\n batch['mention_target_is_masked']),\n }\n metrics['el_intermediate_non_masked'] = {\n 'acc':\n jnp.dot(el_im_correct_mask, (1 - mention_is_masked)),\n 'denominator':\n jnp.dot(batch['mention_target_weights'],\n (1 - batch['mention_target_is_masked'])),\n }\n\n im_final_mention_encodings_cos_sim = jut.cosine_similarity(\n intermediate_target_mention_encodings,\n loss_helpers['target_mention_encodings'])\n metrics['im_final_mention_encodings'] = {\n 'cos_sim':\n jnp.dot(im_final_mention_encodings_cos_sim,\n batch['mention_target_weights']),\n 'denominator':\n batch['mention_target_weights'].sum(),\n }\n\n (el_final_loss, el_final_metrics,\n (el_final_acc_per_mention,\n el_final_weight_per_mention)) = mention_losses.entity_linking_loss(\n loss_helpers['target_mention_encodings'],\n loss_helpers['entity_embeddings'], mention_target_ids,\n batch['mention_target_weights'], el_score_mode)\n el_final_denom = el_final_metrics['denominator']\n metrics['el_final'] = el_final_metrics\n metrics['el_final_masked'] = {\n 'acc':\n jnp.dot(el_final_acc_per_mention,\n el_final_weight_per_mention * mention_target_is_masked),\n 'denominator':\n jnp.dot(el_final_weight_per_mention, mention_target_is_masked),\n }\n metrics['el_final_non_masked'] = {\n 'acc':\n jnp.dot(\n el_final_acc_per_mention,\n el_final_weight_per_mention * mention_target_is_not_masked),\n 'denominator':\n jnp.dot(el_final_weight_per_mention,\n mention_target_is_not_masked),\n }\n\n loss = mlm_weight * mlm_loss / mlm_denom\n loss += el_im_weight * el_im_loss / el_im_denom\n loss += el_final_weight * el_final_loss / el_final_denom\n\n if mtb_im_weight > 0:\n (mtb_im_loss, mtb_im_metrics) = mention_losses.mtb_loss(\n intermediate_target_mention_encodings,\n batch['mention_target_batch_positions'], mention_target_ids,\n batch_size, mtb_score_mode, mention_target_is_masked, 'im_')\n mtb_im_denom = mtb_im_metrics['im_mtb']['denominator']\n loss += mtb_im_weight * mtb_im_loss / mtb_im_denom\n metrics.update(mtb_im_metrics)\n\n if mtb_final_weight > 0:\n (mtb_final_loss, mtb_final_metrics) = mention_losses.mtb_loss(\n loss_helpers['target_mention_encodings'],\n batch['mention_target_batch_positions'], mention_target_ids,\n batch_size, mtb_score_mode, mention_target_is_masked, 'final_')\n mtb_final_denom = mtb_final_metrics['final_mtb']['denominator']\n loss += mtb_final_weight * mtb_final_loss / mtb_final_denom\n metrics.update(mtb_final_metrics)\n\n metrics['agg'] = {\n 'loss': loss,\n 'denominator': 1.0,\n }\n return loss, metrics, {} # pytype: disable=bad-return-type # jax-ndarray","def compute_loss(self):","def model_loss(inp, fake, real_label, fake_label):\n \n \n Dreal,realcls,R1 = gradpen(inp)\n [Dfake,fakecls] = D(fake)\n # 1. Adversarial loss\n \n glabel = tf.ones_like(Dfake)#tf.random.uniform((Dfake.shape), 1-LN, 1)\n dlabelr = tf.ones_like(Dreal)#tf.random.uniform((Dreal.shape), 1-LN, 1)\n dlabelf = tf.zeros_like(Dfake)#tf.random.uniform((Dfake.shape), 0, LN)\n \n \n \n # D has no sigmoid activation: \"from_logits=True\"\n real_loss = tf.keras.losses.binary_crossentropy(\n dlabelr, Dreal, from_logits=True)\n real_loss = tf.reduce_mean(real_loss)\n \n fake_loss = tf.keras.losses.binary_crossentropy(\n dlabelf, Dfake, from_logits=True)\n fake_loss = tf.reduce_mean(fake_loss)\n \n Dadv = 0.5*(real_loss+fake_loss)\n \n Gadv = tf.keras.losses.binary_crossentropy(\n glabel, Dfake, from_logits=True)\n Gadv = tf.reduce_mean(Gadv)\n \n # 2. Classification loss\n \n Dcls = tf.keras.losses.binary_crossentropy(real_label, realcls, from_logits=True)\n Dcls = tf.reduce_mean(Dcls)\n \n Gcls = tf.keras.losses.binary_crossentropy(fake_label, fakecls, from_logits=True)\n Gcls = tf.reduce_mean(Gcls)\n \n # 3. Total loss\n \n Dloss = Dadv + (GAMMA/2)*R1 + LAMBDA_CLS*Dcls\n \n Gloss = Gadv + LAMBDA_CLS*Gcls\n \n return (Dloss, Dadv, Dcls, R1), (Gloss, Gadv, Gcls)","def compute_loss(self, text, mel_in, mel_target):\n y, ylogit , a = self.forward(text, mel_in)\n\n # compute loss\n l1_loss = F.mse_loss(y, mel_target)\n bin_loss = F.binary_cross_entropy_with_logits(ylogit, mel_target)\n # now attention loss\n N = text.shape[-1]\n T = mel_in.shape[-1]\n def w_fun(n, t):\n return 1 - np.exp(-((n/(N-1) - t/(T-1))**2) / (2 * self.hp.g**2))\n w = np.fromfunction(w_fun, (a.shape[1], T), dtype='f')\n w = torch.from_numpy(w).to(self.device)\n loss_att = (w * a[:, :, :T]).mean()\n loss = l1_loss + bin_loss + loss_att\n return loss, y, a","def get_loss(self):\r\n\r\n if F.loss_type==\"cosine\":\r\n self.losscos = r2d*tf.acos(1-tf.losses.cosine_distance(tf.nn.l2_normalize(self.labels,1), tf.nn.l2_normalize(self.out, 1), dim=1))\r\n self.loss = tf.losses.cosine_distance(tf.nn.l2_normalize(self.labels,1), tf.nn.l2_normalize(self.out, 1), dim=1)\r\n elif F.loss_type==\"mse2d\":\r\n xl, yl, zl = tf.split(self.labels, 3, axis=1)\r\n xo, yo, zo = tf.split(self.out, 3, axis=1)\r\n thetal, thetao = tf.asin(-yl), tf.asin(-yo)\r\n phil, phio = tf.atan2(-zl, -xl), tf.atan2(-zo, -xo)\r\n self.lb = tf.concat([thetal, phil], axis=1)\r\n self.ob = tf.concat([thetao, phio], axis=1)\r\n self.loss = tf.scalar_mul(tf.constant(r2d), tf.losses.mean_squared_error(self.lb, self.ob, 2))\r\n elif F.loss_type==\"mse3d\":\r\n self.loss = tf.losses.mean_squared_error(tf.nn.l2_normalize(self.labels, 0), tf.nn.l2_normalize(self.out, 0))","def get_loss(self, criterion, target, preds, epoch=0):\n assert isinstance(target, dict)\n assert isinstance(preds, dict)\n assert isinstance(criterion, dict)\n\n loss = {\"total\": 0, \"all_class\": 0}\n\n for key in target[\"class\"].keys():\n labels = target[\"class\"][key]\n batch_size = target[\"class\"][key].shape[0]\n loss[key] = criterion[\"crossentropy\"](preds[key], labels)\n loss[\"all_class\"] += loss[key]\n\n loss[\"total\"] += loss[\"all_class\"]\n\n if self.use_attention and not self.cfg.model.attention.use_fixed:\n if self.training and epoch + 1 < self.cfg.model.attention.decay_step:\n prior_multiplier = 0\n contrast_multiplier = 0\n entropy_multiplier = 0\n else:\n prior_multiplier = self.cfg.model.attention.wt_decay\n contrast_multiplier = self.cfg.model.attention.contrast_decay\n entropy_multiplier = self.cfg.model.attention.entropy_decay\n\n wts = preds[\"weights\"].squeeze(1)\n\n if self.cfg.model.attention.use_prior:\n b, n, _, _ = target[\"weights\"].shape\n assert wts.shape[0] == b * n\n prior = target[\"weights\"].reshape(b * n, -1)\n if self.cfg.model.attention.wt_loss == \"kl\":\n wts = torch.log(wts + 1e-7)\n loss[\"prior\"] = criterion[\"prior\"](wts, prior)\n loss[\"total\"] += prior_multiplier * loss[\"prior\"]\n if self.cfg.model.attention.use_contrast:\n loss[\"contrast\"] = criterion[\"contrast\"](wts)\n loss[\"total\"] += contrast_multiplier * loss[\"contrast\"]\n if self.cfg.model.attention.use_entropy:\n loss[\"entropy\"] = Categorical(probs=wts + 1e-6).entropy().mean()\n # if the loss minimization goes below threshold, stop training with entropy loss\n if (\n self.training\n and entropy_multiplier > 0\n and loss[\"entropy\"] < self.cfg.model.attention.entropy_thresh\n ):\n entropy_multiplier = 0\n loss[\"total\"] += entropy_multiplier * loss[\"entropy\"]\n\n return loss, batch_size","def loss(self, prediction_dict, gt_boxes_list, gt_labels_list):\n with tf.name_scope(None, 'Loss', prediction_dict.values()):\n (batch_cls_targets, batch_cls_weights, batch_reg_targets, batch_reg_weights,\n match_list) = self._assign_targets(gt_boxes_list, gt_labels_list)\n # num_positives = [tf.reduce_sum(tf.cast(tf.not_equal(matches.match_results, -1), tf.float32))\n # for matches in match_list]\n self._summarize_target_assignment(gt_boxes_list, match_list)\n reg_loss = regression_loss(prediction_dict[\"box_pred\"], batch_reg_targets, batch_reg_weights)\n cls_loss = focal_loss(prediction_dict[\"cls_pred\"], batch_cls_targets, batch_cls_weights)\n # normalize loss by num of matches\n # num_pos_anchors = [tf.reduce_sum(tf.cast(tf.not_equal(match.match_results, -1), tf.float32))\n # for match in match_list]\n normalizer = tf.maximum(tf.to_float(tf.reduce_sum(batch_reg_weights)), 1.0)\n # normalize reg loss by box codesize (here is 4)\n reg_normalizer = normalizer * 4\n normalized_reg_loss = tf.multiply(reg_loss, 1.0/reg_normalizer, name=\"regression_loss\")\n normalized_cls_loss = tf.multiply(cls_loss, 1.0/normalizer, name=\"classification_loss\")\n return normalized_reg_loss, normalized_cls_loss, batch_reg_weights, batch_cls_weights","def pseudo_loss(self, params, batches):\n loss = 0\n for batch in batches:\n states = batch[\"states\"]\n actions = batch[\"actions\"]\n returns = batch[\"returns\"]\n\n preds = self.predict_jax(params, states)\n\n baseline = jnp.mean(returns, axis=0)\n preds_select = jnp.take_along_axis(preds, jnp.expand_dims(actions, axis=2), axis=2).squeeze()\n loss += (-jnp.mean(jnp.sum(preds_select * (returns - baseline))))\n\n return loss + self.l2_regularizer(params, 0.001) # try to divide by len(batches)?","def build_loss(self):\n\n opt = tf.train.AdamOptimizer(self.learning_rate)\n mse = tf.losses.mean_squared_error(self.label[-1], self.outputs[-1])\n loss = tf.losses.get_total_loss()\n\n return mse, loss","def get_style_loss(features, targets):\n ### START CODE HERE ###\n \n # Calculate the style loss\n style_loss = tf.reduce_mean(tf.square(features - targets))\n \n ### END CODE HERE ###\n return style_loss","def loss_function(self, targets, outputs):\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=targets, logits=outputs)\n return tf.reduce_mean(cross_entropy)","def full_loss(preds, targets, chamfer_lambda, physical_lambda, has_anno=None, joint_idxs=None):\n\n coords_pred = preds[2]\n if has_anno is not None:\n coords_pred = coords_pred[has_anno]\n if joint_idxs is not None:\n coords_pred = coords_pred[:, joint_idxs]\n\n # Coord Loss Only\n coord_loss = F.mse_loss(coords_pred, targets[0])\n loss = coord_loss\n\n # Chamfer Loss\n # with torch.no_grad():\n # coord_loss = F.mse_loss(coords_pred, targets[0])\n dist1, idx1, dist2, idx2, _ = chamfer_dist(preds[0], targets[1])\n chamfer_loss = (dist1 + dist2).mean()\n # loss = chamfer_lambda * chamfer_loss + coord_loss\n # loss = chamfer_loss\n\n # Physical loss\n p_loss = physical_loss(preds[6])\n # loss += (physical_lambda * p_loss)\n\n return loss, coord_loss, chamfer_loss, p_loss","def compute_loss(self,\n inputs: Union[\n # Tuple of (features, labels).\n Tuple[\n Dict[str, tf.Tensor],\n tf.Tensor\n ],\n # Tuple of (features, labels, sample weights).\n Tuple[\n Dict[str, tf.Tensor],\n tf.Tensor,\n Optional[tf.Tensor]\n ]\n ],\n training: bool = False) -> tf.Tensor:\n\n # We need to work around a bug in mypy - tuple narrowing\n # based on length checks doesn't work.\n # See https://github.com/python/mypy/issues/1178 for details.\n if len(inputs) == 2:\n inputs = cast(\n Tuple[\n Dict[str, tf.Tensor],\n tf.Tensor\n ],\n inputs\n )\n features, labels = inputs\n sample_weight = None\n elif len(inputs) == 3:\n inputs = cast(\n Tuple[\n Dict[str, tf.Tensor],\n tf.Tensor,\n Optional[tf.Tensor],\n ],\n inputs\n )\n features, labels, sample_weight = inputs\n else:\n raise ValueError(\n \"Inputs should either be a tuple of (features, labels), \"\n \"or a tuple of (features, labels, sample weights). \"\n \"Got a length {len(inputs)} tuple instead: {inputs}.\"\n )\n\n outputs = self(features, training=training)\n\n loss = self._task(labels, outputs, sample_weight=sample_weight)\n loss = tf.reduce_mean(loss)\n # Scales loss as the default gradients allreduce performs sum inside the\n # optimizer.\n return loss / tf.distribute.get_strategy().num_replicas_in_sync","def loss_fn(model):\n with flax.nn.stateful(state) as new_state:\n with flax.nn.stochastic(prng_key):\n logits = model(batch['image'])\n loss = cross_entropy_loss(logits, batch['label'])\n # TODO(britefury): check if applying L2 regularization to weights but\n # *not* biases improves results\n weight_penalty_params = jax.tree_leaves(model.params)\n weight_l2 = sum([jnp.sum(x ** 2)\n for x in weight_penalty_params\n if x.ndim > 1])\n weight_penalty = l2_reg * 0.5 * weight_l2\n loss = loss + weight_penalty\n return loss, (new_state, logits)","def compute_loss(self, model, inputs, return_outputs=False):\n # global cnt, align_list1, align_list2, op\n word_loss = torch.nn.MSELoss(reduction='sum')\n outputs = model(**inputs)\n # We don't use .loss here since the model may return tuples instead of ModelOutput.\n loss = outputs[\"loss\"] if isinstance(outputs, dict) else outputs[0]\n # if align_list1:\n if self.args.align_list1:\n new_loss = 0.5 * word_loss(\n model.bert.embeddings.word_embeddings(\n torch.tensor([self.args.align_list1], dtype=torch.long).to(self.args.device)),\n model.bert.embeddings.word_embeddings(\n torch.tensor([self.args.align_list2], dtype=torch.long).to(self.args.device)),\n )\n loss = loss + new_loss\n self.args.improve_cnt += 1\n if self.args.improve_cnt >= 500 and self.args.improve_cnt % 500 == 0 and len(self.args.align_list1) == 50:\n self.args.align_list1, self.args.align_list2 = get_list(self.args.improve_op,\n model,\n self.args.improve_cnt)\n return (loss, outputs) if return_outputs else loss","def loss_fn(outputs, labels, wts):\n\n # reshape labels to give a flat vector of length batch_size*seq_len\n loss_noreduce = nn.BCEWithLogitsLoss(reduce=False)\n loss = torch.mean(loss_noreduce(outputs, labels)*wts)\n\t\n # compute cross entropy loss for all tokens\n return loss","def compute_loss(self, sample):\n observations_batch, actions_batch, return_batch, masks_batch, \\\n old_action_log_probs_batch, adv_targ = sample\n\n assert old_action_log_probs_batch.shape == (self.mini_batch_size, 1)\n assert adv_targ.shape == (self.mini_batch_size, 1)\n assert return_batch.shape == (self.mini_batch_size, 1)\n\n values, action_log_probs, dist_entropy = self.evaluate_actions(\n observations_batch, actions_batch)\n\n assert values.shape == (self.mini_batch_size, 1)\n assert action_log_probs.shape == (self.mini_batch_size, 1)\n assert values.requires_grad\n assert action_log_probs.requires_grad\n assert dist_entropy.requires_grad\n\n # [TODO] Implement policy loss\n ratio = torch.exp(action_log_probs - old_action_log_probs_batch)\n surr1 = ratio * adv_targ\n surr2 = torch.clamp(ratio, 1.0 - self.clip_param, 1.0 + self.clip_param) * adv_targ\n policy_loss = -torch.min(surr1, surr2).mean()\n\n # [TODO] Implement value loss\n value_loss = F.mse_loss(return_batch, values)\n\n # This is the total loss\n loss = policy_loss + self.config.value_loss_weight * value_loss - self.config.entropy_loss_weight * dist_entropy\n\n return loss, policy_loss, value_loss, dist_entropy","def loss(logits, labels):\n with tf.name_scope('loss'):\n char_pre = tf.reshape(logits[:, :, :, 0], -1, name='char_pre')\n aff_pre = tf.reshape(logits[:, :, :, 1], -1, name='aff_pre')\n char_gt = tf.reshape(labels[:, :, :, 0], -1, name='char_gt')\n aff_gt = tf.reshape(labels[:, :, :, 1], -1, name='aff_gt')\n char_loss = tf.norm(tf.subtract(char_pre, char_gt))\n aff_loss = tf.norm(tf.subtract(aff_pre, aff_gt))\n loss = tf.reduce_mean(-tf.reduce_sum(tf.add(char_loss, aff_loss)))\n return loss","def compute_loss(self, **kwargs):\n raise NotImplementedError","def add_loss_op(self, pred):\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(\n labels=self.labels_placeholder,\n logits=pred,\n name=\"loss\"\n )\n loss = tf.reduce_mean(loss)\n\n return loss","def _total_loss(self, inputs, logits, labels, image_size, is_training=None):\n if self.cfg.WITH_RECONSTRUCTION:\n loss, classifier_loss, reconstruct_loss, reconstructed_images = \\\n self._loss_with_rec(\n inputs, logits, labels, image_size, is_training=is_training)\n else:\n loss = self._loss_without_rec(logits, labels)\n classifier_loss, reconstruct_loss, reconstructed_images = \\\n None, None, None\n\n loss = tf.identity(loss, name='loss')\n\n return loss, classifier_loss, reconstruct_loss, reconstructed_images","def _get_ner_loss(self):\n # per example loss\n no_entity_id = self.config[\"model\"][\"ner\"][\"no_entity_id\"]\n logits_shape = tf.shape(self.ner_logits_train)\n labels_shape = logits_shape[:3]\n labels = get_dense_labels_from_indices(indices=self.ner_labels_ph, shape=labels_shape, no_label_id=no_entity_id)\n per_example_loss = tf.nn.sparse_softmax_cross_entropy_with_logits(\n labels=labels, logits=self.ner_logits_train\n ) # [batch_size, num_tokens, num_tokens]\n\n # mask\n maxlen = logits_shape[1]\n span_mask = upper_triangular(maxlen, dtype=tf.float32)\n sequence_mask = tf.sequence_mask(self.num_tokens_ph, dtype=tf.float32) # [batch_size, num_tokens]\n mask = span_mask[None, :, :] * sequence_mask[:, None, :] * sequence_mask[:, :, None] # [batch_size, num_tokens, num_tokens]\n\n masked_per_example_loss = per_example_loss * mask\n total_loss = tf.reduce_sum(masked_per_example_loss)\n num_valid_spans = tf.cast(tf.reduce_sum(mask), tf.float32)\n loss = total_loss / num_valid_spans\n\n loss *= self.config[\"model\"][\"ner\"][\"loss_coef\"]\n return loss","def calc_entropy_tuning_loss(self, log_probs):\n with torch.no_grad():\n inner_prod = (log_probs + self.target_entropy).detach()\n alpha_loss = -(self.log_alpha * inner_prod).mean()\n return alpha_loss","def forward(self, y_pred: Dict[str, torch.Tensor], target: Union[torch.Tensor, rnn.PackedSequence]) -> torch.Tensor:\n # unpack\n if isinstance(target, rnn.PackedSequence):\n target, lengths = rnn.pad_packed_sequence(target, batch_first=True)\n # batch sizes reside on the CPU by default -> we need to bring them to GPU\n lengths = lengths.to(target.device)\n else:\n lengths = torch.ones(target.size(0), device=target.device, dtype=torch.long) * target.size(1)\n assert not target.requires_grad\n\n # calculate loss with \"none\" reduction\n if target.ndim == 3:\n weight = target[..., 1]\n target = target[..., 0]\n else:\n weight = None\n\n losses = self.loss(y_pred, target)\n # weight samples\n if weight is not None:\n losses = losses * weight.unsqueeze(-1)\n\n # mask loss\n mask = torch.arange(target.size(1), device=target.device).unsqueeze(0) >= lengths.unsqueeze(-1)\n if losses.ndim > 2:\n mask = mask.unsqueeze(-1)\n dim_normalizer = losses.size(-1)\n else:\n dim_normalizer = 1.0\n # reduce to one number\n if self.reduction == \"none\":\n loss = losses.masked_fill(mask, float(\"nan\"))\n else:\n if self.reduction == \"mean\":\n losses = losses.masked_fill(mask, 0.0)\n loss = losses.sum() / lengths.sum() / dim_normalizer\n elif self.reduction == \"sqrt-mean\":\n losses = losses.masked_fill(mask, 0.0)\n loss = losses.sum() / lengths.sum() / dim_normalizer\n loss = loss.sqrt()\n assert not torch.isnan(loss), (\n \"Loss should not be nan - i.e. something went wrong \"\n \"in calculating the loss (e.g. log of a negative number)\"\n )\n assert torch.isfinite(\n loss\n ), \"Loss should not be infinite - i.e. something went wrong (e.g. input is not in log space)\"\n return loss","def add_loss_op(self, preds):\n ### YOUR CODE HERE (~2-4 lines)\n trans = tf.get_variable('trans',\n shape=[Config.n_classes, Config.n_classes],\n initializer=tf.contrib.layers.xavier_initializer())\n log_likelihood, _ = crf_log_likelihood(preds,\n self.labels_placeholder,\n self.length_placeholder,\n trans)\n #log_likelihood = tf.boolean_mask(log_likelihood, self.mask_placeholder)\n loss = tf.reduce_mean(-1.0 * log_likelihood)\n \n ### END YOUR CODE\n return trans, loss","def calculate_loss(self, output, target, redmode = 'mean'):\n\n loss = F.cross_entropy(output, target, reduction = redmode)\n return loss","def loss(loss_name):\n \n def contrastive_loss(y_true, y_pred, margin = 1):\n \"\"\"Implementation of the triplet loss function\n\n\n Contrastive loss = 0.5 * mean( (1-true_value) * square(distance) + true_value * square( max(margin-distance, 0) ))\n\n Args:\n y_true (int): true label, positive pair (same class) -> 0, \n negative pair (different class) -> 1\n \n y_pred (list): python list containing two objects in a pair of tensors:\n left : the encodings for one image data in a pair\n right : the encodings for the other image data in a pair\n margin (float, optional): m > 0 determines how far the embeddings of \n a negative pair should be pushed apart. Defaults to 1.\n\n\n Returns:\n loss (float): real number, value of the loss\n \"\"\"\n\n left = y_pred[0]\n right = y_pred[1]\n\n distance = tf.math.sqrt(tf.math.reduce_sum(tf.math.square(left - right), axis=-1))\n\n loss_positive = tf.math.square(distance)\n loss_negative = tf.math.square(tf.maximum(0., margin - distance))\n \n loss = y_true * loss_negative + (1 - y_true) * loss_positive\n loss = 0.5 * tf.math.reduce_mean(loss)\n\n return loss\n\n def triplet_loss(y_true, y_pred, margin = 1):\n \"\"\"Implementation of the triplet loss function\n\n Arguments:\n y_true : true labels, required when you define a loss in Keras, \n not applied in this function.\n\n y_pred (list): python list containing three objects:\n anchor : the encodings for the anchor data\n positive : the encodings for the positive data (similar to anchor)\n negative : the encodings for the negative data (different from anchor)\n \n margin (float, optional): m > 0 determines how far the embeddings of \n a negative data should be pushed apart. Defaults to 1.\n\n Returns:\n loss (float): real number, value of the loss\n \"\"\"\n\n anchor = y_pred[0]\n positive = y_pred[1]\n negative = y_pred[2]\n\n # squared distance between the anchor and the positive\n pos_dist = tf.math.reduce_sum(tf.math.square(anchor - positive), axis=-1)\n\n # squared distance between the anchor and the negative\n neg_dist = tf.math.reduce_sum(tf.math.square(anchor - negative), axis=-1)\n\n # compute loss\n basic_loss = margin + pos_dist - neg_dist\n loss = tf.math.maximum(basic_loss,0.0)\n loss = tf.math.reduce_mean(loss)\n return loss\n\n \n if loss_name == 'contrastive_loss':\n return contrastive_loss\n \n if loss_name == 'triplet_loss':\n return triplet_loss","def loss(self, top_out, targets, weights_fn=None):\n logits = top_out\n if weights_fn is None:\n weights_fn = self.targets_weights_fn\n return common_layers.padded_cross_entropy(\n logits,\n targets,\n self._model_hparams.label_smoothing,\n weights_fn=weights_fn)","def loss_fn(model):\n with flax.deprecated.nn.stateful() as state:\n with flax.deprecated.nn.stochastic(dropout_rng):\n logits = model(example, train=True)\n loss, weight_sum = compute_weighted_cross_entropy(logits, targets)\n mean_loss = loss / weight_sum\n return mean_loss, (logits, state)","def setup_loss(self):\n with vs.variable_scope(\"loss\"):\n self.loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels=self.label_placeholder, logits=self.label_predictions))","def get_loss(self, inputs, targets, dags):\n if not isinstance(dags, list):\n dags = [dags]\n\n loss = 0\n for dag in dags:\n output = self.shared(inputs, dag)\n sample_loss = (self.model_loss(output, targets) /\n self.args.shared_num_sample)\n loss += sample_loss\n\n loss =loss/len(dags)\n\n return loss","def build_loss(self):\n import tensorflow as tf\n\n y_1d = [tf.reduce_sum(tf.multiply(self.variables[\"y\"][i], self.variables[\"y_action\"][i]), axis=1) for i in range(len(self.variables[\"y\"]))]\n loss = np.sum([tf.nn.l2_loss(y_1d[i] - self.variables[\"y_true\"]) for i in range(len(y_1d))])\n\n l1_reg = 0\n l2_reg = 0\n\n keys = sorted(self.variables.keys())\n keys = [key for key in keys if critere_keys(key) and \"W\" in key]\n for key in keys:\n l1_reg += tf.reduce_sum(tf.abs(self.variables[key]))\n l2_reg += tf.nn.l2_loss(self.variables[key])\n\n self.loss = loss + self.alpha_reg * l1_reg + self.beta_reg * l2_reg\n\n self.train_step = tf.train.RMSPropOptimizer(self.decay_learning_rate,\n decay=0.99, momentum=0., centered=True).minimize(self.loss, global_step=self.global_step)","def make_loss_fn(\n cls, config: ml_collections.ConfigDict\n ) -> Callable[..., Tuple[float, MetricGroups, Dict[str, Any]]]:\n mlm_weight = config.mlm_weight\n el_im_weight = config.el_im_weight\n el_final_weight = config.el_final_weight\n el_score_mode = config.get('el_score_mode', 'dot')\n mtb_im_weight = config.get('mtb_im_weight', 0)\n mtb_final_weight = config.get('mtb_final_weight', 0)\n mtb_score_mode = config.get('mtb_score_mode', 'dot')\n\n def loss_fn(\n model_config: ml_collections.FrozenConfigDict,\n model_params: Dict[str, Any],\n model_vars: Dict[str, Any], # pylint: disable=unused-argument\n batch: Dict[str, Any],\n deterministic: bool,\n dropout_rng: Optional[Dict[str, Array]] = None,\n ) -> Tuple[float, MetricGroups, Dict[str, Any]]:\n \"\"\"Task-specific loss function. See BaseTask.\"\"\"\n\n batch_size = batch['text_ids'].shape[0]\n loss_helpers, logging_helpers = cls.build_model(model_config).apply( # pylint: disable=unused-variable\n {'params': model_params},\n batch,\n deterministic=deterministic,\n rngs=dropout_rng)\n mention_target_is_masked = batch['mention_target_is_masked']\n mention_target_is_not_masked = 1 - batch['mention_target_is_masked']\n mention_target_ids = batch['mention_target_ids']\n mention_target_ids = mention_target_ids * batch['mention_target_weights']\n\n mlm_logits = loss_helpers['mlm_logits']\n\n mlm_loss, mlm_denom = metric_utils.compute_weighted_cross_entropy(\n mlm_logits, batch['mlm_target_ids'], batch['mlm_target_weights'])\n\n mlm_correct_mask = jnp.equal(\n jnp.argmax(mlm_logits, axis=-1),\n batch['mlm_target_ids']) * batch['mlm_target_weights']\n mlm_acc = mlm_correct_mask.sum()\n mlm_mention_acc = (mlm_correct_mask *\n batch['mlm_target_is_mention']).sum()\n mlm_mention_denom = (batch['mlm_target_weights'] *\n batch['mlm_target_is_mention']).sum()\n mlm_non_mention_acc = (mlm_correct_mask *\n (1 - batch['mlm_target_is_mention'])).sum()\n mlm_non_mention_denom = (batch['mlm_target_weights'] *\n (1 - batch['mlm_target_is_mention'])).sum()\n\n metrics = {\n 'mlm': {\n 'loss': mlm_loss,\n 'acc': mlm_acc,\n 'denominator': mlm_denom,\n },\n 'mlm_mention': {\n 'acc': mlm_mention_acc,\n 'denominator': mlm_mention_denom,\n },\n 'mlm_non_mention': {\n 'acc': mlm_non_mention_acc,\n 'denominator': mlm_non_mention_denom,\n },\n }\n\n if 'intermediate_mention_encodings' in loss_helpers:\n intermediate_target_mention_encodings = jut.matmul_slice(\n loss_helpers['intermediate_mention_encodings'],\n batch['mention_target_indices'])\n else:\n intermediate_target_mention_encodings = loss_helpers[\n 'im_target_mention_encodings']\n\n if model_config.encoder_config.get('no_entity_attention', False):\n (el_im_loss, el_im_metrics,\n (el_im_acc_per_mention,\n el_im_weight_per_mention)) = mention_losses.entity_linking_loss(\n intermediate_target_mention_encodings,\n loss_helpers['entity_embeddings'], mention_target_ids,\n batch['mention_target_weights'], el_score_mode)\n el_im_denom = el_im_metrics['denominator']\n metrics['el_intermediate'] = el_im_metrics\n metrics['el_intermediate_masked'] = {\n 'acc':\n jnp.dot(el_im_acc_per_mention,\n el_im_weight_per_mention * mention_target_is_masked),\n 'denominator':\n jnp.dot(el_im_weight_per_mention, mention_target_is_not_masked),\n }\n metrics['el_intermediate_non_masked'] = {\n 'acc':\n jnp.dot(el_im_acc_per_mention,\n el_im_weight_per_mention * mention_target_is_masked),\n 'denominator':\n jnp.dot(el_im_weight_per_mention, mention_target_is_not_masked),\n }\n else:\n intermediate_entity_attention = loss_helpers[\n 'intermediate_entity_attention']\n\n # Construct targets and ids for intermediate entity linking loss\n intermediate_target_ids = jnp.zeros_like(batch['mention_mask'])\n intermediate_target_ids = intermediate_target_ids.at[\n batch['mention_target_indices']].add(\n mention_target_ids * batch['mention_target_weights'])\n\n intermediate_target_weights = jnp.zeros_like(\n batch['mention_mask'], dtype=intermediate_entity_attention.dtype)\n intermediate_target_weights = intermediate_target_weights.at[\n batch['mention_target_indices']].add(\n batch['mention_target_weights'])\n\n mention_is_masked = jnp.zeros_like(batch['mention_mask'])\n mention_is_masked = mention_is_masked.at[\n batch['mention_target_indices']].add(\n mention_target_is_masked * batch['mention_target_weights'])\n\n el_im_loss, el_im_denom = metric_utils.compute_weighted_cross_entropy(\n intermediate_entity_attention,\n intermediate_target_ids,\n intermediate_target_weights,\n inputs_are_prob=True)\n\n el_im_correct_mask = jnp.equal(\n jnp.argmax(intermediate_entity_attention, axis=-1),\n intermediate_target_ids) * intermediate_target_weights\n el_im_acc = el_im_correct_mask.sum()\n\n el_im_acc, _ = metric_utils.compute_weighted_accuracy(\n intermediate_entity_attention, intermediate_target_ids,\n intermediate_target_weights)\n\n intermediate_entity_cos_sim = loss_helpers[\n 'intermediate_entity_cos_sim'][batch['mention_target_indices'],\n mention_target_ids]\n\n metrics['el_intermediate'] = {\n 'loss':\n el_im_loss,\n 'acc':\n el_im_acc,\n 'cos_sim':\n jnp.dot(intermediate_entity_cos_sim,\n batch['mention_target_weights']),\n 'denominator':\n el_im_denom,\n }\n metrics['el_intermediate_masked'] = {\n 'acc':\n jnp.dot(el_im_correct_mask, mention_is_masked),\n 'denominator':\n jnp.dot(batch['mention_target_weights'],\n batch['mention_target_is_masked']),\n }\n metrics['el_intermediate_non_masked'] = {\n 'acc':\n jnp.dot(el_im_correct_mask, (1 - mention_is_masked)),\n 'denominator':\n jnp.dot(batch['mention_target_weights'],\n (1 - batch['mention_target_is_masked'])),\n }\n\n im_final_mention_encodings_cos_sim = jut.cosine_similarity(\n intermediate_target_mention_encodings,\n loss_helpers['target_mention_encodings'])\n metrics['im_final_mention_encodings'] = {\n 'cos_sim':\n jnp.dot(im_final_mention_encodings_cos_sim,\n batch['mention_target_weights']),\n 'denominator':\n batch['mention_target_weights'].sum(),\n }\n\n (el_final_loss, el_final_metrics,\n (el_final_acc_per_mention,\n el_final_weight_per_mention)) = mention_losses.entity_linking_loss(\n loss_helpers['target_mention_encodings'],\n loss_helpers['entity_embeddings'], mention_target_ids,\n batch['mention_target_weights'], el_score_mode)\n el_final_denom = el_final_metrics['denominator']\n metrics['el_final'] = el_final_metrics\n metrics['el_final_masked'] = {\n 'acc':\n jnp.dot(el_final_acc_per_mention,\n el_final_weight_per_mention * mention_target_is_masked),\n 'denominator':\n jnp.dot(el_final_weight_per_mention, mention_target_is_masked),\n }\n metrics['el_final_non_masked'] = {\n 'acc':\n jnp.dot(\n el_final_acc_per_mention,\n el_final_weight_per_mention * mention_target_is_not_masked),\n 'denominator':\n jnp.dot(el_final_weight_per_mention,\n mention_target_is_not_masked),\n }\n\n loss = mlm_weight * mlm_loss / mlm_denom\n loss += el_im_weight * el_im_loss / el_im_denom\n loss += el_final_weight * el_final_loss / el_final_denom\n\n if mtb_im_weight > 0:\n (mtb_im_loss, mtb_im_metrics) = mention_losses.mtb_loss(\n intermediate_target_mention_encodings,\n batch['mention_target_batch_positions'], mention_target_ids,\n batch_size, mtb_score_mode, mention_target_is_masked, 'im_')\n mtb_im_denom = mtb_im_metrics['im_mtb']['denominator']\n loss += mtb_im_weight * mtb_im_loss / mtb_im_denom\n metrics.update(mtb_im_metrics)\n\n if mtb_final_weight > 0:\n (mtb_final_loss, mtb_final_metrics) = mention_losses.mtb_loss(\n loss_helpers['target_mention_encodings'],\n batch['mention_target_batch_positions'], mention_target_ids,\n batch_size, mtb_score_mode, mention_target_is_masked, 'final_')\n mtb_final_denom = mtb_final_metrics['final_mtb']['denominator']\n loss += mtb_final_weight * mtb_final_loss / mtb_final_denom\n metrics.update(mtb_final_metrics)\n\n metrics['agg'] = {\n 'loss': loss,\n 'denominator': 1.0,\n }\n return loss, metrics, {} # pytype: disable=bad-return-type # jax-ndarray\n\n return loss_fn","def _get_loss_weight(self) -> torch.Tensor:\n n_pos: torch.Tensor = 0.0\n n_neg: torch.Tensor = 0.0\n\n for _, ground_truth in self.train_loader:\n n_poss_curr = ground_truth.sum()\n n_pos += n_poss_curr\n n_neg += ground_truth.numel() - n_poss_curr\n\n eps = torch.finfo(n_pos.dtype).eps\n return n_neg / (n_pos + eps)","def compute_loss(model, loss_weights, init_img, gram_style_features, content_features):\n style_weight, content_weight = loss_weights\n\n # Feed our init image through our model. This will give us the content and\n # style representations at our desired layers. Since we're using eager\n # our model is callable just like any other function!\n model_outputs = model(init_img)\n\n style_output_features = model_outputs[:num_style_layers]\n content_output_features = model_outputs[num_style_layers:]\n\n style_loss = 0\n content_loss = 0\n\n # Accumulate style losses from all layers\n # Here, we equally weight each contribution of each loss layer\n weight_per_style_layer = 1.0 / float(num_style_layers)\n for target_style, comb_style in zip(gram_style_features, style_output_features):\n style_loss += weight_per_style_layer * get_style_loss(comb_style[0], target_style)\n\n # Accumulate content losses from all layers \n weight_per_content_layer = 1.0 / float(num_content_layers)\n for target_content, comb_content in zip(content_features, content_output_features):\n content_loss += weight_per_content_layer* get_content_loss(comb_content[0], target_content)\n\n style_loss *= style_weight\n content_loss *= content_weight\n\n # Get total loss\n loss = style_loss + content_loss\n return loss, style_loss, content_loss","def construct_loss(self, logits, labels):\n model_loss = tf.reduce_mean(\n tf.nn.softmax_cross_entropy_with_logits_v2(labels=labels,\n logits=logits))\n return model_loss","def loss(labels, embeddings):\n # sourced from:\n # https://github.com/tensorflow/tensorflow/blob/r1.14/tensorflow/contrib/losses/python/metric_learning/metric_loss_ops.py#L160-L239\n labels = tf.cast(labels, tf.int32)\n embeddings = tf.cast(embeddings, tf.float32)\n embeddings = tf.nn.l2_normalize(embeddings, axis=1)\n\n # Reshape [batch_size] label tensor to a [batch_size, 1] label tensor.\n lshape = tf.shape(labels)\n if lshape.shape == 1:\n labels = tf.reshape(labels, [lshape[0], 1])\n\n # Build pairwise squared distance matrix.\n if metric == \"cosine\":\n pdist_matrix = cosine_pairwise_distance(embeddings)\n elif metric == \"euclidean\":\n pdist_matrix = euclidean_pairwise_distance(\n embeddings, squared=False)\n elif metric == \"squared_euclidean\":\n pdist_matrix = euclidean_pairwise_distance(\n embeddings, squared=True)\n # Build pairwise binary adjacency matrix.\n adjacency = tf.equal(labels, tf.transpose(labels))\n # Invert so we can select negatives only.\n adjacency_not = tf.logical_not(adjacency)\n\n batch_size = tf.size(labels)\n\n # Compute the mask.\n pdist_matrix_tile = tf.tile(pdist_matrix, [batch_size, 1])\n mask = tf.logical_and(\n tf.tile(adjacency_not, [batch_size, 1]),\n tf.math.greater(\n pdist_matrix_tile, tf.reshape(\n tf.transpose(pdist_matrix), [-1, 1])))\n mask_final = tf.reshape(\n tf.math.greater(\n tf.math.reduce_sum(\n tf.cast(mask, dtype=tf.float32), 1, keepdims=True),\n 0.0), [batch_size, batch_size])\n mask_final = tf.transpose(mask_final)\n\n adjacency_not = tf.cast(adjacency_not, dtype=tf.float32)\n mask = tf.cast(mask, dtype=tf.float32)\n\n # negatives_outside: smallest D_an where D_an > D_ap.\n negatives_outside = tf.reshape(\n masked_minimum(pdist_matrix_tile, mask), [batch_size, batch_size])\n negatives_outside = tf.transpose(negatives_outside)\n\n # negatives_inside: largest D_an.\n negatives_inside = tf.tile(\n masked_maximum(pdist_matrix, adjacency_not), [1, batch_size])\n semi_hard_negatives = tf.where(\n mask_final, negatives_outside, negatives_inside)\n\n loss_mat = tf.math.add(margin, pdist_matrix - semi_hard_negatives)\n\n mask_positives = tf.cast(\n adjacency, dtype=tf.float32) - tf.linalg.diag(\n tf.ones([batch_size]))\n\n # In lifted-struct, the authors multiply 0.5 for upper triangular\n # in semihard, they take all positive pairs except the diagonal.\n num_positives = tf.math.reduce_sum(mask_positives)\n\n triplet_loss = tf.math.truediv(\n tf.math.reduce_sum(\n tf.math.maximum(\n tf.math.multiply(loss_mat, mask_positives), y=0.0)),\n num_positives, name=\"triplet_semihard_loss\")\n\n return triplet_loss","def loss_fn(y_true,y_pred): \n loss = tf.nn.softmax_cross_entropy_with_logits_v2(y_true,\n y_pred,\n axis=-1,\n )\n loss = tf.reduce_mean(loss,name=\"loss\")\n return loss","def _compute_kp_offset_loss(self, input_height, input_width, task_name,\n offset_predictions, localization_loss_fn):\n gt_keypoints_list = self.groundtruth_lists(fields.BoxListFields.keypoints)\n gt_classes_list = self.groundtruth_lists(fields.BoxListFields.classes)\n gt_weights_list = self.groundtruth_lists(fields.BoxListFields.weights)\n\n assigner = self._target_assigner_dict[task_name]\n (batch_indices, batch_offsets,\n batch_weights) = assigner.assign_keypoints_offset_targets(\n height=input_height,\n width=input_width,\n gt_keypoints_list=gt_keypoints_list,\n gt_weights_list=gt_weights_list,\n gt_classes_list=gt_classes_list)\n\n # Keypoint offset loss.\n loss = 0.0\n for prediction in offset_predictions:\n batch_size, out_height, out_width, channels = _get_shape(prediction, 4)\n if channels > 2:\n prediction = tf.reshape(\n prediction, shape=[batch_size, out_height, out_width, -1, 2])\n prediction = cn_assigner.get_batch_predictions_from_indices(\n prediction, batch_indices)\n # The dimensions passed are not as per the doc string but the loss\n # still computes the correct value.\n unweighted_loss = localization_loss_fn(\n prediction,\n batch_offsets,\n weights=tf.expand_dims(tf.ones_like(batch_weights), -1))\n # Apply the weights after the loss function to have full control over it.\n loss += batch_weights * tf.reduce_sum(unweighted_loss, axis=1)\n\n loss = tf.reduce_sum(loss) / (\n float(len(offset_predictions)) *\n tf.maximum(tf.reduce_sum(batch_weights), 1.0))\n return loss","def weighted_loss(y_true, y_pred):\r\n # initialize loss to zero\r\n loss = 0.0\r\n for i in range(len(freq_pos)):\r\n # for each class, add average weighted loss for that class \r\n loss += -K.mean(freq_neg[i]*y_true[:,i]*K.log(y_pred[:,i] + epsilon) + freq_pos[i]*(1-y_true[:,i])*K.log(1-y_pred[:,i] + epsilon)) #complete this line\r\n return loss","def build_loss(self):\n if self.mode != \"encode\":\n total_loss = tf.losses.get_total_loss()\n tf.summary.scalar(\"losses/total\", total_loss)\n\n self.total_loss = total_loss","def loss(self,\n inputs: Union[Tensor, Tuple[Tensor]],\n batch_data_samples: OptSampleList,\n train_cfg: ConfigType = {}) -> dict:\n\n pred_outputs = self.forward(inputs)\n\n lifting_target_label = torch.cat([\n d.gt_instance_labels.lifting_target_label\n for d in batch_data_samples\n ])\n trajectory_weights = torch.cat([\n d.gt_instance_labels.trajectory_weights for d in batch_data_samples\n ])\n\n # calculate losses\n losses = dict()\n loss = self.loss_module(pred_outputs, lifting_target_label,\n trajectory_weights.unsqueeze(-1))\n\n losses.update(loss_traj=loss)\n\n # calculate accuracy\n _, avg_acc, _ = keypoint_pck_accuracy(\n pred=to_numpy(pred_outputs),\n gt=to_numpy(lifting_target_label),\n mask=to_numpy(trajectory_weights) > 0,\n thr=0.05,\n norm_factor=np.ones((pred_outputs.size(0), 3), dtype=np.float32))\n\n mpjpe_traj = torch.tensor(avg_acc, device=lifting_target_label.device)\n losses.update(mpjpe_traj=mpjpe_traj)\n\n return losses","def loss(self, X, Y, lmd):\n P, _ = self.forward(X)\n loss = np.mean(-np.log(np.einsum('ij,ji->i', Y.T, P)))\n\n reg = 0 # Regularization term\n for w in self.W:\n reg += np.sum(np.square(w))\n\n reg *= lmd\n\n cost = loss + reg\n\n return cost","def compute_loss(self,state,targets):\n reshaped_targets = targets.reshape(-1,2,1)\n\n # reshape targets to match the dimension of means\n for i in range(self.output_size-1):\n reshaped_targets = torch.cat((reshaped_targets,targets.reshape(-1,2,1)),2)\n\n # compute output distribution from model\n means,stds,weights = self.forward(state)\n\n # compute the mixed log pdf\n mixed_pdf = mixed_prob(means,stds,weights,reshaped_targets)\n\n # compute the average negative log likelihood\n return -torch.log(mixed_pdf).mean()","def triplet_loss(y_true, y_pred, margin = 1):\n\n anchor = y_pred[0]\n positive = y_pred[1]\n negative = y_pred[2]\n\n # squared distance between the anchor and the positive\n pos_dist = tf.math.reduce_sum(tf.math.square(anchor - positive), axis=-1)\n\n # squared distance between the anchor and the negative\n neg_dist = tf.math.reduce_sum(tf.math.square(anchor - negative), axis=-1)\n\n # compute loss\n basic_loss = margin + pos_dist - neg_dist\n loss = tf.math.maximum(basic_loss,0.0)\n loss = tf.math.reduce_mean(loss)\n return loss","def compute_loss(self, *args, **kwargs):\n raise NotImplementedError","def compute_loss(self, x, label):\n # Forward propagation\n y_hat = self.forward_pass(x)\n return -np.log(y_hat[label])","def calc_loss(self, codes, encodings):\n return tf.reduce_mean((encodings - tf.stop_gradient(codes)) ** 2)","def loss_fn(outputs, labels):\n\n # reshape labels to give a flat vector of length batch_size*seq_len\n labels = labels.view(-1)\n\n # since PADding tokens have label -1, we can generate a mask to exclude the loss from those terms\n mask = (labels >= 0).float()\n\n # indexing with negative values is not supported. Since PADded tokens have label -1, we convert them to a positive\n # number. This does not affect training, since we ignore the PADded tokens with the mask.\n labels = labels % outputs.shape[1]\n\n num_tokens = int(torch.sum(mask))\n\n # compute cross entropy loss for all tokens (except PADding tokens), by multiplying with mask.\n return -torch.sum(outputs[range(outputs.shape[0]), labels]*mask)/num_tokens","def compute_loss(self, x, y):\n\n self.batch_size = x.shape[0]\n self.x = x\n self.y = y\n self.soft = self.softmax(x) + 10**(-11)\n out = np.zeros(self.batch_size)\n for i in range(self.batch_size):\n out[i] = -(y[i] @ np.log(self.soft[i]))\n\n return out","def loss(self, prediction_dict, preprocessed_dict, epsilon=1e-12):\r\n gt_images = preprocessed_dict.get('images')\r\n gt_fg = preprocessed_dict.get('images_fg')\r\n gt_bg = preprocessed_dict.get('images_bg')\r\n gt_alpha_matte = preprocessed_dict.get('alpha_mattes')\r\n gt_trimaps = preprocessed_dict.get('trimaps')\r\n\r\n pred_trimaps = prediction_dict.get('pred_trimap')\r\n alpha_matte_r = prediction_dict.get('alpha_matte_r')\r\n alpha_matte_p = prediction_dict.get('alpha_matte_p')\r\n background = prediction_dict.get('background')\r\n foreground = prediction_dict.get('foreground')\r\n\r\n pred_images = tf.multiply(alpha_matte_p, gt_fg) + tf.multiply(1 - alpha_matte_p, gt_bg)\r\n\r\n # weights = tf.where(tf.equal(pred_trimaps, 128),\r\n # tf.ones_like(pred_trimaps),\r\n # tf.zeros_like(pred_trimaps))\r\n # total_weights = tf.reduce_sum(weights) + epsilon\r\n\r\n # trimap_losses = tf.sqrt(tf.square(pred_trimaps - gt_trimaps) + epsilon)\r\n # trimap_losses = tf.reduce_mean(trimap_losses)\r\n\r\n trimap_losses = tf.losses.softmax_cross_entropy(\r\n tf.concat([gt_alpha_matte, 1 - gt_alpha_matte], axis=3),\r\n tf.concat([foreground, background], axis=3))\r\n alpha_losses = tf.sqrt(tf.square(alpha_matte_p - gt_alpha_matte) + epsilon)\r\n alpha_losses = tf.reduce_mean(alpha_losses)\r\n\r\n composition_losses = tf.sqrt(tf.square(pred_images / 255. - gt_images / 255.) + epsilon)\r\n composition_losses = tf.reduce_mean(composition_losses)\r\n\r\n loss = (self._alpha_loss_weight * alpha_losses +\r\n self._first_stage_image_loss_weight * composition_losses +\r\n self._trimap_loss_weight * trimap_losses)\r\n loss_dict = {'trimap_losses': trimap_losses,\r\n 'alpha_losses': alpha_losses,\r\n 'composition_losses': composition_losses,\r\n 'loss': loss}\r\n return loss_dict","def calc_loss(self, codes, encodings):\n return tf.reduce_mean((tf.stop_gradient(encodings) - codes) ** 2)","def _create_loss(self):\n with tf.device('/cpu:0'):\n with tf.name_scope('loss'):\n self.loss = tf.reduce_mean(\n tf.nn.softmax_cross_entropy_with_logits(\n labels=self.labels_placeholder, \n logits=self.logits, name='loss'))","def add_loss(self):\n with vs.variable_scope(\"loss\"):\n weights = tf.to_float(tf.not_equal(self.ans_ids, PAD_ID)) # [batch_size, context_len]\n\n # shift the weight right to include the end id\n batch_size = tf.shape(weights)[0]\n shift_val = tf.ones([batch_size, 1])\n\n self.new_ans_ids = tf.concat([self.ans_ids[:, 1:], tf.fill([batch_size, 1], 0)], 1)\n self.logits = self.train_logits\n weights = tf.concat([shift_val, weights], 1)[:, :-1]\n self.loss = tf.contrib.seq2seq.sequence_loss(self.logits, self.new_ans_ids, weights=weights)\n tf.summary.scalar('train_loss', self.loss)\n tf.summary.scalar('sampling_prob', self.sampling_prob)\n\n if self.FLAGS.pred_method == 'beam':\n self.dev_logits = tf.Print(self.dev_logits[:, :, 0], [tf.shape(self.dev_logit), self.dev_logits[0, :, 0]])\n self.dev_loss = tf.cast(self.dev_logits[0, 0], tf.float32)\n return\n dev_logits_len = tf.to_int32(tf.shape(self.dev_logits)[1])\n weights = tf.concat([weights[:, 1:], tf.fill([batch_size, 1], 0.0)], 1)\n self.dev_loss = tf.contrib.seq2seq.sequence_loss(\n self.dev_logits, self.new_ans_ids[:, :dev_logits_len],\n weights=weights[:, :dev_logits_len])","def calculate_loss(self, train_x, train_y):\n self.log.info(\"Calculating average categorical crossentropy loss...\")\n\n num_words = np.sum([len(y) for y in train_y])\n return self.calculate_total_loss(train_x, train_y)/float(num_words)","def loss(self, labels, logits, mask=None):\n losses = tf.nn.softmax_cross_entropy_with_logits(tf.one_hot(labels, depth=logits.shape[-1]), logits, axis=-1)\n seq_mask = mask # logits._keras_mask# tf.sequence_mask(lengths, self.seq_len)\n loss = tf.reduce_mean(tf.boolean_mask(losses, seq_mask))\n\n return loss","def calc_loss(self, x: np.ndarray, y: np.ndarray) -> float:\n return self.descent.calc_loss(x, y)","def compute_loss(model, loader, loss_fn, optimizer=None):\n\n total_loss = 0.0\n count_batches = 0\n for x_, y_, qm_, db_mask, blink_mask in loader:\n batch_loss_list = []\n xbatch_list = []\n for mask in [db_mask, blink_mask]:\n idxes = get_idxes_from_mask(mask)\n x_pick, y_pick, qm_pick = x_[idxes], y_[idxes], qm_[idxes]\n y_pos_idxes = torch.nonzero(y_pick.squeeze(), as_tuple=False).reshape(1, -1)[0]\n y_neg_idxes = torch.nonzero(~y_pick.squeeze().bool(), as_tuple=False).reshape(1, -1)[0]\n\n if (len(y_pos_idxes) == 0) or (len(y_neg_idxes) == 0):\n xbatch_list.append(torch.tensor([]))\n continue\n elif len(x_pick) <= 1:\n xbatch_list.append(torch.tensor([]))\n continue\n elif len(y_pos_idxes) == 1:\n y_pos_idx = y_pos_idxes[0]\n else: # len(y_pos_idxes) > 1:\n # TODO: I am just always using the first positive example for now\n # rand_idx = random.choice(list(range(len(y_pos_idxes))))\n # print(y_pos_idxes)\n rand_idx = 0\n y_pos_idx = y_pos_idxes[rand_idx]\n\n batch_length = 1 + len(y_neg_idxes)\n batch_feature_len = x_.shape[1]\n x_batch = torch.zeros(batch_length, batch_feature_len)\n x_batch[:-1:, :] = x_pick[y_neg_idxes]\n x_batch[-1, :] = x_pick[y_pos_idx] # put positive to the end\n xbatch_list.append(x_batch)\n # print(y_pos_idx, len(y_neg_idxes))\n # print(\"batch\", x_batch.shape)\n\n if (len(xbatch_list[0]) == 0) and (len(xbatch_list[1]) == 0):\n # skip if both batches are []\n # print(\"hitting cases without any examples [SHOULD BE WRONG]\")\n continue\n elif (len(xbatch_list[0]) == 0) or (len(xbatch_list[1]) == 0):\n # continue # TODO: testing whether improvements made if we only use cases where there are sources from both\n yhat = model(xbatch_list[0], xbatch_list[1])\n extended_batch_length = len(yhat) - 1\n yhat_neg = yhat[:-1]\n yhat_pos = yhat[-1].repeat(extended_batch_length, 1)\n loss = loss_fn(yhat_pos, yhat_neg, torch.ones((len(yhat) - 1), 1).to(device))\n batch_loss_list.append(loss)\n total_loss += loss.item() * extended_batch_length\n count_batches += 1\n else:\n # get yhats for both BLINK and DB batches\n # print(len(xbatch_list[0]), len(xbatch_list[1]))\n # print((xbatch_list[0], xbatch_list[1]))\n yhat = model(xbatch_list[0], xbatch_list[1])\n extended_batch_length = len(yhat) - 2\n yhat_neg = torch.zeros(extended_batch_length, 1)\n yhat_neg[:len(xbatch_list[0])-1] = yhat[:len(xbatch_list[0])-1]\n yhat_neg[len(xbatch_list[0])-1:] = yhat[len(xbatch_list[0]):-1]\n for idx in [len(xbatch_list[0]), -1]:\n yhat_pos = yhat[idx].repeat(extended_batch_length, 1)\n loss = loss_fn(yhat_pos, yhat_neg, torch.ones(extended_batch_length, 1).to(device))\n batch_loss_list.append(loss)\n total_loss += loss.item() * extended_batch_length\n count_batches += 1\n\n # update every question-mention\n if batch_loss_list and optimizer:\n (sum(batch_loss_list)/len(batch_loss_list)).backward()\n optimizer.step()\n\n avg_loss = total_loss / count_batches\n\n return avg_loss, batch_length","def loss(self, prediction_dict, groundtruth_lists):\r\n pass","def meta_amortized_loss(network, model_indices, params, sim_data):\n\n out_inference, out_evidence = network(model_indices, params, sim_data)\n if out_inference is not None:\n z, log_det_J = out_inference\n kl_loss = tf.reduce_mean(0.5 * tf.square(tf.norm(z, axis=-1)) - log_det_J)\n else:\n kl_loss = 0\n \n if out_evidence is not None:\n model_probs = out_evidence\n model_probs = tf.clip_by_value(model_probs, 1e-15, 1 - 1e-15)\n log_loss = -tf.reduce_mean(tf.reduce_sum(model_indices * tf.math.log(model_probs), axis=1))\n else:\n log_loss = 0\n return kl_loss + log_loss","def calculate_validation_loss(self):\n self.network.train()\n self.validation_average_loss = self.calculate_average_loss(self.validation_dataloader)","def loss(self, logits, labels):\r\n return tf.reduce_mean(tf.keras.losses.binary_crossentropy(labels,logits))","def unlabeled_loss_calculation(self, labeled_examples, unlabeled_examples):\n _, fake_scores = self.D(unlabeled_examples)\n criterion = BCEWithLogitsLoss()\n unlabeled_loss = criterion(fake_scores, torch.zeros_like(fake_scores))\n unlabeled_loss *= self.settings.matching_loss_multiplier\n unlabeled_loss *= self.settings.dggan_loss_multiplier\n return unlabeled_loss","def compute_loss(self, logits, targets, mu, sigma):\n logits_flat = tf.reshape(logits, [self.batch_size, self.height*self.width*self.cdim])\n targets_flat = tf.reshape(targets, [self.batch_size, self.height*self.width*self.cdim])\n #encode_decode_loss = targets_flat * tf.log(1e-10 + logits_flat) + (1 - targets_flat) * tf.log(1e-10 + 1 - logits_flat)\n #encode_decode_loss = -tf.reduce_sum(encode_decode_loss, 1)\n latent_loss = 1 + sigma - tf.square(mu) - tf.exp(sigma)\n latent_loss = -0.1 * tf.reduce_sum(latent_loss, 1)\n img_loss = tf.losses.absolute_difference(labels=targets_flat, predictions=logits_flat)\n loss = tf.reduce_mean(img_loss)\n return loss","def calculate_loss(self, a, label):\n if self.loss == 'mse':\n diff = a - label\n err = np.square(diff).mean(axis=0).mean()\n elif self.loss == 'ce':\n return sum(-np.log2(a[label > 0]))\n else:\n raise ValueError('loss function not implemented')\n return err","def loss(data, y_pred):\n # TODO: Try using points other than the training data points for the divergence calculation.\n y_true = data[:,:2]\n p1 = data[:,2:5]\n p2 = data[:,5:8]\n p3 = data[:,8:11]\n p4 = data[:,11:14]\n\n ### Calculate divergence using model predictions:\n\n # Step 1: Use the model to calculate predicted wind field in the surrounding points p1, p2, p3 and p4.\n y_pred_p1 = model(p1)\n y_pred_p2 = model(p2)\n y_pred_p3 = model(p3)\n y_pred_p4 = model(p4)\n\n # Step 2: Calculate the partial derivatives with a three-point centered difference.\n scale_x = self.scaler_data.scale_[0] #scale-factor for x\n scale_y = self.scaler_data.scale_[1] #scale-factor for y\n\n dudx = (y_pred_p1[:, 0] - y_pred_p3[:, 0]) / (p1[:,0] - p3[:,0]) # <- pj = transformed data\n dvdy = (y_pred_p2[:, 1] - y_pred_p4[:, 1]) / (p2[:,1] - p4[:,1]) # <- pj = transformed data\n\n # Step 3: Calculate the divergence.\n divergence = ( dudx / scale_x + dvdy / scale_y ) * np.mean([scale_x, scale_y])\n #tf.print(K.mean(K.abs(divergence)))\n\n # Step 4: Calculate and return total loss.\n return K.mean(K.square(y_true - y_pred)) + gamma*K.mean(K.square(divergence))","def _compute_loss(self, inputs, logits, targets, idxes):\n clf_loss = F.cross_entropy(logits, targets)\n\n if self._task == 0:\n distil_loss = torch.zeros(1, device=self._device)\n else:\n if self._finetuning:\n # We only do distillation on current task during the distillation\n # phase:\n last_index = len(self._task_idxes)\n else:\n last_index = len(self._task_idxes) - 1\n\n distil_loss = 0.\n #with torch.no_grad():\n previous_logits = self._old_model(inputs)\n\n for i in range(last_index):\n task_idxes = self._task_idxes[i]\n\n distil_loss += F.binary_cross_entropy(\n F.softmax(logits[..., task_idxes] / self._temperature, dim=1),\n F.softmax(previous_logits[..., task_idxes] / self._temperature, dim=1)\n )\n\n return clf_loss, distil_loss","def triplet_loss(y_true, y_pred, alpha = 0.2):\r\n \r\n anchor, positive, negative = y_pred[0], y_pred[1], y_pred[2]\r\n \r\n # Step 1: Compute the (encoding) distance between the anchor and the positive, you will need to sum over axis=-1\r\n pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, positive)), axis=-1)\r\n # Step 2: Compute the (encoding) distance between the anchor and the negative, you will need to sum over axis=-1\r\n neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, negative)), axis=-1)\r\n # Step 3: subtract the two previous distances and add alpha.\r\n basic_loss = tf.add(tf.subtract(pos_dist, neg_dist), alpha)\r\n # Step 4: Take the maximum of basic_loss and 0.0. Sum over the training examples.\r\n loss = tf.reduce_sum(tf.maximum(basic_loss, 0))\r\n # END CODE HERE \r\n \r\n return loss","def _compute_loss(self, loss_weights, init_image, gram_style_features,\n content_features):\n style_weight, content_weight, ta_weight = loss_weights\n\n # Feed our init image through our model. This will give us the content and\n # style representations at our desired layers.\n model_outputs = self.model(init_image)\n\n style_output_features = model_outputs[:self.num_style_layers]\n content_output_features = model_outputs[self.num_style_layers:]\n\n total_style_score = 0\n total_content_score = 0\n total_ta_score = 0\n # Accumulate style losses from all layers\n # Here, we equally weight each contribution of each loss layer\n averge_style_weight = 1.0 / float(self.num_style_layers)\n for target_style, comb_style in zip(gram_style_features,\n style_output_features):\n total_style_score += averge_style_weight * \\\n self._get_style_loss(comb_style[0], target_style)\n\n # Accumulate content losses from all layers\n average_content_weight = 1.0 / float(self.num_content_layers)\n for target_content, comb_content in zip(content_features,\n content_output_features):\n total_content_score += average_content_weight * \\\n self._get_content_loss(comb_content[0], target_content)\n # Get Variation loss of the image\n total_ta_score = self._get_total_variational_loss(\n init_image) * ta_weight\n total_style_score *= style_weight\n total_content_score *= content_weight\n\n # Get total loss\n total_loss = total_style_score + total_content_score + total_ta_score\n return total_loss, total_style_score, total_content_score","def triplet_loss(y_true, y_pred, alpha = 0.2):\n \n anchor, positive, negative = y_pred[0], y_pred[1], y_pred[2]\n \n ### START CODE HERE ### (≈ 4 lines)\n # Step 1: Compute the (encoding) distance between the anchor and the positive, you will need to sum over axis=-1\n pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor,positive)),axis=-1)\n # Step 2: Compute the (encoding) distance between the anchor and the negative, you will need to sum over axis=-1\n neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor,negative)),axis=-1)\n # Step 3: subtract the two previous distances and add alpha.\n basic_loss = pos_dist-neg_dist+alpha\n # Step 4: Take the maximum of basic_loss and 0.0. Sum over the training examples.\n loss = tf.reduce_sum(tf.maximum(basic_loss, 0.0))\n ### END CODE HERE ###\n \n return loss","def calculate_loss(self, outputs, teacher_predictions, labels=None):\n return self.loss(outputs,\n (teacher_predictions[:, :, :self.target_dim],\n teacher_predictions[:, :, self.target_dim:]))","def compute_loss(self, x, gt):\n loss = sum([torch.mean((out - gt)**2) for out in self.forward(x)])\n return loss","def calculate_loss(estimated_separation, true_separation, mask, true_latents, estimated_mix, true_mix, args):\n stats = torch.zeros(7)\n sdr = sdr_objective(estimated_separation, true_separation, mask)\n stats[:4] = sdr\n total_loss = -sdr.sum()\n reconstruction_sdr = sdr_objective(estimated_mix, true_mix).mean() if args.reconstruction_loss_weight > 0 else 0.0\n stats[4] = reconstruction_sdr\n total_loss += -args.reconstruction_loss_weight * reconstruction_sdr\n if args.similarity_loss_weight > 0.0 or args.dissimilarity_loss_weight > 0.0:\n mask = mask.squeeze(-1)\n true_latents = true_latents * mask.unsqueeze(-1).unsqueeze(-1)\n true_latents = true_latents.transpose(0, 1)\n dissimilarity = dissimilarity_loss(true_latents, mask) if args.dissimilarity_loss_weight > 0.0 else 0.0\n stats[5] = dissimilarity\n total_loss += args.dissimilarity_loss_weight * dissimilarity\n similarity = similarity_loss(true_latents, mask) if args.similarity_loss_weight > 0.0 else 0.0\n stats[6] = similarity\n total_loss += -args.similarity_loss_weight * similarity\n return total_loss, stats"],"string":"[\n \"def compute_loss(self):\\n self.test_logits = self.compute_logits()\\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(\\n labels=self.data.test_labels, logits=self.test_logits)\\n cross_entropy_loss = tf.reduce_mean(loss)\\n regularization = tf.reduce_sum(\\n tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))\\n loss = cross_entropy_loss + self.weight_decay * regularization\\n return loss\",\n \"def _compute_loss(self, predictions, targets, **params):\\n pass\",\n \"def calculate_loss(self, pred, gold, smoothing=False):\\n gold = gold.contiguous().view(-1)\\n if smoothing:\\n epsilon = 0.1\\n n_class = pred.size(1)\\n one_hot = torch.zeros_like(pred).scatter(1, gold.view(-1, 1), 1)\\n one_hot = one_hot * (1 - epsilon) + \\\\\\n (1 - one_hot) * epsilon / (n_class - 1)\\n\\n log_prb = F.log_softmax(pred, dim=1)\\n # create non-padding mask with torch.ne()\\n non_pad_mask = gold.ne(self.constants.PAD)\\n loss = -(one_hot * log_prb).sum(dim=1)\\n # losses are averaged later\\n loss = loss.masked_select(non_pad_mask).sum()\\n else:\\n loss = F.cross_entropy(\\n pred, gold, ignore_index=self.constants.PAD, reduction='sum')\\n return loss\",\n \"def lfads_training_loss(params, lfads_hps, key, x_bxt, kl_scale, keep_rate):\\n losses = lfads_losses(params, lfads_hps, key, x_bxt, kl_scale, keep_rate)\\n return losses['total']\",\n \"def loss_function(self, train_head, train_tail, train_relation, train_head_corrupted, train_tail_corrupted):\\n\\n # train_head = tf.nn.l2_normalize(train_head, 1)\\n # train_tail = tf.nn.l2_normalize(train_tail, 1)\\n # train_head_corrupted = tf.nn.l2_normalize(train_head_corrupted, 1)\\n # train_tail_corrupted = tf.nn.l2_normalize(train_tail_corrupted, 1)\\n\\n # loss = tf.reduce_mean(\\n # tf.maximum(self.dict_paras['margin']\\n # + self.distance(tf.add(train_head, train_relation), train_tail)\\n # - self.distance(tf.add(train_head_corrupted, train_relation), train_tail_corrupted), 0.))\\n\\n loss = tf.reduce_mean(self.distance(tf.add(train_head, train_relation), train_tail))\\n\\n return loss\",\n \"def compute_loss(self):\\n def calc_loss(inputs, outputs):\\n reconstruction_loss = tf.metrics.binary_crossentropy(\\n tf_flat(inputs), tf_flat(outputs))\\n reconstruction_loss *= OUT_SIZE * OUT_SIZE\\n kl_loss = -0.5 * tf.reduce_sum(1.0 + self.log_sigma - tf.square(\\n self.mu) - tf.exp(self.log_sigma), 1)\\n return tf.reduce_mean(reconstruction_loss + kl_loss)\\n return calc_loss\",\n \"def calculate_loss(self, word_inputs, feature_inputs, word_seq_lengths, char_inputs, char_seq_lengths, \\\\\\r\\n char_seq_recover, batch_label, mask, vfeature_input, v_modal_label, t_modal_label, v_mask, alpha=0):\\r\\n outs, textual_clf_outputs, visual_clf_outputs = self._get_lstm_features(word_inputs, feature_inputs,\\r\\n word_seq_lengths, char_inputs,\\r\\n char_seq_lengths, char_seq_recover,\\r\\n vfeature_input, v_mask, alpha)\\r\\n batch_size = word_inputs.size(0)\\r\\n seq_len = word_inputs.size(1)\\r\\n # crf\\r\\n ner_loss = self.crf.neg_log_likelihood_loss(outs, mask, batch_label)\\r\\n scores, tag_seq = self.crf._viterbi_decode(outs, mask) # batch,\\r\\n if self.average_batch:\\r\\n ner_loss = ner_loss / batch_size\\r\\n\\r\\n # modal clf loss\\r\\n # visual_clf_outputs: (obj*b, 2) mask (b, obj) ->\\r\\n visual_loss = self.modal_clf_loss(visual_clf_outputs, v_modal_label)\\r\\n textual_loss = self.modal_clf_loss(textual_clf_outputs, t_modal_label)\\r\\n\\r\\n total_loss = self.ner_loss_lambda * ner_loss + self.v_loss_lambda * visual_loss \\\\\\r\\n + self.t_loss_lambda * textual_loss\\r\\n\\r\\n return total_loss, \\\\\\r\\n self.ner_loss_lambda * ner_loss, \\\\\\r\\n self.t_loss_lambda * textual_loss, \\\\\\r\\n self.v_loss_lambda * visual_loss, \\\\\\r\\n tag_seq, textual_clf_outputs, visual_clf_outputs\",\n \"def compute_loss(self):\\n self.prototypes = self.compute_prototypes()\\n self.test_logits = self.compute_logits()\\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(\\n labels=self.episode.test_labels, logits=self.test_logits)\\n cross_entropy_loss = tf.reduce_mean(loss)\\n regularization = tf.reduce_sum(\\n tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))\\n loss = cross_entropy_loss + self.weight_decay * regularization\\n return loss\",\n \"def loss_fn(params):\\n logits = models.ProgramTransformer(config).apply(\\n {'params': params},\\n inputs,\\n outputs,\\n programs,\\n rngs={'dropout': train_rng})\\n loss, weight_sum = compute_weighted_cross_entropy(logits, programs, weights)\\n mean_loss = loss / weight_sum\\n return mean_loss, logits\",\n \"def _compute_loss(self, decoder_output, labels):\\n with tf.name_scope(\\\"compute_loss\\\"):\\n language_logit = decoder_output.logits[0]\\n attention_logit = decoder_output.logits[1]\\n batch_size = self.params['dataset']['batch_size']\\n\\n language_losses = self._cross_entropy_sequence_loss(\\n logits=language_logit,\\n targets=tf.transpose(labels[\\\"label\\\"], [1, 0]),\\n sequence_length=labels[\\\"length\\\"])\\n attention_losses = self._cross_entropy_sequence_loss(\\n logits=attention_logit,\\n targets=tf.transpose(labels[\\\"label\\\"], [1, 0]),\\n sequence_length=labels[\\\"length\\\"])\\n\\n language_loss = tf.reduce_sum(language_losses) / batch_size\\n attention_loss = tf.reduce_sum(attention_losses) / batch_size\\n loss = language_loss + attention_loss\\n\\n return loss\",\n \"def _calc_loss(self, fvs, labels, w, b):\\n\\n loss = 0.5 * self.lda * (np.linalg.norm(w) ** 2)\\n tmp = sum(map(lambda x, y: (x - y) ** 2, fvs.dot(w) + b, labels))\\n loss += tmp / fvs.shape[0]\\n\\n return loss\",\n \"def compute_loss(self, targets, logits, seq_length):\\n\\n\\t\\twith tf.name_scope('evaluate_loss'):\\n\\t\\t\\tloss, norm = self.loss_computer(targets, logits, seq_length)\\n\\t\\t\\t\\n\\t\\treturn loss, norm\",\n \"def _compute_loss(self, parameters, inputs, ground_truth):\\n predictions = self.network_forward(parameters, inputs)\\n loss = np.mean((ground_truth - predictions) ** 2)\\n return loss\",\n \"def _compute_loss(self, parameters, inputs, ground_truth):\\n predictions = self.network_forward(parameters, inputs)\\n loss = np.mean((ground_truth - predictions) ** 2)\\n return loss\",\n \"def _create_loss_op(self):\\n # 1.) The reconstruction loss, which forces the NN towards reconstructing more accurately the\\n # given input. This function is configurable, but usually it is the Bernoulli negative log-likelihood.\\n if self.cost_function == 'abs':\\n reconstr_loss = tf.reduce_sum(tf.abs(self.x_decoded - self.x_in), 1)\\n elif self.cost_function in ('mse', 'l2', 'square'):\\n reconstr_loss = tf.reduce_sum(tf.squared_difference(self.x_in, self.x_decoded), 1)\\n elif self.cost_function in ('xentropy', 'log'):\\n reconstr_loss = \\\\\\n -tf.reduce_sum(self.x_in * tf.log(1e-10 + self.x_decoded)\\n + (1 - self.x_in) * tf.log(1e-10 + 1 - self.x_decoded),\\n 1)\\n else:\\n raise ValueError(self.cost_function, \\\"Unknown cost function name!\\\")\\n\\n # 2.) The latent loss, which is defined as the Kullback Leibler divergence\\n ## between the distribution in latent space induced by the encoder on\\n # the data and some prior. This acts as a kind of regularizer.\\n # This can be interpreted as the number of \\\"nats\\\" required\\n # for transmitting the the latent space distribution given\\n # the prior.\\n latent_loss = -0.5 * tf.reduce_sum(1. + self.z_log_sigma_sq\\n - tf.square(self.z_mean)\\n - tf.exp(self.z_log_sigma_sq), 1)\\n\\n self.loss_op = tf.reduce_mean(reconstr_loss + latent_loss) # average over batch\\n tf.add_to_collection(\\\"losses\\\", self.loss_op)\\n\\n if self.learning_rate is not None:\\n global_step = tf.train.get_or_create_global_step()\\n self.train_op = tf.train.AdamOptimizer(learning_rate=self.learning_rate).minimize(\\n self.loss_op,\\n global_step=global_step,\\n var_list=tf.get_collection(self.training_scope) if self.training_scope is not None else None)\\n\\n tf.add_to_collection(\\\"train_ops\\\", self.train_op)\\n tf_logging.info(\\\"Added AdamOptimizer with learning rate: %.8f\\\" % self.learning_rate)\\n\\n tf.summary.scalar(\\\"latent_loss\\\", tf.reduce_mean(latent_loss))\\n tf.summary.scalar(\\\"reconstruction_loss\\\", tf.reduce_mean(reconstr_loss))\\n tf.summary.scalar(\\\"vae_loss\\\", self.loss_op)\",\n \"def _training_loss(features,\\n labels,\\n logits,\\n loss_fn,\\n weight_column_name=None,\\n head_name=None):\\n with ops.name_scope(None, \\\"training_loss\\\",\\n tuple(six.itervalues(features)) +\\n (labels, logits)) as name:\\n loss, weighted_average_loss = _loss(\\n loss_fn(logits, labels),\\n _weight_tensor(features, weight_column_name),\\n name=name)\\n # The tag must be same as the tag for eval loss, so the losses will show up\\n # in the same graph in tensorboard.\\n logging_ops.scalar_summary(\\n _summary_key(head_name, \\\"loss\\\"), weighted_average_loss)\\n return loss\",\n \"def _compute_loss(self):\\n state, action, reward, next_state, done = self.replay_buffer.sample(self.batch_size)\\n\\n state = torch.FloatTensor(state)\\n next_state = torch.FloatTensor(next_state)\\n action = torch.LongTensor(action)\\n reward = torch.FloatTensor(reward)\\n done = torch.FloatTensor(done)\\n\\n q_values = self.dqn(state)\\n q_value = q_values.gather(1, action.unsqueeze(1)).squeeze(1)\\n\\n next_q_values = self.target_dqn(next_state)\\n next_q_value = next_q_values.max(1)[0]\\n target = reward + self.discount_factor * next_q_value * (1 - done)\\n\\n # loss = F.smooth_l1_loss(q_value, target.detach())\\n loss = F.mse_loss(q_value, target.detach())\\n\\n return loss\",\n \"def loss_fn(self, recons, inputs, mu, log_var, **kwargs):\\n# kld_weight = kwargs['M_N'] # Account for the minibatch samples from the dataset\\n recons_loss = F.mse_loss(recons, inputs)\\n# recons_loss = F.binary_cross_entropy(recons, inputs)\\n KLD = torch.mean(-0.5 * torch.sum(1 + log_var - mu**2 - log_var.exp(), dim=1), dim=0)\\n loss = recons_loss - KLD\\n return loss, recons_loss, KLD\",\n \"def dnn_loss_calculation(self, labeled_examples, labels):\\n predicted_labels, _ = self.DNN(labeled_examples)\\n labeled_loss = self.labeled_loss_function(predicted_labels, labels, order=self.settings.labeled_loss_order)\\n labeled_loss *= self.settings.labeled_loss_multiplier\\n return labeled_loss\",\n \"def calculate_training_loss(self):\\n self.network.train()\\n self.training_average_loss = self.calculate_average_loss(self.training_dataloader)\",\n \"def loss(self, labels, input_data):\\n\\n pred, out = self.inference(input_data)\\n loss = tf.reduce_mean(tf.losses.sparse_softmax_cross_entropy(labels, out), name=\\\"loss\\\") + \\\\\\n tf.losses.get_regularization_loss()\\n return loss, pred\",\n \"def calc_loss(predictions, labels):\\n return np.mean(np.square(predictions - labels))\",\n \"def labeled_loss_calculation(self, labeled_examples, labels):\\n predicted_labels, _ = self.D(labeled_examples)\\n labeled_loss = self.labeled_loss_function(predicted_labels, labels, order=self.settings.labeled_loss_order)\\n labeled_loss *= self.settings.labeled_loss_multiplier\\n return labeled_loss\",\n \"def calc_loss(self, outputs, labels):\\n information_loss = self.bottleneck.buffer_capacity.mean() # Taking the mean is equivalent of scaling with 1/K\\n cross_entropy = F.cross_entropy(outputs, target=labels)\\n total = cross_entropy + self.beta * information_loss\\n self.ce_loss.append(cross_entropy.cpu().detach().numpy())\\n self.info_loss.append(information_loss.cpu().detach().numpy())\\n self.total_loss.append(total.cpu().detach().numpy())\\n return total\",\n \"def loss_fn(self, targets, outputs, model):\",\n \"def loss_function(cls, logits, label, targeted):\\n\\n if targeted:\\n adv_loss = - torch.gather(logits, 1, label)\\n else:\\n adv_loss = torch.gather(logits, 1, label)\\n\\n return adv_loss.mean()\",\n \"def loss(self, features: Tensor, tags: Tensor, masks: Tensor):\\n \\n features = self.linear(features)\\n T = features.size(1)\\n masks_ = masks[:, :T].float()\\n forward_score = self.forward_algorithm(features, masks_)\\n gold_score = self._score(features, tags[:, :T].long(), masks_)\\n loss = (forward_score - gold_score).mean()\\n return loss\",\n \"def loss_fn(\\n model_config: ml_collections.FrozenConfigDict,\\n model_params: Dict[str, Any],\\n model_vars: Dict[str, Any], # pylint: disable=unused-argument\\n batch: Dict[str, Any],\\n deterministic: bool,\\n dropout_rng: Optional[Dict[str, Array]] = None,\\n ) -> Tuple[float, MetricGroups, Dict[str, Any]]:\\n\\n batch_size = batch['text_ids'].shape[0]\\n loss_helpers, logging_helpers = cls.build_model(model_config).apply( # pylint: disable=unused-variable\\n {'params': model_params},\\n batch,\\n deterministic=deterministic,\\n rngs=dropout_rng)\\n mention_target_is_masked = batch['mention_target_is_masked']\\n mention_target_is_not_masked = 1 - batch['mention_target_is_masked']\\n mention_target_ids = batch['mention_target_ids']\\n mention_target_ids = mention_target_ids * batch['mention_target_weights']\\n\\n mlm_logits = loss_helpers['mlm_logits']\\n\\n mlm_loss, mlm_denom = metric_utils.compute_weighted_cross_entropy(\\n mlm_logits, batch['mlm_target_ids'], batch['mlm_target_weights'])\\n\\n mlm_correct_mask = jnp.equal(\\n jnp.argmax(mlm_logits, axis=-1),\\n batch['mlm_target_ids']) * batch['mlm_target_weights']\\n mlm_acc = mlm_correct_mask.sum()\\n mlm_mention_acc = (mlm_correct_mask *\\n batch['mlm_target_is_mention']).sum()\\n mlm_mention_denom = (batch['mlm_target_weights'] *\\n batch['mlm_target_is_mention']).sum()\\n mlm_non_mention_acc = (mlm_correct_mask *\\n (1 - batch['mlm_target_is_mention'])).sum()\\n mlm_non_mention_denom = (batch['mlm_target_weights'] *\\n (1 - batch['mlm_target_is_mention'])).sum()\\n\\n metrics = {\\n 'mlm': {\\n 'loss': mlm_loss,\\n 'acc': mlm_acc,\\n 'denominator': mlm_denom,\\n },\\n 'mlm_mention': {\\n 'acc': mlm_mention_acc,\\n 'denominator': mlm_mention_denom,\\n },\\n 'mlm_non_mention': {\\n 'acc': mlm_non_mention_acc,\\n 'denominator': mlm_non_mention_denom,\\n },\\n }\\n\\n if 'intermediate_mention_encodings' in loss_helpers:\\n intermediate_target_mention_encodings = jut.matmul_slice(\\n loss_helpers['intermediate_mention_encodings'],\\n batch['mention_target_indices'])\\n else:\\n intermediate_target_mention_encodings = loss_helpers[\\n 'im_target_mention_encodings']\\n\\n if model_config.encoder_config.get('no_entity_attention', False):\\n (el_im_loss, el_im_metrics,\\n (el_im_acc_per_mention,\\n el_im_weight_per_mention)) = mention_losses.entity_linking_loss(\\n intermediate_target_mention_encodings,\\n loss_helpers['entity_embeddings'], mention_target_ids,\\n batch['mention_target_weights'], el_score_mode)\\n el_im_denom = el_im_metrics['denominator']\\n metrics['el_intermediate'] = el_im_metrics\\n metrics['el_intermediate_masked'] = {\\n 'acc':\\n jnp.dot(el_im_acc_per_mention,\\n el_im_weight_per_mention * mention_target_is_masked),\\n 'denominator':\\n jnp.dot(el_im_weight_per_mention, mention_target_is_not_masked),\\n }\\n metrics['el_intermediate_non_masked'] = {\\n 'acc':\\n jnp.dot(el_im_acc_per_mention,\\n el_im_weight_per_mention * mention_target_is_masked),\\n 'denominator':\\n jnp.dot(el_im_weight_per_mention, mention_target_is_not_masked),\\n }\\n else:\\n intermediate_entity_attention = loss_helpers[\\n 'intermediate_entity_attention']\\n\\n # Construct targets and ids for intermediate entity linking loss\\n intermediate_target_ids = jnp.zeros_like(batch['mention_mask'])\\n intermediate_target_ids = intermediate_target_ids.at[\\n batch['mention_target_indices']].add(\\n mention_target_ids * batch['mention_target_weights'])\\n\\n intermediate_target_weights = jnp.zeros_like(\\n batch['mention_mask'], dtype=intermediate_entity_attention.dtype)\\n intermediate_target_weights = intermediate_target_weights.at[\\n batch['mention_target_indices']].add(\\n batch['mention_target_weights'])\\n\\n mention_is_masked = jnp.zeros_like(batch['mention_mask'])\\n mention_is_masked = mention_is_masked.at[\\n batch['mention_target_indices']].add(\\n mention_target_is_masked * batch['mention_target_weights'])\\n\\n el_im_loss, el_im_denom = metric_utils.compute_weighted_cross_entropy(\\n intermediate_entity_attention,\\n intermediate_target_ids,\\n intermediate_target_weights,\\n inputs_are_prob=True)\\n\\n el_im_correct_mask = jnp.equal(\\n jnp.argmax(intermediate_entity_attention, axis=-1),\\n intermediate_target_ids) * intermediate_target_weights\\n el_im_acc = el_im_correct_mask.sum()\\n\\n el_im_acc, _ = metric_utils.compute_weighted_accuracy(\\n intermediate_entity_attention, intermediate_target_ids,\\n intermediate_target_weights)\\n\\n intermediate_entity_cos_sim = loss_helpers[\\n 'intermediate_entity_cos_sim'][batch['mention_target_indices'],\\n mention_target_ids]\\n\\n metrics['el_intermediate'] = {\\n 'loss':\\n el_im_loss,\\n 'acc':\\n el_im_acc,\\n 'cos_sim':\\n jnp.dot(intermediate_entity_cos_sim,\\n batch['mention_target_weights']),\\n 'denominator':\\n el_im_denom,\\n }\\n metrics['el_intermediate_masked'] = {\\n 'acc':\\n jnp.dot(el_im_correct_mask, mention_is_masked),\\n 'denominator':\\n jnp.dot(batch['mention_target_weights'],\\n batch['mention_target_is_masked']),\\n }\\n metrics['el_intermediate_non_masked'] = {\\n 'acc':\\n jnp.dot(el_im_correct_mask, (1 - mention_is_masked)),\\n 'denominator':\\n jnp.dot(batch['mention_target_weights'],\\n (1 - batch['mention_target_is_masked'])),\\n }\\n\\n im_final_mention_encodings_cos_sim = jut.cosine_similarity(\\n intermediate_target_mention_encodings,\\n loss_helpers['target_mention_encodings'])\\n metrics['im_final_mention_encodings'] = {\\n 'cos_sim':\\n jnp.dot(im_final_mention_encodings_cos_sim,\\n batch['mention_target_weights']),\\n 'denominator':\\n batch['mention_target_weights'].sum(),\\n }\\n\\n (el_final_loss, el_final_metrics,\\n (el_final_acc_per_mention,\\n el_final_weight_per_mention)) = mention_losses.entity_linking_loss(\\n loss_helpers['target_mention_encodings'],\\n loss_helpers['entity_embeddings'], mention_target_ids,\\n batch['mention_target_weights'], el_score_mode)\\n el_final_denom = el_final_metrics['denominator']\\n metrics['el_final'] = el_final_metrics\\n metrics['el_final_masked'] = {\\n 'acc':\\n jnp.dot(el_final_acc_per_mention,\\n el_final_weight_per_mention * mention_target_is_masked),\\n 'denominator':\\n jnp.dot(el_final_weight_per_mention, mention_target_is_masked),\\n }\\n metrics['el_final_non_masked'] = {\\n 'acc':\\n jnp.dot(\\n el_final_acc_per_mention,\\n el_final_weight_per_mention * mention_target_is_not_masked),\\n 'denominator':\\n jnp.dot(el_final_weight_per_mention,\\n mention_target_is_not_masked),\\n }\\n\\n loss = mlm_weight * mlm_loss / mlm_denom\\n loss += el_im_weight * el_im_loss / el_im_denom\\n loss += el_final_weight * el_final_loss / el_final_denom\\n\\n if mtb_im_weight > 0:\\n (mtb_im_loss, mtb_im_metrics) = mention_losses.mtb_loss(\\n intermediate_target_mention_encodings,\\n batch['mention_target_batch_positions'], mention_target_ids,\\n batch_size, mtb_score_mode, mention_target_is_masked, 'im_')\\n mtb_im_denom = mtb_im_metrics['im_mtb']['denominator']\\n loss += mtb_im_weight * mtb_im_loss / mtb_im_denom\\n metrics.update(mtb_im_metrics)\\n\\n if mtb_final_weight > 0:\\n (mtb_final_loss, mtb_final_metrics) = mention_losses.mtb_loss(\\n loss_helpers['target_mention_encodings'],\\n batch['mention_target_batch_positions'], mention_target_ids,\\n batch_size, mtb_score_mode, mention_target_is_masked, 'final_')\\n mtb_final_denom = mtb_final_metrics['final_mtb']['denominator']\\n loss += mtb_final_weight * mtb_final_loss / mtb_final_denom\\n metrics.update(mtb_final_metrics)\\n\\n metrics['agg'] = {\\n 'loss': loss,\\n 'denominator': 1.0,\\n }\\n return loss, metrics, {} # pytype: disable=bad-return-type # jax-ndarray\",\n \"def compute_loss(self):\",\n \"def model_loss(inp, fake, real_label, fake_label):\\n \\n \\n Dreal,realcls,R1 = gradpen(inp)\\n [Dfake,fakecls] = D(fake)\\n # 1. Adversarial loss\\n \\n glabel = tf.ones_like(Dfake)#tf.random.uniform((Dfake.shape), 1-LN, 1)\\n dlabelr = tf.ones_like(Dreal)#tf.random.uniform((Dreal.shape), 1-LN, 1)\\n dlabelf = tf.zeros_like(Dfake)#tf.random.uniform((Dfake.shape), 0, LN)\\n \\n \\n \\n # D has no sigmoid activation: \\\"from_logits=True\\\"\\n real_loss = tf.keras.losses.binary_crossentropy(\\n dlabelr, Dreal, from_logits=True)\\n real_loss = tf.reduce_mean(real_loss)\\n \\n fake_loss = tf.keras.losses.binary_crossentropy(\\n dlabelf, Dfake, from_logits=True)\\n fake_loss = tf.reduce_mean(fake_loss)\\n \\n Dadv = 0.5*(real_loss+fake_loss)\\n \\n Gadv = tf.keras.losses.binary_crossentropy(\\n glabel, Dfake, from_logits=True)\\n Gadv = tf.reduce_mean(Gadv)\\n \\n # 2. Classification loss\\n \\n Dcls = tf.keras.losses.binary_crossentropy(real_label, realcls, from_logits=True)\\n Dcls = tf.reduce_mean(Dcls)\\n \\n Gcls = tf.keras.losses.binary_crossentropy(fake_label, fakecls, from_logits=True)\\n Gcls = tf.reduce_mean(Gcls)\\n \\n # 3. Total loss\\n \\n Dloss = Dadv + (GAMMA/2)*R1 + LAMBDA_CLS*Dcls\\n \\n Gloss = Gadv + LAMBDA_CLS*Gcls\\n \\n return (Dloss, Dadv, Dcls, R1), (Gloss, Gadv, Gcls)\",\n \"def compute_loss(self, text, mel_in, mel_target):\\n y, ylogit , a = self.forward(text, mel_in)\\n\\n # compute loss\\n l1_loss = F.mse_loss(y, mel_target)\\n bin_loss = F.binary_cross_entropy_with_logits(ylogit, mel_target)\\n # now attention loss\\n N = text.shape[-1]\\n T = mel_in.shape[-1]\\n def w_fun(n, t):\\n return 1 - np.exp(-((n/(N-1) - t/(T-1))**2) / (2 * self.hp.g**2))\\n w = np.fromfunction(w_fun, (a.shape[1], T), dtype='f')\\n w = torch.from_numpy(w).to(self.device)\\n loss_att = (w * a[:, :, :T]).mean()\\n loss = l1_loss + bin_loss + loss_att\\n return loss, y, a\",\n \"def get_loss(self):\\r\\n\\r\\n if F.loss_type==\\\"cosine\\\":\\r\\n self.losscos = r2d*tf.acos(1-tf.losses.cosine_distance(tf.nn.l2_normalize(self.labels,1), tf.nn.l2_normalize(self.out, 1), dim=1))\\r\\n self.loss = tf.losses.cosine_distance(tf.nn.l2_normalize(self.labels,1), tf.nn.l2_normalize(self.out, 1), dim=1)\\r\\n elif F.loss_type==\\\"mse2d\\\":\\r\\n xl, yl, zl = tf.split(self.labels, 3, axis=1)\\r\\n xo, yo, zo = tf.split(self.out, 3, axis=1)\\r\\n thetal, thetao = tf.asin(-yl), tf.asin(-yo)\\r\\n phil, phio = tf.atan2(-zl, -xl), tf.atan2(-zo, -xo)\\r\\n self.lb = tf.concat([thetal, phil], axis=1)\\r\\n self.ob = tf.concat([thetao, phio], axis=1)\\r\\n self.loss = tf.scalar_mul(tf.constant(r2d), tf.losses.mean_squared_error(self.lb, self.ob, 2))\\r\\n elif F.loss_type==\\\"mse3d\\\":\\r\\n self.loss = tf.losses.mean_squared_error(tf.nn.l2_normalize(self.labels, 0), tf.nn.l2_normalize(self.out, 0))\",\n \"def get_loss(self, criterion, target, preds, epoch=0):\\n assert isinstance(target, dict)\\n assert isinstance(preds, dict)\\n assert isinstance(criterion, dict)\\n\\n loss = {\\\"total\\\": 0, \\\"all_class\\\": 0}\\n\\n for key in target[\\\"class\\\"].keys():\\n labels = target[\\\"class\\\"][key]\\n batch_size = target[\\\"class\\\"][key].shape[0]\\n loss[key] = criterion[\\\"crossentropy\\\"](preds[key], labels)\\n loss[\\\"all_class\\\"] += loss[key]\\n\\n loss[\\\"total\\\"] += loss[\\\"all_class\\\"]\\n\\n if self.use_attention and not self.cfg.model.attention.use_fixed:\\n if self.training and epoch + 1 < self.cfg.model.attention.decay_step:\\n prior_multiplier = 0\\n contrast_multiplier = 0\\n entropy_multiplier = 0\\n else:\\n prior_multiplier = self.cfg.model.attention.wt_decay\\n contrast_multiplier = self.cfg.model.attention.contrast_decay\\n entropy_multiplier = self.cfg.model.attention.entropy_decay\\n\\n wts = preds[\\\"weights\\\"].squeeze(1)\\n\\n if self.cfg.model.attention.use_prior:\\n b, n, _, _ = target[\\\"weights\\\"].shape\\n assert wts.shape[0] == b * n\\n prior = target[\\\"weights\\\"].reshape(b * n, -1)\\n if self.cfg.model.attention.wt_loss == \\\"kl\\\":\\n wts = torch.log(wts + 1e-7)\\n loss[\\\"prior\\\"] = criterion[\\\"prior\\\"](wts, prior)\\n loss[\\\"total\\\"] += prior_multiplier * loss[\\\"prior\\\"]\\n if self.cfg.model.attention.use_contrast:\\n loss[\\\"contrast\\\"] = criterion[\\\"contrast\\\"](wts)\\n loss[\\\"total\\\"] += contrast_multiplier * loss[\\\"contrast\\\"]\\n if self.cfg.model.attention.use_entropy:\\n loss[\\\"entropy\\\"] = Categorical(probs=wts + 1e-6).entropy().mean()\\n # if the loss minimization goes below threshold, stop training with entropy loss\\n if (\\n self.training\\n and entropy_multiplier > 0\\n and loss[\\\"entropy\\\"] < self.cfg.model.attention.entropy_thresh\\n ):\\n entropy_multiplier = 0\\n loss[\\\"total\\\"] += entropy_multiplier * loss[\\\"entropy\\\"]\\n\\n return loss, batch_size\",\n \"def loss(self, prediction_dict, gt_boxes_list, gt_labels_list):\\n with tf.name_scope(None, 'Loss', prediction_dict.values()):\\n (batch_cls_targets, batch_cls_weights, batch_reg_targets, batch_reg_weights,\\n match_list) = self._assign_targets(gt_boxes_list, gt_labels_list)\\n # num_positives = [tf.reduce_sum(tf.cast(tf.not_equal(matches.match_results, -1), tf.float32))\\n # for matches in match_list]\\n self._summarize_target_assignment(gt_boxes_list, match_list)\\n reg_loss = regression_loss(prediction_dict[\\\"box_pred\\\"], batch_reg_targets, batch_reg_weights)\\n cls_loss = focal_loss(prediction_dict[\\\"cls_pred\\\"], batch_cls_targets, batch_cls_weights)\\n # normalize loss by num of matches\\n # num_pos_anchors = [tf.reduce_sum(tf.cast(tf.not_equal(match.match_results, -1), tf.float32))\\n # for match in match_list]\\n normalizer = tf.maximum(tf.to_float(tf.reduce_sum(batch_reg_weights)), 1.0)\\n # normalize reg loss by box codesize (here is 4)\\n reg_normalizer = normalizer * 4\\n normalized_reg_loss = tf.multiply(reg_loss, 1.0/reg_normalizer, name=\\\"regression_loss\\\")\\n normalized_cls_loss = tf.multiply(cls_loss, 1.0/normalizer, name=\\\"classification_loss\\\")\\n return normalized_reg_loss, normalized_cls_loss, batch_reg_weights, batch_cls_weights\",\n \"def pseudo_loss(self, params, batches):\\n loss = 0\\n for batch in batches:\\n states = batch[\\\"states\\\"]\\n actions = batch[\\\"actions\\\"]\\n returns = batch[\\\"returns\\\"]\\n\\n preds = self.predict_jax(params, states)\\n\\n baseline = jnp.mean(returns, axis=0)\\n preds_select = jnp.take_along_axis(preds, jnp.expand_dims(actions, axis=2), axis=2).squeeze()\\n loss += (-jnp.mean(jnp.sum(preds_select * (returns - baseline))))\\n\\n return loss + self.l2_regularizer(params, 0.001) # try to divide by len(batches)?\",\n \"def build_loss(self):\\n\\n opt = tf.train.AdamOptimizer(self.learning_rate)\\n mse = tf.losses.mean_squared_error(self.label[-1], self.outputs[-1])\\n loss = tf.losses.get_total_loss()\\n\\n return mse, loss\",\n \"def get_style_loss(features, targets):\\n ### START CODE HERE ###\\n \\n # Calculate the style loss\\n style_loss = tf.reduce_mean(tf.square(features - targets))\\n \\n ### END CODE HERE ###\\n return style_loss\",\n \"def loss_function(self, targets, outputs):\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=targets, logits=outputs)\\n return tf.reduce_mean(cross_entropy)\",\n \"def full_loss(preds, targets, chamfer_lambda, physical_lambda, has_anno=None, joint_idxs=None):\\n\\n coords_pred = preds[2]\\n if has_anno is not None:\\n coords_pred = coords_pred[has_anno]\\n if joint_idxs is not None:\\n coords_pred = coords_pred[:, joint_idxs]\\n\\n # Coord Loss Only\\n coord_loss = F.mse_loss(coords_pred, targets[0])\\n loss = coord_loss\\n\\n # Chamfer Loss\\n # with torch.no_grad():\\n # coord_loss = F.mse_loss(coords_pred, targets[0])\\n dist1, idx1, dist2, idx2, _ = chamfer_dist(preds[0], targets[1])\\n chamfer_loss = (dist1 + dist2).mean()\\n # loss = chamfer_lambda * chamfer_loss + coord_loss\\n # loss = chamfer_loss\\n\\n # Physical loss\\n p_loss = physical_loss(preds[6])\\n # loss += (physical_lambda * p_loss)\\n\\n return loss, coord_loss, chamfer_loss, p_loss\",\n \"def compute_loss(self,\\n inputs: Union[\\n # Tuple of (features, labels).\\n Tuple[\\n Dict[str, tf.Tensor],\\n tf.Tensor\\n ],\\n # Tuple of (features, labels, sample weights).\\n Tuple[\\n Dict[str, tf.Tensor],\\n tf.Tensor,\\n Optional[tf.Tensor]\\n ]\\n ],\\n training: bool = False) -> tf.Tensor:\\n\\n # We need to work around a bug in mypy - tuple narrowing\\n # based on length checks doesn't work.\\n # See https://github.com/python/mypy/issues/1178 for details.\\n if len(inputs) == 2:\\n inputs = cast(\\n Tuple[\\n Dict[str, tf.Tensor],\\n tf.Tensor\\n ],\\n inputs\\n )\\n features, labels = inputs\\n sample_weight = None\\n elif len(inputs) == 3:\\n inputs = cast(\\n Tuple[\\n Dict[str, tf.Tensor],\\n tf.Tensor,\\n Optional[tf.Tensor],\\n ],\\n inputs\\n )\\n features, labels, sample_weight = inputs\\n else:\\n raise ValueError(\\n \\\"Inputs should either be a tuple of (features, labels), \\\"\\n \\\"or a tuple of (features, labels, sample weights). \\\"\\n \\\"Got a length {len(inputs)} tuple instead: {inputs}.\\\"\\n )\\n\\n outputs = self(features, training=training)\\n\\n loss = self._task(labels, outputs, sample_weight=sample_weight)\\n loss = tf.reduce_mean(loss)\\n # Scales loss as the default gradients allreduce performs sum inside the\\n # optimizer.\\n return loss / tf.distribute.get_strategy().num_replicas_in_sync\",\n \"def loss_fn(model):\\n with flax.nn.stateful(state) as new_state:\\n with flax.nn.stochastic(prng_key):\\n logits = model(batch['image'])\\n loss = cross_entropy_loss(logits, batch['label'])\\n # TODO(britefury): check if applying L2 regularization to weights but\\n # *not* biases improves results\\n weight_penalty_params = jax.tree_leaves(model.params)\\n weight_l2 = sum([jnp.sum(x ** 2)\\n for x in weight_penalty_params\\n if x.ndim > 1])\\n weight_penalty = l2_reg * 0.5 * weight_l2\\n loss = loss + weight_penalty\\n return loss, (new_state, logits)\",\n \"def compute_loss(self, model, inputs, return_outputs=False):\\n # global cnt, align_list1, align_list2, op\\n word_loss = torch.nn.MSELoss(reduction='sum')\\n outputs = model(**inputs)\\n # We don't use .loss here since the model may return tuples instead of ModelOutput.\\n loss = outputs[\\\"loss\\\"] if isinstance(outputs, dict) else outputs[0]\\n # if align_list1:\\n if self.args.align_list1:\\n new_loss = 0.5 * word_loss(\\n model.bert.embeddings.word_embeddings(\\n torch.tensor([self.args.align_list1], dtype=torch.long).to(self.args.device)),\\n model.bert.embeddings.word_embeddings(\\n torch.tensor([self.args.align_list2], dtype=torch.long).to(self.args.device)),\\n )\\n loss = loss + new_loss\\n self.args.improve_cnt += 1\\n if self.args.improve_cnt >= 500 and self.args.improve_cnt % 500 == 0 and len(self.args.align_list1) == 50:\\n self.args.align_list1, self.args.align_list2 = get_list(self.args.improve_op,\\n model,\\n self.args.improve_cnt)\\n return (loss, outputs) if return_outputs else loss\",\n \"def loss_fn(outputs, labels, wts):\\n\\n # reshape labels to give a flat vector of length batch_size*seq_len\\n loss_noreduce = nn.BCEWithLogitsLoss(reduce=False)\\n loss = torch.mean(loss_noreduce(outputs, labels)*wts)\\n\\t\\n # compute cross entropy loss for all tokens\\n return loss\",\n \"def compute_loss(self, sample):\\n observations_batch, actions_batch, return_batch, masks_batch, \\\\\\n old_action_log_probs_batch, adv_targ = sample\\n\\n assert old_action_log_probs_batch.shape == (self.mini_batch_size, 1)\\n assert adv_targ.shape == (self.mini_batch_size, 1)\\n assert return_batch.shape == (self.mini_batch_size, 1)\\n\\n values, action_log_probs, dist_entropy = self.evaluate_actions(\\n observations_batch, actions_batch)\\n\\n assert values.shape == (self.mini_batch_size, 1)\\n assert action_log_probs.shape == (self.mini_batch_size, 1)\\n assert values.requires_grad\\n assert action_log_probs.requires_grad\\n assert dist_entropy.requires_grad\\n\\n # [TODO] Implement policy loss\\n ratio = torch.exp(action_log_probs - old_action_log_probs_batch)\\n surr1 = ratio * adv_targ\\n surr2 = torch.clamp(ratio, 1.0 - self.clip_param, 1.0 + self.clip_param) * adv_targ\\n policy_loss = -torch.min(surr1, surr2).mean()\\n\\n # [TODO] Implement value loss\\n value_loss = F.mse_loss(return_batch, values)\\n\\n # This is the total loss\\n loss = policy_loss + self.config.value_loss_weight * value_loss - self.config.entropy_loss_weight * dist_entropy\\n\\n return loss, policy_loss, value_loss, dist_entropy\",\n \"def loss(logits, labels):\\n with tf.name_scope('loss'):\\n char_pre = tf.reshape(logits[:, :, :, 0], -1, name='char_pre')\\n aff_pre = tf.reshape(logits[:, :, :, 1], -1, name='aff_pre')\\n char_gt = tf.reshape(labels[:, :, :, 0], -1, name='char_gt')\\n aff_gt = tf.reshape(labels[:, :, :, 1], -1, name='aff_gt')\\n char_loss = tf.norm(tf.subtract(char_pre, char_gt))\\n aff_loss = tf.norm(tf.subtract(aff_pre, aff_gt))\\n loss = tf.reduce_mean(-tf.reduce_sum(tf.add(char_loss, aff_loss)))\\n return loss\",\n \"def compute_loss(self, **kwargs):\\n raise NotImplementedError\",\n \"def add_loss_op(self, pred):\\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(\\n labels=self.labels_placeholder,\\n logits=pred,\\n name=\\\"loss\\\"\\n )\\n loss = tf.reduce_mean(loss)\\n\\n return loss\",\n \"def _total_loss(self, inputs, logits, labels, image_size, is_training=None):\\n if self.cfg.WITH_RECONSTRUCTION:\\n loss, classifier_loss, reconstruct_loss, reconstructed_images = \\\\\\n self._loss_with_rec(\\n inputs, logits, labels, image_size, is_training=is_training)\\n else:\\n loss = self._loss_without_rec(logits, labels)\\n classifier_loss, reconstruct_loss, reconstructed_images = \\\\\\n None, None, None\\n\\n loss = tf.identity(loss, name='loss')\\n\\n return loss, classifier_loss, reconstruct_loss, reconstructed_images\",\n \"def _get_ner_loss(self):\\n # per example loss\\n no_entity_id = self.config[\\\"model\\\"][\\\"ner\\\"][\\\"no_entity_id\\\"]\\n logits_shape = tf.shape(self.ner_logits_train)\\n labels_shape = logits_shape[:3]\\n labels = get_dense_labels_from_indices(indices=self.ner_labels_ph, shape=labels_shape, no_label_id=no_entity_id)\\n per_example_loss = tf.nn.sparse_softmax_cross_entropy_with_logits(\\n labels=labels, logits=self.ner_logits_train\\n ) # [batch_size, num_tokens, num_tokens]\\n\\n # mask\\n maxlen = logits_shape[1]\\n span_mask = upper_triangular(maxlen, dtype=tf.float32)\\n sequence_mask = tf.sequence_mask(self.num_tokens_ph, dtype=tf.float32) # [batch_size, num_tokens]\\n mask = span_mask[None, :, :] * sequence_mask[:, None, :] * sequence_mask[:, :, None] # [batch_size, num_tokens, num_tokens]\\n\\n masked_per_example_loss = per_example_loss * mask\\n total_loss = tf.reduce_sum(masked_per_example_loss)\\n num_valid_spans = tf.cast(tf.reduce_sum(mask), tf.float32)\\n loss = total_loss / num_valid_spans\\n\\n loss *= self.config[\\\"model\\\"][\\\"ner\\\"][\\\"loss_coef\\\"]\\n return loss\",\n \"def calc_entropy_tuning_loss(self, log_probs):\\n with torch.no_grad():\\n inner_prod = (log_probs + self.target_entropy).detach()\\n alpha_loss = -(self.log_alpha * inner_prod).mean()\\n return alpha_loss\",\n \"def forward(self, y_pred: Dict[str, torch.Tensor], target: Union[torch.Tensor, rnn.PackedSequence]) -> torch.Tensor:\\n # unpack\\n if isinstance(target, rnn.PackedSequence):\\n target, lengths = rnn.pad_packed_sequence(target, batch_first=True)\\n # batch sizes reside on the CPU by default -> we need to bring them to GPU\\n lengths = lengths.to(target.device)\\n else:\\n lengths = torch.ones(target.size(0), device=target.device, dtype=torch.long) * target.size(1)\\n assert not target.requires_grad\\n\\n # calculate loss with \\\"none\\\" reduction\\n if target.ndim == 3:\\n weight = target[..., 1]\\n target = target[..., 0]\\n else:\\n weight = None\\n\\n losses = self.loss(y_pred, target)\\n # weight samples\\n if weight is not None:\\n losses = losses * weight.unsqueeze(-1)\\n\\n # mask loss\\n mask = torch.arange(target.size(1), device=target.device).unsqueeze(0) >= lengths.unsqueeze(-1)\\n if losses.ndim > 2:\\n mask = mask.unsqueeze(-1)\\n dim_normalizer = losses.size(-1)\\n else:\\n dim_normalizer = 1.0\\n # reduce to one number\\n if self.reduction == \\\"none\\\":\\n loss = losses.masked_fill(mask, float(\\\"nan\\\"))\\n else:\\n if self.reduction == \\\"mean\\\":\\n losses = losses.masked_fill(mask, 0.0)\\n loss = losses.sum() / lengths.sum() / dim_normalizer\\n elif self.reduction == \\\"sqrt-mean\\\":\\n losses = losses.masked_fill(mask, 0.0)\\n loss = losses.sum() / lengths.sum() / dim_normalizer\\n loss = loss.sqrt()\\n assert not torch.isnan(loss), (\\n \\\"Loss should not be nan - i.e. something went wrong \\\"\\n \\\"in calculating the loss (e.g. log of a negative number)\\\"\\n )\\n assert torch.isfinite(\\n loss\\n ), \\\"Loss should not be infinite - i.e. something went wrong (e.g. input is not in log space)\\\"\\n return loss\",\n \"def add_loss_op(self, preds):\\n ### YOUR CODE HERE (~2-4 lines)\\n trans = tf.get_variable('trans',\\n shape=[Config.n_classes, Config.n_classes],\\n initializer=tf.contrib.layers.xavier_initializer())\\n log_likelihood, _ = crf_log_likelihood(preds,\\n self.labels_placeholder,\\n self.length_placeholder,\\n trans)\\n #log_likelihood = tf.boolean_mask(log_likelihood, self.mask_placeholder)\\n loss = tf.reduce_mean(-1.0 * log_likelihood)\\n \\n ### END YOUR CODE\\n return trans, loss\",\n \"def calculate_loss(self, output, target, redmode = 'mean'):\\n\\n loss = F.cross_entropy(output, target, reduction = redmode)\\n return loss\",\n \"def loss(loss_name):\\n \\n def contrastive_loss(y_true, y_pred, margin = 1):\\n \\\"\\\"\\\"Implementation of the triplet loss function\\n\\n\\n Contrastive loss = 0.5 * mean( (1-true_value) * square(distance) + true_value * square( max(margin-distance, 0) ))\\n\\n Args:\\n y_true (int): true label, positive pair (same class) -> 0, \\n negative pair (different class) -> 1\\n \\n y_pred (list): python list containing two objects in a pair of tensors:\\n left : the encodings for one image data in a pair\\n right : the encodings for the other image data in a pair\\n margin (float, optional): m > 0 determines how far the embeddings of \\n a negative pair should be pushed apart. Defaults to 1.\\n\\n\\n Returns:\\n loss (float): real number, value of the loss\\n \\\"\\\"\\\"\\n\\n left = y_pred[0]\\n right = y_pred[1]\\n\\n distance = tf.math.sqrt(tf.math.reduce_sum(tf.math.square(left - right), axis=-1))\\n\\n loss_positive = tf.math.square(distance)\\n loss_negative = tf.math.square(tf.maximum(0., margin - distance))\\n \\n loss = y_true * loss_negative + (1 - y_true) * loss_positive\\n loss = 0.5 * tf.math.reduce_mean(loss)\\n\\n return loss\\n\\n def triplet_loss(y_true, y_pred, margin = 1):\\n \\\"\\\"\\\"Implementation of the triplet loss function\\n\\n Arguments:\\n y_true : true labels, required when you define a loss in Keras, \\n not applied in this function.\\n\\n y_pred (list): python list containing three objects:\\n anchor : the encodings for the anchor data\\n positive : the encodings for the positive data (similar to anchor)\\n negative : the encodings for the negative data (different from anchor)\\n \\n margin (float, optional): m > 0 determines how far the embeddings of \\n a negative data should be pushed apart. Defaults to 1.\\n\\n Returns:\\n loss (float): real number, value of the loss\\n \\\"\\\"\\\"\\n\\n anchor = y_pred[0]\\n positive = y_pred[1]\\n negative = y_pred[2]\\n\\n # squared distance between the anchor and the positive\\n pos_dist = tf.math.reduce_sum(tf.math.square(anchor - positive), axis=-1)\\n\\n # squared distance between the anchor and the negative\\n neg_dist = tf.math.reduce_sum(tf.math.square(anchor - negative), axis=-1)\\n\\n # compute loss\\n basic_loss = margin + pos_dist - neg_dist\\n loss = tf.math.maximum(basic_loss,0.0)\\n loss = tf.math.reduce_mean(loss)\\n return loss\\n\\n \\n if loss_name == 'contrastive_loss':\\n return contrastive_loss\\n \\n if loss_name == 'triplet_loss':\\n return triplet_loss\",\n \"def loss(self, top_out, targets, weights_fn=None):\\n logits = top_out\\n if weights_fn is None:\\n weights_fn = self.targets_weights_fn\\n return common_layers.padded_cross_entropy(\\n logits,\\n targets,\\n self._model_hparams.label_smoothing,\\n weights_fn=weights_fn)\",\n \"def loss_fn(model):\\n with flax.deprecated.nn.stateful() as state:\\n with flax.deprecated.nn.stochastic(dropout_rng):\\n logits = model(example, train=True)\\n loss, weight_sum = compute_weighted_cross_entropy(logits, targets)\\n mean_loss = loss / weight_sum\\n return mean_loss, (logits, state)\",\n \"def setup_loss(self):\\n with vs.variable_scope(\\\"loss\\\"):\\n self.loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels=self.label_placeholder, logits=self.label_predictions))\",\n \"def get_loss(self, inputs, targets, dags):\\n if not isinstance(dags, list):\\n dags = [dags]\\n\\n loss = 0\\n for dag in dags:\\n output = self.shared(inputs, dag)\\n sample_loss = (self.model_loss(output, targets) /\\n self.args.shared_num_sample)\\n loss += sample_loss\\n\\n loss =loss/len(dags)\\n\\n return loss\",\n \"def build_loss(self):\\n import tensorflow as tf\\n\\n y_1d = [tf.reduce_sum(tf.multiply(self.variables[\\\"y\\\"][i], self.variables[\\\"y_action\\\"][i]), axis=1) for i in range(len(self.variables[\\\"y\\\"]))]\\n loss = np.sum([tf.nn.l2_loss(y_1d[i] - self.variables[\\\"y_true\\\"]) for i in range(len(y_1d))])\\n\\n l1_reg = 0\\n l2_reg = 0\\n\\n keys = sorted(self.variables.keys())\\n keys = [key for key in keys if critere_keys(key) and \\\"W\\\" in key]\\n for key in keys:\\n l1_reg += tf.reduce_sum(tf.abs(self.variables[key]))\\n l2_reg += tf.nn.l2_loss(self.variables[key])\\n\\n self.loss = loss + self.alpha_reg * l1_reg + self.beta_reg * l2_reg\\n\\n self.train_step = tf.train.RMSPropOptimizer(self.decay_learning_rate,\\n decay=0.99, momentum=0., centered=True).minimize(self.loss, global_step=self.global_step)\",\n \"def make_loss_fn(\\n cls, config: ml_collections.ConfigDict\\n ) -> Callable[..., Tuple[float, MetricGroups, Dict[str, Any]]]:\\n mlm_weight = config.mlm_weight\\n el_im_weight = config.el_im_weight\\n el_final_weight = config.el_final_weight\\n el_score_mode = config.get('el_score_mode', 'dot')\\n mtb_im_weight = config.get('mtb_im_weight', 0)\\n mtb_final_weight = config.get('mtb_final_weight', 0)\\n mtb_score_mode = config.get('mtb_score_mode', 'dot')\\n\\n def loss_fn(\\n model_config: ml_collections.FrozenConfigDict,\\n model_params: Dict[str, Any],\\n model_vars: Dict[str, Any], # pylint: disable=unused-argument\\n batch: Dict[str, Any],\\n deterministic: bool,\\n dropout_rng: Optional[Dict[str, Array]] = None,\\n ) -> Tuple[float, MetricGroups, Dict[str, Any]]:\\n \\\"\\\"\\\"Task-specific loss function. See BaseTask.\\\"\\\"\\\"\\n\\n batch_size = batch['text_ids'].shape[0]\\n loss_helpers, logging_helpers = cls.build_model(model_config).apply( # pylint: disable=unused-variable\\n {'params': model_params},\\n batch,\\n deterministic=deterministic,\\n rngs=dropout_rng)\\n mention_target_is_masked = batch['mention_target_is_masked']\\n mention_target_is_not_masked = 1 - batch['mention_target_is_masked']\\n mention_target_ids = batch['mention_target_ids']\\n mention_target_ids = mention_target_ids * batch['mention_target_weights']\\n\\n mlm_logits = loss_helpers['mlm_logits']\\n\\n mlm_loss, mlm_denom = metric_utils.compute_weighted_cross_entropy(\\n mlm_logits, batch['mlm_target_ids'], batch['mlm_target_weights'])\\n\\n mlm_correct_mask = jnp.equal(\\n jnp.argmax(mlm_logits, axis=-1),\\n batch['mlm_target_ids']) * batch['mlm_target_weights']\\n mlm_acc = mlm_correct_mask.sum()\\n mlm_mention_acc = (mlm_correct_mask *\\n batch['mlm_target_is_mention']).sum()\\n mlm_mention_denom = (batch['mlm_target_weights'] *\\n batch['mlm_target_is_mention']).sum()\\n mlm_non_mention_acc = (mlm_correct_mask *\\n (1 - batch['mlm_target_is_mention'])).sum()\\n mlm_non_mention_denom = (batch['mlm_target_weights'] *\\n (1 - batch['mlm_target_is_mention'])).sum()\\n\\n metrics = {\\n 'mlm': {\\n 'loss': mlm_loss,\\n 'acc': mlm_acc,\\n 'denominator': mlm_denom,\\n },\\n 'mlm_mention': {\\n 'acc': mlm_mention_acc,\\n 'denominator': mlm_mention_denom,\\n },\\n 'mlm_non_mention': {\\n 'acc': mlm_non_mention_acc,\\n 'denominator': mlm_non_mention_denom,\\n },\\n }\\n\\n if 'intermediate_mention_encodings' in loss_helpers:\\n intermediate_target_mention_encodings = jut.matmul_slice(\\n loss_helpers['intermediate_mention_encodings'],\\n batch['mention_target_indices'])\\n else:\\n intermediate_target_mention_encodings = loss_helpers[\\n 'im_target_mention_encodings']\\n\\n if model_config.encoder_config.get('no_entity_attention', False):\\n (el_im_loss, el_im_metrics,\\n (el_im_acc_per_mention,\\n el_im_weight_per_mention)) = mention_losses.entity_linking_loss(\\n intermediate_target_mention_encodings,\\n loss_helpers['entity_embeddings'], mention_target_ids,\\n batch['mention_target_weights'], el_score_mode)\\n el_im_denom = el_im_metrics['denominator']\\n metrics['el_intermediate'] = el_im_metrics\\n metrics['el_intermediate_masked'] = {\\n 'acc':\\n jnp.dot(el_im_acc_per_mention,\\n el_im_weight_per_mention * mention_target_is_masked),\\n 'denominator':\\n jnp.dot(el_im_weight_per_mention, mention_target_is_not_masked),\\n }\\n metrics['el_intermediate_non_masked'] = {\\n 'acc':\\n jnp.dot(el_im_acc_per_mention,\\n el_im_weight_per_mention * mention_target_is_masked),\\n 'denominator':\\n jnp.dot(el_im_weight_per_mention, mention_target_is_not_masked),\\n }\\n else:\\n intermediate_entity_attention = loss_helpers[\\n 'intermediate_entity_attention']\\n\\n # Construct targets and ids for intermediate entity linking loss\\n intermediate_target_ids = jnp.zeros_like(batch['mention_mask'])\\n intermediate_target_ids = intermediate_target_ids.at[\\n batch['mention_target_indices']].add(\\n mention_target_ids * batch['mention_target_weights'])\\n\\n intermediate_target_weights = jnp.zeros_like(\\n batch['mention_mask'], dtype=intermediate_entity_attention.dtype)\\n intermediate_target_weights = intermediate_target_weights.at[\\n batch['mention_target_indices']].add(\\n batch['mention_target_weights'])\\n\\n mention_is_masked = jnp.zeros_like(batch['mention_mask'])\\n mention_is_masked = mention_is_masked.at[\\n batch['mention_target_indices']].add(\\n mention_target_is_masked * batch['mention_target_weights'])\\n\\n el_im_loss, el_im_denom = metric_utils.compute_weighted_cross_entropy(\\n intermediate_entity_attention,\\n intermediate_target_ids,\\n intermediate_target_weights,\\n inputs_are_prob=True)\\n\\n el_im_correct_mask = jnp.equal(\\n jnp.argmax(intermediate_entity_attention, axis=-1),\\n intermediate_target_ids) * intermediate_target_weights\\n el_im_acc = el_im_correct_mask.sum()\\n\\n el_im_acc, _ = metric_utils.compute_weighted_accuracy(\\n intermediate_entity_attention, intermediate_target_ids,\\n intermediate_target_weights)\\n\\n intermediate_entity_cos_sim = loss_helpers[\\n 'intermediate_entity_cos_sim'][batch['mention_target_indices'],\\n mention_target_ids]\\n\\n metrics['el_intermediate'] = {\\n 'loss':\\n el_im_loss,\\n 'acc':\\n el_im_acc,\\n 'cos_sim':\\n jnp.dot(intermediate_entity_cos_sim,\\n batch['mention_target_weights']),\\n 'denominator':\\n el_im_denom,\\n }\\n metrics['el_intermediate_masked'] = {\\n 'acc':\\n jnp.dot(el_im_correct_mask, mention_is_masked),\\n 'denominator':\\n jnp.dot(batch['mention_target_weights'],\\n batch['mention_target_is_masked']),\\n }\\n metrics['el_intermediate_non_masked'] = {\\n 'acc':\\n jnp.dot(el_im_correct_mask, (1 - mention_is_masked)),\\n 'denominator':\\n jnp.dot(batch['mention_target_weights'],\\n (1 - batch['mention_target_is_masked'])),\\n }\\n\\n im_final_mention_encodings_cos_sim = jut.cosine_similarity(\\n intermediate_target_mention_encodings,\\n loss_helpers['target_mention_encodings'])\\n metrics['im_final_mention_encodings'] = {\\n 'cos_sim':\\n jnp.dot(im_final_mention_encodings_cos_sim,\\n batch['mention_target_weights']),\\n 'denominator':\\n batch['mention_target_weights'].sum(),\\n }\\n\\n (el_final_loss, el_final_metrics,\\n (el_final_acc_per_mention,\\n el_final_weight_per_mention)) = mention_losses.entity_linking_loss(\\n loss_helpers['target_mention_encodings'],\\n loss_helpers['entity_embeddings'], mention_target_ids,\\n batch['mention_target_weights'], el_score_mode)\\n el_final_denom = el_final_metrics['denominator']\\n metrics['el_final'] = el_final_metrics\\n metrics['el_final_masked'] = {\\n 'acc':\\n jnp.dot(el_final_acc_per_mention,\\n el_final_weight_per_mention * mention_target_is_masked),\\n 'denominator':\\n jnp.dot(el_final_weight_per_mention, mention_target_is_masked),\\n }\\n metrics['el_final_non_masked'] = {\\n 'acc':\\n jnp.dot(\\n el_final_acc_per_mention,\\n el_final_weight_per_mention * mention_target_is_not_masked),\\n 'denominator':\\n jnp.dot(el_final_weight_per_mention,\\n mention_target_is_not_masked),\\n }\\n\\n loss = mlm_weight * mlm_loss / mlm_denom\\n loss += el_im_weight * el_im_loss / el_im_denom\\n loss += el_final_weight * el_final_loss / el_final_denom\\n\\n if mtb_im_weight > 0:\\n (mtb_im_loss, mtb_im_metrics) = mention_losses.mtb_loss(\\n intermediate_target_mention_encodings,\\n batch['mention_target_batch_positions'], mention_target_ids,\\n batch_size, mtb_score_mode, mention_target_is_masked, 'im_')\\n mtb_im_denom = mtb_im_metrics['im_mtb']['denominator']\\n loss += mtb_im_weight * mtb_im_loss / mtb_im_denom\\n metrics.update(mtb_im_metrics)\\n\\n if mtb_final_weight > 0:\\n (mtb_final_loss, mtb_final_metrics) = mention_losses.mtb_loss(\\n loss_helpers['target_mention_encodings'],\\n batch['mention_target_batch_positions'], mention_target_ids,\\n batch_size, mtb_score_mode, mention_target_is_masked, 'final_')\\n mtb_final_denom = mtb_final_metrics['final_mtb']['denominator']\\n loss += mtb_final_weight * mtb_final_loss / mtb_final_denom\\n metrics.update(mtb_final_metrics)\\n\\n metrics['agg'] = {\\n 'loss': loss,\\n 'denominator': 1.0,\\n }\\n return loss, metrics, {} # pytype: disable=bad-return-type # jax-ndarray\\n\\n return loss_fn\",\n \"def _get_loss_weight(self) -> torch.Tensor:\\n n_pos: torch.Tensor = 0.0\\n n_neg: torch.Tensor = 0.0\\n\\n for _, ground_truth in self.train_loader:\\n n_poss_curr = ground_truth.sum()\\n n_pos += n_poss_curr\\n n_neg += ground_truth.numel() - n_poss_curr\\n\\n eps = torch.finfo(n_pos.dtype).eps\\n return n_neg / (n_pos + eps)\",\n \"def compute_loss(model, loss_weights, init_img, gram_style_features, content_features):\\n style_weight, content_weight = loss_weights\\n\\n # Feed our init image through our model. This will give us the content and\\n # style representations at our desired layers. Since we're using eager\\n # our model is callable just like any other function!\\n model_outputs = model(init_img)\\n\\n style_output_features = model_outputs[:num_style_layers]\\n content_output_features = model_outputs[num_style_layers:]\\n\\n style_loss = 0\\n content_loss = 0\\n\\n # Accumulate style losses from all layers\\n # Here, we equally weight each contribution of each loss layer\\n weight_per_style_layer = 1.0 / float(num_style_layers)\\n for target_style, comb_style in zip(gram_style_features, style_output_features):\\n style_loss += weight_per_style_layer * get_style_loss(comb_style[0], target_style)\\n\\n # Accumulate content losses from all layers \\n weight_per_content_layer = 1.0 / float(num_content_layers)\\n for target_content, comb_content in zip(content_features, content_output_features):\\n content_loss += weight_per_content_layer* get_content_loss(comb_content[0], target_content)\\n\\n style_loss *= style_weight\\n content_loss *= content_weight\\n\\n # Get total loss\\n loss = style_loss + content_loss\\n return loss, style_loss, content_loss\",\n \"def construct_loss(self, logits, labels):\\n model_loss = tf.reduce_mean(\\n tf.nn.softmax_cross_entropy_with_logits_v2(labels=labels,\\n logits=logits))\\n return model_loss\",\n \"def loss(labels, embeddings):\\n # sourced from:\\n # https://github.com/tensorflow/tensorflow/blob/r1.14/tensorflow/contrib/losses/python/metric_learning/metric_loss_ops.py#L160-L239\\n labels = tf.cast(labels, tf.int32)\\n embeddings = tf.cast(embeddings, tf.float32)\\n embeddings = tf.nn.l2_normalize(embeddings, axis=1)\\n\\n # Reshape [batch_size] label tensor to a [batch_size, 1] label tensor.\\n lshape = tf.shape(labels)\\n if lshape.shape == 1:\\n labels = tf.reshape(labels, [lshape[0], 1])\\n\\n # Build pairwise squared distance matrix.\\n if metric == \\\"cosine\\\":\\n pdist_matrix = cosine_pairwise_distance(embeddings)\\n elif metric == \\\"euclidean\\\":\\n pdist_matrix = euclidean_pairwise_distance(\\n embeddings, squared=False)\\n elif metric == \\\"squared_euclidean\\\":\\n pdist_matrix = euclidean_pairwise_distance(\\n embeddings, squared=True)\\n # Build pairwise binary adjacency matrix.\\n adjacency = tf.equal(labels, tf.transpose(labels))\\n # Invert so we can select negatives only.\\n adjacency_not = tf.logical_not(adjacency)\\n\\n batch_size = tf.size(labels)\\n\\n # Compute the mask.\\n pdist_matrix_tile = tf.tile(pdist_matrix, [batch_size, 1])\\n mask = tf.logical_and(\\n tf.tile(adjacency_not, [batch_size, 1]),\\n tf.math.greater(\\n pdist_matrix_tile, tf.reshape(\\n tf.transpose(pdist_matrix), [-1, 1])))\\n mask_final = tf.reshape(\\n tf.math.greater(\\n tf.math.reduce_sum(\\n tf.cast(mask, dtype=tf.float32), 1, keepdims=True),\\n 0.0), [batch_size, batch_size])\\n mask_final = tf.transpose(mask_final)\\n\\n adjacency_not = tf.cast(adjacency_not, dtype=tf.float32)\\n mask = tf.cast(mask, dtype=tf.float32)\\n\\n # negatives_outside: smallest D_an where D_an > D_ap.\\n negatives_outside = tf.reshape(\\n masked_minimum(pdist_matrix_tile, mask), [batch_size, batch_size])\\n negatives_outside = tf.transpose(negatives_outside)\\n\\n # negatives_inside: largest D_an.\\n negatives_inside = tf.tile(\\n masked_maximum(pdist_matrix, adjacency_not), [1, batch_size])\\n semi_hard_negatives = tf.where(\\n mask_final, negatives_outside, negatives_inside)\\n\\n loss_mat = tf.math.add(margin, pdist_matrix - semi_hard_negatives)\\n\\n mask_positives = tf.cast(\\n adjacency, dtype=tf.float32) - tf.linalg.diag(\\n tf.ones([batch_size]))\\n\\n # In lifted-struct, the authors multiply 0.5 for upper triangular\\n # in semihard, they take all positive pairs except the diagonal.\\n num_positives = tf.math.reduce_sum(mask_positives)\\n\\n triplet_loss = tf.math.truediv(\\n tf.math.reduce_sum(\\n tf.math.maximum(\\n tf.math.multiply(loss_mat, mask_positives), y=0.0)),\\n num_positives, name=\\\"triplet_semihard_loss\\\")\\n\\n return triplet_loss\",\n \"def loss_fn(y_true,y_pred): \\n loss = tf.nn.softmax_cross_entropy_with_logits_v2(y_true,\\n y_pred,\\n axis=-1,\\n )\\n loss = tf.reduce_mean(loss,name=\\\"loss\\\")\\n return loss\",\n \"def _compute_kp_offset_loss(self, input_height, input_width, task_name,\\n offset_predictions, localization_loss_fn):\\n gt_keypoints_list = self.groundtruth_lists(fields.BoxListFields.keypoints)\\n gt_classes_list = self.groundtruth_lists(fields.BoxListFields.classes)\\n gt_weights_list = self.groundtruth_lists(fields.BoxListFields.weights)\\n\\n assigner = self._target_assigner_dict[task_name]\\n (batch_indices, batch_offsets,\\n batch_weights) = assigner.assign_keypoints_offset_targets(\\n height=input_height,\\n width=input_width,\\n gt_keypoints_list=gt_keypoints_list,\\n gt_weights_list=gt_weights_list,\\n gt_classes_list=gt_classes_list)\\n\\n # Keypoint offset loss.\\n loss = 0.0\\n for prediction in offset_predictions:\\n batch_size, out_height, out_width, channels = _get_shape(prediction, 4)\\n if channels > 2:\\n prediction = tf.reshape(\\n prediction, shape=[batch_size, out_height, out_width, -1, 2])\\n prediction = cn_assigner.get_batch_predictions_from_indices(\\n prediction, batch_indices)\\n # The dimensions passed are not as per the doc string but the loss\\n # still computes the correct value.\\n unweighted_loss = localization_loss_fn(\\n prediction,\\n batch_offsets,\\n weights=tf.expand_dims(tf.ones_like(batch_weights), -1))\\n # Apply the weights after the loss function to have full control over it.\\n loss += batch_weights * tf.reduce_sum(unweighted_loss, axis=1)\\n\\n loss = tf.reduce_sum(loss) / (\\n float(len(offset_predictions)) *\\n tf.maximum(tf.reduce_sum(batch_weights), 1.0))\\n return loss\",\n \"def weighted_loss(y_true, y_pred):\\r\\n # initialize loss to zero\\r\\n loss = 0.0\\r\\n for i in range(len(freq_pos)):\\r\\n # for each class, add average weighted loss for that class \\r\\n loss += -K.mean(freq_neg[i]*y_true[:,i]*K.log(y_pred[:,i] + epsilon) + freq_pos[i]*(1-y_true[:,i])*K.log(1-y_pred[:,i] + epsilon)) #complete this line\\r\\n return loss\",\n \"def build_loss(self):\\n if self.mode != \\\"encode\\\":\\n total_loss = tf.losses.get_total_loss()\\n tf.summary.scalar(\\\"losses/total\\\", total_loss)\\n\\n self.total_loss = total_loss\",\n \"def loss(self,\\n inputs: Union[Tensor, Tuple[Tensor]],\\n batch_data_samples: OptSampleList,\\n train_cfg: ConfigType = {}) -> dict:\\n\\n pred_outputs = self.forward(inputs)\\n\\n lifting_target_label = torch.cat([\\n d.gt_instance_labels.lifting_target_label\\n for d in batch_data_samples\\n ])\\n trajectory_weights = torch.cat([\\n d.gt_instance_labels.trajectory_weights for d in batch_data_samples\\n ])\\n\\n # calculate losses\\n losses = dict()\\n loss = self.loss_module(pred_outputs, lifting_target_label,\\n trajectory_weights.unsqueeze(-1))\\n\\n losses.update(loss_traj=loss)\\n\\n # calculate accuracy\\n _, avg_acc, _ = keypoint_pck_accuracy(\\n pred=to_numpy(pred_outputs),\\n gt=to_numpy(lifting_target_label),\\n mask=to_numpy(trajectory_weights) > 0,\\n thr=0.05,\\n norm_factor=np.ones((pred_outputs.size(0), 3), dtype=np.float32))\\n\\n mpjpe_traj = torch.tensor(avg_acc, device=lifting_target_label.device)\\n losses.update(mpjpe_traj=mpjpe_traj)\\n\\n return losses\",\n \"def loss(self, X, Y, lmd):\\n P, _ = self.forward(X)\\n loss = np.mean(-np.log(np.einsum('ij,ji->i', Y.T, P)))\\n\\n reg = 0 # Regularization term\\n for w in self.W:\\n reg += np.sum(np.square(w))\\n\\n reg *= lmd\\n\\n cost = loss + reg\\n\\n return cost\",\n \"def compute_loss(self,state,targets):\\n reshaped_targets = targets.reshape(-1,2,1)\\n\\n # reshape targets to match the dimension of means\\n for i in range(self.output_size-1):\\n reshaped_targets = torch.cat((reshaped_targets,targets.reshape(-1,2,1)),2)\\n\\n # compute output distribution from model\\n means,stds,weights = self.forward(state)\\n\\n # compute the mixed log pdf\\n mixed_pdf = mixed_prob(means,stds,weights,reshaped_targets)\\n\\n # compute the average negative log likelihood\\n return -torch.log(mixed_pdf).mean()\",\n \"def triplet_loss(y_true, y_pred, margin = 1):\\n\\n anchor = y_pred[0]\\n positive = y_pred[1]\\n negative = y_pred[2]\\n\\n # squared distance between the anchor and the positive\\n pos_dist = tf.math.reduce_sum(tf.math.square(anchor - positive), axis=-1)\\n\\n # squared distance between the anchor and the negative\\n neg_dist = tf.math.reduce_sum(tf.math.square(anchor - negative), axis=-1)\\n\\n # compute loss\\n basic_loss = margin + pos_dist - neg_dist\\n loss = tf.math.maximum(basic_loss,0.0)\\n loss = tf.math.reduce_mean(loss)\\n return loss\",\n \"def compute_loss(self, *args, **kwargs):\\n raise NotImplementedError\",\n \"def compute_loss(self, x, label):\\n # Forward propagation\\n y_hat = self.forward_pass(x)\\n return -np.log(y_hat[label])\",\n \"def calc_loss(self, codes, encodings):\\n return tf.reduce_mean((encodings - tf.stop_gradient(codes)) ** 2)\",\n \"def loss_fn(outputs, labels):\\n\\n # reshape labels to give a flat vector of length batch_size*seq_len\\n labels = labels.view(-1)\\n\\n # since PADding tokens have label -1, we can generate a mask to exclude the loss from those terms\\n mask = (labels >= 0).float()\\n\\n # indexing with negative values is not supported. Since PADded tokens have label -1, we convert them to a positive\\n # number. This does not affect training, since we ignore the PADded tokens with the mask.\\n labels = labels % outputs.shape[1]\\n\\n num_tokens = int(torch.sum(mask))\\n\\n # compute cross entropy loss for all tokens (except PADding tokens), by multiplying with mask.\\n return -torch.sum(outputs[range(outputs.shape[0]), labels]*mask)/num_tokens\",\n \"def compute_loss(self, x, y):\\n\\n self.batch_size = x.shape[0]\\n self.x = x\\n self.y = y\\n self.soft = self.softmax(x) + 10**(-11)\\n out = np.zeros(self.batch_size)\\n for i in range(self.batch_size):\\n out[i] = -(y[i] @ np.log(self.soft[i]))\\n\\n return out\",\n \"def loss(self, prediction_dict, preprocessed_dict, epsilon=1e-12):\\r\\n gt_images = preprocessed_dict.get('images')\\r\\n gt_fg = preprocessed_dict.get('images_fg')\\r\\n gt_bg = preprocessed_dict.get('images_bg')\\r\\n gt_alpha_matte = preprocessed_dict.get('alpha_mattes')\\r\\n gt_trimaps = preprocessed_dict.get('trimaps')\\r\\n\\r\\n pred_trimaps = prediction_dict.get('pred_trimap')\\r\\n alpha_matte_r = prediction_dict.get('alpha_matte_r')\\r\\n alpha_matte_p = prediction_dict.get('alpha_matte_p')\\r\\n background = prediction_dict.get('background')\\r\\n foreground = prediction_dict.get('foreground')\\r\\n\\r\\n pred_images = tf.multiply(alpha_matte_p, gt_fg) + tf.multiply(1 - alpha_matte_p, gt_bg)\\r\\n\\r\\n # weights = tf.where(tf.equal(pred_trimaps, 128),\\r\\n # tf.ones_like(pred_trimaps),\\r\\n # tf.zeros_like(pred_trimaps))\\r\\n # total_weights = tf.reduce_sum(weights) + epsilon\\r\\n\\r\\n # trimap_losses = tf.sqrt(tf.square(pred_trimaps - gt_trimaps) + epsilon)\\r\\n # trimap_losses = tf.reduce_mean(trimap_losses)\\r\\n\\r\\n trimap_losses = tf.losses.softmax_cross_entropy(\\r\\n tf.concat([gt_alpha_matte, 1 - gt_alpha_matte], axis=3),\\r\\n tf.concat([foreground, background], axis=3))\\r\\n alpha_losses = tf.sqrt(tf.square(alpha_matte_p - gt_alpha_matte) + epsilon)\\r\\n alpha_losses = tf.reduce_mean(alpha_losses)\\r\\n\\r\\n composition_losses = tf.sqrt(tf.square(pred_images / 255. - gt_images / 255.) + epsilon)\\r\\n composition_losses = tf.reduce_mean(composition_losses)\\r\\n\\r\\n loss = (self._alpha_loss_weight * alpha_losses +\\r\\n self._first_stage_image_loss_weight * composition_losses +\\r\\n self._trimap_loss_weight * trimap_losses)\\r\\n loss_dict = {'trimap_losses': trimap_losses,\\r\\n 'alpha_losses': alpha_losses,\\r\\n 'composition_losses': composition_losses,\\r\\n 'loss': loss}\\r\\n return loss_dict\",\n \"def calc_loss(self, codes, encodings):\\n return tf.reduce_mean((tf.stop_gradient(encodings) - codes) ** 2)\",\n \"def _create_loss(self):\\n with tf.device('/cpu:0'):\\n with tf.name_scope('loss'):\\n self.loss = tf.reduce_mean(\\n tf.nn.softmax_cross_entropy_with_logits(\\n labels=self.labels_placeholder, \\n logits=self.logits, name='loss'))\",\n \"def add_loss(self):\\n with vs.variable_scope(\\\"loss\\\"):\\n weights = tf.to_float(tf.not_equal(self.ans_ids, PAD_ID)) # [batch_size, context_len]\\n\\n # shift the weight right to include the end id\\n batch_size = tf.shape(weights)[0]\\n shift_val = tf.ones([batch_size, 1])\\n\\n self.new_ans_ids = tf.concat([self.ans_ids[:, 1:], tf.fill([batch_size, 1], 0)], 1)\\n self.logits = self.train_logits\\n weights = tf.concat([shift_val, weights], 1)[:, :-1]\\n self.loss = tf.contrib.seq2seq.sequence_loss(self.logits, self.new_ans_ids, weights=weights)\\n tf.summary.scalar('train_loss', self.loss)\\n tf.summary.scalar('sampling_prob', self.sampling_prob)\\n\\n if self.FLAGS.pred_method == 'beam':\\n self.dev_logits = tf.Print(self.dev_logits[:, :, 0], [tf.shape(self.dev_logit), self.dev_logits[0, :, 0]])\\n self.dev_loss = tf.cast(self.dev_logits[0, 0], tf.float32)\\n return\\n dev_logits_len = tf.to_int32(tf.shape(self.dev_logits)[1])\\n weights = tf.concat([weights[:, 1:], tf.fill([batch_size, 1], 0.0)], 1)\\n self.dev_loss = tf.contrib.seq2seq.sequence_loss(\\n self.dev_logits, self.new_ans_ids[:, :dev_logits_len],\\n weights=weights[:, :dev_logits_len])\",\n \"def calculate_loss(self, train_x, train_y):\\n self.log.info(\\\"Calculating average categorical crossentropy loss...\\\")\\n\\n num_words = np.sum([len(y) for y in train_y])\\n return self.calculate_total_loss(train_x, train_y)/float(num_words)\",\n \"def loss(self, labels, logits, mask=None):\\n losses = tf.nn.softmax_cross_entropy_with_logits(tf.one_hot(labels, depth=logits.shape[-1]), logits, axis=-1)\\n seq_mask = mask # logits._keras_mask# tf.sequence_mask(lengths, self.seq_len)\\n loss = tf.reduce_mean(tf.boolean_mask(losses, seq_mask))\\n\\n return loss\",\n \"def calc_loss(self, x: np.ndarray, y: np.ndarray) -> float:\\n return self.descent.calc_loss(x, y)\",\n \"def compute_loss(model, loader, loss_fn, optimizer=None):\\n\\n total_loss = 0.0\\n count_batches = 0\\n for x_, y_, qm_, db_mask, blink_mask in loader:\\n batch_loss_list = []\\n xbatch_list = []\\n for mask in [db_mask, blink_mask]:\\n idxes = get_idxes_from_mask(mask)\\n x_pick, y_pick, qm_pick = x_[idxes], y_[idxes], qm_[idxes]\\n y_pos_idxes = torch.nonzero(y_pick.squeeze(), as_tuple=False).reshape(1, -1)[0]\\n y_neg_idxes = torch.nonzero(~y_pick.squeeze().bool(), as_tuple=False).reshape(1, -1)[0]\\n\\n if (len(y_pos_idxes) == 0) or (len(y_neg_idxes) == 0):\\n xbatch_list.append(torch.tensor([]))\\n continue\\n elif len(x_pick) <= 1:\\n xbatch_list.append(torch.tensor([]))\\n continue\\n elif len(y_pos_idxes) == 1:\\n y_pos_idx = y_pos_idxes[0]\\n else: # len(y_pos_idxes) > 1:\\n # TODO: I am just always using the first positive example for now\\n # rand_idx = random.choice(list(range(len(y_pos_idxes))))\\n # print(y_pos_idxes)\\n rand_idx = 0\\n y_pos_idx = y_pos_idxes[rand_idx]\\n\\n batch_length = 1 + len(y_neg_idxes)\\n batch_feature_len = x_.shape[1]\\n x_batch = torch.zeros(batch_length, batch_feature_len)\\n x_batch[:-1:, :] = x_pick[y_neg_idxes]\\n x_batch[-1, :] = x_pick[y_pos_idx] # put positive to the end\\n xbatch_list.append(x_batch)\\n # print(y_pos_idx, len(y_neg_idxes))\\n # print(\\\"batch\\\", x_batch.shape)\\n\\n if (len(xbatch_list[0]) == 0) and (len(xbatch_list[1]) == 0):\\n # skip if both batches are []\\n # print(\\\"hitting cases without any examples [SHOULD BE WRONG]\\\")\\n continue\\n elif (len(xbatch_list[0]) == 0) or (len(xbatch_list[1]) == 0):\\n # continue # TODO: testing whether improvements made if we only use cases where there are sources from both\\n yhat = model(xbatch_list[0], xbatch_list[1])\\n extended_batch_length = len(yhat) - 1\\n yhat_neg = yhat[:-1]\\n yhat_pos = yhat[-1].repeat(extended_batch_length, 1)\\n loss = loss_fn(yhat_pos, yhat_neg, torch.ones((len(yhat) - 1), 1).to(device))\\n batch_loss_list.append(loss)\\n total_loss += loss.item() * extended_batch_length\\n count_batches += 1\\n else:\\n # get yhats for both BLINK and DB batches\\n # print(len(xbatch_list[0]), len(xbatch_list[1]))\\n # print((xbatch_list[0], xbatch_list[1]))\\n yhat = model(xbatch_list[0], xbatch_list[1])\\n extended_batch_length = len(yhat) - 2\\n yhat_neg = torch.zeros(extended_batch_length, 1)\\n yhat_neg[:len(xbatch_list[0])-1] = yhat[:len(xbatch_list[0])-1]\\n yhat_neg[len(xbatch_list[0])-1:] = yhat[len(xbatch_list[0]):-1]\\n for idx in [len(xbatch_list[0]), -1]:\\n yhat_pos = yhat[idx].repeat(extended_batch_length, 1)\\n loss = loss_fn(yhat_pos, yhat_neg, torch.ones(extended_batch_length, 1).to(device))\\n batch_loss_list.append(loss)\\n total_loss += loss.item() * extended_batch_length\\n count_batches += 1\\n\\n # update every question-mention\\n if batch_loss_list and optimizer:\\n (sum(batch_loss_list)/len(batch_loss_list)).backward()\\n optimizer.step()\\n\\n avg_loss = total_loss / count_batches\\n\\n return avg_loss, batch_length\",\n \"def loss(self, prediction_dict, groundtruth_lists):\\r\\n pass\",\n \"def meta_amortized_loss(network, model_indices, params, sim_data):\\n\\n out_inference, out_evidence = network(model_indices, params, sim_data)\\n if out_inference is not None:\\n z, log_det_J = out_inference\\n kl_loss = tf.reduce_mean(0.5 * tf.square(tf.norm(z, axis=-1)) - log_det_J)\\n else:\\n kl_loss = 0\\n \\n if out_evidence is not None:\\n model_probs = out_evidence\\n model_probs = tf.clip_by_value(model_probs, 1e-15, 1 - 1e-15)\\n log_loss = -tf.reduce_mean(tf.reduce_sum(model_indices * tf.math.log(model_probs), axis=1))\\n else:\\n log_loss = 0\\n return kl_loss + log_loss\",\n \"def calculate_validation_loss(self):\\n self.network.train()\\n self.validation_average_loss = self.calculate_average_loss(self.validation_dataloader)\",\n \"def loss(self, logits, labels):\\r\\n return tf.reduce_mean(tf.keras.losses.binary_crossentropy(labels,logits))\",\n \"def unlabeled_loss_calculation(self, labeled_examples, unlabeled_examples):\\n _, fake_scores = self.D(unlabeled_examples)\\n criterion = BCEWithLogitsLoss()\\n unlabeled_loss = criterion(fake_scores, torch.zeros_like(fake_scores))\\n unlabeled_loss *= self.settings.matching_loss_multiplier\\n unlabeled_loss *= self.settings.dggan_loss_multiplier\\n return unlabeled_loss\",\n \"def compute_loss(self, logits, targets, mu, sigma):\\n logits_flat = tf.reshape(logits, [self.batch_size, self.height*self.width*self.cdim])\\n targets_flat = tf.reshape(targets, [self.batch_size, self.height*self.width*self.cdim])\\n #encode_decode_loss = targets_flat * tf.log(1e-10 + logits_flat) + (1 - targets_flat) * tf.log(1e-10 + 1 - logits_flat)\\n #encode_decode_loss = -tf.reduce_sum(encode_decode_loss, 1)\\n latent_loss = 1 + sigma - tf.square(mu) - tf.exp(sigma)\\n latent_loss = -0.1 * tf.reduce_sum(latent_loss, 1)\\n img_loss = tf.losses.absolute_difference(labels=targets_flat, predictions=logits_flat)\\n loss = tf.reduce_mean(img_loss)\\n return loss\",\n \"def calculate_loss(self, a, label):\\n if self.loss == 'mse':\\n diff = a - label\\n err = np.square(diff).mean(axis=0).mean()\\n elif self.loss == 'ce':\\n return sum(-np.log2(a[label > 0]))\\n else:\\n raise ValueError('loss function not implemented')\\n return err\",\n \"def loss(data, y_pred):\\n # TODO: Try using points other than the training data points for the divergence calculation.\\n y_true = data[:,:2]\\n p1 = data[:,2:5]\\n p2 = data[:,5:8]\\n p3 = data[:,8:11]\\n p4 = data[:,11:14]\\n\\n ### Calculate divergence using model predictions:\\n\\n # Step 1: Use the model to calculate predicted wind field in the surrounding points p1, p2, p3 and p4.\\n y_pred_p1 = model(p1)\\n y_pred_p2 = model(p2)\\n y_pred_p3 = model(p3)\\n y_pred_p4 = model(p4)\\n\\n # Step 2: Calculate the partial derivatives with a three-point centered difference.\\n scale_x = self.scaler_data.scale_[0] #scale-factor for x\\n scale_y = self.scaler_data.scale_[1] #scale-factor for y\\n\\n dudx = (y_pred_p1[:, 0] - y_pred_p3[:, 0]) / (p1[:,0] - p3[:,0]) # <- pj = transformed data\\n dvdy = (y_pred_p2[:, 1] - y_pred_p4[:, 1]) / (p2[:,1] - p4[:,1]) # <- pj = transformed data\\n\\n # Step 3: Calculate the divergence.\\n divergence = ( dudx / scale_x + dvdy / scale_y ) * np.mean([scale_x, scale_y])\\n #tf.print(K.mean(K.abs(divergence)))\\n\\n # Step 4: Calculate and return total loss.\\n return K.mean(K.square(y_true - y_pred)) + gamma*K.mean(K.square(divergence))\",\n \"def _compute_loss(self, inputs, logits, targets, idxes):\\n clf_loss = F.cross_entropy(logits, targets)\\n\\n if self._task == 0:\\n distil_loss = torch.zeros(1, device=self._device)\\n else:\\n if self._finetuning:\\n # We only do distillation on current task during the distillation\\n # phase:\\n last_index = len(self._task_idxes)\\n else:\\n last_index = len(self._task_idxes) - 1\\n\\n distil_loss = 0.\\n #with torch.no_grad():\\n previous_logits = self._old_model(inputs)\\n\\n for i in range(last_index):\\n task_idxes = self._task_idxes[i]\\n\\n distil_loss += F.binary_cross_entropy(\\n F.softmax(logits[..., task_idxes] / self._temperature, dim=1),\\n F.softmax(previous_logits[..., task_idxes] / self._temperature, dim=1)\\n )\\n\\n return clf_loss, distil_loss\",\n \"def triplet_loss(y_true, y_pred, alpha = 0.2):\\r\\n \\r\\n anchor, positive, negative = y_pred[0], y_pred[1], y_pred[2]\\r\\n \\r\\n # Step 1: Compute the (encoding) distance between the anchor and the positive, you will need to sum over axis=-1\\r\\n pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, positive)), axis=-1)\\r\\n # Step 2: Compute the (encoding) distance between the anchor and the negative, you will need to sum over axis=-1\\r\\n neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, negative)), axis=-1)\\r\\n # Step 3: subtract the two previous distances and add alpha.\\r\\n basic_loss = tf.add(tf.subtract(pos_dist, neg_dist), alpha)\\r\\n # Step 4: Take the maximum of basic_loss and 0.0. Sum over the training examples.\\r\\n loss = tf.reduce_sum(tf.maximum(basic_loss, 0))\\r\\n # END CODE HERE \\r\\n \\r\\n return loss\",\n \"def _compute_loss(self, loss_weights, init_image, gram_style_features,\\n content_features):\\n style_weight, content_weight, ta_weight = loss_weights\\n\\n # Feed our init image through our model. This will give us the content and\\n # style representations at our desired layers.\\n model_outputs = self.model(init_image)\\n\\n style_output_features = model_outputs[:self.num_style_layers]\\n content_output_features = model_outputs[self.num_style_layers:]\\n\\n total_style_score = 0\\n total_content_score = 0\\n total_ta_score = 0\\n # Accumulate style losses from all layers\\n # Here, we equally weight each contribution of each loss layer\\n averge_style_weight = 1.0 / float(self.num_style_layers)\\n for target_style, comb_style in zip(gram_style_features,\\n style_output_features):\\n total_style_score += averge_style_weight * \\\\\\n self._get_style_loss(comb_style[0], target_style)\\n\\n # Accumulate content losses from all layers\\n average_content_weight = 1.0 / float(self.num_content_layers)\\n for target_content, comb_content in zip(content_features,\\n content_output_features):\\n total_content_score += average_content_weight * \\\\\\n self._get_content_loss(comb_content[0], target_content)\\n # Get Variation loss of the image\\n total_ta_score = self._get_total_variational_loss(\\n init_image) * ta_weight\\n total_style_score *= style_weight\\n total_content_score *= content_weight\\n\\n # Get total loss\\n total_loss = total_style_score + total_content_score + total_ta_score\\n return total_loss, total_style_score, total_content_score\",\n \"def triplet_loss(y_true, y_pred, alpha = 0.2):\\n \\n anchor, positive, negative = y_pred[0], y_pred[1], y_pred[2]\\n \\n ### START CODE HERE ### (≈ 4 lines)\\n # Step 1: Compute the (encoding) distance between the anchor and the positive, you will need to sum over axis=-1\\n pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor,positive)),axis=-1)\\n # Step 2: Compute the (encoding) distance between the anchor and the negative, you will need to sum over axis=-1\\n neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor,negative)),axis=-1)\\n # Step 3: subtract the two previous distances and add alpha.\\n basic_loss = pos_dist-neg_dist+alpha\\n # Step 4: Take the maximum of basic_loss and 0.0. Sum over the training examples.\\n loss = tf.reduce_sum(tf.maximum(basic_loss, 0.0))\\n ### END CODE HERE ###\\n \\n return loss\",\n \"def calculate_loss(self, outputs, teacher_predictions, labels=None):\\n return self.loss(outputs,\\n (teacher_predictions[:, :, :self.target_dim],\\n teacher_predictions[:, :, self.target_dim:]))\",\n \"def compute_loss(self, x, gt):\\n loss = sum([torch.mean((out - gt)**2) for out in self.forward(x)])\\n return loss\",\n \"def calculate_loss(estimated_separation, true_separation, mask, true_latents, estimated_mix, true_mix, args):\\n stats = torch.zeros(7)\\n sdr = sdr_objective(estimated_separation, true_separation, mask)\\n stats[:4] = sdr\\n total_loss = -sdr.sum()\\n reconstruction_sdr = sdr_objective(estimated_mix, true_mix).mean() if args.reconstruction_loss_weight > 0 else 0.0\\n stats[4] = reconstruction_sdr\\n total_loss += -args.reconstruction_loss_weight * reconstruction_sdr\\n if args.similarity_loss_weight > 0.0 or args.dissimilarity_loss_weight > 0.0:\\n mask = mask.squeeze(-1)\\n true_latents = true_latents * mask.unsqueeze(-1).unsqueeze(-1)\\n true_latents = true_latents.transpose(0, 1)\\n dissimilarity = dissimilarity_loss(true_latents, mask) if args.dissimilarity_loss_weight > 0.0 else 0.0\\n stats[5] = dissimilarity\\n total_loss += args.dissimilarity_loss_weight * dissimilarity\\n similarity = similarity_loss(true_latents, mask) if args.similarity_loss_weight > 0.0 else 0.0\\n stats[6] = similarity\\n total_loss += -args.similarity_loss_weight * similarity\\n return total_loss, stats\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.712148","0.70395255","0.7023037","0.6964694","0.6878926","0.6830145","0.6824834","0.6801352","0.6765133","0.67370236","0.67324895","0.67233557","0.67031574","0.67031574","0.6662697","0.6619361","0.6566079","0.6541267","0.6530644","0.6516976","0.6510028","0.6506518","0.6490678","0.64813644","0.6474931","0.64581525","0.64505494","0.644302","0.64193135","0.6418019","0.6418007","0.63963854","0.6376169","0.6363336","0.63565415","0.63496596","0.63458663","0.63278675","0.6326512","0.6324953","0.63238907","0.6321847","0.6320801","0.6310645","0.6309402","0.6305369","0.6296458","0.6293064","0.62881845","0.6263457","0.6260065","0.6259741","0.6258208","0.6252107","0.6245093","0.6243781","0.62405753","0.62387276","0.621047","0.62077993","0.6202383","0.61964583","0.6189335","0.6185913","0.61829823","0.6181536","0.6176693","0.6173103","0.61704683","0.6163325","0.615677","0.6155049","0.61518437","0.61481506","0.614069","0.61366403","0.6134634","0.6133144","0.61267734","0.6115182","0.61143064","0.6110962","0.61004263","0.60944015","0.60837054","0.6078664","0.60780585","0.60636","0.6063008","0.6059914","0.60574204","0.6051259","0.6050723","0.60497606","0.6047383","0.6043832","0.6037558","0.603474","0.60345346","0.6034348"],"string":"[\n \"0.712148\",\n \"0.70395255\",\n \"0.7023037\",\n \"0.6964694\",\n \"0.6878926\",\n \"0.6830145\",\n \"0.6824834\",\n \"0.6801352\",\n \"0.6765133\",\n \"0.67370236\",\n \"0.67324895\",\n \"0.67233557\",\n \"0.67031574\",\n \"0.67031574\",\n \"0.6662697\",\n \"0.6619361\",\n \"0.6566079\",\n \"0.6541267\",\n \"0.6530644\",\n \"0.6516976\",\n \"0.6510028\",\n \"0.6506518\",\n \"0.6490678\",\n \"0.64813644\",\n \"0.6474931\",\n \"0.64581525\",\n \"0.64505494\",\n \"0.644302\",\n \"0.64193135\",\n \"0.6418019\",\n \"0.6418007\",\n \"0.63963854\",\n \"0.6376169\",\n \"0.6363336\",\n \"0.63565415\",\n \"0.63496596\",\n \"0.63458663\",\n \"0.63278675\",\n \"0.6326512\",\n \"0.6324953\",\n \"0.63238907\",\n \"0.6321847\",\n \"0.6320801\",\n \"0.6310645\",\n \"0.6309402\",\n \"0.6305369\",\n \"0.6296458\",\n \"0.6293064\",\n \"0.62881845\",\n \"0.6263457\",\n \"0.6260065\",\n \"0.6259741\",\n \"0.6258208\",\n \"0.6252107\",\n \"0.6245093\",\n \"0.6243781\",\n \"0.62405753\",\n \"0.62387276\",\n \"0.621047\",\n \"0.62077993\",\n \"0.6202383\",\n \"0.61964583\",\n \"0.6189335\",\n \"0.6185913\",\n \"0.61829823\",\n \"0.6181536\",\n \"0.6176693\",\n \"0.6173103\",\n \"0.61704683\",\n \"0.6163325\",\n \"0.615677\",\n \"0.6155049\",\n \"0.61518437\",\n \"0.61481506\",\n \"0.614069\",\n \"0.61366403\",\n \"0.6134634\",\n \"0.6133144\",\n \"0.61267734\",\n \"0.6115182\",\n \"0.61143064\",\n \"0.6110962\",\n \"0.61004263\",\n \"0.60944015\",\n \"0.60837054\",\n \"0.6078664\",\n \"0.60780585\",\n \"0.60636\",\n \"0.6063008\",\n \"0.6059914\",\n \"0.60574204\",\n \"0.6051259\",\n \"0.6050723\",\n \"0.60497606\",\n \"0.6047383\",\n \"0.6043832\",\n \"0.6037558\",\n \"0.603474\",\n \"0.60345346\",\n \"0.6034348\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7048177"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":81980,"cells":{"query":{"kind":"string","value":"Implementing this function makes the model usable for translation, eg. for use in SGNMT via the nizza predictor. This function must return a distribution log P(f_j|f_1^j_1, e_1^I) such that summing over all target words yields log P(f_1^J|e_1^J). For example, This often requires maginalizing over the alignments."},"document":{"kind":"string","value":"def predict_next_word(self, features, params, precomputed):\n raise NotImplementedError(\"Model does not implement word prediction.\")"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def compute_log_probs(self, phrases, save_to_file=None):\n # Co-ocurrence for source and target phrase\n tgt_src_cnt = defaultdict(lambda: defaultdict(int))\n \n # ocurrence for target (English)\n tgt_cnt = defaultdict(int)\n\n # Compute frequency and co-occurence\n for phrase_pair in phrases:\n\n assert len(phrase_pair) == 2\n src_p, tgt_p = phrase_pair\n # defaultdict[target_phrase][source_phrase]\n tgt_src_cnt[tgt_p][src_p]+=1\n # defaultdict[target_phrase]\n tgt_cnt[tgt_p]+=1\n\n\n # Calculate log prob of translation model p(f|e)\n log_prob_lst = list()\n for tgt_phrase in tgt_src_cnt:\n for src_phrase in tgt_src_cnt[tgt_phrase]:\n # count(source, target) / count(target)\n prob = float(tgt_src_cnt[tgt_phrase][src_phrase])/tgt_cnt[tgt_phrase]\n log_prob = math.log(prob)\n\n log_prob_str = f\"{src_phrase} ||| {tgt_phrase} ||| {str(log_prob)}\"\n log_prob_lst.append(log_prob_str)\n \n # Save to file \n if save_to_file is not None:\n with Path(save_to_file).open(\"w\") as wf:\n wf.write('\\n'.join(log_prob_lst))\n sys.stdout.write(f\"Saving phrase log probability file to path: {save_to_file}.\\n\")\n \n # List of log probability for phrase pair\n return log_prob_lst","def log_prob(self):","def train(self, documents):\n prior_log_prob, label_to_col = self.get_prior_log_probabilities(documents)\n self.my_model[\"vocabulary\"] = make_vocabulary(documents)\n\n # find frequencies of features\n num_classes = len(label_to_col)\n num_features = len(self.extract_f_vector(documents[0]))\n features_freq = np.zeros((num_features, num_classes))\n for doc in documents:\n f_vector = self.extract_f_vector(doc)\n col_for_f_vector = label_to_col[doc.label]\n features_freq[:, col_for_f_vector] += f_vector\n\n # laplace smoothing\n total_per_label = np.sum(features_freq, axis=0)\n features_freq += np.ones(total_per_label.shape, int)\n normalizer = total_per_label + np.full(total_per_label.shape, num_features, int)\n features_freq /= normalizer\n\n # stack all probabilities to one matrix and take log\n # result: self.all_log_prob\n # |-----------------------------------|\n # | log P(f1|C1) | ... | log P(f1|Cn) |\n # | log P(f2|C1) | ... | log P(f2|Cn) |\n # | . | . | . |\n # | . | . | . |\n # | . | . | . |\n # | log P(fm|C1) | ... | log P(fm|Cn) |\n # | log P(C1) | ... | log P(Cn) |\n # |-----------------------------------|\n likelihood_log_prob = np.log(features_freq)\n all_log_prob = np.vstack((likelihood_log_prob, prior_log_prob))\n self.my_model[\"all_log_prob\"] = all_log_prob","def log_prob(sentence, LM, smoothing=False, delta=0, vocabSize=0):\n word_list = sentence.split()\n log_prob = 0\n for i in range(len(word_list)-1):\n print(word_list[i], word_list[i+1])\n bi_count = LM['bi'][word_list[i]][word_list[i+1]]\n uni_count = LM['uni'][word_list[i]]\n if uni_count == 0 and smoothing:\n return float('-inf')\n log_prob += log(((bi_count + delta)/(uni_count + delta * vocabSize)))\n return log_prob","def calculate_log_perplexity(self, output, flat_labels): #completed, expensive, should be compiled\n return -np.sum(np.log2(np.clip(output, a_min=1E-12, a_max=1.0))[np.arange(flat_labels.shape[0]), flat_labels[:,1]])","def get_value(self, **kwargs):\n super(PerplexityMetric, self).set_parameters(**kwargs)\n corpus_words = sum(cnt for document in self.corpus for _, cnt in document)\n # 単語1語あたりの、接続候補の数。少ないほどエントロピーが少なくて良くまとまっている\n perwordbound = self.model.bound(self.corpus) / corpus_words\n self.log.add(perwordbound)\n if len(self.log) > 2:\n diff = np.diff(np.array(self.log))\n # とても心苦しいが、early stoppingで止める方法がexception raiseしか思いつかなかった。\n # ## exceptionをこんなふうに使ってよかったっけ?\n if np.abs(1 - np.mean(diff[-self.patience]) / diff[-1]) < self.must_move_this_rate:\n # 直近patience回の平均が変わらないなら、多分収束\n raise EarlyStoppingException(\"no movement\")\n if np.abs(diff[-1] / diff[0]) < self.must_move_this_rate:\n # 初期変化量のmust_move_this_rate(float < 1)も変わらなければ、多分収束\n raise EarlyStoppingException(\"converged\")\n\n return np.exp2(-perwordbound)","def calculate_perplexity(sentence, n_gram_counts, n_plus1_gram_counts, vocabulary_size, k=1.0):\r\n # length of previous words\r\n n = len(list(n_gram_counts.keys())[0]) \r\n \r\n # prepend <s> and append <e>\r\n sentence = [\"<s>\"] * n + sentence + [\"<e>\"]\r\n \r\n # Cast the sentence from a list to a tuple\r\n sentence = tuple(sentence)\r\n \r\n # length of sentence (after adding <s> and <e> tokens)\r\n N = len(sentence)\r\n \r\n\r\n product_pi = 1.0\r\n \r\n \r\n # Index t ranges from n to N - 1, inclusive on both ends\r\n for t in range(n, N): \r\n\r\n # get the n-gram preceding the word at position t\r\n n_gram = sentence[t-n:t]\r\n \r\n # get the word at position t\r\n word = sentence[t]\r\n \r\n\r\n probability = estimate_probability(word, n_gram, n_gram_counts, n_plus1_gram_counts, vocabulary_size, k=1.0)\r\n \r\n\r\n product_pi *= 1/probability\r\n\r\n # Take the Nth root of the product\r\n perplexity = product_pi**(1/float(N))\r\n return perplexity","def log_joint(self):\n return sum([\n self.log_marg_like(self.gamma, self.gamma0, self.lamb, self.nu),\n self._gamma0_distribution.logpdf(self.gamma0),\n self._nu_distribution.logpdf(self.nu),\n self._lambda_distribution.logpdf(self.lamb),\n self.probit_distribution(self.xi).logpdf(self.gamma),\n self._xi_distribution.logpdf(self.xi) if self.sample_xi else 0.0\n ])","def perplexity(sentences: List[Tuple[List[int], List[int]]], model: Seq2SeqAttentionModel) -> float:\n LL_Total = torch.tensor(0, dtype=torch.float)\n total_words = torch.tensor(0, dtype=torch.float)\n for i, (source_sentence, target_sentence) in enumerate(sentences):\n LL_Total += log_likelihood(source_sentence, target_sentence, model)\n total_words += len(target_sentence)\n\n return torch.exp(-LL_Total / total_words)","def nce_logprobs(self, logit_target_in_model, logit_noise_in_model, logit_noise_in_noise, logit_target_in_noise):\n\n # NOTE: prob <= 1 is not guaranteed\n logit_model = torch.cat([logit_target_in_model.unsqueeze(2), logit_noise_in_model], dim=2)\n logit_noise = torch.cat([logit_target_in_noise.unsqueeze(2), logit_noise_in_noise], dim=2)\n\n # predicted probability of the word comes from true data distribution\n # The posterior can be computed as following\n # p_true = logit_model.exp() / (logit_model.exp() + self.noise_ratio * logit_noise.exp())\n # For numeric stability we compute the logits of true label and\n # directly use bce_with_logits.\n # Ref https://pytorch.org/docs/stable/nn.html?highlight=bce#torch.nn.BCEWithLogitsLoss\n #logit_true = logit_model - logit_noise - math.log(self.noise_ratio)\n p_true = logit_model.exp() / (logit_model.exp() + self.noise_ratio * logit_noise.exp())\n \n label = torch.zeros_like(logit_model)\n label[:, :, 0] = 1\n\n #logprobs = -self.bce_with_logits(logit_true, label)\n logprobs = -nn.BCELoss(reduction='none')(p_true, label)\n logprobs = torch.sum(logprobs.view(logprobs.size(0), -1), dim=1)\n \n return logprobs","def compute_probabilities():\n global total_spam_words, total_ham_words\n total_words = total_spam_words+total_ham_words\n unique_words = len(all_dict)\n print(\"Training Set Description: \")\n len_ham = len(ham_file_list)\n len_spam = len(spam_file_list)\n print(\"SPAM EMAILS: \",len_spam)\n print(\"HAM EMAILS: \",len_ham)\n print(\"Total words: \",total_words)\n print(\"Training...\")\n \n spam_probability = math.log((len_spam)/(len_spam+len_ham))\n ham_probability = math.log((len_ham)/(len_spam+len_ham))\n \n \n \n output_file = open(\"nbmodel.txt\", \"w+\", encoding=\"latin-1\")\n output_file.write(\"model_params \"+str(spam_probability)+\" \"+str(ham_probability)+\"\\n\")\n \n nbmodel = {}\n nbmodel[\"model_params\"] = (spam_probability,ham_probability)\n for word in all_dict.keys():\n spam_count = 1\n if word in spam_dict:\n spam_count+= spam_dict[word]\n \n word_spam_probability = math.log(spam_count / (total_spam_words+unique_words))\n \n ham_count = 1\n if word in ham_dict:\n ham_count+= ham_dict[word]\n \n word_ham_probability = math.log(ham_count / (total_ham_words+unique_words))\n \n output_file.write(word+\" \"+str(word_spam_probability)+\" \"+str(word_ham_probability)+\"\\n\")\n nbmodel[word] = (word_spam_probability, word_ham_probability) \n \n print(\"nbmodel.txt generated successfully...\")\n print(\"SPAM Probability: \",spam_probability)\n print(\"HAM Probability: \",ham_probability)\n output_file.close()","def weight_distribution(self):\n all_scores = []\n for zettel in self.lemma_tokens:\n scores = []\n for word in zettel:\n cur_tf_idf = self.tf_idf_scores[word[0]] / 3 #range: 0-3+\n if word[1] == 'NG':\n word_list = re.split(\" \", word[0])\n cur_word_score = 0\n i = 0\n for new_word in word_list:\n cur_word_score += self.word_scores[new_word]\n i += 1\n cur_word_score = cur_word_score / i / 2 #range: 0-2+\n else:\n cur_word_score = self.word_scores[word[0]] / 2 #range: 0-2+\n cur_keyword_score = self.keyword_scores[word[0]] / 4 #0-4+\n cur_text_rank = self.text_ranks[word[0]] / 10 #range: 0-12+\n cur_pos_score = self.pos_scores[word[0]]\n cur_area_score = self.z_area_scores[word[0]]\n cur_total_score = ((cur_tf_idf * self.score_weights[0]) + (cur_word_score * self.score_weights[1]) +\n (cur_keyword_score * self.score_weights[2]) + (cur_text_rank * self.score_weights[3]) +\n (cur_pos_score * self.score_weights[4]) + (cur_area_score * self.score_weights[5])) / 6\n scores.append(cur_total_score)\n all_scores.append(scores)\n return all_scores","def posterior(self, model, sentence, label):\r\n\r\n if model == \"Simple\":\r\n cost = sum(\r\n [\r\n (\r\n (math.log(self.emission_probability[label[i]][sentence[i]]))\r\n + (math.log(self.posterior_probability[label[i]]))\r\n if sentence[i] in self.emission_probability[label[i]]\r\n else (math.log(1 / float(10 ** 10)))\r\n + (math.log(self.posterior_probability[label[i]]))\r\n )\r\n for i in range(len(sentence))\r\n ]\r\n )\r\n return cost\r\n elif model == \"Complex\":\r\n post_array = []\r\n for i in range(len(sentence)):\r\n if i == 0:\r\n post_array.append(\r\n self.emission_probability[label[i]][sentence[i]]\r\n * self.initial_probability[label[i]]\r\n if sentence[i] in self.emission_probability[label[i]]\r\n else (1 / float(10 ** 10)) * self.initial_probability[label[i]]\r\n )\r\n elif i == 1:\r\n post_array.append(\r\n self.emission_probability[label[i]][sentence[i]]\r\n * (\r\n self.transition_probability[label[i - 1]][label[i]]\r\n * self.posterior_probability[label[i - 1]]\r\n / self.posterior_probability[label[i]]\r\n )\r\n * self.posterior_probability[label[i]]\r\n if sentence[i] in self.emission_probability[label[i]]\r\n else (1 / float(10 ** 10))\r\n * (\r\n self.transition_probability[label[i - 1]][label[i]]\r\n * self.posterior_probability[label[i - 1]]\r\n / self.posterior_probability[label[i]]\r\n )\r\n * self.posterior_probability[label[i]]\r\n )\r\n else:\r\n post_array.append(\r\n self.emission_probability[label[i]][sentence[i]]\r\n * (\r\n self.transition_probability[label[i - 1]][label[i]]\r\n * self.posterior_probability[label[i - 1]]\r\n / self.posterior_probability[label[i]]\r\n )\r\n * (\r\n self.transition_probability[label[i - 1]][label[i]]\r\n * self.posterior_probability[label[i - 2]]\r\n / self.posterior_probability[label[i]]\r\n )\r\n * self.posterior_probability[label[i]]\r\n if sentence[i] in self.emission_probability[label[i]]\r\n else (1 / float(10 ** 10))\r\n * (\r\n self.transition_probability[label[i - 1]][label[i]]\r\n * self.posterior_probability[label[i - 1]]\r\n / self.posterior_probability[label[i]]\r\n )\r\n * (\r\n self.transition_probability[label[i - 2]][label[i]]\r\n * self.posterior_probability[label[i - 2]]\r\n / self.posterior_probability[label[i]]\r\n )\r\n * self.posterior_probability[label[i]]\r\n )\r\n post_array = [math.log(p) for p in post_array]\r\n cost = sum(post_array)\r\n return cost\r\n\r\n elif model == \"HMM\":\r\n post_array = []\r\n for i in range(len(sentence)):\r\n if i == 0:\r\n post_array.append(\r\n (\r\n self.initial_probability[label[i]]\r\n * self.emission_probability[label[i]][sentence[i]]\r\n )\r\n if sentence[i] in self.emission_probability[label[i]]\r\n else (self.initial_probability[label[i]] * (1 / float(10 ** 8)))\r\n )\r\n else:\r\n emi = (\r\n (self.emission_probability[label[i]][sentence[i]])\r\n if sentence[i] in self.emission_probability[label[i]]\r\n else (1 / float(10 ** 10))\r\n )\r\n\r\n min_val = post_array[i - 1] * (\r\n (self.transition_probability[label[i - 1]][label[i]])\r\n )\r\n\r\n post_array.append(emi * min_val)\r\n\r\n post_array = [math.log(p) for p in post_array]\r\n\r\n cost = sum(post_array)\r\n\r\n return cost\r\n else:\r\n print(\"Unknown algorithm!\")","def log_likelihood(self) -> tf.Tensor:\n # K⁻¹ + GᵀΣ⁻¹G = LLᵀ.\n l_post = self._k_inv_post.cholesky\n num_data = self.observations_index.shape[0]\n\n # Hμ [..., num_transitions + 1, output_dim]\n marginal = self.emission.project_state_to_f(self.prior_ssm.marginal_means)\n marginal = self._drop_batch_shape(marginal)\n\n # y = obs - Hμ [..., num_transitions + 1, output_dim]\n disp = self.observations - marginal\n disp_data = self.sparse_observations - self.dense_to_sparse(marginal)\n\n # cst is the constant term for a gaussian log likelihood\n cst = (\n -0.5 * np.log(2 * np.pi) * tf.cast(self.emission.output_dim * num_data, default_float())\n )\n\n term1 = -0.5 * tf.reduce_sum(\n input_tensor=tf.einsum(\"...op,...p,...o->...o\", self._r_inv_data, disp_data, disp_data), axis=[-1, -2]\n )\n\n # term 2 is: ½|L⁻¹(GᵀΣ⁻¹)y|²\n # (GᵀΣ⁻¹)y [..., num_transitions + 1, state_dim]\n obs_proj = self._back_project_y_to_state(disp)\n\n # ½|L⁻¹(GᵀΣ⁻¹)y|² [...]\n term2 = 0.5 * tf.reduce_sum(\n input_tensor=tf.square(l_post.solve(obs_proj, transpose_left=False)), axis=[-1, -2]\n )\n\n ## term 3 is: ½log |K⁻¹| - log |L| + ½ log |Σ⁻¹|\n # where log |Σ⁻¹| = num_data * log|R⁻¹|\n term3 = (\n 0.5 * self.prior_ssm.log_det_precision()\n - l_post.abs_log_det()\n + 0.5 * self._log_det_observation_precision\n )\n\n return tf.reduce_sum(cst + term1 + term2 + term3)","def log_marg(self):\n log_prob_X_given_z = 0.\n for k in range(self.K):\n log_prob_X_given_z += self.log_marg_k(k)\n return log_prob_X_given_z","def log_m_probs(self):\n m = self.kernel.feature_log_prob_[self._match_class_pos()]\n return self._prob_inverse_transform(m)","def compute_my_variability(event_log: Log) -> float:\n prefixes: List[List[Event]] = []\n bar: Bar = IncrementalBar(\"Prefix generation\", max=len(event_log.trace_list))\n for trace in event_log.trace_list:\n trace_prefixes: List[List[Event]] = trace.get_all_prefixes()\n\n for prefix in trace_prefixes:\n if prefix not in prefixes:\n prefixes.append(prefix)\n bar.next()\n bar.finish()\n\n entropy: float = 0\n\n bar = ShadyBar(\"Prefix likelihood estimation\", max=len(prefixes))\n for prefix in prefixes:\n\n p: float = _prefix_likelihood_estimator(event_log, prefix)\n entropy += p * logarithm(p, 10)\n\n bar.next()\n bar.finish()\n\n entropy *= -1\n\n return entropy","def weights(self):\n m = self.kernel.feature_log_prob_[self._match_class_pos()]\n u = self.kernel.feature_log_prob_[self._nonmatch_class_pos()]\n\n return self._prob_inverse_transform(numpy.exp(m - u))","def model(X, Y, word_to_vec_map, learning_rate = 0.01, num_iterations = 400):\n \n # Get a valid word contained in the word_to_vec_map \n any_word = list(word_to_vec_map.keys())[0]\n \n # Initialize cost. It is needed during grading\n cost = 0\n \n # Define number of training examples\n m = Y.shape[0] # number of training examples\n n_y = len(np.unique(Y)) # number of classes \n n_h = word_to_vec_map[any_word].shape[0] # dimensions of the GloVe vectors \n \n # Initialize parameters using Xavier initialization\n W = np.random.randn(n_y, n_h) / np.sqrt(n_h)\n b = np.zeros((n_y,))\n \n # Convert Y to Y_onehot with n_y classes\n Y_oh = convert_to_one_hot(Y, C = n_y) \n \n # Optimization loop\n for t in range(num_iterations): # Loop over the number of iterations\n for i in range(m): # Loop over the training examples\n \n ### START CODE HERE ### (≈ 4 lines of code)\n # Average the word vectors of the words from the i'th training example\n # def sentence_to_avg(sentence, word_to_vec_map): # return avg\n avg = sentence_to_avg(X[i], word_to_vec_map)\n\n # Forward propagate the avg through the softmax layer. \n # You can use np.dot() to perform the multiplication.\n z = np.dot(W, avg) + b\n a = softmax(z)\n\n # Compute cost using the i'th training label's one hot representation and \"A\" (the output of the softmax)\n cost = - np.sum(Y_oh[i] * a)\n ### END CODE HERE ###\n \n # Compute gradients \n dz = a - Y_oh[i]\n dW = np.dot(dz.reshape(n_y,1), avg.reshape(1, n_h))\n db = dz\n\n # Update parameters with Stochastic Gradient Descent\n W = W - learning_rate * dW\n b = b - learning_rate * db\n \n if t % 100 == 0:\n print(\"Epoch: \" + str(t) + \" --- cost = \" + str(cost))\n pred = predict(X, Y, W, b, word_to_vec_map) #predict is defined in emo_utils.py\n\n return pred, W, b","def margalef(counts):\n return (observed_species(counts)-1)/log(counts.sum())","def define_y(words):\r\n num_words = len(words)\r\n loglam = math.log10(num_words)\r\n freq = nltk.FreqDist(words)\r\n \r\n entropy = 0.0\r\n for w in freq:\r\n pi = freq[w]\r\n entropy += pi * (loglam - math.log10(pi)) / float(num_words)\r\n rel_entropy = entropy / loglam\r\n return rel_entropy","def predictability(self):\n temp = self.probs\n for n in range(10):\n temp = temp.dot(temp)\n final = temp[0,:]\n #Let's assume that all words have unique initial letters\n probs = map(len, self.words)\n probs = array(probs)\n probs = (probs + self.probs.max(1)-1)/probs\n return sum(final*probs)","def translate(self):\n\n # load test data\n test_loader, max_token_seq_len, is_bpe, decoder = self.load_testdata(self.opt.src, self.opt.vocab)\n\n self.model.word_prob_prj = nn.LogSoftmax(dim=1)\n self.model.eval()\n\n translator = Translator(self.opt, new=False)\n translator.model = self.model\n translator.max_token_seq_len = max_token_seq_len\n\n hypotheses = []\n\n with open(self.opt.output, 'w') as f:\n for batch in tqdm(test_loader, desc='Translating', leave=False, dynamic_ncols=True):\n # get sequences through beam search.\n all_hyp, _ = translator.translate_batch(*batch)\n # write outputs as we get them so we can see progress.\n if is_bpe:\n lines = self.translate_decode_bpe(all_hyp, decoder)\n else:\n lines = self.translate_decode_dict(all_hyp, decoder)\n for line in lines:\n f.write(line + \"\\n\")\n \n if self.opt.verbose:\n print('[Info] Finished.')\n return hypotheses","def summer(n_terms, n_words):\n try:\n math.log(math.log(n_terms)) / math.log(math.log(n_words))\n except ValueError:\n return 0","def compute_logits(self):\n # [num train labels, num classes] where each row is a one-hot-encoded label.\n one_hot_train_labels = tf.one_hot(self.data.train_labels, self.way)\n\n # Undocumented in the paper, but *very important*: *only* the support set\n # embeddings is L2-normalized, which means that the distance is not exactly\n # a cosine distance. For comparison we also allow for the actual cosine\n # distance to be computed, which is controlled with the\n # `exact_cosine_distance` instance attribute.\n train_embeddings = tf.nn.l2_normalize(\n self.train_embeddings, 1, epsilon=1e-3)\n test_embeddings = self.test_embeddings\n if self.exact_cosine_distance:\n test_embeddings = tf.nn.l2_normalize(test_embeddings, 1, epsilon=1e-3)\n # [num_test_images, num_train_images]\n similarities = tf.matmul(\n test_embeddings, train_embeddings, transpose_b=True)\n attention = tf.nn.softmax(similarities)\n\n # [num_test_images, way]\n probs = tf.matmul(attention, one_hot_train_labels)\n self.test_logits = tf.log(probs)\n return self.test_logits","def logprob(predictions, labels):\n predictions[predictions < 1e-10] = 1e-10\n return np.sum(np.multiply(labels, -np.log(predictions)))","def compute_loss(self,state,targets):\n reshaped_targets = targets.reshape(-1,2,1)\n\n # reshape targets to match the dimension of means\n for i in range(self.output_size-1):\n reshaped_targets = torch.cat((reshaped_targets,targets.reshape(-1,2,1)),2)\n\n # compute output distribution from model\n means,stds,weights = self.forward(state)\n\n # compute the mixed log pdf\n mixed_pdf = mixed_prob(means,stds,weights,reshaped_targets)\n\n # compute the average negative log likelihood\n return -torch.log(mixed_pdf).mean()","def nll_logprobs(self, input, target_idx):\n raise NotImplementedError()","def likelihood(self, w, class_words):\n return log((class_words.count(w) + 1)/(len(class_words) + self.N))","def target_log_prob_fn(self, *args, **kwargs): # pylint: disable=unused-argument\n\n def log_joint_fn(*args, **kwargs): # pylint: disable=unused-argument\n states = dict(zip(self.unobserved.keys(), args))\n states.update(self.observed)\n interceptor = interceptors.CollectLogProb(states)\n with ed.interception(interceptor):\n self._f(self._cfg)\n\n log_prob = sum(interceptor.log_probs)\n return log_prob\n return log_joint_fn","def _logp(self, trace, **inputs):\n def calc_log(step):\n exp_pred = np.dot(inputs['gwas_gen'],\n step['beta_med'].T).ravel()\n phen_pred = step['alpha'] * exp_pred\n phen_prob = norm.logpdf(x=inputs['gwas_phen'],\n loc=phen_pred,\n scale=step['phenotype_sigma'])\n return phen_prob\n\n phen_probs = [calc_log(trace[idx])\n for idx in np.random.randint(0, len(self.trace), 500)]\n phen_probs = np.asmatrix(phen_probs)\n mc_logp = phen_probs.sum(axis=1).mean()\n return mc_logp","def logprob(predictions, labels):\n predictions[predictions < 1e-10] = 1e-10\n return np.sum(np.multiply(labels, -np.log(predictions))) / labels.shape[0]","def logprob(predictions, labels):\n predictions[predictions < 1e-10] = 1e-10\n return np.sum(np.multiply(labels, -np.log(predictions))) / labels.shape[0]","def preprocessing():\n english_dictionary = nltk.corpus.brown.words()\n slang_vocab = pickle.load(open('vocab_pattern_match_with_freq.pkl', 'rb'))\n\n normalize_english_dict = len(english_dictionary)\n normalize_slang_vocab = 0\n for w, n in slang_vocab.items():\n normalize_slang_vocab += n\n\n words = {}\n for w, n in Counter(english_dictionary).items():\n words[w] = n/normalize_english_dict\n \n for w, n in slang_vocab.items():\n if w not in words:\n words[w] = 0.\n words[w] += n/normalize_slang_vocab\n\n words_by_freq = [w for w,_ in sorted(words.items(), key=lambda x: x[1], reverse=True)]\n\n # Build a cost dictionary, assuming Zipf's law and cost = -math.log(probability).\n #words = open(\"words_by_frequency.txt\").read().split()\n wordcost = dict((k, log((i+1)*log(len(words_by_freq)))) for i,k in enumerate(words_by_freq))\n maxword = max(len(x) for x in words_by_freq)\n return wordcost,maxword","def naiveBayesMixture(train_set, train_labels, dev_set, bigram_lambda,unigram_smoothing_parameter, bigram_smoothing_parameter, pos_prior):\n\n # TODO: Write your code here\n # return predicted labels of development set\n\n # counters for Training Phase\n ham = Counter()\n ham_bi = Counter()\n spam = Counter()\n spam_bi = Counter()\n\n for string, label in zip(train_set, train_labels):\n for i in range(len(string)):\n word = string[i]\n if i != len(string)-1:\n word_bi = string[i] + ' ' + string[i+1]\n if label == 1:\n ham_bi.update({word_bi:1})\n else:\n spam_bi.update({word_bi:1})\n if label == 1:\n ham.update({word:1})\n else:\n spam.update({word:1})\n\n ham_len = 0\n for w in ham:\n ham_len += ham[w]\n spam_len = 0\n for w in spam:\n spam_len += spam[w]\n \n hambi_len = 0\n for w in ham_bi:\n hambi_len += ham_bi[w]\n spambi_len = 0\n for w in spam_bi:\n spambi_len += spam_bi[w]\n\n # labels for Development Phase\n dev_labels = []\n # dicts for P(word|ham) and P(word|spam)\n p_ham = {}\n p_spam = {}\n p_hambi = {}\n p_spambi = {}\n\n # develop likelihoods based on dev_set\n for word in ham:\n numerator = ham[word] + unigram_smoothing_parameter\n denominator = ham_len + unigram_smoothing_parameter*(len(ham))\n p_ham[word] = numerator / denominator\n for word in spam:\n numerator = spam[word] + unigram_smoothing_parameter\n denominator = spam_len + unigram_smoothing_parameter*(len(spam))\n p_spam[word] = numerator / denominator\n\n for word_bi in ham_bi:\n numerator = ham_bi[word_bi] + bigram_smoothing_parameter\n denominator = hambi_len + bigram_smoothing_parameter*(len(ham_bi))\n p_hambi[word_bi] = numerator / denominator\n for word_bi in spam_bi:\n numerator = spam_bi[word_bi] + bigram_smoothing_parameter\n denominator = spambi_len + bigram_smoothing_parameter*(len(spam_bi))\n p_spambi[word_bi] = numerator / denominator\n \n numerator = unigram_smoothing_parameter\n denominator = ham_len + unigram_smoothing_parameter*(len(ham))\n p_ham_zero = numerator / denominator\n denominator = spam_len + unigram_smoothing_parameter*(len(spam))\n p_spam_zero = numerator / denominator\n\n numerator = bigram_smoothing_parameter\n denominator = hambi_len + bigram_smoothing_parameter*(len(ham_bi))\n p_hambi_zero = numerator / denominator\n denominator = spambi_len + bigram_smoothing_parameter*(len(spam_bi))\n p_spambi_zero = numerator / denominator\n\n for string in dev_set:\n p_words_ham = math.log(pos_prior)\n p_words_spam = math.log(1 - pos_prior)\n\n p_words_hambi = math.log(pos_prior)\n p_words_spambi = math.log(1 - pos_prior)\n \n for i in range(len(string)):\n word = string[i]\n if word in p_ham:\n p_words_ham += math.log(p_ham[word])\n else:\n p_words_ham += math.log(p_ham_zero)\n if word in p_spam:\n p_words_spam += math.log(p_spam[word])\n else:\n p_words_spam += math.log(p_spam_zero)\n\n if i != len(string)-1:\n word_bi = string[i] + ' ' + string[i+1]\n if word_bi in p_hambi:\n p_words_hambi += math.log(p_hambi[word_bi])\n else:\n p_words_hambi += math.log(p_hambi_zero)\n if word_bi in p_spambi:\n p_words_spambi += math.log(p_spambi[word_bi])\n else:\n p_words_spambi += math.log(p_spambi_zero)\n\n p_ham_mix = p_words_ham*(1-bigram_lambda) + p_words_hambi*bigram_lambda\n p_spam_mix = p_words_spam*(1-bigram_lambda) + p_words_spambi*bigram_lambda\n\n dev_labels.append(p_ham_mix >= p_spam_mix)\n\n return dev_labels","def sentence_logprob(self, sentence):\n line = get_ngrams(sentence,3)\n log_por = 0.0\n for item in line:\n raw_por = self.smoothed_trigram_probability(item)\n log_por = log_por+math.log2(raw_por)\n\n return float(log_por)","def featureLikelihood():\r\n\r\n\t# Lists\r\n\twords = []\r\n\tfinalWords = []\r\n\tposWords = []\r\n\tnegWords = []\r\n\tfeatureListPos = []\r\n\tfeatureListNeg = []\r\n\r\n\t# Counters\r\n\tposCount = 0.0\r\n\tnegCount = 0.0\r\n\r\n\t# Temporary Lists for formating\r\n\tfeatureListPosFormat = []\r\n\tfeatureListNegFormat = []\r\n\r\n\t# Strings\r\n\ts = \" \"\r\n\tposString = \"\"\r\n\tnegString = \"\"\r\n\r\n\tseen = set()\r\n\r\n\t# Add all words to words list and count positive & negative occurences\r\n\tfor item in trainingData:\r\n\t\tfor word in item[2]:\r\n\t\t\twords.append(word)\r\n\t\tif item[1] == '0':\r\n\t\t\tfor word in item[2]:\r\n\t\t\t\tposWords.append(word)\r\n\t\t\t\tposCount += 1\r\n\t\tif item[1] == '1':\r\n\t\t\tfor word in item[2]:\r\n\t\t\t\tnegWords.append(word)\r\n\t\t\t\tnegCount +=1\r\n\r\n\t# Adds all values into finalWords, skipping duplicates\r\n\tfor values in words:\r\n\t\tif values not in seen:\r\n\t\t\tfinalWords.append(values)\r\n\t\t\tseen.add(values)\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t# Add positive and negative counts to feature list and dictionaries\r\n\tfor word in finalWords:\r\n\t\ts += '{:12s}'.format(word)\r\n\t\t\r\n\t\tpCount = 0\r\n\t\tnCount = 0\r\n\t\t\r\n\t\tfor row in trainingData:\r\n\t\t\tif row[1] == '0':\r\n\t\t\t\tif word in row[2]: pCount += 1\r\n\t\t\tif row[1] == '1':\r\n\t\t\t\tif word in row[2]: nCount += 1\r\n\t\t\t\t\r\n\t\tfeatureListPos.append((pCount + 1) / (posCount + 9))\r\n\t\tclass0Dict[word] = ((pCount + 1) / (posCount + 9))\r\n\t\t\r\n\t\tfeatureListNeg.append((nCount + 1) / (negCount + 9))\r\n\t\tclass1Dict[word] = ((nCount + 1) / (negCount + 9))\r\n\r\n\t\t\r\n\t\t\r\n\t# Formatting for the positive feature list\r\n\tfor item in featureListPos:\r\n\t\tfeatureListPosFormat.append('{0:.5f}'.format(item))\r\n\t\t\r\n\tfor item in featureListPosFormat:\r\n\t\tposString += '{:12s}'.format(item)\r\n\r\n\t# Formatting for the negative feature list\r\n\tfor item in featureListNeg:\r\n\t\tfeatureListNegFormat.append('{0:.5f}'.format(item))\r\n\t\t\r\n\tfor item in featureListNegFormat:\r\n\t\tnegString += '{:12s}'.format(item)\r\n\r\n\r\n\t\t\r\n\treturn(s, posString, negString)","def log_probability_of_sentence(self, tokens: Sequence[str]):\n if isinstance(tokens, str):\n raise ValueError(\"Input to log_probability_of_sentence is a sequence of token strings,\"\n \" not a single string\")\n # these don't matter when we are running the model in inference mode\n targets = np.zeros([_BATCH_SIZE, _NUM_TIMESTEPS], np.int32)\n weights = np.ones([_BATCH_SIZE, _NUM_TIMESTEPS], np.float32)\n\n # these contain information about the previous word\n # we initialize them with the beginning-of-sentence marker\n inputs = np.zeros([_BATCH_SIZE, _NUM_TIMESTEPS], np.int32)\n inputs[0, 0] = self._vocab.word_to_id(_START_SENTENCE_SYMBOL)\n\n char_ids_inputs = np.zeros(\n [_BATCH_SIZE, _NUM_TIMESTEPS, self._vocab.max_word_length], np.int32)\n char_ids_inputs[0, 0, :] = self._vocab.word_to_char_ids(_START_SENTENCE_SYMBOL)\n\n # we take the log probability of a token sequence to be the sum of the log-probs\n # of each of its tokens given the preceding context\n log_prob_sum = 0.0\n for token in tokens:\n with contexttimer.Timer() as token_timer:\n dist_over_next_words = self._session.run(\n self._name_to_node['softmax_out'],\n feed_dict={\n self._name_to_node['char_inputs_in']: char_ids_inputs,\n self._name_to_node['inputs_in']: inputs,\n self._name_to_node['targets_in']: targets,\n self._name_to_node['target_weights_in']: weights})\n token_idx = self._vocab.word_to_id(token)\n log_prob_sum += math.log(dist_over_next_words[0][token_idx])\n\n # prepare this word to be the context for the next word\n inputs[0, 0] = token_idx\n char_ids_inputs[0, 0, :] = self._vocab.word_to_char_ids(token)\n\n # restore original state so that future calls to log_probability_of_sentence\n # are not affected by past calls\n self._reset_state()\n\n return log_prob_sum","def loglike(self, params):\n\n if type(params) is not MixedLMParams:\n params = MixedLMParams.from_packed(params, self.k_fe,\n self.use_sqrt)\n\n fe_params = params.get_fe_params()\n cov_re = params.get_cov_re()\n try:\n cov_re_inv = np.linalg.inv(cov_re)\n except np.linalg.LinAlgError:\n cov_re_inv = None\n _, cov_re_logdet = np.linalg.slogdet(cov_re)\n\n # The residuals\n expval = np.dot(self.exog, fe_params)\n resid_all = self.endog - expval\n\n likeval = 0.\n\n # Handle the covariance penalty\n if self.cov_pen is not None:\n likeval -= self.cov_pen.func(cov_re, cov_re_inv)\n\n # Handle the fixed effects penalty\n if self.fe_pen is not None:\n likeval -= self.fe_pen.func(fe_params)\n\n xvx, qf = 0., 0.\n for k, lab in enumerate(self.group_labels):\n\n exog = self.exog_li[k]\n ex_r = self.exog_re_li[k]\n ex2_r = self.exog_re2_li[k]\n resid = resid_all[self.row_indices[lab]]\n\n # Part 1 of the log likelihood (for both ML and REML)\n ld = _smw_logdet(1., ex_r, ex2_r, cov_re, cov_re_inv,\n cov_re_logdet)\n likeval -= ld / 2.\n\n # Part 2 of the log likelihood (for both ML and REML)\n u = _smw_solve(1., ex_r, ex2_r, cov_re, cov_re_inv, resid)\n qf += np.dot(resid, u)\n\n # Adjustment for REML\n if self.reml:\n mat = _smw_solve(1., ex_r, ex2_r, cov_re, cov_re_inv,\n exog)\n xvx += np.dot(exog.T, mat)\n\n if self.reml:\n likeval -= (self.n_totobs - self.k_fe) * np.log(qf) / 2.\n _,ld = np.linalg.slogdet(xvx)\n likeval -= ld / 2.\n likeval -= (self.n_totobs - self.k_fe) * np.log(2 * np.pi) / 2.\n likeval += ((self.n_totobs - self.k_fe) *\n np.log(self.n_totobs - self.k_fe) / 2.)\n likeval -= (self.n_totobs - self.k_fe) / 2.\n else:\n likeval -= self.n_totobs * np.log(qf) / 2.\n likeval -= self.n_totobs * np.log(2 * np.pi) / 2.\n likeval += self.n_totobs * np.log(self.n_totobs) / 2.\n likeval -= self.n_totobs / 2.\n\n return likeval","def log_prob(self, scores : torch.Tensor, permutations):\n s = torch.log(select_indices(scores, permutations))\n n = len(scores)\n p = self.upto if self.upto is not None else n - 1\n return -sum(\n torch.log(torch.exp((s[k:] - s[k]) * self.shape).sum(dim=0))\n for k in range(p))","def test_LM(self):\n\t\t\n\t\tprecision = 10**-8\n\t\t\t\t \n\t\tif self.n == 1:\n\t\t\t\t \n\t\t\tP_sum = sum(self.estimate_prob('', w) for w in self.vocab)\n\t\t\t\n\t\t\tassert abs(1.0 - P_sum) < precision, 'Probability mass does not sum up to one.'\n\t\t\t\t \n\t\telif self.n == 2:\n\t\t\thistories = ['the', 'in', 'at', 'blue', 'white']\n\t\t\t\t \n\t\t\tfor h in histories:\n\t\t\t\t \n\t\t\t\tP_sum = sum(self.estimate_prob(h, w) for w in self.vocab)\n\t\t\t\t\n\t\t\t\tassert abs(1.0 - P_sum) < precision, 'Probability mass does not sum up to one for history' + h\n\t\t\t\t\t \n\t\tprint('TEST SUCCESSFUL!')","def log_weights(self):\n m = self.kernel.feature_log_prob_[self._match_class_pos()]\n u = self.kernel.feature_log_prob_[self._nonmatch_class_pos()]\n\n return self._prob_inverse_transform(m - u)","def logistic_pen(weights, data, targets, hyperparameters):\n\n wr = hyperparameters['weight_regularization']\n \n t = np.transpose(np.repeat(np.reshape(weights[:-1], (len(weights)-1, 1)), len(data), axis = 1))\n f_e = data * t\n z_sums = np.sum(f_e, axis=1)\n y = sigmoid(z_sums +weights[-1])\n f = np.sum(np.log(1 + np.exp(-z_sums - weights[-1])) + (1 - np.transpose(targets)) * (z_sums + weights[-1]))\n df = np.sum(data * np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0)\n df = np.append(df, np.sum(np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0))\n\n f += np.dot(weights[:-1].transpose()[0], weights[:-1].transpose()[0]) * wr / 2\n df = np.reshape(df, ((len(df), 1)))\n df += np.reshape(np.append(weights[:-1] * wr, 0), (len(weights), 1))\n\n f += (weights[-1, 0] ** 2) * wr / 2\n df[-1] += weights[-1,0] * wr \n\n return f, df, np.reshape(y, (len(y), 1))","def M(f):\n return 1127 * numpy.log(1 + f/700.0)","def loss(labels,q,M,a,b):\n x=-(labels*np.log(s.expit(z(q,M,a,b)))+(1-labels)*np.log(1-s.expit(z(q,M,a,b))))\n return np.sum(x)+l/2*(np.sum(M**2)+b**2)","def maas(n_terms, n_words):\n # We cap this score at 0.2\n if n_words <= 1:\n return 0.2\n score = (math.log(n_words) - math.log(n_terms)) / \\\n (math.log(n_words) ** 2)\n return min(score, 0.2)","def log_u_probs(self):\n u = self.kernel.feature_log_prob_[self._nonmatch_class_pos()]\n return self._prob_inverse_transform(u)","def forward(self, motif_size, motif_log_embeddings):\n\n # D = 1 - exp(-sum_j(prod_i(d_ij)))\n # log(1-D) = -sum_j(exp(sum_i(log(d_ij))))\n x = lbann.MatMul(\n lbann.Constant(value=1, num_neurons=str_list([1, motif_size])),\n motif_log_embeddings,\n )\n x = lbann.Exp(x)\n x = lbann.Reduction(x, mode='sum')\n x = lbann.Negative(x)\n log_not_prob = x\n\n # Convert log-probability to linear space\n # Note: D=-expm1(x) is accurate when D~0. When D~1, prefer\n # 1-D=exp(x).\n prob = lbann.Negative(lbann.Expm1(log_not_prob))\n\n return prob, log_not_prob","def gmmloglik(log_emlik, weights):","def gmmloglik(log_emlik, weights):","def get_marginals(word, model):\n # forward and backward message at once\n char_count, _ = word.shape\n alpha = np.zeros((char_count, model.dimY)) # alphas\n lbeta = np.zeros((char_count, model.dimY)) # log version of betas\n\n first_term = np.dot(word, model.getW(model.labels))\n second_term_a = model._T\n second_term_b = model._T.T\n for i in range(1, char_count):\n sum_term_a = (first_term[i-1] + alpha[i-1]) + second_term_a\n sum_term_b = (first_term[char_count-i] +lbeta[char_count-i]) + second_term_b\n alpha[i] = np.apply_along_axis(logsumexp_trick, 1, sum_term_a) \n lbeta[char_count-i-1] = np.apply_along_axis(logsumexp_trick, 1, sum_term_b)\n\n marginal_Y = np.zeros((char_count, model.dimY))\n marginal_Y_Y1 = np.zeros((char_count-1, model.dimY, model.dimY)) \n \n for i in range(char_count):\n sum_term = first_term[i] + alpha[i] + lbeta[i]\n log_marginal_y = sum_term - logsumexp_trick(sum_term)\n marginal_Y[i] = np.exp(log_marginal_y)\n # calculate other marginal dist as well\n if i < char_count-1:\n transition = model._T.transpose() # T_{yi, yi+1}\n outer_sum_w = np.add.outer(first_term[i], first_term[i+1]).reshape(model.dimY,model.dimY)\n outer_sum_m = np.add.outer(alpha[i], lbeta[i+1])\n sum_term_all = outer_sum_w + transition + outer_sum_m\n log_marginal_y_y1 = sum_term_all - logsumexp_trick(sum_term_all)\n marginal_Y_Y1[i] = np.exp(log_marginal_y_y1)\n # Got Denominator same as Zx , which is correct\n return marginal_Y, marginal_Y_Y1","def Ls(GTn:torch.tensor, Mn:torch.tensor) -> torch.tensor:\n return (-(GTn * torch.log(Mn+1e-15) + (1- GTn) * torch.log((1- Mn)+1e-15))).sum()","def step(self, x, y, learning_rate=1e-3):\n \n # Input transformation\n \"\"\"\n Input is represented with M-dimensional vectors\n We convert them to (N, M) matrices such that columns are one-hot \n representations of the input\n \"\"\"\n x = self.one_hot(x, self.N)\n y = self.one_hot(y, self.N)\n\n \n # Forward propagation\n \"\"\"\n Returns\n -------\n embedding: array\n (D, M) matrix where columns are word embedding from U matrix\n logits: array\n (N, M) matrix where columns are output logits\n prob: array\n (N, M) matrix where columns are output probabilities\n \"\"\"\n \n ### YOUR CODE HERE ###\n #Omran:\n #U and V of dimension (D, N) and (N, D) respectively\n\n embedding = np.dot(self.U, x)\n logits = np.dot(self.V, embedding)\n prob = self.softmax(logits,0)# take care of the axis, I am not quite sure how you will implement it\n \n assert embedding.shape == (self.D, x.shape[1])\n assert logits.shape == (self.N, x.shape[1])\n assert prob.shape == (self.N, x.shape[1])\n \n \n # Loss calculation\n \"\"\"\n Returns\n -------\n loss: int\n Cross-entropy loss using true values and probabilities\n \"\"\"\n \n ### YOUR CODE HERE ###\n loss = self.loss(y, prob)\n \n # Backward propagation\n \"\"\"\n Returns\n -------\n d_U: array\n (N, D) matrix of partial derivatives of loss w.r.t. U\n d_V: array\n (D, N) matrix of partial derivatives of loss w.r.t. V\n \"\"\"\n \n ### YOUR CODE HERE ###\n #I am not quite sure of this!!\n \n# difference = np.sum(np.subtract(prob, y), axis=1)\n difference = prob - y\n d_V = difference @ embedding.T\n# print(self.N, self.D)\n# print(difference.shape)\n# print(d_V.shape)\n d_U = (self.V.T @ difference) @ x.T\n# d_U = self.V.T @ np.outer(difference, x)\n \n assert d_V.shape == (self.N, self.D)\n assert d_U.shape == (self.D, self.N)\n \n \n # Update the parameters\n \"\"\"\n Updates the weights with gradient descent such that W_new = W - alpha * dL/dW, \n where alpha is the learning rate and dL/dW is the partial derivative of loss w.r.t. \n the weights W\n \"\"\"\n \n ### YOUR CODE HERE ###\n self.V = self.V - learning_rate * d_V\n self.U = self.U - learning_rate * d_U\n\n return loss, d_U, d_V","def score(self, sentence):\n # TODO your code here\n\n # initialize count with trained data\n unigram_count = self.count.copy()\n N = self.total\n\n # make a new key for UNK, add-one later\n for token in sentence:\n if token not in unigram_count:\n unigram_count[token] = 0\n\n # calcutate lopP(<s>) + logP(w1) + logP(w2) + ...\n score = 0.0 # P(<s>) = 1\n V = len(unigram_count) # the number of vocab including UNK\n for word in sentence:\n prob = float((unigram_count[word] + 1) / (N + V)) # c(w) + 1 / N + V\n score += math.log(prob)\n\n return score","def calculate_perplexity_new(self, sentence_probability, input_y, words_to_idx):\n \n batch_size = sentence_probability.shape[0]\n sentence_length = sentence_probability.shape[1]\n perplexity = np.zeros(batch_size)\n pad_index = words_to_idx['<pad>'] # index of pad\n \n for sentence_i in range(batch_size):\n word_index = 1 # start at 1 to discard bos\n log_sum = 0\n while ((word_index < sentence_length) and (input_y[sentence_i][word_index] != pad_index)): # stop when the first pad token is reached\n \n log_sum += np.log2(sentence_probability[sentence_i, word_index, \n input_y[sentence_i][word_index]])\n word_index += 1 \n word_index -= 1 # remove one count because of discarded bos\n try:\n # catch sentence with all pad's\n perplexity[sentence_i] = np.power(2, -(log_sum/word_index))\n except:\n print(input_y[sentence_i])\n print('sencentece with just pads')\n perplexity[sentence_i] = np.nan \n \n return perplexity","def m_probs(self):\n log_m = self.kernel.feature_log_prob_[self._match_class_pos()]\n\n return self._prob_inverse_transform(numpy.exp(log_m))","def entropy(self, text_ngrams):\n return -1 * _mean(\n [self.logscore(ngram[-1], ngram[:-1]) for ngram in text_ngrams]\n )","def predict(self, X):\n words = X.split()\n chance = []\n for cur_label in self.model[\"labels\"]:\n probability = self.model[\"labels\"][cur_label][\"probability\"]\n total_grade = math.log(probability, math.e)\n for word in words:\n word_dict = self.model[\"words\"].get(word, None)\n if word_dict:\n total_grade += math.log(word_dict[cur_label], math.e)\n chance.append((total_grade, cur_label))\n _, prediction = max(chance)\n return prediction","def logprob(predictions, labels):\n # prevent negative probability\n predictions[predictions < 1e-10] = 1e-10\n return np.sum(np.multiply(labels, -np.log(predictions))) / labels.shape[0]","def information_gain(features, attribute_index, targets):\r\n\r\n possible_feature_values = [0,1]\r\n \r\n possible_classifications = [0,1]\r\n \r\n feature = features[:,attribute_index]\r\n \r\n \r\n number_of_samples = len(feature)\r\n \r\n import math\r\n \r\n \r\n #current_entropy = np.sum([-(len(targets[targets==possible_classification])/number_of_samples)*math.log(len(targets[targets==possible_classification])/number_of_samples, 2) for possible_classification in possible_classifications])\r\n \r\n terms_to_be_summed_for_current_entropy = []\r\n \r\n for classification in possible_classifications:\r\n \r\n number_of_elements_with_this_classification = len(targets[targets==classification])\r\n \r\n p_for_this_classification = number_of_elements_with_this_classification/len(targets)\r\n \r\n if p_for_this_classification != 0:\r\n terms_to_be_summed_for_current_entropy.append(-p_for_this_classification*math.log(p_for_this_classification,2))\r\n else:\r\n terms_to_be_summed_for_current_entropy.append(0)\r\n \r\n current_entropy = np.sum(terms_to_be_summed_for_current_entropy)\r\n \r\n \r\n \r\n terms_to_be_summed_for_weighted_entropy = []\r\n \r\n for possible_value in possible_feature_values:\r\n \r\n targets_split_by_feature_value = targets[feature.flatten() == possible_value]\r\n \r\n if len(targets_split_by_feature_value) != 0:\r\n \r\n \r\n weight_of_feature_value = len(targets_split_by_feature_value)/len(targets)\r\n \r\n terms_for_entropy_within_subset = []\r\n \r\n for classification in possible_classifications:\r\n \r\n number_of_subset_elements_with_this_classification = len(targets_split_by_feature_value[targets_split_by_feature_value==classification])\r\n \r\n p_in_subset_for_this_classification = number_of_subset_elements_with_this_classification/len(targets_split_by_feature_value)\r\n \r\n if p_in_subset_for_this_classification != 0:\r\n terms_for_entropy_within_subset.append(-p_in_subset_for_this_classification*math.log(p_in_subset_for_this_classification,2))\r\n else:\r\n terms_for_entropy_within_subset.append(0)\r\n \r\n entropy_within_subset = np.sum(terms_for_entropy_within_subset)\r\n \r\n terms_to_be_summed_for_weighted_entropy.append(weight_of_feature_value*entropy_within_subset)\r\n \r\n weighted_entropy = np.sum(terms_to_be_summed_for_weighted_entropy)\r\n \r\n \r\n #current_entropy = np.sum(terms_to_be_summed_for_current_entropy)\r\n \r\n #weighted_entropy = np.sum([(len(feature[feature==possible_value])/number_of_samples)*(len(targets[feature==possible_value][targets[feature==possible_value]==possible_classification])/len(targets[feature==possible_value]))*math.log((len(targets[feature==possible_value][targets[feature==possible_value]==possible_classification])/len(targets[feature==possible_value])), 2) for possible_classification in possible_classifications for possible_value in possible_feature_values])\r\n\r\n information_gain = current_entropy - weighted_entropy \r\n \r\n return information_gain","def _LL(state, effects, observed_frequencies) -> float:\n observed_frequencies = np.array(observed_frequencies)\n predicted_probs = np.array([np.real(np.trace(state.dot(effect))) for effect in effects])\n return sum(np.log10(predicted_probs) * observed_frequencies)","def logloss(self,tple):\n feats = self.dataset.input_features\n res = 0\n cc = self.class_counts\n fc = self.feature_counts\n for c in range(self.num_classes):\n res += prod(fc[i][feat(tple)][c]\n for (i,feat) in enumerate(feats))/(cc[c]**(len(feats)-1))\n if res>0:\n return -math.log2(res/len(self.dataset.train))\n else:\n return float(\"inf\") #infinity","def _loglike(self, y, f):\n bincoef = tf.lgamma(self.n + 1) - tf.lgamma(y + 1) \\\n - tf.lgamma(self.n - y + 1)\n ll = bincoef + y * tf.log(pos(f)) + (self.n - y) * tf.log(pos(1 - f))\n return ll","def perplexity(self, corpus):\n sum_pro = 0.0\n total_words = 0\n for sentence in corpus:\n sen_pro = self.sentence_logprob(sentence)\n sum_pro += sen_pro\n total_words += len(sentence)\n\n \n\n l = sum_pro/total_words\n w = 0.0\n w = 2**(-l)\n\n return w","def compute_log_prob(self,params: ndarray) -> float:\n return self.compute_log_prior(params) + self.compute_log_likelihood(params)","def train_model(self, d=0.7):\n #eg: model = spammy.train_model()\n count_dict = self.freq_count()\n N = sum(count_dict.values())\n n_plus = len(count_dict)\n alpha = (d * n_plus) / N\n normalizer = alpha * (1/len(self._vocab_set))\n model = defaultdict(lambda:normalizer)\n \n for word in set(self._vocab_set):\n prob = normalizer\n if word in count_dict:\n prob += (count_dict[word] - d) / N\n prob = math.log(prob)\n model[word] = prob\n return model","def test_smoohted_LM(self):\n\t\tprecision = 10**-8\n\t\t\t\t \n\t\tif self.n == 1:\n\t\t\t\t \n\t\t\tP_sum = sum(self.estimate_smoothed_prob('', w) for w in self.vocab)\n\t\t\t\n\t\t\tassert abs(1.0 - P_sum) < precision, 'Probability mass does not sum up to one.'\n\t\t\t\t \n\t\telif self.n == 2:\n\t\t\thistories = ['the', 'in', 'at', 'blue', 'white']\n\t\t\t\t \n\t\t\tfor h in histories:\n\t\t\t\t \n\t\t\t\tP_sum = sum(self.estimate_smoothed_prob(h, w) for w in self.vocab)\n\t\t\t\t\n\t\t\t\tassert abs(1.0 - P_sum) < precision, 'Probability mass does not sum up to one for history' + h\n\t\t\t\t\t \n\t\tprint('TEST SUCCESSFUL!')\n\t\t# YOUR CODE HERE","def entropy(self, text):\n\n# text = self.myReplacer.replace(text)\n# text = self.tokenizer.tokenize(text)\n new_text = []\n for word in text:\n if word.count('\\'') > 0:\n words = word.split('\\'')\n for w in words:\n new_text.append(w)\n else:\n new_text.append(word)\n text = new_text\n \n e = 0.0\n lenth = len(text)\n if lenth == 0:\n return 0\n elif lenth < self._n:\n current_n = lenth\n else:\n current_n = self._n\n \n for i in range(current_n - 1, len(text)):\n context = tuple(text[(i - current_n + 1) : i])\n token = text[i]\n e += self.logprob(token, context)\n return e","def entropy(self, f):\n f_log = -torch.log(self.einsum(\"q,q->q\", [f, 1 / self.w]))\n return self.einsum(\"q,q->\", [f, f_log])","def print_translations(sentences: List[Tuple[List[int], List[int]]], model: Seq2SeqAttentionModel,\n source_vocab: Dict[int, str], target_vocab: Dict[int, str], beam_width):\n total_log_lhood = 0\n for (source_sentence, target_sentence) in sentences:\n if beam_width > 0:\n translation, log_lhood = translate_beam_search(source_sentence, model, beam_width)\n total_log_lhood += log_lhood\n else:\n translation, _ = translate_greedy_search(source_sentence, model)\n\n print(\"source sentence:\" + \" \".join([source_vocab[word] for word in source_sentence]))\n print(\"target sentence:\" + \" \".join([target_vocab[word] for word in target_sentence]))\n print(\"translation:\\t\" + \" \".join([target_vocab[word] for word in translation]))\n print(\"\")\n print(\"Avg log Likelihood = \", total_log_lhood/len(sentences))","def log_marginal_likelihood(X_train,y_train,phi,tau=1.,Ve=1.e-10):","def joint_logpdf(self, x1, x2 = None):\n dists = self.conditionalMVNs\n joint_pdfs = np.array([d.joint_pdf(x1, x2) for d in dists])\n return np.log(np.sum(self.weights * joint_pdfs))","def word_to_perplexity(model, timeseries, indices, words, args):\n accum = 0\n words_len = len(words)-args.window_size\n batches = math.floor(words_len / args.batch_size)\n print(batches)\n for start in range(0, batches):\n idx = start*args.batch_size\n inp = np.array([timeseries[i:i+args.window_size] for i in range(idx, idx+args.batch_size)])\n label = np.asarray([indices[x] for x in words[idx+args.window_size:idx+args.window_size+args.batch_size]]) \n \n pred = model.predict(inp, batch_size=128)\n lp = np.log(pred)\n for i, ent in enumerate(lp):\n accum += ent[label[i]]\n if start % 5 == 0:\n print(\"{} / {}. Perplexity so far: {}\".format(start, batches, np.exp(-accum / (start*args.batch_size+1))))\n accum = -accum\n print(accum)\n avg = accum / words_len \n print(avg)\n perplex = np.power(avg, 2)\n print(perplex)","def _perplexity(self, X, log_w):\n return np.exp(-log_w/X.sum())","def my_loglike(theta, x, data, sigma):\n\n model = my_model(theta, x)\n\n return -0.5*len(x)*np.log(2*math.pi*sigma**2) - (0.5/sigma**2) * np.sum((data-model)**2)","def compute_loglike(self, tools: ModelingTools) -> float:\n return -1.5","def define_model_log_prob(model, model_loss, x, y, params_flattened_list, params_shape_list, tau_list, tau_out, normalizing_const=1., predict=False, prior_scale = 1.0, device = 'cpu'):\n\n fmodel = util.make_functional(model)\n dist_list = []\n for tau in tau_list:\n dist_list.append(torch.distributions.Normal(torch.zeros_like(tau), tau**-0.5))\n\n def log_prob_func(params):\n # model.zero_grad()\n # params is flat\n # Below we update the network weights to be params\n params_unflattened = util.unflatten(model, params)\n\n i_prev = 0\n l_prior = torch.zeros_like( params[0], requires_grad=True) # Set l2_reg to be on the same device as params\n for weights, index, shape, dist in zip(model.parameters(), params_flattened_list, params_shape_list, dist_list):\n # weights.data = params[i_prev:index+i_prev].reshape(shape)\n w = params[i_prev:index+i_prev]\n l_prior = dist.log_prob(w).sum() + l_prior\n i_prev += index\n\n # Sample prior if no data\n if x is None:\n # print('hi')\n return l_prior/prior_scale\n\n x_device = x.to(device)\n y_device = y.to(device)\n\n\n output = fmodel(x_device, params=params_unflattened)\n\n if model_loss == 'binary_class_linear_output':\n crit = nn.BCEWithLogitsLoss(reduction='sum')\n ll = - tau_out *(crit(output, y_device))\n elif model_loss == 'multi_class_linear_output':\n # crit = nn.MSELoss(reduction='mean')\n crit = nn.CrossEntropyLoss(reduction='sum')\n # crit = nn.BCEWithLogitsLoss(reduction='sum')\n ll = - tau_out *(crit(output, y_device.long().view(-1)))\n # ll = - tau_out *(torch.nn.functional.nll_loss(output, y.long().view(-1)))\n elif model_loss == 'multi_class_log_softmax_output':\n ll = - tau_out *(torch.nn.functional.nll_loss(output, y_device.long().view(-1)))\n\n elif model_loss == 'regression':\n # crit = nn.MSELoss(reduction='sum')\n ll = - 0.5 * tau_out * ((output - y_device) ** 2).sum(0)#sum(0)\n\n elif callable(model_loss):\n # Assume defined custom log-likelihood.\n ll = - model_loss(output, y_device).sum(0)\n else:\n raise NotImplementedError()\n\n if torch.cuda.is_available():\n del x_device, y_device\n torch.cuda.empty_cache()\n\n if predict:\n return (ll + l_prior/prior_scale), output\n else:\n return (ll + l_prior/prior_scale)\n\n return log_prob_func","def score(self, word):\n assert self.words is not None, \"You need to train first.\"\n if word in self.words:\n return np.log(1 - self.a) + np.log(self.words[word] / self.nwords)\n else:\n logprob = 0\n for l in word:\n # this calculates add+1-smoothed probabilities to make\n # sure that unknown letters are treated correctly.\n # not required, using simply the relative\n # frequency is sufficient.\n logprob += np.log(self.letters.get(l, 1) /\n (self.nletters + len(self.letters)))\n return np.log(self.a) + logprob","def sentence_logprob(self, sentence):\n grams = get_ngrams(sentence, 3)\n p = 1\n\n for gram in grams:\n p *= np.longfloat(self.smoothed_trigram_probability(gram))\n\n return np.log2(p)","def log_probability(self, tokens):\n\n log_sum = 0\n for leader, token in generate_ngrams(tokens, self.size, include_terminator = self.include_terminator):\n if not leader in self.frequencies:\n return float(\"-inf\")\n\n word_frequency = self.frequencies[leader][token]\n leader_frequency = self.frequencies[leader].total\n\n probability = (word_frequency + self.smoothing) / (leader_frequency + len(self.vocab) * self.smoothing)\n\n if probability == 0:\n return float(\"-inf\")\n\n log_sum += math.log2(probability)\n \n return log_sum","def log_marg_like(self, gamma, gamma0, lamb, nu):\n return self.ppi_distribution(gamma, gamma0, lamb).logpdf(self.Y, precision_multiplier=nu)","def _predict_doc(self, x, flag):\n\n if flag == 1:\n denom = self.X.num_positive()\n else:\n denom = self.X.num_negative()\n denom += self.X.vocab_size()\n\n # multiply word probabilities for all words in x\n words = tokenize(x)\n # prob = 1.0\n # for word in words:\n # wi = self._doc_count_for_word(word, flag=flag)\n # # utilize the Laplace Smooth\n # prob *= ((float(wi)+1.0) / (float(denom)+2.0))\n\n prob = math.log(self.X.priors[str(flag)])\n for word in words:\n wi = self._doc_count_for_word(word, flag=flag)\n # utilize the Laplace Smooth\n prob += math.log((float(wi)+1.0) / (float(denom)+2.0))\n\n # prob *= math.log(self.X.priors[str(flag)])\n\n return prob","def log_prob_of_file(filepath, model):\n vocab = set(counts_un.keys())\n tot = 0\n count = 0\n prev_prev = \"<s>\\n\"\n prev = \"<s>\\n\"\n with open(filepath) as f:\n for line in f:\n count += 2\n line = line.strip()+\"\\n\"\n tri_prob = model.get_trigram_prob(prev_prev, prev, line)\n tot += math.log(tri_prob)\n prev_prev = prev\n prev = line \n for line in [\"</s>\\n\", \"</s>\\n\"]:\n tri_prob = model.get_trigram_prob(prev_prev, prev, line)\n tot += math.log(tri_prob)\n prev_prev = prev\n prev = line \n return tot, count","def probability(self, words):\n if len(words) == 0:\n return 0\n \n prob = 1\n model = self.mdl\n \n words_ngram = NGramLM(self.N, []).create_ngrams(words) # Create NGram model for words\n for ngram in words_ngram:\n # Never seen before ngram or n-1gram\n if (ngram not in list(model['ngram'])) or (ngram[:-1] not in list(model['n1gram'])):\n return 0\n if isinstance(self, NGramLM):\n prob *= model[model['ngram'] == ngram]['prob'].values[0]\n \n def recur_prob(model, w):\n prob = 1\n prev_mod = model.prev_mdl\n if isinstance(prev_mod, UnigramLM): # Unigram base case\n prob *= prev_mod.mdl[w[0]]\n else:\n words_n1gram = NGramLM(prev_mod.N, []).create_ngrams(w) # Create NGram model for words\n prob *= prev_mod.mdl[prev_mod.mdl['ngram'] == words_n1gram[0]]['prob'].values[0]\n prob *= recur_prob(prev_mod, words_n1gram[0]) # Recursive call\n return prob\n\n prob *= recur_prob(self, words_ngram[0])\n \n return prob","def log_marg_likelihood(self):\n self.A = np.linalg.inv(self.Sn)\n term1 = self.t - self.design_matrix@self.mn\n self.Evidence_mN = (self.beta/2)*np.linalg.norm(term1)+ (self.alpha/2)*self.mn.T@self.mn\n A_abs = np.linalg.eigvals(self.A)\n A_abs = np.prod(A_abs)\n\n self.marg_lik = ((self.p)/2)*np.log(self.alpha) + (self.n/2)*np.log(self.beta) - self.Evidence_mN - (1/2)*np.log(A_abs) - (self.n/2)*np.log(2*np.pi)\n\n return self.marg_lik","def n_gram_MLE(self, given_words, predicted_words, gram_type=1):\n try:\n if gram_type == 1:\n return math.log((self.unigram[given_words] + 1) / (len(self.word_list) + len(self.unigram)))\n elif gram_type == 2:\n return math.log((self.bigram[predicted_words] + 1) / (self.unigram[given_words] + len(self.unigram)))\n elif gram_type == 3:\n return math.log(self.trigram[predicted_words] + 1) / (self.bigram[given_words] + len(self.unigram))\n elif gram_type == 4:\n return math.log(self.four_gram[predicted_words] + 1) / (self.trigram[given_words] + len(self.unigram))\n elif gram_type == 5:\n return math.log(self.five_gram[predicted_words] + 1) / (self.four_gram[given_words] + len(self.unigram))\n except ZeroDivisionError:\n return 0\n except KeyError:\n return 0","def maximization_step(self, number_of_topics, verbose):\n if verbose:\n print(\"M step:\")\n\n self.topic_word_prob = np.zeros((number_of_topics, len(self.vocabulary)))\n self.topic_word_prob_collection_specific = []\n\n for k in range(self.number_of_collections):\n topic_word_prob_collection_specific = np.zeros((number_of_topics, len(self.vocabulary)))\n for i in range(self.number_of_documents):\n # update P(w | z)\n\n # ############################\n\n self.topic_word_prob = np.add(self.topic_word_prob,\n np.transpose(np.multiply(np.multiply(np.multiply(self.term_doc_matrix[k][i], 1 - self.topic_prob_B[k][i]), self.topic_prob_j[k][i]), self.topic_prob_C[k][i])))\n\n topic_word_prob_collection_specific = np.add(self.topic_word_prob,\n np.transpose(np.multiply(np.multiply(np.multiply(self.term_doc_matrix[k][i], 1 - self.topic_prob_B[k][i]), self.topic_prob_j[k][i]), 1 - self.topic_prob_C[k][i])))\n\n # update P(z | d)\n\n # ############################\n\n matrix = np.dot(np.transpose(self.term_doc_matrix[k][i]), self.topic_prob_j[k][i])\n self.document_topic_prob[k][i] = normalize_row(matrix)\n topic_word_prob_collection_specific = normalize_row(topic_word_prob_collection_specific)\n self.topic_word_prob_collection_specific.append(topic_word_prob_collection_specific)\n\n self.topic_word_prob = normalize_row(self.topic_word_prob)\n\n #print(\"pi:\")\n #print(self.document_topic_prob)\n #print(\"p(w|theta):\")\n #print(self.topic_word_prob)","def calculate_log_p_multinomial(self, n_counts, nbins, batch_size):\n\n n_counts = tf.cast(n_counts, tf.float32)\n nbins = tf.cast(nbins, tf.float32)\n batch_size = tf.cast(batch_size, tf.float32)\n\n term_a = tf.lgamma(batch_size + 1)\n term_b = tf.reduce_sum(tf.lgamma(n_counts + 1))\n term_c = batch_size * tf.log(nbins)\n\n return term_a - term_b - term_c","def em_step(t, eng, fre):\n # TODO\n # Lecture Steps:\n # 1. Make a table of P(f|e) for all possible pairs of f and e, prob_tab\n # 2. Make a grid where each sentence pair is a row and each possible\n # alignment is a column\n # 3. For each sentence pair and alignment compute P(F|a,E)\n # Given aligned words f1,f2,...,fn and e1,e2,...,en in the pair:\n # P(F|a,E) = prob_tab[f1][e1] * ... * prob_tab[fn][en]\n # 4. For each sentence pair and alignment\n # divide P(F|a,E) by the sum of the P(F|a,E)'s in the row\n # this is P(a|E,F)\n # 5. For each possible word pair e and f, sum P(a|E,F) across all\n # alignments and sentence pairs for each instance that e is aligned\n # with f, this gets out a TCount table\n # 6. Sum over the rows of TCount to get the total estimates for each\n # english word e.\n # 7. Compute P(f|e) = TCount[f][e] / Total[e]\n # This is the model after 1 iteration.\n\n '''\n Tutorial Steps:\n initialize P(f|e)\n for a number of iterations:\n set tcount(f, e) to 0 for all f, e\n set total(e) to 0 for all e\n for each sentence pair (F, E) in training corpus:\n for each unique word f in F:\n denom_c = 0\n for each unique word e in E:\n denom_c += P(f|e) * F.count(f)\n for each unique word e in E:\n tcount(f, e) += P(f|e) * F.count(f) * E.count(e) / denom_c\n total(e) += P(f|e) * F.count(f) * E.count(e) / denom_c\n for each e in domain(total(:)):\n for each f in domain(tcount(:,e)):\n P(f|e) = tcount(f, e) / total(e)\n '''\n\n '''\n My Pseudocode:\n The Table of P(f|e) is already initiated as the AM dictionary.\n Presumably the AM is passed in as t.\n Initialize TCount as a dictionary like AM, e.g. TCount[e][f] = 0\n Initialize Total as a dictionary with the same entries as TCount[e] = 0\n for i in range(0,len(eng)):\n\n '''\n AM = dict.fromkeys(t.keys(), 0)\n Total = dict.fromkeys(t.keys(), 0)\n TCount = dict.fromkeys(t.keys(), 0)\n for key in TCount.keys():\n TCount[key] = dict.fromkeys(t[key].keys(), 0)\n AM[key] = dict.fromkeys(t[key].keys(), 0)\n\n num_sentences = min(len(eng), len(fre))\n for i in range(0, num_sentences):\n E = eng[i]\n F = fre[i]\n E_uniques = list(set(E))\n F_uniques = list(set(F))\n for f in F_uniques:\n denom_c = 0\n for e in E_uniques:\n denom_c += t[e][f] * F.count(f)\n for e in E_uniques:\n TCount[e][f] += t[e][f] * F.count(f) * E.count(e) / denom_c\n Total[e] += t[e][f] * F.count(f) * E.count(e) / denom_c\n for e in Total.keys():\n for f in TCount[e].keys():\n AM[e][f] = TCount[e][f] / Total[e]\n\n return AM","def log_prob(sentence, LM, smoothing=False, delta=0, vocabSize=0):\n\tlog_prob = 0\n\tdenominator = 0\n\tnumerator = 0\n\tword_list = sentence.split()\n\tlength_w = len(word_list) -1\n\tfor i in range(length_w):\n\t\tword = word_list[i]\n\t\tif word in LM['uni'].keys():\n\t\t\tdenominator = LM['uni'][word]\n\t\telse:\n\t\t\tdenominator = 0\n\t\tnext_word = word_list[i+1]\n\t\tif word in LM['bi'].keys() and next_word in LM['bi'][word].keys():\n\t\t\tnumerator = LM['bi'][word][next_word]\n\t\telse:\n\t\t\tnumerator = 0\n\t\t# case when numerator/denominator = 0/0 and if it is not smoothing the log_prob will be -infinite\n\t\tif (numerator == 0 or denominator == 0) and (not smoothing):\n\t\t\treturn float('-inf')\n\t\telse:\n\t\t\tnumerator += delta\n\t\t\tdenominator += delta*vocabSize\n\t\t\tprob = (numerator) / (denominator)\n\t\t\tlog_prob+= log(prob, 2)\n\treturn log_prob","def target_distribution(q):\n weight = q ** 2 / q.sum(0)\n return (weight.T / weight.sum(1)).T","def sampled_softmax_logprobs(self, logit_target_in_model, logit_noise_in_model, logit_noise_in_noise, logit_target_in_noise):\n logits = torch.cat([logit_target_in_model.unsqueeze(2), logit_noise_in_model], dim=2)\n q_logits = torch.cat([logit_target_in_noise.unsqueeze(2), logit_noise_in_noise], dim=2)\n # subtract Q for correction of biased sampling\n logits = logits - q_logits\n logproba = torch.nn.LogSoftmax(dim=-1)(logits)\n \n labels = torch.zeros_like(logits.narrow(2, 0, 1)).squeeze(2).long()\n \n logprobs = -torch.nn.NLLLoss(reduction='none')(logproba.view(-1, logproba.size(-1)), labels.view(-1)).view_as(labels)\n logprobs = torch.sum(logprobs, dim=1)\n \n return logprobs","def smooth_tag_model(cls, heldout_data):\n\n # bi_transition_counts = defaultdict(int)\n n = 0 # count word-tags\n e = .0001 # stopping condition\n L = [.25, .25, .25, .25] # initialize lambdas uniformly\n i = 1 # iteration\n while True:\n # E Step (Step 1)\n # Iterate through all occurring trigrams\n # in the heldout.txt data (H), i.e. minimizing\n # log likelihood\n counts = [0, 0, 0, 0]\n ratio = [0, 0, 0, 0]\n nextL = 4 * [0] # next lambda\n\n for sent in heldout_data:\n\n # Handle beginning of sentence\n t = '<s>'\n u = '<s>'\n # bi_transition_counts[t, u] += 1\n\n # if first == '<s>' and second == '<s>': # add bigram for nulls\n\n for word, tag in sent:\n v = tag\n # tri_transitions[t, u, v] += 1\n # bi_transitions[u, v] += 1\n # # if first == '<s>' and second == '<s>': # add bigram for nulls\n # # tagger._bi_transitions[('<s>', '<s>')] += 1\n # uni_transitions[v] += 1\n # cls._emissions[word, tag] += 1\n # tags.add(v)\n # words.add(word)\n # uni_words[word] += 1\n\n\n # Calculate expected counts of lambdas\n ratio = cls.calc_tag_ratio(t, u, v, L)\n\n # M-step (Step 2)\n # Calculate expected counts of lambdas, i.e. weight, taking\n # into account the number of occurrences of each trigram (cnt)\n for j in range(len(L)):\n counts[j] += ratio[j] # weight of lambda in whole equation (count)\n\n t = u\n u = v\n # n += 1\n\n # Handle end of sentence\n # tri_transitions[t, u, '</s>'] += 1\n v = '</s>'\n ratio = cls.calc_tag_ratio(t, u, v, L)\n for j in range(len(L)):\n counts[j] += ratio[j] # weight of lambda in whole equation (count)\n\n # cls._bi_transitions[first, second] += 1\n # cls._tri_transitions[second, '</s>', '</s>'] += 1\n\n\n # Update values for parameters given current distribution\n for k in range(len(L)):\n total = np.sum(counts)\n nextL[k] = counts[k] / total # next lambda\n\n # Check if lambda values have converged\n converged = True\n for l in range(len(L)):\n if np.abs(nextL[l] - L[l]) > e: # tolerance = e\n converged = False\n L = nextL\n\n # Return values if lambdas have converged\n if converged:\n break\n\n i += 1 # increment iteration counter\n\n\n return L # copy lambdas passed by reference","def log_prior_grad(self, inputs):","def get_logCRF(train, model):\n word = train[0]\n Y = train[1]\n char_count, _ = word.shape\n # calculating forward messages\n alpha = np.zeros((char_count, model.dimY))\n first_term = np.dot(word, model.getW(model.labels))\n second_term = model._T\n for i in range(1, char_count):\n sum_term = (first_term[i-1] + alpha[i-1]) + second_term\n alpha[i] = np.apply_along_axis(logsumexp_trick, 1, sum_term) \n # getting logZ from messages\n logZ = logsumexp_trick(first_term[char_count-1]+alpha[char_count-1])\n w_term = np.sum(model.getW(Y).transpose() * word) # $\\sum_{j=1}^m {W_{yj} . x_j}$\n t_term = np.sum(model.getT(Y[:-1], Y[1:])) #$T_{yj, yj+1}\n value = -logZ + w_term + t_term\n return value","def log_loss(self):\n probabilities = self.probability_array().copy()\n # need to flip the probabilities for p < 0.5 with this binary case.\n # 1 - old_val is same as oldval*-1 + 1. Do in 2 steps:\n probabilities[np.equal(0, self.y)] *= -1\n probabilities[np.equal(0, self.y)] += 1\n # when multiclass: np.amax(probabilities, 1)\n return np.log(probabilities).sum()","def predict_next(self, words):\n prefix = \"%s \" % ' '.join(self.history)\n order = len(self.history) + 1\n scaling_factor = math.log(10) if self.convert_to_ln else 1.0\n ret = {w: getNgramProb(\n self.lm,\n prefix + (\"</s>\" if w == utils.EOS_ID else str(w)),\n order) * scaling_factor for w in words}\n return ret","def log_prob(self):\n res = -self.L_h/2*np.log(2*np.pi*self.la)\n res = res + self.L_h*(self.L_h-1)/2*self.a\n\n\n res = res - 1/(2*self.la)*np.square(np.linalg.norm(self.e*self.pie))\n\n res = res - 1/(2*self.la)*np.sum(self.e2*self.pie_var)\n\n res = res - self.L_h/2*np.log(2*np.pi*self.sigma2)\n res = res - 1/(2*self.sigma2)*(np.square(np.linalg.norm(self.w))+np.trace(self.R))\n\n print(\"Log-probability difference = {}\".format(res - self.LP), file=self.logfile)\n self.LP = res\n return res","def ER_Theory(N,Kappa) :\n\tMu2 = Kappa - ( 2*Kappa*(1.0 - (Kappa/N))*math.log(N) )**0.5 + (( (Kappa*(1.0 - (Kappa/N)))/math.log(N) )**0.5)*( math.log( (2*math.pi*math.log((N**2)/(2*math.pi))) ) - 0.5772)\n\treturn Mu2","def __init__(self, n, sents, corpus='', gamma=None, addone=True):\n self.n = n\n self.smoothingtechnique = 'Interpolated (Jelinek Mercer) Smoothing'\n self.gamma = gamma\n self.addone = addone\n self.counts = counts = defaultdict(int)\n self.gamma_flag = True\n self.corpus = corpus\n # way more efficient than use set unions\n voc = ['</s>']\n for s in sents:\n voc += s\n self.voc = list(set(voc))\n\n if gamma is None:\n self.gamma_flag = False\n\n # if not gamma given\n if not self.gamma_flag:\n total_sents = len(sents)\n aux = int(total_sents * 90 / 100)\n # 90 per cent for training\n train_sents = sents[:aux]\n # 10 per cent for perplexity (held out data)\n held_out_sents = sents[-total_sents+aux:]\n\n train_sents = list(map((lambda x: ['<s>']*(n-1) + x), train_sents))\n train_sents = list(map((lambda x: x + ['</s>']), train_sents))\n\n for sent in train_sents:\n for j in range(n+1):\n # move along the sent saving all its j-grams\n for i in range(n-j, len(sent) - j + 1):\n ngram = tuple(sent[i: i + j])\n counts[ngram] += 1\n # added by hand\n counts[('</s>',)] = len(train_sents)\n # variable only for tests\n self.tocounts = counts\n # search the gamma that gives lower perplexity\n gamma_candidates = [i*50 for i in range(1, 15)]\n # xs is a list with (gamma, perplexity)\n xs = []\n sents = train_sents\n for aux_gamma in gamma_candidates:\n self.gamma = aux_gamma\n aux_perx = self.perplexity(held_out_sents)\n xs.append((aux_gamma, aux_perx))\n xs.sort(key=lambda x: x[1])\n self.gamma = xs[0][0]\n with open('old-stuff/interpolated_' + str(n) + '_parameters_'+corpus, 'a') as f:\n f.write('Order: {}\\n'.format(self.n))\n f.write('Gamma: {}\\n'.format(self.gamma))\n f.write('AddOne: {}\\n'.format(self.addone))\n f.write('Perplexity observed: {}\\n'.format(xs[0][1]))\n f.write('-------------------------------\\n')\n f.close()\n\n else:\n sents = list(map((lambda x: ['<s>']*(n-1) + x), sents))\n sents = list(map((lambda x: x + ['</s>']), sents))\n\n for sent in sents:\n # counts now holds all k-grams for 0 < k < n + 1\n for j in range(n+1):\n # move along the sent saving all its j-grams\n for i in range(n-j, len(sent) - j + 1):\n ngram = tuple(sent[i: i + j])\n counts[ngram] += 1\n # added by hand\n counts[('</s>',)] = len(sents)","def _loglike(self, y, f):\n ll = y * tf.log(pos(f)) + (1 - y) * tf.log(pos(1 - f))\n return ll"],"string":"[\n \"def compute_log_probs(self, phrases, save_to_file=None):\\n # Co-ocurrence for source and target phrase\\n tgt_src_cnt = defaultdict(lambda: defaultdict(int))\\n \\n # ocurrence for target (English)\\n tgt_cnt = defaultdict(int)\\n\\n # Compute frequency and co-occurence\\n for phrase_pair in phrases:\\n\\n assert len(phrase_pair) == 2\\n src_p, tgt_p = phrase_pair\\n # defaultdict[target_phrase][source_phrase]\\n tgt_src_cnt[tgt_p][src_p]+=1\\n # defaultdict[target_phrase]\\n tgt_cnt[tgt_p]+=1\\n\\n\\n # Calculate log prob of translation model p(f|e)\\n log_prob_lst = list()\\n for tgt_phrase in tgt_src_cnt:\\n for src_phrase in tgt_src_cnt[tgt_phrase]:\\n # count(source, target) / count(target)\\n prob = float(tgt_src_cnt[tgt_phrase][src_phrase])/tgt_cnt[tgt_phrase]\\n log_prob = math.log(prob)\\n\\n log_prob_str = f\\\"{src_phrase} ||| {tgt_phrase} ||| {str(log_prob)}\\\"\\n log_prob_lst.append(log_prob_str)\\n \\n # Save to file \\n if save_to_file is not None:\\n with Path(save_to_file).open(\\\"w\\\") as wf:\\n wf.write('\\\\n'.join(log_prob_lst))\\n sys.stdout.write(f\\\"Saving phrase log probability file to path: {save_to_file}.\\\\n\\\")\\n \\n # List of log probability for phrase pair\\n return log_prob_lst\",\n \"def log_prob(self):\",\n \"def train(self, documents):\\n prior_log_prob, label_to_col = self.get_prior_log_probabilities(documents)\\n self.my_model[\\\"vocabulary\\\"] = make_vocabulary(documents)\\n\\n # find frequencies of features\\n num_classes = len(label_to_col)\\n num_features = len(self.extract_f_vector(documents[0]))\\n features_freq = np.zeros((num_features, num_classes))\\n for doc in documents:\\n f_vector = self.extract_f_vector(doc)\\n col_for_f_vector = label_to_col[doc.label]\\n features_freq[:, col_for_f_vector] += f_vector\\n\\n # laplace smoothing\\n total_per_label = np.sum(features_freq, axis=0)\\n features_freq += np.ones(total_per_label.shape, int)\\n normalizer = total_per_label + np.full(total_per_label.shape, num_features, int)\\n features_freq /= normalizer\\n\\n # stack all probabilities to one matrix and take log\\n # result: self.all_log_prob\\n # |-----------------------------------|\\n # | log P(f1|C1) | ... | log P(f1|Cn) |\\n # | log P(f2|C1) | ... | log P(f2|Cn) |\\n # | . | . | . |\\n # | . | . | . |\\n # | . | . | . |\\n # | log P(fm|C1) | ... | log P(fm|Cn) |\\n # | log P(C1) | ... | log P(Cn) |\\n # |-----------------------------------|\\n likelihood_log_prob = np.log(features_freq)\\n all_log_prob = np.vstack((likelihood_log_prob, prior_log_prob))\\n self.my_model[\\\"all_log_prob\\\"] = all_log_prob\",\n \"def log_prob(sentence, LM, smoothing=False, delta=0, vocabSize=0):\\n word_list = sentence.split()\\n log_prob = 0\\n for i in range(len(word_list)-1):\\n print(word_list[i], word_list[i+1])\\n bi_count = LM['bi'][word_list[i]][word_list[i+1]]\\n uni_count = LM['uni'][word_list[i]]\\n if uni_count == 0 and smoothing:\\n return float('-inf')\\n log_prob += log(((bi_count + delta)/(uni_count + delta * vocabSize)))\\n return log_prob\",\n \"def calculate_log_perplexity(self, output, flat_labels): #completed, expensive, should be compiled\\n return -np.sum(np.log2(np.clip(output, a_min=1E-12, a_max=1.0))[np.arange(flat_labels.shape[0]), flat_labels[:,1]])\",\n \"def get_value(self, **kwargs):\\n super(PerplexityMetric, self).set_parameters(**kwargs)\\n corpus_words = sum(cnt for document in self.corpus for _, cnt in document)\\n # 単語1語あたりの、接続候補の数。少ないほどエントロピーが少なくて良くまとまっている\\n perwordbound = self.model.bound(self.corpus) / corpus_words\\n self.log.add(perwordbound)\\n if len(self.log) > 2:\\n diff = np.diff(np.array(self.log))\\n # とても心苦しいが、early stoppingで止める方法がexception raiseしか思いつかなかった。\\n # ## exceptionをこんなふうに使ってよかったっけ?\\n if np.abs(1 - np.mean(diff[-self.patience]) / diff[-1]) < self.must_move_this_rate:\\n # 直近patience回の平均が変わらないなら、多分収束\\n raise EarlyStoppingException(\\\"no movement\\\")\\n if np.abs(diff[-1] / diff[0]) < self.must_move_this_rate:\\n # 初期変化量のmust_move_this_rate(float < 1)も変わらなければ、多分収束\\n raise EarlyStoppingException(\\\"converged\\\")\\n\\n return np.exp2(-perwordbound)\",\n \"def calculate_perplexity(sentence, n_gram_counts, n_plus1_gram_counts, vocabulary_size, k=1.0):\\r\\n # length of previous words\\r\\n n = len(list(n_gram_counts.keys())[0]) \\r\\n \\r\\n # prepend <s> and append <e>\\r\\n sentence = [\\\"<s>\\\"] * n + sentence + [\\\"<e>\\\"]\\r\\n \\r\\n # Cast the sentence from a list to a tuple\\r\\n sentence = tuple(sentence)\\r\\n \\r\\n # length of sentence (after adding <s> and <e> tokens)\\r\\n N = len(sentence)\\r\\n \\r\\n\\r\\n product_pi = 1.0\\r\\n \\r\\n \\r\\n # Index t ranges from n to N - 1, inclusive on both ends\\r\\n for t in range(n, N): \\r\\n\\r\\n # get the n-gram preceding the word at position t\\r\\n n_gram = sentence[t-n:t]\\r\\n \\r\\n # get the word at position t\\r\\n word = sentence[t]\\r\\n \\r\\n\\r\\n probability = estimate_probability(word, n_gram, n_gram_counts, n_plus1_gram_counts, vocabulary_size, k=1.0)\\r\\n \\r\\n\\r\\n product_pi *= 1/probability\\r\\n\\r\\n # Take the Nth root of the product\\r\\n perplexity = product_pi**(1/float(N))\\r\\n return perplexity\",\n \"def log_joint(self):\\n return sum([\\n self.log_marg_like(self.gamma, self.gamma0, self.lamb, self.nu),\\n self._gamma0_distribution.logpdf(self.gamma0),\\n self._nu_distribution.logpdf(self.nu),\\n self._lambda_distribution.logpdf(self.lamb),\\n self.probit_distribution(self.xi).logpdf(self.gamma),\\n self._xi_distribution.logpdf(self.xi) if self.sample_xi else 0.0\\n ])\",\n \"def perplexity(sentences: List[Tuple[List[int], List[int]]], model: Seq2SeqAttentionModel) -> float:\\n LL_Total = torch.tensor(0, dtype=torch.float)\\n total_words = torch.tensor(0, dtype=torch.float)\\n for i, (source_sentence, target_sentence) in enumerate(sentences):\\n LL_Total += log_likelihood(source_sentence, target_sentence, model)\\n total_words += len(target_sentence)\\n\\n return torch.exp(-LL_Total / total_words)\",\n \"def nce_logprobs(self, logit_target_in_model, logit_noise_in_model, logit_noise_in_noise, logit_target_in_noise):\\n\\n # NOTE: prob <= 1 is not guaranteed\\n logit_model = torch.cat([logit_target_in_model.unsqueeze(2), logit_noise_in_model], dim=2)\\n logit_noise = torch.cat([logit_target_in_noise.unsqueeze(2), logit_noise_in_noise], dim=2)\\n\\n # predicted probability of the word comes from true data distribution\\n # The posterior can be computed as following\\n # p_true = logit_model.exp() / (logit_model.exp() + self.noise_ratio * logit_noise.exp())\\n # For numeric stability we compute the logits of true label and\\n # directly use bce_with_logits.\\n # Ref https://pytorch.org/docs/stable/nn.html?highlight=bce#torch.nn.BCEWithLogitsLoss\\n #logit_true = logit_model - logit_noise - math.log(self.noise_ratio)\\n p_true = logit_model.exp() / (logit_model.exp() + self.noise_ratio * logit_noise.exp())\\n \\n label = torch.zeros_like(logit_model)\\n label[:, :, 0] = 1\\n\\n #logprobs = -self.bce_with_logits(logit_true, label)\\n logprobs = -nn.BCELoss(reduction='none')(p_true, label)\\n logprobs = torch.sum(logprobs.view(logprobs.size(0), -1), dim=1)\\n \\n return logprobs\",\n \"def compute_probabilities():\\n global total_spam_words, total_ham_words\\n total_words = total_spam_words+total_ham_words\\n unique_words = len(all_dict)\\n print(\\\"Training Set Description: \\\")\\n len_ham = len(ham_file_list)\\n len_spam = len(spam_file_list)\\n print(\\\"SPAM EMAILS: \\\",len_spam)\\n print(\\\"HAM EMAILS: \\\",len_ham)\\n print(\\\"Total words: \\\",total_words)\\n print(\\\"Training...\\\")\\n \\n spam_probability = math.log((len_spam)/(len_spam+len_ham))\\n ham_probability = math.log((len_ham)/(len_spam+len_ham))\\n \\n \\n \\n output_file = open(\\\"nbmodel.txt\\\", \\\"w+\\\", encoding=\\\"latin-1\\\")\\n output_file.write(\\\"model_params \\\"+str(spam_probability)+\\\" \\\"+str(ham_probability)+\\\"\\\\n\\\")\\n \\n nbmodel = {}\\n nbmodel[\\\"model_params\\\"] = (spam_probability,ham_probability)\\n for word in all_dict.keys():\\n spam_count = 1\\n if word in spam_dict:\\n spam_count+= spam_dict[word]\\n \\n word_spam_probability = math.log(spam_count / (total_spam_words+unique_words))\\n \\n ham_count = 1\\n if word in ham_dict:\\n ham_count+= ham_dict[word]\\n \\n word_ham_probability = math.log(ham_count / (total_ham_words+unique_words))\\n \\n output_file.write(word+\\\" \\\"+str(word_spam_probability)+\\\" \\\"+str(word_ham_probability)+\\\"\\\\n\\\")\\n nbmodel[word] = (word_spam_probability, word_ham_probability) \\n \\n print(\\\"nbmodel.txt generated successfully...\\\")\\n print(\\\"SPAM Probability: \\\",spam_probability)\\n print(\\\"HAM Probability: \\\",ham_probability)\\n output_file.close()\",\n \"def weight_distribution(self):\\n all_scores = []\\n for zettel in self.lemma_tokens:\\n scores = []\\n for word in zettel:\\n cur_tf_idf = self.tf_idf_scores[word[0]] / 3 #range: 0-3+\\n if word[1] == 'NG':\\n word_list = re.split(\\\" \\\", word[0])\\n cur_word_score = 0\\n i = 0\\n for new_word in word_list:\\n cur_word_score += self.word_scores[new_word]\\n i += 1\\n cur_word_score = cur_word_score / i / 2 #range: 0-2+\\n else:\\n cur_word_score = self.word_scores[word[0]] / 2 #range: 0-2+\\n cur_keyword_score = self.keyword_scores[word[0]] / 4 #0-4+\\n cur_text_rank = self.text_ranks[word[0]] / 10 #range: 0-12+\\n cur_pos_score = self.pos_scores[word[0]]\\n cur_area_score = self.z_area_scores[word[0]]\\n cur_total_score = ((cur_tf_idf * self.score_weights[0]) + (cur_word_score * self.score_weights[1]) +\\n (cur_keyword_score * self.score_weights[2]) + (cur_text_rank * self.score_weights[3]) +\\n (cur_pos_score * self.score_weights[4]) + (cur_area_score * self.score_weights[5])) / 6\\n scores.append(cur_total_score)\\n all_scores.append(scores)\\n return all_scores\",\n \"def posterior(self, model, sentence, label):\\r\\n\\r\\n if model == \\\"Simple\\\":\\r\\n cost = sum(\\r\\n [\\r\\n (\\r\\n (math.log(self.emission_probability[label[i]][sentence[i]]))\\r\\n + (math.log(self.posterior_probability[label[i]]))\\r\\n if sentence[i] in self.emission_probability[label[i]]\\r\\n else (math.log(1 / float(10 ** 10)))\\r\\n + (math.log(self.posterior_probability[label[i]]))\\r\\n )\\r\\n for i in range(len(sentence))\\r\\n ]\\r\\n )\\r\\n return cost\\r\\n elif model == \\\"Complex\\\":\\r\\n post_array = []\\r\\n for i in range(len(sentence)):\\r\\n if i == 0:\\r\\n post_array.append(\\r\\n self.emission_probability[label[i]][sentence[i]]\\r\\n * self.initial_probability[label[i]]\\r\\n if sentence[i] in self.emission_probability[label[i]]\\r\\n else (1 / float(10 ** 10)) * self.initial_probability[label[i]]\\r\\n )\\r\\n elif i == 1:\\r\\n post_array.append(\\r\\n self.emission_probability[label[i]][sentence[i]]\\r\\n * (\\r\\n self.transition_probability[label[i - 1]][label[i]]\\r\\n * self.posterior_probability[label[i - 1]]\\r\\n / self.posterior_probability[label[i]]\\r\\n )\\r\\n * self.posterior_probability[label[i]]\\r\\n if sentence[i] in self.emission_probability[label[i]]\\r\\n else (1 / float(10 ** 10))\\r\\n * (\\r\\n self.transition_probability[label[i - 1]][label[i]]\\r\\n * self.posterior_probability[label[i - 1]]\\r\\n / self.posterior_probability[label[i]]\\r\\n )\\r\\n * self.posterior_probability[label[i]]\\r\\n )\\r\\n else:\\r\\n post_array.append(\\r\\n self.emission_probability[label[i]][sentence[i]]\\r\\n * (\\r\\n self.transition_probability[label[i - 1]][label[i]]\\r\\n * self.posterior_probability[label[i - 1]]\\r\\n / self.posterior_probability[label[i]]\\r\\n )\\r\\n * (\\r\\n self.transition_probability[label[i - 1]][label[i]]\\r\\n * self.posterior_probability[label[i - 2]]\\r\\n / self.posterior_probability[label[i]]\\r\\n )\\r\\n * self.posterior_probability[label[i]]\\r\\n if sentence[i] in self.emission_probability[label[i]]\\r\\n else (1 / float(10 ** 10))\\r\\n * (\\r\\n self.transition_probability[label[i - 1]][label[i]]\\r\\n * self.posterior_probability[label[i - 1]]\\r\\n / self.posterior_probability[label[i]]\\r\\n )\\r\\n * (\\r\\n self.transition_probability[label[i - 2]][label[i]]\\r\\n * self.posterior_probability[label[i - 2]]\\r\\n / self.posterior_probability[label[i]]\\r\\n )\\r\\n * self.posterior_probability[label[i]]\\r\\n )\\r\\n post_array = [math.log(p) for p in post_array]\\r\\n cost = sum(post_array)\\r\\n return cost\\r\\n\\r\\n elif model == \\\"HMM\\\":\\r\\n post_array = []\\r\\n for i in range(len(sentence)):\\r\\n if i == 0:\\r\\n post_array.append(\\r\\n (\\r\\n self.initial_probability[label[i]]\\r\\n * self.emission_probability[label[i]][sentence[i]]\\r\\n )\\r\\n if sentence[i] in self.emission_probability[label[i]]\\r\\n else (self.initial_probability[label[i]] * (1 / float(10 ** 8)))\\r\\n )\\r\\n else:\\r\\n emi = (\\r\\n (self.emission_probability[label[i]][sentence[i]])\\r\\n if sentence[i] in self.emission_probability[label[i]]\\r\\n else (1 / float(10 ** 10))\\r\\n )\\r\\n\\r\\n min_val = post_array[i - 1] * (\\r\\n (self.transition_probability[label[i - 1]][label[i]])\\r\\n )\\r\\n\\r\\n post_array.append(emi * min_val)\\r\\n\\r\\n post_array = [math.log(p) for p in post_array]\\r\\n\\r\\n cost = sum(post_array)\\r\\n\\r\\n return cost\\r\\n else:\\r\\n print(\\\"Unknown algorithm!\\\")\",\n \"def log_likelihood(self) -> tf.Tensor:\\n # K⁻¹ + GᵀΣ⁻¹G = LLᵀ.\\n l_post = self._k_inv_post.cholesky\\n num_data = self.observations_index.shape[0]\\n\\n # Hμ [..., num_transitions + 1, output_dim]\\n marginal = self.emission.project_state_to_f(self.prior_ssm.marginal_means)\\n marginal = self._drop_batch_shape(marginal)\\n\\n # y = obs - Hμ [..., num_transitions + 1, output_dim]\\n disp = self.observations - marginal\\n disp_data = self.sparse_observations - self.dense_to_sparse(marginal)\\n\\n # cst is the constant term for a gaussian log likelihood\\n cst = (\\n -0.5 * np.log(2 * np.pi) * tf.cast(self.emission.output_dim * num_data, default_float())\\n )\\n\\n term1 = -0.5 * tf.reduce_sum(\\n input_tensor=tf.einsum(\\\"...op,...p,...o->...o\\\", self._r_inv_data, disp_data, disp_data), axis=[-1, -2]\\n )\\n\\n # term 2 is: ½|L⁻¹(GᵀΣ⁻¹)y|²\\n # (GᵀΣ⁻¹)y [..., num_transitions + 1, state_dim]\\n obs_proj = self._back_project_y_to_state(disp)\\n\\n # ½|L⁻¹(GᵀΣ⁻¹)y|² [...]\\n term2 = 0.5 * tf.reduce_sum(\\n input_tensor=tf.square(l_post.solve(obs_proj, transpose_left=False)), axis=[-1, -2]\\n )\\n\\n ## term 3 is: ½log |K⁻¹| - log |L| + ½ log |Σ⁻¹|\\n # where log |Σ⁻¹| = num_data * log|R⁻¹|\\n term3 = (\\n 0.5 * self.prior_ssm.log_det_precision()\\n - l_post.abs_log_det()\\n + 0.5 * self._log_det_observation_precision\\n )\\n\\n return tf.reduce_sum(cst + term1 + term2 + term3)\",\n \"def log_marg(self):\\n log_prob_X_given_z = 0.\\n for k in range(self.K):\\n log_prob_X_given_z += self.log_marg_k(k)\\n return log_prob_X_given_z\",\n \"def log_m_probs(self):\\n m = self.kernel.feature_log_prob_[self._match_class_pos()]\\n return self._prob_inverse_transform(m)\",\n \"def compute_my_variability(event_log: Log) -> float:\\n prefixes: List[List[Event]] = []\\n bar: Bar = IncrementalBar(\\\"Prefix generation\\\", max=len(event_log.trace_list))\\n for trace in event_log.trace_list:\\n trace_prefixes: List[List[Event]] = trace.get_all_prefixes()\\n\\n for prefix in trace_prefixes:\\n if prefix not in prefixes:\\n prefixes.append(prefix)\\n bar.next()\\n bar.finish()\\n\\n entropy: float = 0\\n\\n bar = ShadyBar(\\\"Prefix likelihood estimation\\\", max=len(prefixes))\\n for prefix in prefixes:\\n\\n p: float = _prefix_likelihood_estimator(event_log, prefix)\\n entropy += p * logarithm(p, 10)\\n\\n bar.next()\\n bar.finish()\\n\\n entropy *= -1\\n\\n return entropy\",\n \"def weights(self):\\n m = self.kernel.feature_log_prob_[self._match_class_pos()]\\n u = self.kernel.feature_log_prob_[self._nonmatch_class_pos()]\\n\\n return self._prob_inverse_transform(numpy.exp(m - u))\",\n \"def model(X, Y, word_to_vec_map, learning_rate = 0.01, num_iterations = 400):\\n \\n # Get a valid word contained in the word_to_vec_map \\n any_word = list(word_to_vec_map.keys())[0]\\n \\n # Initialize cost. It is needed during grading\\n cost = 0\\n \\n # Define number of training examples\\n m = Y.shape[0] # number of training examples\\n n_y = len(np.unique(Y)) # number of classes \\n n_h = word_to_vec_map[any_word].shape[0] # dimensions of the GloVe vectors \\n \\n # Initialize parameters using Xavier initialization\\n W = np.random.randn(n_y, n_h) / np.sqrt(n_h)\\n b = np.zeros((n_y,))\\n \\n # Convert Y to Y_onehot with n_y classes\\n Y_oh = convert_to_one_hot(Y, C = n_y) \\n \\n # Optimization loop\\n for t in range(num_iterations): # Loop over the number of iterations\\n for i in range(m): # Loop over the training examples\\n \\n ### START CODE HERE ### (≈ 4 lines of code)\\n # Average the word vectors of the words from the i'th training example\\n # def sentence_to_avg(sentence, word_to_vec_map): # return avg\\n avg = sentence_to_avg(X[i], word_to_vec_map)\\n\\n # Forward propagate the avg through the softmax layer. \\n # You can use np.dot() to perform the multiplication.\\n z = np.dot(W, avg) + b\\n a = softmax(z)\\n\\n # Compute cost using the i'th training label's one hot representation and \\\"A\\\" (the output of the softmax)\\n cost = - np.sum(Y_oh[i] * a)\\n ### END CODE HERE ###\\n \\n # Compute gradients \\n dz = a - Y_oh[i]\\n dW = np.dot(dz.reshape(n_y,1), avg.reshape(1, n_h))\\n db = dz\\n\\n # Update parameters with Stochastic Gradient Descent\\n W = W - learning_rate * dW\\n b = b - learning_rate * db\\n \\n if t % 100 == 0:\\n print(\\\"Epoch: \\\" + str(t) + \\\" --- cost = \\\" + str(cost))\\n pred = predict(X, Y, W, b, word_to_vec_map) #predict is defined in emo_utils.py\\n\\n return pred, W, b\",\n \"def margalef(counts):\\n return (observed_species(counts)-1)/log(counts.sum())\",\n \"def define_y(words):\\r\\n num_words = len(words)\\r\\n loglam = math.log10(num_words)\\r\\n freq = nltk.FreqDist(words)\\r\\n \\r\\n entropy = 0.0\\r\\n for w in freq:\\r\\n pi = freq[w]\\r\\n entropy += pi * (loglam - math.log10(pi)) / float(num_words)\\r\\n rel_entropy = entropy / loglam\\r\\n return rel_entropy\",\n \"def predictability(self):\\n temp = self.probs\\n for n in range(10):\\n temp = temp.dot(temp)\\n final = temp[0,:]\\n #Let's assume that all words have unique initial letters\\n probs = map(len, self.words)\\n probs = array(probs)\\n probs = (probs + self.probs.max(1)-1)/probs\\n return sum(final*probs)\",\n \"def translate(self):\\n\\n # load test data\\n test_loader, max_token_seq_len, is_bpe, decoder = self.load_testdata(self.opt.src, self.opt.vocab)\\n\\n self.model.word_prob_prj = nn.LogSoftmax(dim=1)\\n self.model.eval()\\n\\n translator = Translator(self.opt, new=False)\\n translator.model = self.model\\n translator.max_token_seq_len = max_token_seq_len\\n\\n hypotheses = []\\n\\n with open(self.opt.output, 'w') as f:\\n for batch in tqdm(test_loader, desc='Translating', leave=False, dynamic_ncols=True):\\n # get sequences through beam search.\\n all_hyp, _ = translator.translate_batch(*batch)\\n # write outputs as we get them so we can see progress.\\n if is_bpe:\\n lines = self.translate_decode_bpe(all_hyp, decoder)\\n else:\\n lines = self.translate_decode_dict(all_hyp, decoder)\\n for line in lines:\\n f.write(line + \\\"\\\\n\\\")\\n \\n if self.opt.verbose:\\n print('[Info] Finished.')\\n return hypotheses\",\n \"def summer(n_terms, n_words):\\n try:\\n math.log(math.log(n_terms)) / math.log(math.log(n_words))\\n except ValueError:\\n return 0\",\n \"def compute_logits(self):\\n # [num train labels, num classes] where each row is a one-hot-encoded label.\\n one_hot_train_labels = tf.one_hot(self.data.train_labels, self.way)\\n\\n # Undocumented in the paper, but *very important*: *only* the support set\\n # embeddings is L2-normalized, which means that the distance is not exactly\\n # a cosine distance. For comparison we also allow for the actual cosine\\n # distance to be computed, which is controlled with the\\n # `exact_cosine_distance` instance attribute.\\n train_embeddings = tf.nn.l2_normalize(\\n self.train_embeddings, 1, epsilon=1e-3)\\n test_embeddings = self.test_embeddings\\n if self.exact_cosine_distance:\\n test_embeddings = tf.nn.l2_normalize(test_embeddings, 1, epsilon=1e-3)\\n # [num_test_images, num_train_images]\\n similarities = tf.matmul(\\n test_embeddings, train_embeddings, transpose_b=True)\\n attention = tf.nn.softmax(similarities)\\n\\n # [num_test_images, way]\\n probs = tf.matmul(attention, one_hot_train_labels)\\n self.test_logits = tf.log(probs)\\n return self.test_logits\",\n \"def logprob(predictions, labels):\\n predictions[predictions < 1e-10] = 1e-10\\n return np.sum(np.multiply(labels, -np.log(predictions)))\",\n \"def compute_loss(self,state,targets):\\n reshaped_targets = targets.reshape(-1,2,1)\\n\\n # reshape targets to match the dimension of means\\n for i in range(self.output_size-1):\\n reshaped_targets = torch.cat((reshaped_targets,targets.reshape(-1,2,1)),2)\\n\\n # compute output distribution from model\\n means,stds,weights = self.forward(state)\\n\\n # compute the mixed log pdf\\n mixed_pdf = mixed_prob(means,stds,weights,reshaped_targets)\\n\\n # compute the average negative log likelihood\\n return -torch.log(mixed_pdf).mean()\",\n \"def nll_logprobs(self, input, target_idx):\\n raise NotImplementedError()\",\n \"def likelihood(self, w, class_words):\\n return log((class_words.count(w) + 1)/(len(class_words) + self.N))\",\n \"def target_log_prob_fn(self, *args, **kwargs): # pylint: disable=unused-argument\\n\\n def log_joint_fn(*args, **kwargs): # pylint: disable=unused-argument\\n states = dict(zip(self.unobserved.keys(), args))\\n states.update(self.observed)\\n interceptor = interceptors.CollectLogProb(states)\\n with ed.interception(interceptor):\\n self._f(self._cfg)\\n\\n log_prob = sum(interceptor.log_probs)\\n return log_prob\\n return log_joint_fn\",\n \"def _logp(self, trace, **inputs):\\n def calc_log(step):\\n exp_pred = np.dot(inputs['gwas_gen'],\\n step['beta_med'].T).ravel()\\n phen_pred = step['alpha'] * exp_pred\\n phen_prob = norm.logpdf(x=inputs['gwas_phen'],\\n loc=phen_pred,\\n scale=step['phenotype_sigma'])\\n return phen_prob\\n\\n phen_probs = [calc_log(trace[idx])\\n for idx in np.random.randint(0, len(self.trace), 500)]\\n phen_probs = np.asmatrix(phen_probs)\\n mc_logp = phen_probs.sum(axis=1).mean()\\n return mc_logp\",\n \"def logprob(predictions, labels):\\n predictions[predictions < 1e-10] = 1e-10\\n return np.sum(np.multiply(labels, -np.log(predictions))) / labels.shape[0]\",\n \"def logprob(predictions, labels):\\n predictions[predictions < 1e-10] = 1e-10\\n return np.sum(np.multiply(labels, -np.log(predictions))) / labels.shape[0]\",\n \"def preprocessing():\\n english_dictionary = nltk.corpus.brown.words()\\n slang_vocab = pickle.load(open('vocab_pattern_match_with_freq.pkl', 'rb'))\\n\\n normalize_english_dict = len(english_dictionary)\\n normalize_slang_vocab = 0\\n for w, n in slang_vocab.items():\\n normalize_slang_vocab += n\\n\\n words = {}\\n for w, n in Counter(english_dictionary).items():\\n words[w] = n/normalize_english_dict\\n \\n for w, n in slang_vocab.items():\\n if w not in words:\\n words[w] = 0.\\n words[w] += n/normalize_slang_vocab\\n\\n words_by_freq = [w for w,_ in sorted(words.items(), key=lambda x: x[1], reverse=True)]\\n\\n # Build a cost dictionary, assuming Zipf's law and cost = -math.log(probability).\\n #words = open(\\\"words_by_frequency.txt\\\").read().split()\\n wordcost = dict((k, log((i+1)*log(len(words_by_freq)))) for i,k in enumerate(words_by_freq))\\n maxword = max(len(x) for x in words_by_freq)\\n return wordcost,maxword\",\n \"def naiveBayesMixture(train_set, train_labels, dev_set, bigram_lambda,unigram_smoothing_parameter, bigram_smoothing_parameter, pos_prior):\\n\\n # TODO: Write your code here\\n # return predicted labels of development set\\n\\n # counters for Training Phase\\n ham = Counter()\\n ham_bi = Counter()\\n spam = Counter()\\n spam_bi = Counter()\\n\\n for string, label in zip(train_set, train_labels):\\n for i in range(len(string)):\\n word = string[i]\\n if i != len(string)-1:\\n word_bi = string[i] + ' ' + string[i+1]\\n if label == 1:\\n ham_bi.update({word_bi:1})\\n else:\\n spam_bi.update({word_bi:1})\\n if label == 1:\\n ham.update({word:1})\\n else:\\n spam.update({word:1})\\n\\n ham_len = 0\\n for w in ham:\\n ham_len += ham[w]\\n spam_len = 0\\n for w in spam:\\n spam_len += spam[w]\\n \\n hambi_len = 0\\n for w in ham_bi:\\n hambi_len += ham_bi[w]\\n spambi_len = 0\\n for w in spam_bi:\\n spambi_len += spam_bi[w]\\n\\n # labels for Development Phase\\n dev_labels = []\\n # dicts for P(word|ham) and P(word|spam)\\n p_ham = {}\\n p_spam = {}\\n p_hambi = {}\\n p_spambi = {}\\n\\n # develop likelihoods based on dev_set\\n for word in ham:\\n numerator = ham[word] + unigram_smoothing_parameter\\n denominator = ham_len + unigram_smoothing_parameter*(len(ham))\\n p_ham[word] = numerator / denominator\\n for word in spam:\\n numerator = spam[word] + unigram_smoothing_parameter\\n denominator = spam_len + unigram_smoothing_parameter*(len(spam))\\n p_spam[word] = numerator / denominator\\n\\n for word_bi in ham_bi:\\n numerator = ham_bi[word_bi] + bigram_smoothing_parameter\\n denominator = hambi_len + bigram_smoothing_parameter*(len(ham_bi))\\n p_hambi[word_bi] = numerator / denominator\\n for word_bi in spam_bi:\\n numerator = spam_bi[word_bi] + bigram_smoothing_parameter\\n denominator = spambi_len + bigram_smoothing_parameter*(len(spam_bi))\\n p_spambi[word_bi] = numerator / denominator\\n \\n numerator = unigram_smoothing_parameter\\n denominator = ham_len + unigram_smoothing_parameter*(len(ham))\\n p_ham_zero = numerator / denominator\\n denominator = spam_len + unigram_smoothing_parameter*(len(spam))\\n p_spam_zero = numerator / denominator\\n\\n numerator = bigram_smoothing_parameter\\n denominator = hambi_len + bigram_smoothing_parameter*(len(ham_bi))\\n p_hambi_zero = numerator / denominator\\n denominator = spambi_len + bigram_smoothing_parameter*(len(spam_bi))\\n p_spambi_zero = numerator / denominator\\n\\n for string in dev_set:\\n p_words_ham = math.log(pos_prior)\\n p_words_spam = math.log(1 - pos_prior)\\n\\n p_words_hambi = math.log(pos_prior)\\n p_words_spambi = math.log(1 - pos_prior)\\n \\n for i in range(len(string)):\\n word = string[i]\\n if word in p_ham:\\n p_words_ham += math.log(p_ham[word])\\n else:\\n p_words_ham += math.log(p_ham_zero)\\n if word in p_spam:\\n p_words_spam += math.log(p_spam[word])\\n else:\\n p_words_spam += math.log(p_spam_zero)\\n\\n if i != len(string)-1:\\n word_bi = string[i] + ' ' + string[i+1]\\n if word_bi in p_hambi:\\n p_words_hambi += math.log(p_hambi[word_bi])\\n else:\\n p_words_hambi += math.log(p_hambi_zero)\\n if word_bi in p_spambi:\\n p_words_spambi += math.log(p_spambi[word_bi])\\n else:\\n p_words_spambi += math.log(p_spambi_zero)\\n\\n p_ham_mix = p_words_ham*(1-bigram_lambda) + p_words_hambi*bigram_lambda\\n p_spam_mix = p_words_spam*(1-bigram_lambda) + p_words_spambi*bigram_lambda\\n\\n dev_labels.append(p_ham_mix >= p_spam_mix)\\n\\n return dev_labels\",\n \"def sentence_logprob(self, sentence):\\n line = get_ngrams(sentence,3)\\n log_por = 0.0\\n for item in line:\\n raw_por = self.smoothed_trigram_probability(item)\\n log_por = log_por+math.log2(raw_por)\\n\\n return float(log_por)\",\n \"def featureLikelihood():\\r\\n\\r\\n\\t# Lists\\r\\n\\twords = []\\r\\n\\tfinalWords = []\\r\\n\\tposWords = []\\r\\n\\tnegWords = []\\r\\n\\tfeatureListPos = []\\r\\n\\tfeatureListNeg = []\\r\\n\\r\\n\\t# Counters\\r\\n\\tposCount = 0.0\\r\\n\\tnegCount = 0.0\\r\\n\\r\\n\\t# Temporary Lists for formating\\r\\n\\tfeatureListPosFormat = []\\r\\n\\tfeatureListNegFormat = []\\r\\n\\r\\n\\t# Strings\\r\\n\\ts = \\\" \\\"\\r\\n\\tposString = \\\"\\\"\\r\\n\\tnegString = \\\"\\\"\\r\\n\\r\\n\\tseen = set()\\r\\n\\r\\n\\t# Add all words to words list and count positive & negative occurences\\r\\n\\tfor item in trainingData:\\r\\n\\t\\tfor word in item[2]:\\r\\n\\t\\t\\twords.append(word)\\r\\n\\t\\tif item[1] == '0':\\r\\n\\t\\t\\tfor word in item[2]:\\r\\n\\t\\t\\t\\tposWords.append(word)\\r\\n\\t\\t\\t\\tposCount += 1\\r\\n\\t\\tif item[1] == '1':\\r\\n\\t\\t\\tfor word in item[2]:\\r\\n\\t\\t\\t\\tnegWords.append(word)\\r\\n\\t\\t\\t\\tnegCount +=1\\r\\n\\r\\n\\t# Adds all values into finalWords, skipping duplicates\\r\\n\\tfor values in words:\\r\\n\\t\\tif values not in seen:\\r\\n\\t\\t\\tfinalWords.append(values)\\r\\n\\t\\t\\tseen.add(values)\\r\\n\\t\\t\\t\\r\\n\\t\\t\\t\\r\\n\\t\\t\\t\\r\\n\\t# Add positive and negative counts to feature list and dictionaries\\r\\n\\tfor word in finalWords:\\r\\n\\t\\ts += '{:12s}'.format(word)\\r\\n\\t\\t\\r\\n\\t\\tpCount = 0\\r\\n\\t\\tnCount = 0\\r\\n\\t\\t\\r\\n\\t\\tfor row in trainingData:\\r\\n\\t\\t\\tif row[1] == '0':\\r\\n\\t\\t\\t\\tif word in row[2]: pCount += 1\\r\\n\\t\\t\\tif row[1] == '1':\\r\\n\\t\\t\\t\\tif word in row[2]: nCount += 1\\r\\n\\t\\t\\t\\t\\r\\n\\t\\tfeatureListPos.append((pCount + 1) / (posCount + 9))\\r\\n\\t\\tclass0Dict[word] = ((pCount + 1) / (posCount + 9))\\r\\n\\t\\t\\r\\n\\t\\tfeatureListNeg.append((nCount + 1) / (negCount + 9))\\r\\n\\t\\tclass1Dict[word] = ((nCount + 1) / (negCount + 9))\\r\\n\\r\\n\\t\\t\\r\\n\\t\\t\\r\\n\\t# Formatting for the positive feature list\\r\\n\\tfor item in featureListPos:\\r\\n\\t\\tfeatureListPosFormat.append('{0:.5f}'.format(item))\\r\\n\\t\\t\\r\\n\\tfor item in featureListPosFormat:\\r\\n\\t\\tposString += '{:12s}'.format(item)\\r\\n\\r\\n\\t# Formatting for the negative feature list\\r\\n\\tfor item in featureListNeg:\\r\\n\\t\\tfeatureListNegFormat.append('{0:.5f}'.format(item))\\r\\n\\t\\t\\r\\n\\tfor item in featureListNegFormat:\\r\\n\\t\\tnegString += '{:12s}'.format(item)\\r\\n\\r\\n\\r\\n\\t\\t\\r\\n\\treturn(s, posString, negString)\",\n \"def log_probability_of_sentence(self, tokens: Sequence[str]):\\n if isinstance(tokens, str):\\n raise ValueError(\\\"Input to log_probability_of_sentence is a sequence of token strings,\\\"\\n \\\" not a single string\\\")\\n # these don't matter when we are running the model in inference mode\\n targets = np.zeros([_BATCH_SIZE, _NUM_TIMESTEPS], np.int32)\\n weights = np.ones([_BATCH_SIZE, _NUM_TIMESTEPS], np.float32)\\n\\n # these contain information about the previous word\\n # we initialize them with the beginning-of-sentence marker\\n inputs = np.zeros([_BATCH_SIZE, _NUM_TIMESTEPS], np.int32)\\n inputs[0, 0] = self._vocab.word_to_id(_START_SENTENCE_SYMBOL)\\n\\n char_ids_inputs = np.zeros(\\n [_BATCH_SIZE, _NUM_TIMESTEPS, self._vocab.max_word_length], np.int32)\\n char_ids_inputs[0, 0, :] = self._vocab.word_to_char_ids(_START_SENTENCE_SYMBOL)\\n\\n # we take the log probability of a token sequence to be the sum of the log-probs\\n # of each of its tokens given the preceding context\\n log_prob_sum = 0.0\\n for token in tokens:\\n with contexttimer.Timer() as token_timer:\\n dist_over_next_words = self._session.run(\\n self._name_to_node['softmax_out'],\\n feed_dict={\\n self._name_to_node['char_inputs_in']: char_ids_inputs,\\n self._name_to_node['inputs_in']: inputs,\\n self._name_to_node['targets_in']: targets,\\n self._name_to_node['target_weights_in']: weights})\\n token_idx = self._vocab.word_to_id(token)\\n log_prob_sum += math.log(dist_over_next_words[0][token_idx])\\n\\n # prepare this word to be the context for the next word\\n inputs[0, 0] = token_idx\\n char_ids_inputs[0, 0, :] = self._vocab.word_to_char_ids(token)\\n\\n # restore original state so that future calls to log_probability_of_sentence\\n # are not affected by past calls\\n self._reset_state()\\n\\n return log_prob_sum\",\n \"def loglike(self, params):\\n\\n if type(params) is not MixedLMParams:\\n params = MixedLMParams.from_packed(params, self.k_fe,\\n self.use_sqrt)\\n\\n fe_params = params.get_fe_params()\\n cov_re = params.get_cov_re()\\n try:\\n cov_re_inv = np.linalg.inv(cov_re)\\n except np.linalg.LinAlgError:\\n cov_re_inv = None\\n _, cov_re_logdet = np.linalg.slogdet(cov_re)\\n\\n # The residuals\\n expval = np.dot(self.exog, fe_params)\\n resid_all = self.endog - expval\\n\\n likeval = 0.\\n\\n # Handle the covariance penalty\\n if self.cov_pen is not None:\\n likeval -= self.cov_pen.func(cov_re, cov_re_inv)\\n\\n # Handle the fixed effects penalty\\n if self.fe_pen is not None:\\n likeval -= self.fe_pen.func(fe_params)\\n\\n xvx, qf = 0., 0.\\n for k, lab in enumerate(self.group_labels):\\n\\n exog = self.exog_li[k]\\n ex_r = self.exog_re_li[k]\\n ex2_r = self.exog_re2_li[k]\\n resid = resid_all[self.row_indices[lab]]\\n\\n # Part 1 of the log likelihood (for both ML and REML)\\n ld = _smw_logdet(1., ex_r, ex2_r, cov_re, cov_re_inv,\\n cov_re_logdet)\\n likeval -= ld / 2.\\n\\n # Part 2 of the log likelihood (for both ML and REML)\\n u = _smw_solve(1., ex_r, ex2_r, cov_re, cov_re_inv, resid)\\n qf += np.dot(resid, u)\\n\\n # Adjustment for REML\\n if self.reml:\\n mat = _smw_solve(1., ex_r, ex2_r, cov_re, cov_re_inv,\\n exog)\\n xvx += np.dot(exog.T, mat)\\n\\n if self.reml:\\n likeval -= (self.n_totobs - self.k_fe) * np.log(qf) / 2.\\n _,ld = np.linalg.slogdet(xvx)\\n likeval -= ld / 2.\\n likeval -= (self.n_totobs - self.k_fe) * np.log(2 * np.pi) / 2.\\n likeval += ((self.n_totobs - self.k_fe) *\\n np.log(self.n_totobs - self.k_fe) / 2.)\\n likeval -= (self.n_totobs - self.k_fe) / 2.\\n else:\\n likeval -= self.n_totobs * np.log(qf) / 2.\\n likeval -= self.n_totobs * np.log(2 * np.pi) / 2.\\n likeval += self.n_totobs * np.log(self.n_totobs) / 2.\\n likeval -= self.n_totobs / 2.\\n\\n return likeval\",\n \"def log_prob(self, scores : torch.Tensor, permutations):\\n s = torch.log(select_indices(scores, permutations))\\n n = len(scores)\\n p = self.upto if self.upto is not None else n - 1\\n return -sum(\\n torch.log(torch.exp((s[k:] - s[k]) * self.shape).sum(dim=0))\\n for k in range(p))\",\n \"def test_LM(self):\\n\\t\\t\\n\\t\\tprecision = 10**-8\\n\\t\\t\\t\\t \\n\\t\\tif self.n == 1:\\n\\t\\t\\t\\t \\n\\t\\t\\tP_sum = sum(self.estimate_prob('', w) for w in self.vocab)\\n\\t\\t\\t\\n\\t\\t\\tassert abs(1.0 - P_sum) < precision, 'Probability mass does not sum up to one.'\\n\\t\\t\\t\\t \\n\\t\\telif self.n == 2:\\n\\t\\t\\thistories = ['the', 'in', 'at', 'blue', 'white']\\n\\t\\t\\t\\t \\n\\t\\t\\tfor h in histories:\\n\\t\\t\\t\\t \\n\\t\\t\\t\\tP_sum = sum(self.estimate_prob(h, w) for w in self.vocab)\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tassert abs(1.0 - P_sum) < precision, 'Probability mass does not sum up to one for history' + h\\n\\t\\t\\t\\t\\t \\n\\t\\tprint('TEST SUCCESSFUL!')\",\n \"def log_weights(self):\\n m = self.kernel.feature_log_prob_[self._match_class_pos()]\\n u = self.kernel.feature_log_prob_[self._nonmatch_class_pos()]\\n\\n return self._prob_inverse_transform(m - u)\",\n \"def logistic_pen(weights, data, targets, hyperparameters):\\n\\n wr = hyperparameters['weight_regularization']\\n \\n t = np.transpose(np.repeat(np.reshape(weights[:-1], (len(weights)-1, 1)), len(data), axis = 1))\\n f_e = data * t\\n z_sums = np.sum(f_e, axis=1)\\n y = sigmoid(z_sums +weights[-1])\\n f = np.sum(np.log(1 + np.exp(-z_sums - weights[-1])) + (1 - np.transpose(targets)) * (z_sums + weights[-1]))\\n df = np.sum(data * np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0)\\n df = np.append(df, np.sum(np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0))\\n\\n f += np.dot(weights[:-1].transpose()[0], weights[:-1].transpose()[0]) * wr / 2\\n df = np.reshape(df, ((len(df), 1)))\\n df += np.reshape(np.append(weights[:-1] * wr, 0), (len(weights), 1))\\n\\n f += (weights[-1, 0] ** 2) * wr / 2\\n df[-1] += weights[-1,0] * wr \\n\\n return f, df, np.reshape(y, (len(y), 1))\",\n \"def M(f):\\n return 1127 * numpy.log(1 + f/700.0)\",\n \"def loss(labels,q,M,a,b):\\n x=-(labels*np.log(s.expit(z(q,M,a,b)))+(1-labels)*np.log(1-s.expit(z(q,M,a,b))))\\n return np.sum(x)+l/2*(np.sum(M**2)+b**2)\",\n \"def maas(n_terms, n_words):\\n # We cap this score at 0.2\\n if n_words <= 1:\\n return 0.2\\n score = (math.log(n_words) - math.log(n_terms)) / \\\\\\n (math.log(n_words) ** 2)\\n return min(score, 0.2)\",\n \"def log_u_probs(self):\\n u = self.kernel.feature_log_prob_[self._nonmatch_class_pos()]\\n return self._prob_inverse_transform(u)\",\n \"def forward(self, motif_size, motif_log_embeddings):\\n\\n # D = 1 - exp(-sum_j(prod_i(d_ij)))\\n # log(1-D) = -sum_j(exp(sum_i(log(d_ij))))\\n x = lbann.MatMul(\\n lbann.Constant(value=1, num_neurons=str_list([1, motif_size])),\\n motif_log_embeddings,\\n )\\n x = lbann.Exp(x)\\n x = lbann.Reduction(x, mode='sum')\\n x = lbann.Negative(x)\\n log_not_prob = x\\n\\n # Convert log-probability to linear space\\n # Note: D=-expm1(x) is accurate when D~0. When D~1, prefer\\n # 1-D=exp(x).\\n prob = lbann.Negative(lbann.Expm1(log_not_prob))\\n\\n return prob, log_not_prob\",\n \"def gmmloglik(log_emlik, weights):\",\n \"def gmmloglik(log_emlik, weights):\",\n \"def get_marginals(word, model):\\n # forward and backward message at once\\n char_count, _ = word.shape\\n alpha = np.zeros((char_count, model.dimY)) # alphas\\n lbeta = np.zeros((char_count, model.dimY)) # log version of betas\\n\\n first_term = np.dot(word, model.getW(model.labels))\\n second_term_a = model._T\\n second_term_b = model._T.T\\n for i in range(1, char_count):\\n sum_term_a = (first_term[i-1] + alpha[i-1]) + second_term_a\\n sum_term_b = (first_term[char_count-i] +lbeta[char_count-i]) + second_term_b\\n alpha[i] = np.apply_along_axis(logsumexp_trick, 1, sum_term_a) \\n lbeta[char_count-i-1] = np.apply_along_axis(logsumexp_trick, 1, sum_term_b)\\n\\n marginal_Y = np.zeros((char_count, model.dimY))\\n marginal_Y_Y1 = np.zeros((char_count-1, model.dimY, model.dimY)) \\n \\n for i in range(char_count):\\n sum_term = first_term[i] + alpha[i] + lbeta[i]\\n log_marginal_y = sum_term - logsumexp_trick(sum_term)\\n marginal_Y[i] = np.exp(log_marginal_y)\\n # calculate other marginal dist as well\\n if i < char_count-1:\\n transition = model._T.transpose() # T_{yi, yi+1}\\n outer_sum_w = np.add.outer(first_term[i], first_term[i+1]).reshape(model.dimY,model.dimY)\\n outer_sum_m = np.add.outer(alpha[i], lbeta[i+1])\\n sum_term_all = outer_sum_w + transition + outer_sum_m\\n log_marginal_y_y1 = sum_term_all - logsumexp_trick(sum_term_all)\\n marginal_Y_Y1[i] = np.exp(log_marginal_y_y1)\\n # Got Denominator same as Zx , which is correct\\n return marginal_Y, marginal_Y_Y1\",\n \"def Ls(GTn:torch.tensor, Mn:torch.tensor) -> torch.tensor:\\n return (-(GTn * torch.log(Mn+1e-15) + (1- GTn) * torch.log((1- Mn)+1e-15))).sum()\",\n \"def step(self, x, y, learning_rate=1e-3):\\n \\n # Input transformation\\n \\\"\\\"\\\"\\n Input is represented with M-dimensional vectors\\n We convert them to (N, M) matrices such that columns are one-hot \\n representations of the input\\n \\\"\\\"\\\"\\n x = self.one_hot(x, self.N)\\n y = self.one_hot(y, self.N)\\n\\n \\n # Forward propagation\\n \\\"\\\"\\\"\\n Returns\\n -------\\n embedding: array\\n (D, M) matrix where columns are word embedding from U matrix\\n logits: array\\n (N, M) matrix where columns are output logits\\n prob: array\\n (N, M) matrix where columns are output probabilities\\n \\\"\\\"\\\"\\n \\n ### YOUR CODE HERE ###\\n #Omran:\\n #U and V of dimension (D, N) and (N, D) respectively\\n\\n embedding = np.dot(self.U, x)\\n logits = np.dot(self.V, embedding)\\n prob = self.softmax(logits,0)# take care of the axis, I am not quite sure how you will implement it\\n \\n assert embedding.shape == (self.D, x.shape[1])\\n assert logits.shape == (self.N, x.shape[1])\\n assert prob.shape == (self.N, x.shape[1])\\n \\n \\n # Loss calculation\\n \\\"\\\"\\\"\\n Returns\\n -------\\n loss: int\\n Cross-entropy loss using true values and probabilities\\n \\\"\\\"\\\"\\n \\n ### YOUR CODE HERE ###\\n loss = self.loss(y, prob)\\n \\n # Backward propagation\\n \\\"\\\"\\\"\\n Returns\\n -------\\n d_U: array\\n (N, D) matrix of partial derivatives of loss w.r.t. U\\n d_V: array\\n (D, N) matrix of partial derivatives of loss w.r.t. V\\n \\\"\\\"\\\"\\n \\n ### YOUR CODE HERE ###\\n #I am not quite sure of this!!\\n \\n# difference = np.sum(np.subtract(prob, y), axis=1)\\n difference = prob - y\\n d_V = difference @ embedding.T\\n# print(self.N, self.D)\\n# print(difference.shape)\\n# print(d_V.shape)\\n d_U = (self.V.T @ difference) @ x.T\\n# d_U = self.V.T @ np.outer(difference, x)\\n \\n assert d_V.shape == (self.N, self.D)\\n assert d_U.shape == (self.D, self.N)\\n \\n \\n # Update the parameters\\n \\\"\\\"\\\"\\n Updates the weights with gradient descent such that W_new = W - alpha * dL/dW, \\n where alpha is the learning rate and dL/dW is the partial derivative of loss w.r.t. \\n the weights W\\n \\\"\\\"\\\"\\n \\n ### YOUR CODE HERE ###\\n self.V = self.V - learning_rate * d_V\\n self.U = self.U - learning_rate * d_U\\n\\n return loss, d_U, d_V\",\n \"def score(self, sentence):\\n # TODO your code here\\n\\n # initialize count with trained data\\n unigram_count = self.count.copy()\\n N = self.total\\n\\n # make a new key for UNK, add-one later\\n for token in sentence:\\n if token not in unigram_count:\\n unigram_count[token] = 0\\n\\n # calcutate lopP(<s>) + logP(w1) + logP(w2) + ...\\n score = 0.0 # P(<s>) = 1\\n V = len(unigram_count) # the number of vocab including UNK\\n for word in sentence:\\n prob = float((unigram_count[word] + 1) / (N + V)) # c(w) + 1 / N + V\\n score += math.log(prob)\\n\\n return score\",\n \"def calculate_perplexity_new(self, sentence_probability, input_y, words_to_idx):\\n \\n batch_size = sentence_probability.shape[0]\\n sentence_length = sentence_probability.shape[1]\\n perplexity = np.zeros(batch_size)\\n pad_index = words_to_idx['<pad>'] # index of pad\\n \\n for sentence_i in range(batch_size):\\n word_index = 1 # start at 1 to discard bos\\n log_sum = 0\\n while ((word_index < sentence_length) and (input_y[sentence_i][word_index] != pad_index)): # stop when the first pad token is reached\\n \\n log_sum += np.log2(sentence_probability[sentence_i, word_index, \\n input_y[sentence_i][word_index]])\\n word_index += 1 \\n word_index -= 1 # remove one count because of discarded bos\\n try:\\n # catch sentence with all pad's\\n perplexity[sentence_i] = np.power(2, -(log_sum/word_index))\\n except:\\n print(input_y[sentence_i])\\n print('sencentece with just pads')\\n perplexity[sentence_i] = np.nan \\n \\n return perplexity\",\n \"def m_probs(self):\\n log_m = self.kernel.feature_log_prob_[self._match_class_pos()]\\n\\n return self._prob_inverse_transform(numpy.exp(log_m))\",\n \"def entropy(self, text_ngrams):\\n return -1 * _mean(\\n [self.logscore(ngram[-1], ngram[:-1]) for ngram in text_ngrams]\\n )\",\n \"def predict(self, X):\\n words = X.split()\\n chance = []\\n for cur_label in self.model[\\\"labels\\\"]:\\n probability = self.model[\\\"labels\\\"][cur_label][\\\"probability\\\"]\\n total_grade = math.log(probability, math.e)\\n for word in words:\\n word_dict = self.model[\\\"words\\\"].get(word, None)\\n if word_dict:\\n total_grade += math.log(word_dict[cur_label], math.e)\\n chance.append((total_grade, cur_label))\\n _, prediction = max(chance)\\n return prediction\",\n \"def logprob(predictions, labels):\\n # prevent negative probability\\n predictions[predictions < 1e-10] = 1e-10\\n return np.sum(np.multiply(labels, -np.log(predictions))) / labels.shape[0]\",\n \"def information_gain(features, attribute_index, targets):\\r\\n\\r\\n possible_feature_values = [0,1]\\r\\n \\r\\n possible_classifications = [0,1]\\r\\n \\r\\n feature = features[:,attribute_index]\\r\\n \\r\\n \\r\\n number_of_samples = len(feature)\\r\\n \\r\\n import math\\r\\n \\r\\n \\r\\n #current_entropy = np.sum([-(len(targets[targets==possible_classification])/number_of_samples)*math.log(len(targets[targets==possible_classification])/number_of_samples, 2) for possible_classification in possible_classifications])\\r\\n \\r\\n terms_to_be_summed_for_current_entropy = []\\r\\n \\r\\n for classification in possible_classifications:\\r\\n \\r\\n number_of_elements_with_this_classification = len(targets[targets==classification])\\r\\n \\r\\n p_for_this_classification = number_of_elements_with_this_classification/len(targets)\\r\\n \\r\\n if p_for_this_classification != 0:\\r\\n terms_to_be_summed_for_current_entropy.append(-p_for_this_classification*math.log(p_for_this_classification,2))\\r\\n else:\\r\\n terms_to_be_summed_for_current_entropy.append(0)\\r\\n \\r\\n current_entropy = np.sum(terms_to_be_summed_for_current_entropy)\\r\\n \\r\\n \\r\\n \\r\\n terms_to_be_summed_for_weighted_entropy = []\\r\\n \\r\\n for possible_value in possible_feature_values:\\r\\n \\r\\n targets_split_by_feature_value = targets[feature.flatten() == possible_value]\\r\\n \\r\\n if len(targets_split_by_feature_value) != 0:\\r\\n \\r\\n \\r\\n weight_of_feature_value = len(targets_split_by_feature_value)/len(targets)\\r\\n \\r\\n terms_for_entropy_within_subset = []\\r\\n \\r\\n for classification in possible_classifications:\\r\\n \\r\\n number_of_subset_elements_with_this_classification = len(targets_split_by_feature_value[targets_split_by_feature_value==classification])\\r\\n \\r\\n p_in_subset_for_this_classification = number_of_subset_elements_with_this_classification/len(targets_split_by_feature_value)\\r\\n \\r\\n if p_in_subset_for_this_classification != 0:\\r\\n terms_for_entropy_within_subset.append(-p_in_subset_for_this_classification*math.log(p_in_subset_for_this_classification,2))\\r\\n else:\\r\\n terms_for_entropy_within_subset.append(0)\\r\\n \\r\\n entropy_within_subset = np.sum(terms_for_entropy_within_subset)\\r\\n \\r\\n terms_to_be_summed_for_weighted_entropy.append(weight_of_feature_value*entropy_within_subset)\\r\\n \\r\\n weighted_entropy = np.sum(terms_to_be_summed_for_weighted_entropy)\\r\\n \\r\\n \\r\\n #current_entropy = np.sum(terms_to_be_summed_for_current_entropy)\\r\\n \\r\\n #weighted_entropy = np.sum([(len(feature[feature==possible_value])/number_of_samples)*(len(targets[feature==possible_value][targets[feature==possible_value]==possible_classification])/len(targets[feature==possible_value]))*math.log((len(targets[feature==possible_value][targets[feature==possible_value]==possible_classification])/len(targets[feature==possible_value])), 2) for possible_classification in possible_classifications for possible_value in possible_feature_values])\\r\\n\\r\\n information_gain = current_entropy - weighted_entropy \\r\\n \\r\\n return information_gain\",\n \"def _LL(state, effects, observed_frequencies) -> float:\\n observed_frequencies = np.array(observed_frequencies)\\n predicted_probs = np.array([np.real(np.trace(state.dot(effect))) for effect in effects])\\n return sum(np.log10(predicted_probs) * observed_frequencies)\",\n \"def logloss(self,tple):\\n feats = self.dataset.input_features\\n res = 0\\n cc = self.class_counts\\n fc = self.feature_counts\\n for c in range(self.num_classes):\\n res += prod(fc[i][feat(tple)][c]\\n for (i,feat) in enumerate(feats))/(cc[c]**(len(feats)-1))\\n if res>0:\\n return -math.log2(res/len(self.dataset.train))\\n else:\\n return float(\\\"inf\\\") #infinity\",\n \"def _loglike(self, y, f):\\n bincoef = tf.lgamma(self.n + 1) - tf.lgamma(y + 1) \\\\\\n - tf.lgamma(self.n - y + 1)\\n ll = bincoef + y * tf.log(pos(f)) + (self.n - y) * tf.log(pos(1 - f))\\n return ll\",\n \"def perplexity(self, corpus):\\n sum_pro = 0.0\\n total_words = 0\\n for sentence in corpus:\\n sen_pro = self.sentence_logprob(sentence)\\n sum_pro += sen_pro\\n total_words += len(sentence)\\n\\n \\n\\n l = sum_pro/total_words\\n w = 0.0\\n w = 2**(-l)\\n\\n return w\",\n \"def compute_log_prob(self,params: ndarray) -> float:\\n return self.compute_log_prior(params) + self.compute_log_likelihood(params)\",\n \"def train_model(self, d=0.7):\\n #eg: model = spammy.train_model()\\n count_dict = self.freq_count()\\n N = sum(count_dict.values())\\n n_plus = len(count_dict)\\n alpha = (d * n_plus) / N\\n normalizer = alpha * (1/len(self._vocab_set))\\n model = defaultdict(lambda:normalizer)\\n \\n for word in set(self._vocab_set):\\n prob = normalizer\\n if word in count_dict:\\n prob += (count_dict[word] - d) / N\\n prob = math.log(prob)\\n model[word] = prob\\n return model\",\n \"def test_smoohted_LM(self):\\n\\t\\tprecision = 10**-8\\n\\t\\t\\t\\t \\n\\t\\tif self.n == 1:\\n\\t\\t\\t\\t \\n\\t\\t\\tP_sum = sum(self.estimate_smoothed_prob('', w) for w in self.vocab)\\n\\t\\t\\t\\n\\t\\t\\tassert abs(1.0 - P_sum) < precision, 'Probability mass does not sum up to one.'\\n\\t\\t\\t\\t \\n\\t\\telif self.n == 2:\\n\\t\\t\\thistories = ['the', 'in', 'at', 'blue', 'white']\\n\\t\\t\\t\\t \\n\\t\\t\\tfor h in histories:\\n\\t\\t\\t\\t \\n\\t\\t\\t\\tP_sum = sum(self.estimate_smoothed_prob(h, w) for w in self.vocab)\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tassert abs(1.0 - P_sum) < precision, 'Probability mass does not sum up to one for history' + h\\n\\t\\t\\t\\t\\t \\n\\t\\tprint('TEST SUCCESSFUL!')\\n\\t\\t# YOUR CODE HERE\",\n \"def entropy(self, text):\\n\\n# text = self.myReplacer.replace(text)\\n# text = self.tokenizer.tokenize(text)\\n new_text = []\\n for word in text:\\n if word.count('\\\\'') > 0:\\n words = word.split('\\\\'')\\n for w in words:\\n new_text.append(w)\\n else:\\n new_text.append(word)\\n text = new_text\\n \\n e = 0.0\\n lenth = len(text)\\n if lenth == 0:\\n return 0\\n elif lenth < self._n:\\n current_n = lenth\\n else:\\n current_n = self._n\\n \\n for i in range(current_n - 1, len(text)):\\n context = tuple(text[(i - current_n + 1) : i])\\n token = text[i]\\n e += self.logprob(token, context)\\n return e\",\n \"def entropy(self, f):\\n f_log = -torch.log(self.einsum(\\\"q,q->q\\\", [f, 1 / self.w]))\\n return self.einsum(\\\"q,q->\\\", [f, f_log])\",\n \"def print_translations(sentences: List[Tuple[List[int], List[int]]], model: Seq2SeqAttentionModel,\\n source_vocab: Dict[int, str], target_vocab: Dict[int, str], beam_width):\\n total_log_lhood = 0\\n for (source_sentence, target_sentence) in sentences:\\n if beam_width > 0:\\n translation, log_lhood = translate_beam_search(source_sentence, model, beam_width)\\n total_log_lhood += log_lhood\\n else:\\n translation, _ = translate_greedy_search(source_sentence, model)\\n\\n print(\\\"source sentence:\\\" + \\\" \\\".join([source_vocab[word] for word in source_sentence]))\\n print(\\\"target sentence:\\\" + \\\" \\\".join([target_vocab[word] for word in target_sentence]))\\n print(\\\"translation:\\\\t\\\" + \\\" \\\".join([target_vocab[word] for word in translation]))\\n print(\\\"\\\")\\n print(\\\"Avg log Likelihood = \\\", total_log_lhood/len(sentences))\",\n \"def log_marginal_likelihood(X_train,y_train,phi,tau=1.,Ve=1.e-10):\",\n \"def joint_logpdf(self, x1, x2 = None):\\n dists = self.conditionalMVNs\\n joint_pdfs = np.array([d.joint_pdf(x1, x2) for d in dists])\\n return np.log(np.sum(self.weights * joint_pdfs))\",\n \"def word_to_perplexity(model, timeseries, indices, words, args):\\n accum = 0\\n words_len = len(words)-args.window_size\\n batches = math.floor(words_len / args.batch_size)\\n print(batches)\\n for start in range(0, batches):\\n idx = start*args.batch_size\\n inp = np.array([timeseries[i:i+args.window_size] for i in range(idx, idx+args.batch_size)])\\n label = np.asarray([indices[x] for x in words[idx+args.window_size:idx+args.window_size+args.batch_size]]) \\n \\n pred = model.predict(inp, batch_size=128)\\n lp = np.log(pred)\\n for i, ent in enumerate(lp):\\n accum += ent[label[i]]\\n if start % 5 == 0:\\n print(\\\"{} / {}. Perplexity so far: {}\\\".format(start, batches, np.exp(-accum / (start*args.batch_size+1))))\\n accum = -accum\\n print(accum)\\n avg = accum / words_len \\n print(avg)\\n perplex = np.power(avg, 2)\\n print(perplex)\",\n \"def _perplexity(self, X, log_w):\\n return np.exp(-log_w/X.sum())\",\n \"def my_loglike(theta, x, data, sigma):\\n\\n model = my_model(theta, x)\\n\\n return -0.5*len(x)*np.log(2*math.pi*sigma**2) - (0.5/sigma**2) * np.sum((data-model)**2)\",\n \"def compute_loglike(self, tools: ModelingTools) -> float:\\n return -1.5\",\n \"def define_model_log_prob(model, model_loss, x, y, params_flattened_list, params_shape_list, tau_list, tau_out, normalizing_const=1., predict=False, prior_scale = 1.0, device = 'cpu'):\\n\\n fmodel = util.make_functional(model)\\n dist_list = []\\n for tau in tau_list:\\n dist_list.append(torch.distributions.Normal(torch.zeros_like(tau), tau**-0.5))\\n\\n def log_prob_func(params):\\n # model.zero_grad()\\n # params is flat\\n # Below we update the network weights to be params\\n params_unflattened = util.unflatten(model, params)\\n\\n i_prev = 0\\n l_prior = torch.zeros_like( params[0], requires_grad=True) # Set l2_reg to be on the same device as params\\n for weights, index, shape, dist in zip(model.parameters(), params_flattened_list, params_shape_list, dist_list):\\n # weights.data = params[i_prev:index+i_prev].reshape(shape)\\n w = params[i_prev:index+i_prev]\\n l_prior = dist.log_prob(w).sum() + l_prior\\n i_prev += index\\n\\n # Sample prior if no data\\n if x is None:\\n # print('hi')\\n return l_prior/prior_scale\\n\\n x_device = x.to(device)\\n y_device = y.to(device)\\n\\n\\n output = fmodel(x_device, params=params_unflattened)\\n\\n if model_loss == 'binary_class_linear_output':\\n crit = nn.BCEWithLogitsLoss(reduction='sum')\\n ll = - tau_out *(crit(output, y_device))\\n elif model_loss == 'multi_class_linear_output':\\n # crit = nn.MSELoss(reduction='mean')\\n crit = nn.CrossEntropyLoss(reduction='sum')\\n # crit = nn.BCEWithLogitsLoss(reduction='sum')\\n ll = - tau_out *(crit(output, y_device.long().view(-1)))\\n # ll = - tau_out *(torch.nn.functional.nll_loss(output, y.long().view(-1)))\\n elif model_loss == 'multi_class_log_softmax_output':\\n ll = - tau_out *(torch.nn.functional.nll_loss(output, y_device.long().view(-1)))\\n\\n elif model_loss == 'regression':\\n # crit = nn.MSELoss(reduction='sum')\\n ll = - 0.5 * tau_out * ((output - y_device) ** 2).sum(0)#sum(0)\\n\\n elif callable(model_loss):\\n # Assume defined custom log-likelihood.\\n ll = - model_loss(output, y_device).sum(0)\\n else:\\n raise NotImplementedError()\\n\\n if torch.cuda.is_available():\\n del x_device, y_device\\n torch.cuda.empty_cache()\\n\\n if predict:\\n return (ll + l_prior/prior_scale), output\\n else:\\n return (ll + l_prior/prior_scale)\\n\\n return log_prob_func\",\n \"def score(self, word):\\n assert self.words is not None, \\\"You need to train first.\\\"\\n if word in self.words:\\n return np.log(1 - self.a) + np.log(self.words[word] / self.nwords)\\n else:\\n logprob = 0\\n for l in word:\\n # this calculates add+1-smoothed probabilities to make\\n # sure that unknown letters are treated correctly.\\n # not required, using simply the relative\\n # frequency is sufficient.\\n logprob += np.log(self.letters.get(l, 1) /\\n (self.nletters + len(self.letters)))\\n return np.log(self.a) + logprob\",\n \"def sentence_logprob(self, sentence):\\n grams = get_ngrams(sentence, 3)\\n p = 1\\n\\n for gram in grams:\\n p *= np.longfloat(self.smoothed_trigram_probability(gram))\\n\\n return np.log2(p)\",\n \"def log_probability(self, tokens):\\n\\n log_sum = 0\\n for leader, token in generate_ngrams(tokens, self.size, include_terminator = self.include_terminator):\\n if not leader in self.frequencies:\\n return float(\\\"-inf\\\")\\n\\n word_frequency = self.frequencies[leader][token]\\n leader_frequency = self.frequencies[leader].total\\n\\n probability = (word_frequency + self.smoothing) / (leader_frequency + len(self.vocab) * self.smoothing)\\n\\n if probability == 0:\\n return float(\\\"-inf\\\")\\n\\n log_sum += math.log2(probability)\\n \\n return log_sum\",\n \"def log_marg_like(self, gamma, gamma0, lamb, nu):\\n return self.ppi_distribution(gamma, gamma0, lamb).logpdf(self.Y, precision_multiplier=nu)\",\n \"def _predict_doc(self, x, flag):\\n\\n if flag == 1:\\n denom = self.X.num_positive()\\n else:\\n denom = self.X.num_negative()\\n denom += self.X.vocab_size()\\n\\n # multiply word probabilities for all words in x\\n words = tokenize(x)\\n # prob = 1.0\\n # for word in words:\\n # wi = self._doc_count_for_word(word, flag=flag)\\n # # utilize the Laplace Smooth\\n # prob *= ((float(wi)+1.0) / (float(denom)+2.0))\\n\\n prob = math.log(self.X.priors[str(flag)])\\n for word in words:\\n wi = self._doc_count_for_word(word, flag=flag)\\n # utilize the Laplace Smooth\\n prob += math.log((float(wi)+1.0) / (float(denom)+2.0))\\n\\n # prob *= math.log(self.X.priors[str(flag)])\\n\\n return prob\",\n \"def log_prob_of_file(filepath, model):\\n vocab = set(counts_un.keys())\\n tot = 0\\n count = 0\\n prev_prev = \\\"<s>\\\\n\\\"\\n prev = \\\"<s>\\\\n\\\"\\n with open(filepath) as f:\\n for line in f:\\n count += 2\\n line = line.strip()+\\\"\\\\n\\\"\\n tri_prob = model.get_trigram_prob(prev_prev, prev, line)\\n tot += math.log(tri_prob)\\n prev_prev = prev\\n prev = line \\n for line in [\\\"</s>\\\\n\\\", \\\"</s>\\\\n\\\"]:\\n tri_prob = model.get_trigram_prob(prev_prev, prev, line)\\n tot += math.log(tri_prob)\\n prev_prev = prev\\n prev = line \\n return tot, count\",\n \"def probability(self, words):\\n if len(words) == 0:\\n return 0\\n \\n prob = 1\\n model = self.mdl\\n \\n words_ngram = NGramLM(self.N, []).create_ngrams(words) # Create NGram model for words\\n for ngram in words_ngram:\\n # Never seen before ngram or n-1gram\\n if (ngram not in list(model['ngram'])) or (ngram[:-1] not in list(model['n1gram'])):\\n return 0\\n if isinstance(self, NGramLM):\\n prob *= model[model['ngram'] == ngram]['prob'].values[0]\\n \\n def recur_prob(model, w):\\n prob = 1\\n prev_mod = model.prev_mdl\\n if isinstance(prev_mod, UnigramLM): # Unigram base case\\n prob *= prev_mod.mdl[w[0]]\\n else:\\n words_n1gram = NGramLM(prev_mod.N, []).create_ngrams(w) # Create NGram model for words\\n prob *= prev_mod.mdl[prev_mod.mdl['ngram'] == words_n1gram[0]]['prob'].values[0]\\n prob *= recur_prob(prev_mod, words_n1gram[0]) # Recursive call\\n return prob\\n\\n prob *= recur_prob(self, words_ngram[0])\\n \\n return prob\",\n \"def log_marg_likelihood(self):\\n self.A = np.linalg.inv(self.Sn)\\n term1 = self.t - self.design_matrix@self.mn\\n self.Evidence_mN = (self.beta/2)*np.linalg.norm(term1)+ (self.alpha/2)*self.mn.T@self.mn\\n A_abs = np.linalg.eigvals(self.A)\\n A_abs = np.prod(A_abs)\\n\\n self.marg_lik = ((self.p)/2)*np.log(self.alpha) + (self.n/2)*np.log(self.beta) - self.Evidence_mN - (1/2)*np.log(A_abs) - (self.n/2)*np.log(2*np.pi)\\n\\n return self.marg_lik\",\n \"def n_gram_MLE(self, given_words, predicted_words, gram_type=1):\\n try:\\n if gram_type == 1:\\n return math.log((self.unigram[given_words] + 1) / (len(self.word_list) + len(self.unigram)))\\n elif gram_type == 2:\\n return math.log((self.bigram[predicted_words] + 1) / (self.unigram[given_words] + len(self.unigram)))\\n elif gram_type == 3:\\n return math.log(self.trigram[predicted_words] + 1) / (self.bigram[given_words] + len(self.unigram))\\n elif gram_type == 4:\\n return math.log(self.four_gram[predicted_words] + 1) / (self.trigram[given_words] + len(self.unigram))\\n elif gram_type == 5:\\n return math.log(self.five_gram[predicted_words] + 1) / (self.four_gram[given_words] + len(self.unigram))\\n except ZeroDivisionError:\\n return 0\\n except KeyError:\\n return 0\",\n \"def maximization_step(self, number_of_topics, verbose):\\n if verbose:\\n print(\\\"M step:\\\")\\n\\n self.topic_word_prob = np.zeros((number_of_topics, len(self.vocabulary)))\\n self.topic_word_prob_collection_specific = []\\n\\n for k in range(self.number_of_collections):\\n topic_word_prob_collection_specific = np.zeros((number_of_topics, len(self.vocabulary)))\\n for i in range(self.number_of_documents):\\n # update P(w | z)\\n\\n # ############################\\n\\n self.topic_word_prob = np.add(self.topic_word_prob,\\n np.transpose(np.multiply(np.multiply(np.multiply(self.term_doc_matrix[k][i], 1 - self.topic_prob_B[k][i]), self.topic_prob_j[k][i]), self.topic_prob_C[k][i])))\\n\\n topic_word_prob_collection_specific = np.add(self.topic_word_prob,\\n np.transpose(np.multiply(np.multiply(np.multiply(self.term_doc_matrix[k][i], 1 - self.topic_prob_B[k][i]), self.topic_prob_j[k][i]), 1 - self.topic_prob_C[k][i])))\\n\\n # update P(z | d)\\n\\n # ############################\\n\\n matrix = np.dot(np.transpose(self.term_doc_matrix[k][i]), self.topic_prob_j[k][i])\\n self.document_topic_prob[k][i] = normalize_row(matrix)\\n topic_word_prob_collection_specific = normalize_row(topic_word_prob_collection_specific)\\n self.topic_word_prob_collection_specific.append(topic_word_prob_collection_specific)\\n\\n self.topic_word_prob = normalize_row(self.topic_word_prob)\\n\\n #print(\\\"pi:\\\")\\n #print(self.document_topic_prob)\\n #print(\\\"p(w|theta):\\\")\\n #print(self.topic_word_prob)\",\n \"def calculate_log_p_multinomial(self, n_counts, nbins, batch_size):\\n\\n n_counts = tf.cast(n_counts, tf.float32)\\n nbins = tf.cast(nbins, tf.float32)\\n batch_size = tf.cast(batch_size, tf.float32)\\n\\n term_a = tf.lgamma(batch_size + 1)\\n term_b = tf.reduce_sum(tf.lgamma(n_counts + 1))\\n term_c = batch_size * tf.log(nbins)\\n\\n return term_a - term_b - term_c\",\n \"def em_step(t, eng, fre):\\n # TODO\\n # Lecture Steps:\\n # 1. Make a table of P(f|e) for all possible pairs of f and e, prob_tab\\n # 2. Make a grid where each sentence pair is a row and each possible\\n # alignment is a column\\n # 3. For each sentence pair and alignment compute P(F|a,E)\\n # Given aligned words f1,f2,...,fn and e1,e2,...,en in the pair:\\n # P(F|a,E) = prob_tab[f1][e1] * ... * prob_tab[fn][en]\\n # 4. For each sentence pair and alignment\\n # divide P(F|a,E) by the sum of the P(F|a,E)'s in the row\\n # this is P(a|E,F)\\n # 5. For each possible word pair e and f, sum P(a|E,F) across all\\n # alignments and sentence pairs for each instance that e is aligned\\n # with f, this gets out a TCount table\\n # 6. Sum over the rows of TCount to get the total estimates for each\\n # english word e.\\n # 7. Compute P(f|e) = TCount[f][e] / Total[e]\\n # This is the model after 1 iteration.\\n\\n '''\\n Tutorial Steps:\\n initialize P(f|e)\\n for a number of iterations:\\n set tcount(f, e) to 0 for all f, e\\n set total(e) to 0 for all e\\n for each sentence pair (F, E) in training corpus:\\n for each unique word f in F:\\n denom_c = 0\\n for each unique word e in E:\\n denom_c += P(f|e) * F.count(f)\\n for each unique word e in E:\\n tcount(f, e) += P(f|e) * F.count(f) * E.count(e) / denom_c\\n total(e) += P(f|e) * F.count(f) * E.count(e) / denom_c\\n for each e in domain(total(:)):\\n for each f in domain(tcount(:,e)):\\n P(f|e) = tcount(f, e) / total(e)\\n '''\\n\\n '''\\n My Pseudocode:\\n The Table of P(f|e) is already initiated as the AM dictionary.\\n Presumably the AM is passed in as t.\\n Initialize TCount as a dictionary like AM, e.g. TCount[e][f] = 0\\n Initialize Total as a dictionary with the same entries as TCount[e] = 0\\n for i in range(0,len(eng)):\\n\\n '''\\n AM = dict.fromkeys(t.keys(), 0)\\n Total = dict.fromkeys(t.keys(), 0)\\n TCount = dict.fromkeys(t.keys(), 0)\\n for key in TCount.keys():\\n TCount[key] = dict.fromkeys(t[key].keys(), 0)\\n AM[key] = dict.fromkeys(t[key].keys(), 0)\\n\\n num_sentences = min(len(eng), len(fre))\\n for i in range(0, num_sentences):\\n E = eng[i]\\n F = fre[i]\\n E_uniques = list(set(E))\\n F_uniques = list(set(F))\\n for f in F_uniques:\\n denom_c = 0\\n for e in E_uniques:\\n denom_c += t[e][f] * F.count(f)\\n for e in E_uniques:\\n TCount[e][f] += t[e][f] * F.count(f) * E.count(e) / denom_c\\n Total[e] += t[e][f] * F.count(f) * E.count(e) / denom_c\\n for e in Total.keys():\\n for f in TCount[e].keys():\\n AM[e][f] = TCount[e][f] / Total[e]\\n\\n return AM\",\n \"def log_prob(sentence, LM, smoothing=False, delta=0, vocabSize=0):\\n\\tlog_prob = 0\\n\\tdenominator = 0\\n\\tnumerator = 0\\n\\tword_list = sentence.split()\\n\\tlength_w = len(word_list) -1\\n\\tfor i in range(length_w):\\n\\t\\tword = word_list[i]\\n\\t\\tif word in LM['uni'].keys():\\n\\t\\t\\tdenominator = LM['uni'][word]\\n\\t\\telse:\\n\\t\\t\\tdenominator = 0\\n\\t\\tnext_word = word_list[i+1]\\n\\t\\tif word in LM['bi'].keys() and next_word in LM['bi'][word].keys():\\n\\t\\t\\tnumerator = LM['bi'][word][next_word]\\n\\t\\telse:\\n\\t\\t\\tnumerator = 0\\n\\t\\t# case when numerator/denominator = 0/0 and if it is not smoothing the log_prob will be -infinite\\n\\t\\tif (numerator == 0 or denominator == 0) and (not smoothing):\\n\\t\\t\\treturn float('-inf')\\n\\t\\telse:\\n\\t\\t\\tnumerator += delta\\n\\t\\t\\tdenominator += delta*vocabSize\\n\\t\\t\\tprob = (numerator) / (denominator)\\n\\t\\t\\tlog_prob+= log(prob, 2)\\n\\treturn log_prob\",\n \"def target_distribution(q):\\n weight = q ** 2 / q.sum(0)\\n return (weight.T / weight.sum(1)).T\",\n \"def sampled_softmax_logprobs(self, logit_target_in_model, logit_noise_in_model, logit_noise_in_noise, logit_target_in_noise):\\n logits = torch.cat([logit_target_in_model.unsqueeze(2), logit_noise_in_model], dim=2)\\n q_logits = torch.cat([logit_target_in_noise.unsqueeze(2), logit_noise_in_noise], dim=2)\\n # subtract Q for correction of biased sampling\\n logits = logits - q_logits\\n logproba = torch.nn.LogSoftmax(dim=-1)(logits)\\n \\n labels = torch.zeros_like(logits.narrow(2, 0, 1)).squeeze(2).long()\\n \\n logprobs = -torch.nn.NLLLoss(reduction='none')(logproba.view(-1, logproba.size(-1)), labels.view(-1)).view_as(labels)\\n logprobs = torch.sum(logprobs, dim=1)\\n \\n return logprobs\",\n \"def smooth_tag_model(cls, heldout_data):\\n\\n # bi_transition_counts = defaultdict(int)\\n n = 0 # count word-tags\\n e = .0001 # stopping condition\\n L = [.25, .25, .25, .25] # initialize lambdas uniformly\\n i = 1 # iteration\\n while True:\\n # E Step (Step 1)\\n # Iterate through all occurring trigrams\\n # in the heldout.txt data (H), i.e. minimizing\\n # log likelihood\\n counts = [0, 0, 0, 0]\\n ratio = [0, 0, 0, 0]\\n nextL = 4 * [0] # next lambda\\n\\n for sent in heldout_data:\\n\\n # Handle beginning of sentence\\n t = '<s>'\\n u = '<s>'\\n # bi_transition_counts[t, u] += 1\\n\\n # if first == '<s>' and second == '<s>': # add bigram for nulls\\n\\n for word, tag in sent:\\n v = tag\\n # tri_transitions[t, u, v] += 1\\n # bi_transitions[u, v] += 1\\n # # if first == '<s>' and second == '<s>': # add bigram for nulls\\n # # tagger._bi_transitions[('<s>', '<s>')] += 1\\n # uni_transitions[v] += 1\\n # cls._emissions[word, tag] += 1\\n # tags.add(v)\\n # words.add(word)\\n # uni_words[word] += 1\\n\\n\\n # Calculate expected counts of lambdas\\n ratio = cls.calc_tag_ratio(t, u, v, L)\\n\\n # M-step (Step 2)\\n # Calculate expected counts of lambdas, i.e. weight, taking\\n # into account the number of occurrences of each trigram (cnt)\\n for j in range(len(L)):\\n counts[j] += ratio[j] # weight of lambda in whole equation (count)\\n\\n t = u\\n u = v\\n # n += 1\\n\\n # Handle end of sentence\\n # tri_transitions[t, u, '</s>'] += 1\\n v = '</s>'\\n ratio = cls.calc_tag_ratio(t, u, v, L)\\n for j in range(len(L)):\\n counts[j] += ratio[j] # weight of lambda in whole equation (count)\\n\\n # cls._bi_transitions[first, second] += 1\\n # cls._tri_transitions[second, '</s>', '</s>'] += 1\\n\\n\\n # Update values for parameters given current distribution\\n for k in range(len(L)):\\n total = np.sum(counts)\\n nextL[k] = counts[k] / total # next lambda\\n\\n # Check if lambda values have converged\\n converged = True\\n for l in range(len(L)):\\n if np.abs(nextL[l] - L[l]) > e: # tolerance = e\\n converged = False\\n L = nextL\\n\\n # Return values if lambdas have converged\\n if converged:\\n break\\n\\n i += 1 # increment iteration counter\\n\\n\\n return L # copy lambdas passed by reference\",\n \"def log_prior_grad(self, inputs):\",\n \"def get_logCRF(train, model):\\n word = train[0]\\n Y = train[1]\\n char_count, _ = word.shape\\n # calculating forward messages\\n alpha = np.zeros((char_count, model.dimY))\\n first_term = np.dot(word, model.getW(model.labels))\\n second_term = model._T\\n for i in range(1, char_count):\\n sum_term = (first_term[i-1] + alpha[i-1]) + second_term\\n alpha[i] = np.apply_along_axis(logsumexp_trick, 1, sum_term) \\n # getting logZ from messages\\n logZ = logsumexp_trick(first_term[char_count-1]+alpha[char_count-1])\\n w_term = np.sum(model.getW(Y).transpose() * word) # $\\\\sum_{j=1}^m {W_{yj} . x_j}$\\n t_term = np.sum(model.getT(Y[:-1], Y[1:])) #$T_{yj, yj+1}\\n value = -logZ + w_term + t_term\\n return value\",\n \"def log_loss(self):\\n probabilities = self.probability_array().copy()\\n # need to flip the probabilities for p < 0.5 with this binary case.\\n # 1 - old_val is same as oldval*-1 + 1. Do in 2 steps:\\n probabilities[np.equal(0, self.y)] *= -1\\n probabilities[np.equal(0, self.y)] += 1\\n # when multiclass: np.amax(probabilities, 1)\\n return np.log(probabilities).sum()\",\n \"def predict_next(self, words):\\n prefix = \\\"%s \\\" % ' '.join(self.history)\\n order = len(self.history) + 1\\n scaling_factor = math.log(10) if self.convert_to_ln else 1.0\\n ret = {w: getNgramProb(\\n self.lm,\\n prefix + (\\\"</s>\\\" if w == utils.EOS_ID else str(w)),\\n order) * scaling_factor for w in words}\\n return ret\",\n \"def log_prob(self):\\n res = -self.L_h/2*np.log(2*np.pi*self.la)\\n res = res + self.L_h*(self.L_h-1)/2*self.a\\n\\n\\n res = res - 1/(2*self.la)*np.square(np.linalg.norm(self.e*self.pie))\\n\\n res = res - 1/(2*self.la)*np.sum(self.e2*self.pie_var)\\n\\n res = res - self.L_h/2*np.log(2*np.pi*self.sigma2)\\n res = res - 1/(2*self.sigma2)*(np.square(np.linalg.norm(self.w))+np.trace(self.R))\\n\\n print(\\\"Log-probability difference = {}\\\".format(res - self.LP), file=self.logfile)\\n self.LP = res\\n return res\",\n \"def ER_Theory(N,Kappa) :\\n\\tMu2 = Kappa - ( 2*Kappa*(1.0 - (Kappa/N))*math.log(N) )**0.5 + (( (Kappa*(1.0 - (Kappa/N)))/math.log(N) )**0.5)*( math.log( (2*math.pi*math.log((N**2)/(2*math.pi))) ) - 0.5772)\\n\\treturn Mu2\",\n \"def __init__(self, n, sents, corpus='', gamma=None, addone=True):\\n self.n = n\\n self.smoothingtechnique = 'Interpolated (Jelinek Mercer) Smoothing'\\n self.gamma = gamma\\n self.addone = addone\\n self.counts = counts = defaultdict(int)\\n self.gamma_flag = True\\n self.corpus = corpus\\n # way more efficient than use set unions\\n voc = ['</s>']\\n for s in sents:\\n voc += s\\n self.voc = list(set(voc))\\n\\n if gamma is None:\\n self.gamma_flag = False\\n\\n # if not gamma given\\n if not self.gamma_flag:\\n total_sents = len(sents)\\n aux = int(total_sents * 90 / 100)\\n # 90 per cent for training\\n train_sents = sents[:aux]\\n # 10 per cent for perplexity (held out data)\\n held_out_sents = sents[-total_sents+aux:]\\n\\n train_sents = list(map((lambda x: ['<s>']*(n-1) + x), train_sents))\\n train_sents = list(map((lambda x: x + ['</s>']), train_sents))\\n\\n for sent in train_sents:\\n for j in range(n+1):\\n # move along the sent saving all its j-grams\\n for i in range(n-j, len(sent) - j + 1):\\n ngram = tuple(sent[i: i + j])\\n counts[ngram] += 1\\n # added by hand\\n counts[('</s>',)] = len(train_sents)\\n # variable only for tests\\n self.tocounts = counts\\n # search the gamma that gives lower perplexity\\n gamma_candidates = [i*50 for i in range(1, 15)]\\n # xs is a list with (gamma, perplexity)\\n xs = []\\n sents = train_sents\\n for aux_gamma in gamma_candidates:\\n self.gamma = aux_gamma\\n aux_perx = self.perplexity(held_out_sents)\\n xs.append((aux_gamma, aux_perx))\\n xs.sort(key=lambda x: x[1])\\n self.gamma = xs[0][0]\\n with open('old-stuff/interpolated_' + str(n) + '_parameters_'+corpus, 'a') as f:\\n f.write('Order: {}\\\\n'.format(self.n))\\n f.write('Gamma: {}\\\\n'.format(self.gamma))\\n f.write('AddOne: {}\\\\n'.format(self.addone))\\n f.write('Perplexity observed: {}\\\\n'.format(xs[0][1]))\\n f.write('-------------------------------\\\\n')\\n f.close()\\n\\n else:\\n sents = list(map((lambda x: ['<s>']*(n-1) + x), sents))\\n sents = list(map((lambda x: x + ['</s>']), sents))\\n\\n for sent in sents:\\n # counts now holds all k-grams for 0 < k < n + 1\\n for j in range(n+1):\\n # move along the sent saving all its j-grams\\n for i in range(n-j, len(sent) - j + 1):\\n ngram = tuple(sent[i: i + j])\\n counts[ngram] += 1\\n # added by hand\\n counts[('</s>',)] = len(sents)\",\n \"def _loglike(self, y, f):\\n ll = y * tf.log(pos(f)) + (1 - y) * tf.log(pos(1 - f))\\n return ll\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6477803","0.6240592","0.61621064","0.6086333","0.6047775","0.60093266","0.5995965","0.5995107","0.5966389","0.59642804","0.59056777","0.5902837","0.58759403","0.58725774","0.5862674","0.5825452","0.58017606","0.58002657","0.5793231","0.57751673","0.5762595","0.576144","0.57566863","0.5741188","0.5720964","0.57192916","0.57186383","0.5714763","0.5712305","0.5703453","0.57016724","0.5701665","0.5701665","0.5689985","0.5688055","0.56864566","0.5682439","0.56772417","0.56769896","0.5671339","0.5667319","0.5665256","0.5661329","0.5642541","0.56422937","0.5639631","0.56306744","0.56151384","0.5614051","0.5614051","0.561037","0.5597891","0.5595321","0.5583832","0.5578242","0.5571829","0.5564497","0.556046","0.555867","0.55482244","0.5543614","0.554336","0.5541291","0.55335987","0.5532799","0.5532344","0.5530754","0.5528925","0.55274576","0.5526762","0.55258775","0.55246514","0.5519787","0.5518588","0.5518388","0.5512322","0.5503326","0.54996735","0.5497545","0.5484189","0.5482835","0.5477704","0.5476256","0.54741514","0.54735214","0.5464721","0.5462801","0.5462441","0.54609936","0.5458504","0.5457506","0.5453118","0.54489213","0.5443999","0.5442607","0.5434229","0.54333025","0.54290116","0.5425842","0.5422663","0.54219043"],"string":"[\n \"0.6477803\",\n \"0.6240592\",\n \"0.61621064\",\n \"0.6086333\",\n \"0.6047775\",\n \"0.60093266\",\n \"0.5995965\",\n \"0.5995107\",\n \"0.5966389\",\n \"0.59642804\",\n \"0.59056777\",\n \"0.5902837\",\n \"0.58759403\",\n \"0.58725774\",\n \"0.5862674\",\n \"0.5825452\",\n \"0.58017606\",\n \"0.58002657\",\n \"0.5793231\",\n \"0.57751673\",\n \"0.5762595\",\n \"0.576144\",\n \"0.57566863\",\n \"0.5741188\",\n \"0.5720964\",\n \"0.57192916\",\n \"0.57186383\",\n \"0.5714763\",\n \"0.5712305\",\n \"0.5703453\",\n \"0.57016724\",\n \"0.5701665\",\n \"0.5701665\",\n \"0.5689985\",\n \"0.5688055\",\n \"0.56864566\",\n \"0.5682439\",\n \"0.56772417\",\n \"0.56769896\",\n \"0.5671339\",\n \"0.5667319\",\n \"0.5665256\",\n \"0.5661329\",\n \"0.5642541\",\n \"0.56422937\",\n \"0.5639631\",\n \"0.56306744\",\n \"0.56151384\",\n \"0.5614051\",\n \"0.5614051\",\n \"0.561037\",\n \"0.5597891\",\n \"0.5595321\",\n \"0.5583832\",\n \"0.5578242\",\n \"0.5571829\",\n \"0.5564497\",\n \"0.556046\",\n \"0.555867\",\n \"0.55482244\",\n \"0.5543614\",\n \"0.554336\",\n \"0.5541291\",\n \"0.55335987\",\n \"0.5532799\",\n \"0.5532344\",\n \"0.5530754\",\n \"0.5528925\",\n \"0.55274576\",\n \"0.5526762\",\n \"0.55258775\",\n \"0.55246514\",\n \"0.5519787\",\n \"0.5518588\",\n \"0.5518388\",\n \"0.5512322\",\n \"0.5503326\",\n \"0.54996735\",\n \"0.5497545\",\n \"0.5484189\",\n \"0.5482835\",\n \"0.5477704\",\n \"0.5476256\",\n \"0.54741514\",\n \"0.54735214\",\n \"0.5464721\",\n \"0.5462801\",\n \"0.5462441\",\n \"0.54609936\",\n \"0.5458504\",\n \"0.5457506\",\n \"0.5453118\",\n \"0.54489213\",\n \"0.5443999\",\n \"0.5442607\",\n \"0.5434229\",\n \"0.54333025\",\n \"0.54290116\",\n \"0.5425842\",\n \"0.5422663\",\n \"0.54219043\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":81981,"cells":{"query":{"kind":"string","value":"Mark a hyperparameter as having a simple monotonic increasing relationship with both CPU time and the goodness of the model."},"document":{"kind":"string","value":"def patience_param(x):\n # -- TODO: make this do something!\n return x"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def mark(self) -> None:\n self.zero = self._monotonic_ms()","def preformance(self, perf):\n self.perf = perf","def __init__(self, time_constant: float, sampling_time: float):\n self.alpha = sampling_time / (time_constant + sampling_time)\n self.state = None","def E_step_precompute(self, model_params, my_suff_stat, my_data):","def prior_sample_parameter(self, parameter):\n pass","def __init__(self):\n super().__init__()\n self.TERRAIN_VARIANCE = 0.0","def update_param(self, name):\n bounds = self.likelihood_param_bounds[name]\n weights = self.get_param_sample_weight(name)\n\n def calculate_nll(value, model, name, bounds, sample):\n if value < bounds[0] or value > bounds[1]:\n return np.inf\n setattr(model, name, value)\n nll = -model.calculate_expected_log_likelihood(sample)\n return nll\n\n value_before = getattr(self.model, name)\n elbo_before = self.model.calculate_expected_log_likelihood(np.ones((self.model.num_segments,), dtype=int))\n\n sample = self._create_sample(weights)\n\n result = scipy.optimize.brute(\n calculate_nll,\n args=(self.model, name, bounds, sample),\n ranges=[bounds],\n full_output=True,\n )\n\n elbo_after = self.model.calculate_expected_log_likelihood(np.ones((self.model.num_segments,), dtype=int))\n if elbo_after < elbo_before:\n print ('[{}] {} rejected, elbo before: {}, after: {}'.format(_gettime(), name, elbo_before, elbo_after))\n setattr(self.model, name, value_before)\n\n else:\n setattr(self.model, name, result[0])","def log_prior(self, params):","def update_parameter(self):\n\n if self.testing: # 1. No random choice when testing\n self.epsilon = 0\n else: # 2. Update parameters when learning\n if self.epsilon > 0.:\n self.epsilon -= 0.01\n\n return self.epsilon","def scheduler(epoch):\n return alpha / (1 + decay_rate * epoch)","def cool(self):\n self.t = self.t - 1","def _weigh_object(self, host_state, weight_properties):\n return 1.0 * host_state.vcpus_total / max(host_state.vcpus_used, 1)","def __call__(self, param):\n count = param.nbatch\n if self.last_count > count:\n self.init = False\n self.last_count = count\n\n if self.init:\n if count % self.frequent == 0:\n speed = self.frequent * self.batch_size / (time.time() - self.tic)\n s = ''\n if param.eval_metric is not None:\n name, value = param.eval_metric.get()\n s = \"Epoch[%d] Batch [%d]\\tSpeed: %.2f samples/sec\\tTrain-\" % (param.epoch, count, speed)\n for n, v in zip(name, value):\n s += \"%s=%f,\\t\" % (n, v)\n else:\n s = \"Iter[%d] Batch [%d]\\tSpeed: %.2f samples/sec\" % (param.epoch, count, speed)\n\n logging.info(s)\n print(s)\n self.tic = time.time()\n else:\n self.init = True\n self.tic = time.time()","def __call__(self, param):\n count = param.nbatch\n if self.last_count > count:\n self.init = False\n self.last_count = count\n\n if self.init:\n if count % self.frequent == 0:\n # #11504\n try:\n speed = self.frequent * self.batch_size / (time.time() - self.tic)\n except ZeroDivisionError:\n speed = float('inf')\n if param.eval_metric is not None:\n name_value = param.eval_metric.get_name_value()\n if self.auto_reset:\n param.eval_metric.reset()\n msg = 'Epoch[%d] Batch [%d-%d]\\tSpeed: %.2f samples/sec'\n msg += '\\t%s=%f'*len(name_value)\n logging.info(msg, param.epoch, count-self.frequent, count, speed, *sum(name_value, ()))\n else:\n msg = 'Epoch[%d] Batch [0-%d]\\tSpeed: %.2f samples/sec'\n msg += '\\t%s=%f'*len(name_value)\n logging.info(msg, param.epoch, count, speed, *sum(name_value, ()))\n else:\n logging.info(\"Iter[%d] Batch [%d]\\tSpeed: %.2f samples/sec\",\n param.epoch, count, speed)\n self.tic = time.time()\n else:\n self.init = True\n self.tic = time.time()","def test_xx1_thr(self):\n u_spec = leabra.UnitSpec()\n u_spec.act_thr = 0.25\n u = leabra.Unit(spec=u_spec)\n self.assertEqual(u_spec.xx1(-0.1), 0.0)\n self.assertTrue(0.0 < u_spec.xx1(0.1))\n self.assertEqual(u_spec.noisy_xx1(-0.1), 0.0)\n self.assertTrue(0.1 < u_spec.noisy_xx1(0.1))","def act(self, state, eps=0.):","def objective(self, param):\n self.__init__(param, self.data)\n # return self.rmse() + self.penalty()\n return self.rmse() + self.penalty()","def objective(hyperparams): \n global iteration #necessary with a global variable because of implementation from hyperopt. \n iteration += 1\n\n result = run_model(hyperparams, iteration)\n loss = -result #transform to loss in order to minimize\n\n return {'loss': loss, 'hyperparams': hyperparams, 'iteration': iteration, 'status': STATUS_OK}","def set_hyperparams(self, params):","def increase_learning(self, factor):\n pass","def ModifyInitialProperties(self):\n super().ModifyInitialProperties()\n for aux_process in self.project_parameters[\"processes\"][\"auxiliar_process_list\"]:\n if aux_process[\"python_module\"].GetString() == \"temporal_statistics_process\":\n aux_process[\"Parameters\"][\"statistics_start_point_control_value\"].SetDouble(self.project_parameters[\"problem_data\"][\"burnin_time\"].GetDouble())","def prior(old_params,params):\n \n for s in range(len(params)):\n if params[s] < 0.0 or params[s] > 2:\n return 0\n return 1","def __init__(self, value):\n self.value = max(min(value,1.0),-1.0)","def __init__(self, value):\n self.value = max(min(value,1.0),-1.0)","def test_early_stopping_call_increasing():\n early_stopping = learning.EarlyStopping(\n patience=PATIENCE,\n decreasing=False,\n )\n assert not early_stopping(PATIENCE + 1)\n for i in range(PATIENCE):\n assert not early_stopping(i)\n assert early_stopping(0)","def training_policy(self, state):\n if self.epsilon > random.random():\n return random.randint(0, 1)\n return self.policy(state)","def cpu_time(self):","def inc_latency(self, *_, **__): # pylint: disable=arguments-differ\n pass","def log_prior(self):\n raise NotImplementedError(\"the log_prior property should \"\n \"be defined in the Estimator sub-class\")","def set_value(self, name, val, **kwargs):\n try:\n assert self.__started\n val = float(val)\n except AssertionError:\n self.unknown_error(\"Start method must be called first!\")\n except (TypeError, ValueError):\n self.unknown_error(\"Performance measures must be numeric!\")\n\n val_dict = {'val': val, 'min': None, 'max': None, 'scale': None,\n 'threshold': 1, 'state': 'ok'}\n\n if 'lowest' in kwargs:\n val_dict['min'] = float(kwargs.get('lowest'))\n\n if 'highest' in kwargs:\n val_dict['max'] = float(kwargs.get('highest'))\n\n if 'threshold' in kwargs:\n val_dict['threshold'] = kwargs['threshold']\n\n # Nagios actually understands most byte and time oriented scales.\n # The developer docs also list a counter scale, but we're not certain\n # if any plugin has ever used that. Only accept known scales.\n\n if 'scale' in kwargs:\n scale = kwargs.get('scale')\n\n if scale.upper() in ('B', 'KB', 'MB', 'GB', 'TB'):\n val_dict['scale'] = scale.upper()\n elif scale.lower() in ('s', 'ms', 'us', 'ns', '%'):\n val_dict['scale'] = scale.lower()\n else:\n raise ValueError(\"\"\"Scale must be one of: B, KB, MB, GB,\n TB, s, ms, us, ns, or %.\"\"\")\n\n self.__perf[name] = val_dict\n\n # We'll use the opportunity to check the status ranges right when the\n # variable is set so we don't have to loop through all of them later.\n\n if len(self.__warning) > 0:\n self.__verbose_print(\"checking warning\")\n self.__check_range('warning', name)\n\n if len(self.__critical) > 0:\n self.__verbose_print(\"checking critical\")\n self.__check_range('critical', name)\n\n return self.__perf[name]['state']","def schedule_variant(epoch):\n\n def _linear_annealing(epoch):\n t = epoch / args.epochs\n lr_ratio = 0.01\n if t <= 0.5:\n factor = 1.0\n elif t <= 0.9:\n factor = 1.0 - (1.0 - lr_ratio) * (t - 0.5) / 0.4\n else:\n factor = lr_ratio\n return args.lr_init * factor\n\n lr_tmp = _linear_annealing(epoch)\n if args.swag:\n if (epoch > args.swag_start) or lr_tmp <= args.swag_lr:\n return _linear_annealing(args.swag_start)\n return lr_tmp","def set_speed():\n pass","def update_alpha(model):\n a = model.params.alpha_prior[0]\n b = model.params.alpha_prior[1]\n\n alpha_old = model.params.alpha\n\n log_p_old = model.feat_alloc_dist.log_p(model.params)\n\n alpha_new = scipy.stats.gamma.rvs(a, scale=(1 / b))\n\n model.params.alpha = alpha_new\n\n log_p_new = model.feat_alloc_dist.log_p(model.params)\n\n if do_metropolis_hastings_accept_reject(log_p_new, log_p_old, 0, 0):\n model.params.alpha = alpha_new\n\n else:\n model.params.alpha = alpha_old","def testHrtPrior(self):\n attr = self.session.create_visit_attr()\n\n self.util.boolTypeTest(self, attr, \"prior\")\n\n self.util.boolPropertyTest(self, attr, \"prior\")","def set_probability_alpha(self, value):\n self.view_state.alpha = value / 100","def _update(self, time_step, **train_kwargs):\n # training is implied here\n self.set_t_cutoff(self.cutoff_t + time_step, **train_kwargs)","def lnprob_white(params, params_min, params_max, t, f, ferr, expTime):\n return lnlike_white(params, t, f, ferr, expTime) + lnprior(params, params_min, params_max)","def test_change_lower(self):\n instance = self.traits_instance\n instance.low = -4.0\n instance.value = -2\n self.assertAlmostEqual(instance.value, -2)","def test_early_stopping_init_increasing():\n early_stopping = learning.EarlyStopping(\n patience=PATIENCE,\n decreasing=False,\n )\n assert early_stopping.patience == PATIENCE\n assert early_stopping.decreasing is False\n assert early_stopping.best == float('-inf')\n assert early_stopping.num_bad == 0","def update_relative_weight(self):\n self.relative_weight = 1\n # Add up all of the historical cpu datapoints (higher CPU = more weight)\n for i in self.cpu_datapoints:\n self.relative_weight += i\n # Multiply by the status value (so VMs with red alarm have most weight)\n self.relative_weight *= (self.heartbeat_status * 10)","def train(self, x={}, **kwargs):\n return 0","def posterior_sample_parameter(self, parameter):\n pass","def update(self, value):\n if self._in_concept_change:\n self.reset()\n\n self.miss_prob = self.miss_prob + (value - self.miss_prob) / float(self.sample_count)\n self.miss_std = np.sqrt(self.miss_prob * (1 - self.miss_prob) / float(self.sample_count))\n self.sample_count += 1\n\n self.estimation = self.miss_prob\n self._in_concept_change = False\n self._in_warning_zone = False\n self.delay = 0\n\n if self.sample_count < self.min_num_instances:\n return self._in_concept_change, self._in_warning_zone\n\n if self.miss_prob + self.miss_std <= self.miss_prob_sd_min:\n self.miss_prob_min = self.miss_prob\n self.miss_sd_min = self.miss_std\n self.miss_prob_sd_min = self.miss_prob + self.miss_std\n\n if self.miss_prob + self.miss_std > self.miss_prob_min + self.out_control_level \\\n * self.miss_sd_min:\n self._in_concept_change = True\n\n elif self.miss_prob + self.miss_std > self.miss_prob_min + self.warning_level \\\n * self.miss_sd_min:\n self._in_warning_zone = True\n\n else:\n self._in_warning_zone = False\n\n return self._in_concept_change, self._in_warning_zone","def __init__(self, label, select_high_quality):\n self.label = label\n self.resource = max(0.1, np.random.random_sample()) # let's assume everyone has at least a tenth of the max resource\n\n # put x one in each team\n if select_high_quality and np.random.uniform(0,1) <= PERCENT_INITIAL_HIGH_QUALITY:\n self.state = np.random.uniform(HIGH_QUALITY_THRESHOLD, 1)\n else:\n self.state = np.random.uniform(0, AVERAGE_DOCUMENTATION_FEQUENCY)\n self.tasks_completed = 0","def lnprior(params):\n a, b, f = params\n if -10.0 < b < 0. and 0. < a < 10 and 0. < f:\n return 0.0\n\n return -np.inf","def set_accuracy_95(num: float) -> float:\n ...","def _onSetParameterLower(self, value):\n self._parameters['lower'] = min(value, self._parameters['upper']) # Limit at upper\n self._logger.info(\"Parameter 'lower' of function '{}' changed to {}\".format(self._function, value))\n self.functionChanged.emit(self._dim, self._function, self._parameters.copy())","def update_learning_rate(self):\r\n self.scheduler.step(self.clock.epoch)","def conditional_entropy_hyper(self) -> float:\n pass","def set_train_switch(self, switch_val=0.0):\n if (switch_val < 0.5):\n switch_val = 0.0\n else:\n switch_val = 1.0\n zero_ary = np.zeros((1,))\n new_val = zero_ary + switch_val\n self.train_switch.set_value(to_fX(new_val))\n return","def set_new_random_processing_time(machine_object):\n if global_settings.processing_time_distribution == \"uniform\":\n machine_object.processing_time = \\\n round(random.uniform(\n machine_object.uniform_processing_time_lower_bound,\n machine_object.uniform_processing_time_upper_bound))\n elif global_settings.processing_time_distribution == \"exponential\":\n machine_object.processing_time = \\\n get_random_exponential_number(machine_object.exponential_processing_time)\n else:\n raise ValueError(\"global_settings.processing_time_distribution invalid value assigned. \"\n \"Must be 'exponential' or 'uniform'\")\n return","def test_PredictionEnsemble_smooth_None(\r\n perfectModelEnsemble_initialized_control_1d_ym_cftime,\r\n):\r\n pm = perfectModelEnsemble_initialized_control_1d_ym_cftime\r\n pm_smoothed = pm.smooth(None)\r\n assert_PredictionEnsemble(pm, pm_smoothed)","def _tune(acc_rate, proposed, step):\n if step.tune_scaling:\n # a and b after Muto & Beck 2008.\n a = 1 / 9\n b = 8 / 9\n step.scaling = (a + b * acc_rate) ** 2\n if step.tune_steps:\n acc_rate = max(1.0 / proposed, acc_rate)\n step.n_steps = min(step.max_steps, 1 + int(np.log(step.p_acc_rate) / np.log(1 - acc_rate)))","def log_prob(self):","def test_trainable_property(self):\n scalar_weighted_addition_model = ScalarWeightedAddition(10)\n np.testing.assert_equal(scalar_weighted_addition_model.is_trainable, True)","def test_temporal_smoothing_how(perfectModelEnsemble_initialized_control_1d_ym_cftime):\r\n pm = perfectModelEnsemble_initialized_control_1d_ym_cftime\r\n pm_smoothed_mean = pm.smooth({\"lead\": 4}, how=\"mean\")\r\n pm_smoothed_sum = pm.smooth({\"lead\": 4}, how=\"sum\")\r\n assert (\r\n pm_smoothed_sum.get_initialized().mean()\r\n > pm_smoothed_mean.get_initialized().mean() * 2\r\n )","def test_am_threshold(Simulator, plt, seed, rng):\n d = 64\n vocab = Vocabulary(d, pointer_gen=rng)\n vocab.populate('A; B; C; D')\n\n d2 = int(d / 2)\n vocab2 = Vocabulary(d2, pointer_gen=rng)\n vocab2.populate('A; B; C; D')\n\n def input_func(t):\n return '0.49 * A' if t < 0.1 else '0.8 * B'\n\n with spa.Network('model', seed=seed) as m:\n m.am = ThresholdingAssocMem(\n threshold=0.5, input_vocab=vocab, output_vocab=vocab2,\n function=filtered_step_fn, mapping='by-key')\n m.stimulus = spa.Transcode(input_func, output_vocab=vocab)\n m.stimulus >> m.am\n\n in_p = nengo.Probe(m.am.input)\n out_p = nengo.Probe(m.am.output, synapse=0.03)\n\n with Simulator(m) as sim:\n sim.run(0.3)\n t = sim.trange()\n below_th = t < 0.1\n above_th = t > 0.25\n\n plt.subplot(2, 1, 1)\n plt.plot(t, similarity(sim.data[in_p], vocab))\n plt.ylabel(\"Input\")\n plt.subplot(2, 1, 2)\n plt.plot(t, similarity(sim.data[out_p], vocab2))\n plt.plot(t[above_th], np.ones(t.shape)[above_th] * 0.9, c='g', lw=2)\n plt.ylabel(\"Output\")\n\n assert np.mean(sim.data[out_p][below_th]) < 0.01\n assert_sp_close(t, sim.data[out_p], vocab2['B'], skip=0.25, duration=0.05)","def _soft_update(self, active, target):\n\n for t_param, param in zip(target.parameters(), active.parameters()):\n t_param.data.copy_(self.tau*param.data + (1-self.tau)*t_param.data)","def set_prior(self,field):\n self.observation_thresholds = [i/self.observations for i in range(0,self.observations)]\n self.observation_samples = 1\n # TODO: For use after integrating image processing with MCESP for Game-Delayed Reinforcements\n # self.norm = field.max()","def test_instrument_val_invariant_under_delegate_cache_set(\n make_observable_parameter, numeric_val):\n initial_value = numeric_val\n t = make_observable_parameter(\n 'observable_parameter', initial_value=initial_value)\n new_source_value = 3\n t.cache.set(new_source_value)\n assert t.get_instr_val() == initial_value","def __call__(self, score, model):\n if self.best_score is None:\n # assign the best score and save the model at the end of the first epoch\n self.best_score = score\n self.save_checkpoint(model)\n elif score < self.best_score + self.delta:\n # if the score not increase of at least delta, increment the counter and if it reach the patience early stops\n self.counter += 1\n if self.counter >= self.patience:\n self.early_stop = True\n else:\n # otherwise the score is better that the saved one, so replace the best score and save the model\n self.best_score = score\n self.save_checkpoint(model)\n self.counter = 0","def linear_warmup(base_value, max_warmup_iter, cur_step):\n if max_warmup_iter <= cur_step:\n return base_value\n return base_value * cur_step / max_warmup_iter","def is_artificial(self):\n\t\treturn 0","def advantage(cpu_dt, gpu_dt):\r\n assert gpu_dt >= 0 and cpu_dt >= 0\r\n if gpu_dt == 0 and cpu_dt == 0:\r\n return numpy.nan\r\n elif gpu_dt == 0:\r\n return numpy.inf\r\n else:\r\n return cpu_dt / gpu_dt","def speed(self, value: int, /) -> None:","def update(self, value):\n if value < self.min:\n self.min = value\n if value > self.max:\n self.max = value\n self.total += value\n self.instances += 1\n self.values.append(value)","def _scheduled_sampling(self):\n step = tf.train.get_or_create_global_step()\n step = tf.cast(step, tf.float32)\n progress = tf.minimum(\n (step-self.args.warmup_step) / float(self.args.max_step-self.args.warmup_step), 1.0)\n return tf.minimum(1.0, 1.0 - progress * (1.0 -self.args.min_rate))","def test_early_stopping_call_decreasing():\n early_stopping = learning.EarlyStopping(patience=PATIENCE, decreasing=True)\n assert not early_stopping(-1)\n for i in range(PATIENCE):\n assert not early_stopping(i)\n assert early_stopping(0)","def __init__(self, \n input_var: tf.Variable, \n predictions_fn: Callable[[tf.Tensor], tf.Tensor], \n loss_fn: Callable[[tf.Tensor], tf.Tensor], \n name: str,\n damping_factor: float = 1.0, \n damping_update_factor: float = 0.999, \n damping_update_frequency: int = 5,\n update_cond_threshold_low: float = 0.5, \n update_cond_threshold_high: float = 1.5,\n damping_threshold_low: float = 1e-7,\n damping_threshold_high: float = 1e7,\n alpha_init: float = 1.0, \n squared_loss: bool = True) -> None:\n self._name = name\n self._input_var = input_var\n \n self._predictions_fn = predictions_fn\n self._loss_fn = loss_fn\n \n # Multiplicating factor to update the damping factor at the end of each cycle\n self._damping_update_factor = damping_update_factor\n self._damping_update_frequency = damping_update_frequency\n self._update_cond_threshold_low = update_cond_threshold_low\n self._update_cond_threshold_high = update_cond_threshold_high\n self._damping_threshold_low = damping_threshold_low\n self._damping_threshold_high = damping_threshold_high\n self._squared_loss = squared_loss\n self._alpha = alpha_init\n\n with tf.variable_scope(name):\n self._predictions_fn_tensor = self._predictions_fn(self._input_var)\n self._loss_fn_tensor = self._loss_fn(self._predictions_fn_tensor)\n \n self._damping_factor = tf.get_variable(\"lambda\", dtype=tf.float32, \n initializer=damping_factor)\n\n # Variable used for momentum-like updates\n self._z = tf.get_variable(\"z\", dtype=tf.float32, \n initializer=tf.zeros_like(self._input_var))\n\n self._dummy_var = tf.get_variable(\"dummy\", dtype=tf.float32, \n initializer=tf.zeros_like(self._predictions_fn_tensor))\n\n self._loss_before_update = tf.get_variable(\"loss_before_update\", dtype=tf.float32,\n initializer=0.)\n self._iteration = tf.get_variable(\"iteration\", shape=[], dtype=tf.int64,\n initializer=tf.zeros_initializer)\n self._expected_quadratic_change = tf.get_variable(\"expected_quadratic_change\", \n dtype=tf.float32,\n initializer=0.)\n\n # Set up the second order calculations\n self._second_order()","def l_point(self):\n self.l_score += 1\n self.update()","def __init__(self, value=1.0):\n self.value = value","def test_get_hyperflex_feature_limit_external_by_moid(self):\n pass","def likelihood(self, sign_switch, hyperparam):\n\n self.timer.tic()\n\n if numpy.isscalar(hyperparam):\n hyperparam_ = numpy.array([hyperparam], dtype=float)\n else:\n hyperparam_ = hyperparam\n\n # Check if likelihood is already computed for an identical hyperparam\n if (self.ell is not None) and \\\n (self.ell_hyperparam is not None) and \\\n (hyperparam_.size == self.ell_hyperparam.size) and \\\n numpy.allclose(hyperparam_, self.ell_hyperparam,\n atol=self.hyperparam_tol):\n\n if sign_switch:\n return -self.ell\n else:\n return self.ell\n\n # Get eta\n eta = self._hyperparam_to_eta(hyperparam_)\n\n # Extract scale from hyperparam\n if (not numpy.isscalar(hyperparam_)) and \\\n (hyperparam_.size > self.scale_index):\n\n # Set scale of the covariance object\n scale = self._hyperparam_to_scale(hyperparam_[self.scale_index:])\n self.mixed_cor.set_scale(scale)\n\n if numpy.abs(eta) >= self.max_eta:\n\n # Optimal sigma02 when eta is very large\n sigma02 = self._find_optimal_sigma02()\n\n # Log likelihood\n ell = -0.5*self.rdof * (numpy.log(2.0*numpy.pi) + 1.0 +\n numpy.log(sigma02))\n\n if self.B is None:\n Cinv = numpy.matmul(self.X.T, self.X)\n logdet_Cinv = numpy.log(numpy.linalg.det(Cinv))\n ell += - 0.5*logdet_Cinv\n # else:\n # logdet_B = numpy.log(numpy.linalg.det(self.B))\n # ell += 0.5*logdet_B\n\n else:\n\n # Update Y, C, Mz (all needed for computing optimal sigma2)\n self._update_Y_C_Mz(hyperparam_)\n\n # Find (or update) optimal sigma2\n sigma2 = self._find_optimal_sigma2(hyperparam_)\n\n logdet_Kn = self.mixed_cor.logdet(eta)\n logdet_Cinv = numpy.log(numpy.linalg.det(self.Cinv))\n\n if numpy.isnan(logdet_Kn):\n raise RuntimeError('Logdet of \"Kn\" is nan at eta: %0.3e.'\n % eta)\n\n # Log likelihood\n ell = -0.5*self.rdof * \\\n (numpy.log(2.0*numpy.pi) + 1.0 + numpy.log(sigma2)) \\\n - 0.5*logdet_Kn - 0.5*logdet_Cinv\n\n if self.B is not None:\n # Note that self.B is indeed B1, that is the matrix B without\n # sigma**2.\n logdet_B = numpy.log(numpy.linalg.det(self.B))\n ell += -0.5*logdet_B\n\n # Store ell to member data (without sign-switch).\n self.ell = ell\n self.ell_hyperparam = hyperparam_\n\n # If ell is used in scipy.optimize.minimize, change the sign to obtain\n # the minimum of -ell\n if sign_switch:\n ell = -ell\n\n self.timer.toc()\n\n return ell","def addHyperparam(self, est, param, hyperParam):\n self.hyperparams[param] = (est, hyperParam)\n return self","def lnprior(params, params_min, params_max):\n inSpace = 1\n for i, p in enumerate(params):\n inSpace = inSpace * (params_max[i] > p > params_min[i])\n if inSpace == 0:\n return -np.inf\n else:\n return 0","def on_stage_start(self, stage, epoch):\n if stage != sb.Stage.TRAIN:\n self.cer_metric = self.hparams.cer_computer()\n self.wer_metric = self.hparams.error_rate_computer()","def test_PredictionEnsemble_goddard(\r\n perfectModelEnsemble_initialized_control_1d_ym_cftime, smooth\r\n):\r\n pm = perfectModelEnsemble_initialized_control_1d_ym_cftime\r\n assert pm.smooth(smooth)","def __init__(self, *args: Any, **kwargs: Any) -> None:\n super(LaneInvasionsMetric, self).__init__(initial_value=0)","def _perturbInPlaceSoft(self):\n kevRandom = KevRandom()\n if random.random() < 0.5:\n newThreshold = -1\n while newThreshold < 0 or newThreshold > 1:\n newThreshold = self.threshold + kevRandom.laplacian() #* 0.1\n self.threshold = newThreshold\n else:\n self.beta += kevRandom.laplacian() #* 0.1","def warmup_step(ckpt_step: int) -> float:\n return ckpt_step * 10","def _simIncToPulses(self, speed_inc):\n top_speed = self.__class__.SPEED_CODES[speed_inc]\n self.sim_state['top_speed'] = top_speed\n if self.sim_state['start_speed'] > top_speed:\n self.sim_state['start_speed'] = top_speed\n if self.sim_state['cutoff_speed'] > top_speed:\n self.sim_state['cutoff_speed'] = top_speed","def bias_prior(self):","def begin_epoch(self, epoch, model):\n super().begin_epoch(epoch, model)\n if hasattr(self.criterion, \"set_epoch\"):\n self.criterion.set_epoch(epoch)","def __init__(self):\n self.counts = [0] * 10\n self.values = [0] * 10\n self.softmaxvalues = [0] * 10\n self.t = 0.3","def test_early_stopping_init_decreasing():\n early_stopping = learning.EarlyStopping(patience=PATIENCE, decreasing=True)\n assert early_stopping.patience == PATIENCE\n assert early_stopping.decreasing is True\n assert early_stopping.best == float('inf')\n assert early_stopping.num_bad == 0","def __init__(self):\n super(RobinBoundary, self).__init__()\n self.value = RobinBoundary.value\n RobinBoundary.value += 1\n self.update(param=\"1\")","def test_train_property():\n atom = ATOMClassifier(X_bin, y_bin, random_state=1)\n atom.run([\"MNB\", \"LR\"])\n assert atom.train.equals(atom.mnb.train)\n assert check_scaling(atom.lr.train)","def advantage(cpu_dt, gpu_dt):\n assert gpu_dt >= 0 and cpu_dt >= 0\n if gpu_dt == 0 and cpu_dt == 0:\n return numpy.nan\n elif gpu_dt == 0:\n return numpy.inf\n else:\n return cpu_dt / gpu_dt","def witnessValue(self, value):\n self.numVisits += 1\n n = self.numVisits\n self.value = (value + (n-1) * self.value) / n","def test_foo(self):\n self.ran = True\n 1 / 0","def with_cpu(ops, model):\n ...","def set_trial_param(\n self,\n trial_id: int,\n param_name: str,\n param_value_internal: float,\n distribution: \"distributions.BaseDistribution\",\n ) -> bool:\n raise NotImplementedError","def TrainOneStep(self):\n pass","def train_one_epoch(self):\n raise NotImplementedError","def objective(self, x):\n pass","def objective(self, x):\n pass","def condition(timestep, *_):\n return tf.less(timestep, tf.shape(score)[1])","def softClassify(self, inputValue):\n result = 1.0 / (1 + math.e ** (-self.beta * (inputValue - self.threshold)))\n logging.debug(\"Classification of %f on value %f for feature %d\" %(result, inputValue, self.feature))\n return result","def addAgility(self):\t\n\t\tself.agility += 1\n\t\tif self.agility > 10:\n\t\t\tself.agility = 10","def setMinValue(self, min_value):\r\n\t\tself.MinValue = min_value\r\n\t\tself.OutputValueIncrement = (self.MaxValue - self.MinValue)/(self.RampDuration/self.Ts)"],"string":"[\n \"def mark(self) -> None:\\n self.zero = self._monotonic_ms()\",\n \"def preformance(self, perf):\\n self.perf = perf\",\n \"def __init__(self, time_constant: float, sampling_time: float):\\n self.alpha = sampling_time / (time_constant + sampling_time)\\n self.state = None\",\n \"def E_step_precompute(self, model_params, my_suff_stat, my_data):\",\n \"def prior_sample_parameter(self, parameter):\\n pass\",\n \"def __init__(self):\\n super().__init__()\\n self.TERRAIN_VARIANCE = 0.0\",\n \"def update_param(self, name):\\n bounds = self.likelihood_param_bounds[name]\\n weights = self.get_param_sample_weight(name)\\n\\n def calculate_nll(value, model, name, bounds, sample):\\n if value < bounds[0] or value > bounds[1]:\\n return np.inf\\n setattr(model, name, value)\\n nll = -model.calculate_expected_log_likelihood(sample)\\n return nll\\n\\n value_before = getattr(self.model, name)\\n elbo_before = self.model.calculate_expected_log_likelihood(np.ones((self.model.num_segments,), dtype=int))\\n\\n sample = self._create_sample(weights)\\n\\n result = scipy.optimize.brute(\\n calculate_nll,\\n args=(self.model, name, bounds, sample),\\n ranges=[bounds],\\n full_output=True,\\n )\\n\\n elbo_after = self.model.calculate_expected_log_likelihood(np.ones((self.model.num_segments,), dtype=int))\\n if elbo_after < elbo_before:\\n print ('[{}] {} rejected, elbo before: {}, after: {}'.format(_gettime(), name, elbo_before, elbo_after))\\n setattr(self.model, name, value_before)\\n\\n else:\\n setattr(self.model, name, result[0])\",\n \"def log_prior(self, params):\",\n \"def update_parameter(self):\\n\\n if self.testing: # 1. No random choice when testing\\n self.epsilon = 0\\n else: # 2. Update parameters when learning\\n if self.epsilon > 0.:\\n self.epsilon -= 0.01\\n\\n return self.epsilon\",\n \"def scheduler(epoch):\\n return alpha / (1 + decay_rate * epoch)\",\n \"def cool(self):\\n self.t = self.t - 1\",\n \"def _weigh_object(self, host_state, weight_properties):\\n return 1.0 * host_state.vcpus_total / max(host_state.vcpus_used, 1)\",\n \"def __call__(self, param):\\n count = param.nbatch\\n if self.last_count > count:\\n self.init = False\\n self.last_count = count\\n\\n if self.init:\\n if count % self.frequent == 0:\\n speed = self.frequent * self.batch_size / (time.time() - self.tic)\\n s = ''\\n if param.eval_metric is not None:\\n name, value = param.eval_metric.get()\\n s = \\\"Epoch[%d] Batch [%d]\\\\tSpeed: %.2f samples/sec\\\\tTrain-\\\" % (param.epoch, count, speed)\\n for n, v in zip(name, value):\\n s += \\\"%s=%f,\\\\t\\\" % (n, v)\\n else:\\n s = \\\"Iter[%d] Batch [%d]\\\\tSpeed: %.2f samples/sec\\\" % (param.epoch, count, speed)\\n\\n logging.info(s)\\n print(s)\\n self.tic = time.time()\\n else:\\n self.init = True\\n self.tic = time.time()\",\n \"def __call__(self, param):\\n count = param.nbatch\\n if self.last_count > count:\\n self.init = False\\n self.last_count = count\\n\\n if self.init:\\n if count % self.frequent == 0:\\n # #11504\\n try:\\n speed = self.frequent * self.batch_size / (time.time() - self.tic)\\n except ZeroDivisionError:\\n speed = float('inf')\\n if param.eval_metric is not None:\\n name_value = param.eval_metric.get_name_value()\\n if self.auto_reset:\\n param.eval_metric.reset()\\n msg = 'Epoch[%d] Batch [%d-%d]\\\\tSpeed: %.2f samples/sec'\\n msg += '\\\\t%s=%f'*len(name_value)\\n logging.info(msg, param.epoch, count-self.frequent, count, speed, *sum(name_value, ()))\\n else:\\n msg = 'Epoch[%d] Batch [0-%d]\\\\tSpeed: %.2f samples/sec'\\n msg += '\\\\t%s=%f'*len(name_value)\\n logging.info(msg, param.epoch, count, speed, *sum(name_value, ()))\\n else:\\n logging.info(\\\"Iter[%d] Batch [%d]\\\\tSpeed: %.2f samples/sec\\\",\\n param.epoch, count, speed)\\n self.tic = time.time()\\n else:\\n self.init = True\\n self.tic = time.time()\",\n \"def test_xx1_thr(self):\\n u_spec = leabra.UnitSpec()\\n u_spec.act_thr = 0.25\\n u = leabra.Unit(spec=u_spec)\\n self.assertEqual(u_spec.xx1(-0.1), 0.0)\\n self.assertTrue(0.0 < u_spec.xx1(0.1))\\n self.assertEqual(u_spec.noisy_xx1(-0.1), 0.0)\\n self.assertTrue(0.1 < u_spec.noisy_xx1(0.1))\",\n \"def act(self, state, eps=0.):\",\n \"def objective(self, param):\\n self.__init__(param, self.data)\\n # return self.rmse() + self.penalty()\\n return self.rmse() + self.penalty()\",\n \"def objective(hyperparams): \\n global iteration #necessary with a global variable because of implementation from hyperopt. \\n iteration += 1\\n\\n result = run_model(hyperparams, iteration)\\n loss = -result #transform to loss in order to minimize\\n\\n return {'loss': loss, 'hyperparams': hyperparams, 'iteration': iteration, 'status': STATUS_OK}\",\n \"def set_hyperparams(self, params):\",\n \"def increase_learning(self, factor):\\n pass\",\n \"def ModifyInitialProperties(self):\\n super().ModifyInitialProperties()\\n for aux_process in self.project_parameters[\\\"processes\\\"][\\\"auxiliar_process_list\\\"]:\\n if aux_process[\\\"python_module\\\"].GetString() == \\\"temporal_statistics_process\\\":\\n aux_process[\\\"Parameters\\\"][\\\"statistics_start_point_control_value\\\"].SetDouble(self.project_parameters[\\\"problem_data\\\"][\\\"burnin_time\\\"].GetDouble())\",\n \"def prior(old_params,params):\\n \\n for s in range(len(params)):\\n if params[s] < 0.0 or params[s] > 2:\\n return 0\\n return 1\",\n \"def __init__(self, value):\\n self.value = max(min(value,1.0),-1.0)\",\n \"def __init__(self, value):\\n self.value = max(min(value,1.0),-1.0)\",\n \"def test_early_stopping_call_increasing():\\n early_stopping = learning.EarlyStopping(\\n patience=PATIENCE,\\n decreasing=False,\\n )\\n assert not early_stopping(PATIENCE + 1)\\n for i in range(PATIENCE):\\n assert not early_stopping(i)\\n assert early_stopping(0)\",\n \"def training_policy(self, state):\\n if self.epsilon > random.random():\\n return random.randint(0, 1)\\n return self.policy(state)\",\n \"def cpu_time(self):\",\n \"def inc_latency(self, *_, **__): # pylint: disable=arguments-differ\\n pass\",\n \"def log_prior(self):\\n raise NotImplementedError(\\\"the log_prior property should \\\"\\n \\\"be defined in the Estimator sub-class\\\")\",\n \"def set_value(self, name, val, **kwargs):\\n try:\\n assert self.__started\\n val = float(val)\\n except AssertionError:\\n self.unknown_error(\\\"Start method must be called first!\\\")\\n except (TypeError, ValueError):\\n self.unknown_error(\\\"Performance measures must be numeric!\\\")\\n\\n val_dict = {'val': val, 'min': None, 'max': None, 'scale': None,\\n 'threshold': 1, 'state': 'ok'}\\n\\n if 'lowest' in kwargs:\\n val_dict['min'] = float(kwargs.get('lowest'))\\n\\n if 'highest' in kwargs:\\n val_dict['max'] = float(kwargs.get('highest'))\\n\\n if 'threshold' in kwargs:\\n val_dict['threshold'] = kwargs['threshold']\\n\\n # Nagios actually understands most byte and time oriented scales.\\n # The developer docs also list a counter scale, but we're not certain\\n # if any plugin has ever used that. Only accept known scales.\\n\\n if 'scale' in kwargs:\\n scale = kwargs.get('scale')\\n\\n if scale.upper() in ('B', 'KB', 'MB', 'GB', 'TB'):\\n val_dict['scale'] = scale.upper()\\n elif scale.lower() in ('s', 'ms', 'us', 'ns', '%'):\\n val_dict['scale'] = scale.lower()\\n else:\\n raise ValueError(\\\"\\\"\\\"Scale must be one of: B, KB, MB, GB,\\n TB, s, ms, us, ns, or %.\\\"\\\"\\\")\\n\\n self.__perf[name] = val_dict\\n\\n # We'll use the opportunity to check the status ranges right when the\\n # variable is set so we don't have to loop through all of them later.\\n\\n if len(self.__warning) > 0:\\n self.__verbose_print(\\\"checking warning\\\")\\n self.__check_range('warning', name)\\n\\n if len(self.__critical) > 0:\\n self.__verbose_print(\\\"checking critical\\\")\\n self.__check_range('critical', name)\\n\\n return self.__perf[name]['state']\",\n \"def schedule_variant(epoch):\\n\\n def _linear_annealing(epoch):\\n t = epoch / args.epochs\\n lr_ratio = 0.01\\n if t <= 0.5:\\n factor = 1.0\\n elif t <= 0.9:\\n factor = 1.0 - (1.0 - lr_ratio) * (t - 0.5) / 0.4\\n else:\\n factor = lr_ratio\\n return args.lr_init * factor\\n\\n lr_tmp = _linear_annealing(epoch)\\n if args.swag:\\n if (epoch > args.swag_start) or lr_tmp <= args.swag_lr:\\n return _linear_annealing(args.swag_start)\\n return lr_tmp\",\n \"def set_speed():\\n pass\",\n \"def update_alpha(model):\\n a = model.params.alpha_prior[0]\\n b = model.params.alpha_prior[1]\\n\\n alpha_old = model.params.alpha\\n\\n log_p_old = model.feat_alloc_dist.log_p(model.params)\\n\\n alpha_new = scipy.stats.gamma.rvs(a, scale=(1 / b))\\n\\n model.params.alpha = alpha_new\\n\\n log_p_new = model.feat_alloc_dist.log_p(model.params)\\n\\n if do_metropolis_hastings_accept_reject(log_p_new, log_p_old, 0, 0):\\n model.params.alpha = alpha_new\\n\\n else:\\n model.params.alpha = alpha_old\",\n \"def testHrtPrior(self):\\n attr = self.session.create_visit_attr()\\n\\n self.util.boolTypeTest(self, attr, \\\"prior\\\")\\n\\n self.util.boolPropertyTest(self, attr, \\\"prior\\\")\",\n \"def set_probability_alpha(self, value):\\n self.view_state.alpha = value / 100\",\n \"def _update(self, time_step, **train_kwargs):\\n # training is implied here\\n self.set_t_cutoff(self.cutoff_t + time_step, **train_kwargs)\",\n \"def lnprob_white(params, params_min, params_max, t, f, ferr, expTime):\\n return lnlike_white(params, t, f, ferr, expTime) + lnprior(params, params_min, params_max)\",\n \"def test_change_lower(self):\\n instance = self.traits_instance\\n instance.low = -4.0\\n instance.value = -2\\n self.assertAlmostEqual(instance.value, -2)\",\n \"def test_early_stopping_init_increasing():\\n early_stopping = learning.EarlyStopping(\\n patience=PATIENCE,\\n decreasing=False,\\n )\\n assert early_stopping.patience == PATIENCE\\n assert early_stopping.decreasing is False\\n assert early_stopping.best == float('-inf')\\n assert early_stopping.num_bad == 0\",\n \"def update_relative_weight(self):\\n self.relative_weight = 1\\n # Add up all of the historical cpu datapoints (higher CPU = more weight)\\n for i in self.cpu_datapoints:\\n self.relative_weight += i\\n # Multiply by the status value (so VMs with red alarm have most weight)\\n self.relative_weight *= (self.heartbeat_status * 10)\",\n \"def train(self, x={}, **kwargs):\\n return 0\",\n \"def posterior_sample_parameter(self, parameter):\\n pass\",\n \"def update(self, value):\\n if self._in_concept_change:\\n self.reset()\\n\\n self.miss_prob = self.miss_prob + (value - self.miss_prob) / float(self.sample_count)\\n self.miss_std = np.sqrt(self.miss_prob * (1 - self.miss_prob) / float(self.sample_count))\\n self.sample_count += 1\\n\\n self.estimation = self.miss_prob\\n self._in_concept_change = False\\n self._in_warning_zone = False\\n self.delay = 0\\n\\n if self.sample_count < self.min_num_instances:\\n return self._in_concept_change, self._in_warning_zone\\n\\n if self.miss_prob + self.miss_std <= self.miss_prob_sd_min:\\n self.miss_prob_min = self.miss_prob\\n self.miss_sd_min = self.miss_std\\n self.miss_prob_sd_min = self.miss_prob + self.miss_std\\n\\n if self.miss_prob + self.miss_std > self.miss_prob_min + self.out_control_level \\\\\\n * self.miss_sd_min:\\n self._in_concept_change = True\\n\\n elif self.miss_prob + self.miss_std > self.miss_prob_min + self.warning_level \\\\\\n * self.miss_sd_min:\\n self._in_warning_zone = True\\n\\n else:\\n self._in_warning_zone = False\\n\\n return self._in_concept_change, self._in_warning_zone\",\n \"def __init__(self, label, select_high_quality):\\n self.label = label\\n self.resource = max(0.1, np.random.random_sample()) # let's assume everyone has at least a tenth of the max resource\\n\\n # put x one in each team\\n if select_high_quality and np.random.uniform(0,1) <= PERCENT_INITIAL_HIGH_QUALITY:\\n self.state = np.random.uniform(HIGH_QUALITY_THRESHOLD, 1)\\n else:\\n self.state = np.random.uniform(0, AVERAGE_DOCUMENTATION_FEQUENCY)\\n self.tasks_completed = 0\",\n \"def lnprior(params):\\n a, b, f = params\\n if -10.0 < b < 0. and 0. < a < 10 and 0. < f:\\n return 0.0\\n\\n return -np.inf\",\n \"def set_accuracy_95(num: float) -> float:\\n ...\",\n \"def _onSetParameterLower(self, value):\\n self._parameters['lower'] = min(value, self._parameters['upper']) # Limit at upper\\n self._logger.info(\\\"Parameter 'lower' of function '{}' changed to {}\\\".format(self._function, value))\\n self.functionChanged.emit(self._dim, self._function, self._parameters.copy())\",\n \"def update_learning_rate(self):\\r\\n self.scheduler.step(self.clock.epoch)\",\n \"def conditional_entropy_hyper(self) -> float:\\n pass\",\n \"def set_train_switch(self, switch_val=0.0):\\n if (switch_val < 0.5):\\n switch_val = 0.0\\n else:\\n switch_val = 1.0\\n zero_ary = np.zeros((1,))\\n new_val = zero_ary + switch_val\\n self.train_switch.set_value(to_fX(new_val))\\n return\",\n \"def set_new_random_processing_time(machine_object):\\n if global_settings.processing_time_distribution == \\\"uniform\\\":\\n machine_object.processing_time = \\\\\\n round(random.uniform(\\n machine_object.uniform_processing_time_lower_bound,\\n machine_object.uniform_processing_time_upper_bound))\\n elif global_settings.processing_time_distribution == \\\"exponential\\\":\\n machine_object.processing_time = \\\\\\n get_random_exponential_number(machine_object.exponential_processing_time)\\n else:\\n raise ValueError(\\\"global_settings.processing_time_distribution invalid value assigned. \\\"\\n \\\"Must be 'exponential' or 'uniform'\\\")\\n return\",\n \"def test_PredictionEnsemble_smooth_None(\\r\\n perfectModelEnsemble_initialized_control_1d_ym_cftime,\\r\\n):\\r\\n pm = perfectModelEnsemble_initialized_control_1d_ym_cftime\\r\\n pm_smoothed = pm.smooth(None)\\r\\n assert_PredictionEnsemble(pm, pm_smoothed)\",\n \"def _tune(acc_rate, proposed, step):\\n if step.tune_scaling:\\n # a and b after Muto & Beck 2008.\\n a = 1 / 9\\n b = 8 / 9\\n step.scaling = (a + b * acc_rate) ** 2\\n if step.tune_steps:\\n acc_rate = max(1.0 / proposed, acc_rate)\\n step.n_steps = min(step.max_steps, 1 + int(np.log(step.p_acc_rate) / np.log(1 - acc_rate)))\",\n \"def log_prob(self):\",\n \"def test_trainable_property(self):\\n scalar_weighted_addition_model = ScalarWeightedAddition(10)\\n np.testing.assert_equal(scalar_weighted_addition_model.is_trainable, True)\",\n \"def test_temporal_smoothing_how(perfectModelEnsemble_initialized_control_1d_ym_cftime):\\r\\n pm = perfectModelEnsemble_initialized_control_1d_ym_cftime\\r\\n pm_smoothed_mean = pm.smooth({\\\"lead\\\": 4}, how=\\\"mean\\\")\\r\\n pm_smoothed_sum = pm.smooth({\\\"lead\\\": 4}, how=\\\"sum\\\")\\r\\n assert (\\r\\n pm_smoothed_sum.get_initialized().mean()\\r\\n > pm_smoothed_mean.get_initialized().mean() * 2\\r\\n )\",\n \"def test_am_threshold(Simulator, plt, seed, rng):\\n d = 64\\n vocab = Vocabulary(d, pointer_gen=rng)\\n vocab.populate('A; B; C; D')\\n\\n d2 = int(d / 2)\\n vocab2 = Vocabulary(d2, pointer_gen=rng)\\n vocab2.populate('A; B; C; D')\\n\\n def input_func(t):\\n return '0.49 * A' if t < 0.1 else '0.8 * B'\\n\\n with spa.Network('model', seed=seed) as m:\\n m.am = ThresholdingAssocMem(\\n threshold=0.5, input_vocab=vocab, output_vocab=vocab2,\\n function=filtered_step_fn, mapping='by-key')\\n m.stimulus = spa.Transcode(input_func, output_vocab=vocab)\\n m.stimulus >> m.am\\n\\n in_p = nengo.Probe(m.am.input)\\n out_p = nengo.Probe(m.am.output, synapse=0.03)\\n\\n with Simulator(m) as sim:\\n sim.run(0.3)\\n t = sim.trange()\\n below_th = t < 0.1\\n above_th = t > 0.25\\n\\n plt.subplot(2, 1, 1)\\n plt.plot(t, similarity(sim.data[in_p], vocab))\\n plt.ylabel(\\\"Input\\\")\\n plt.subplot(2, 1, 2)\\n plt.plot(t, similarity(sim.data[out_p], vocab2))\\n plt.plot(t[above_th], np.ones(t.shape)[above_th] * 0.9, c='g', lw=2)\\n plt.ylabel(\\\"Output\\\")\\n\\n assert np.mean(sim.data[out_p][below_th]) < 0.01\\n assert_sp_close(t, sim.data[out_p], vocab2['B'], skip=0.25, duration=0.05)\",\n \"def _soft_update(self, active, target):\\n\\n for t_param, param in zip(target.parameters(), active.parameters()):\\n t_param.data.copy_(self.tau*param.data + (1-self.tau)*t_param.data)\",\n \"def set_prior(self,field):\\n self.observation_thresholds = [i/self.observations for i in range(0,self.observations)]\\n self.observation_samples = 1\\n # TODO: For use after integrating image processing with MCESP for Game-Delayed Reinforcements\\n # self.norm = field.max()\",\n \"def test_instrument_val_invariant_under_delegate_cache_set(\\n make_observable_parameter, numeric_val):\\n initial_value = numeric_val\\n t = make_observable_parameter(\\n 'observable_parameter', initial_value=initial_value)\\n new_source_value = 3\\n t.cache.set(new_source_value)\\n assert t.get_instr_val() == initial_value\",\n \"def __call__(self, score, model):\\n if self.best_score is None:\\n # assign the best score and save the model at the end of the first epoch\\n self.best_score = score\\n self.save_checkpoint(model)\\n elif score < self.best_score + self.delta:\\n # if the score not increase of at least delta, increment the counter and if it reach the patience early stops\\n self.counter += 1\\n if self.counter >= self.patience:\\n self.early_stop = True\\n else:\\n # otherwise the score is better that the saved one, so replace the best score and save the model\\n self.best_score = score\\n self.save_checkpoint(model)\\n self.counter = 0\",\n \"def linear_warmup(base_value, max_warmup_iter, cur_step):\\n if max_warmup_iter <= cur_step:\\n return base_value\\n return base_value * cur_step / max_warmup_iter\",\n \"def is_artificial(self):\\n\\t\\treturn 0\",\n \"def advantage(cpu_dt, gpu_dt):\\r\\n assert gpu_dt >= 0 and cpu_dt >= 0\\r\\n if gpu_dt == 0 and cpu_dt == 0:\\r\\n return numpy.nan\\r\\n elif gpu_dt == 0:\\r\\n return numpy.inf\\r\\n else:\\r\\n return cpu_dt / gpu_dt\",\n \"def speed(self, value: int, /) -> None:\",\n \"def update(self, value):\\n if value < self.min:\\n self.min = value\\n if value > self.max:\\n self.max = value\\n self.total += value\\n self.instances += 1\\n self.values.append(value)\",\n \"def _scheduled_sampling(self):\\n step = tf.train.get_or_create_global_step()\\n step = tf.cast(step, tf.float32)\\n progress = tf.minimum(\\n (step-self.args.warmup_step) / float(self.args.max_step-self.args.warmup_step), 1.0)\\n return tf.minimum(1.0, 1.0 - progress * (1.0 -self.args.min_rate))\",\n \"def test_early_stopping_call_decreasing():\\n early_stopping = learning.EarlyStopping(patience=PATIENCE, decreasing=True)\\n assert not early_stopping(-1)\\n for i in range(PATIENCE):\\n assert not early_stopping(i)\\n assert early_stopping(0)\",\n \"def __init__(self, \\n input_var: tf.Variable, \\n predictions_fn: Callable[[tf.Tensor], tf.Tensor], \\n loss_fn: Callable[[tf.Tensor], tf.Tensor], \\n name: str,\\n damping_factor: float = 1.0, \\n damping_update_factor: float = 0.999, \\n damping_update_frequency: int = 5,\\n update_cond_threshold_low: float = 0.5, \\n update_cond_threshold_high: float = 1.5,\\n damping_threshold_low: float = 1e-7,\\n damping_threshold_high: float = 1e7,\\n alpha_init: float = 1.0, \\n squared_loss: bool = True) -> None:\\n self._name = name\\n self._input_var = input_var\\n \\n self._predictions_fn = predictions_fn\\n self._loss_fn = loss_fn\\n \\n # Multiplicating factor to update the damping factor at the end of each cycle\\n self._damping_update_factor = damping_update_factor\\n self._damping_update_frequency = damping_update_frequency\\n self._update_cond_threshold_low = update_cond_threshold_low\\n self._update_cond_threshold_high = update_cond_threshold_high\\n self._damping_threshold_low = damping_threshold_low\\n self._damping_threshold_high = damping_threshold_high\\n self._squared_loss = squared_loss\\n self._alpha = alpha_init\\n\\n with tf.variable_scope(name):\\n self._predictions_fn_tensor = self._predictions_fn(self._input_var)\\n self._loss_fn_tensor = self._loss_fn(self._predictions_fn_tensor)\\n \\n self._damping_factor = tf.get_variable(\\\"lambda\\\", dtype=tf.float32, \\n initializer=damping_factor)\\n\\n # Variable used for momentum-like updates\\n self._z = tf.get_variable(\\\"z\\\", dtype=tf.float32, \\n initializer=tf.zeros_like(self._input_var))\\n\\n self._dummy_var = tf.get_variable(\\\"dummy\\\", dtype=tf.float32, \\n initializer=tf.zeros_like(self._predictions_fn_tensor))\\n\\n self._loss_before_update = tf.get_variable(\\\"loss_before_update\\\", dtype=tf.float32,\\n initializer=0.)\\n self._iteration = tf.get_variable(\\\"iteration\\\", shape=[], dtype=tf.int64,\\n initializer=tf.zeros_initializer)\\n self._expected_quadratic_change = tf.get_variable(\\\"expected_quadratic_change\\\", \\n dtype=tf.float32,\\n initializer=0.)\\n\\n # Set up the second order calculations\\n self._second_order()\",\n \"def l_point(self):\\n self.l_score += 1\\n self.update()\",\n \"def __init__(self, value=1.0):\\n self.value = value\",\n \"def test_get_hyperflex_feature_limit_external_by_moid(self):\\n pass\",\n \"def likelihood(self, sign_switch, hyperparam):\\n\\n self.timer.tic()\\n\\n if numpy.isscalar(hyperparam):\\n hyperparam_ = numpy.array([hyperparam], dtype=float)\\n else:\\n hyperparam_ = hyperparam\\n\\n # Check if likelihood is already computed for an identical hyperparam\\n if (self.ell is not None) and \\\\\\n (self.ell_hyperparam is not None) and \\\\\\n (hyperparam_.size == self.ell_hyperparam.size) and \\\\\\n numpy.allclose(hyperparam_, self.ell_hyperparam,\\n atol=self.hyperparam_tol):\\n\\n if sign_switch:\\n return -self.ell\\n else:\\n return self.ell\\n\\n # Get eta\\n eta = self._hyperparam_to_eta(hyperparam_)\\n\\n # Extract scale from hyperparam\\n if (not numpy.isscalar(hyperparam_)) and \\\\\\n (hyperparam_.size > self.scale_index):\\n\\n # Set scale of the covariance object\\n scale = self._hyperparam_to_scale(hyperparam_[self.scale_index:])\\n self.mixed_cor.set_scale(scale)\\n\\n if numpy.abs(eta) >= self.max_eta:\\n\\n # Optimal sigma02 when eta is very large\\n sigma02 = self._find_optimal_sigma02()\\n\\n # Log likelihood\\n ell = -0.5*self.rdof * (numpy.log(2.0*numpy.pi) + 1.0 +\\n numpy.log(sigma02))\\n\\n if self.B is None:\\n Cinv = numpy.matmul(self.X.T, self.X)\\n logdet_Cinv = numpy.log(numpy.linalg.det(Cinv))\\n ell += - 0.5*logdet_Cinv\\n # else:\\n # logdet_B = numpy.log(numpy.linalg.det(self.B))\\n # ell += 0.5*logdet_B\\n\\n else:\\n\\n # Update Y, C, Mz (all needed for computing optimal sigma2)\\n self._update_Y_C_Mz(hyperparam_)\\n\\n # Find (or update) optimal sigma2\\n sigma2 = self._find_optimal_sigma2(hyperparam_)\\n\\n logdet_Kn = self.mixed_cor.logdet(eta)\\n logdet_Cinv = numpy.log(numpy.linalg.det(self.Cinv))\\n\\n if numpy.isnan(logdet_Kn):\\n raise RuntimeError('Logdet of \\\"Kn\\\" is nan at eta: %0.3e.'\\n % eta)\\n\\n # Log likelihood\\n ell = -0.5*self.rdof * \\\\\\n (numpy.log(2.0*numpy.pi) + 1.0 + numpy.log(sigma2)) \\\\\\n - 0.5*logdet_Kn - 0.5*logdet_Cinv\\n\\n if self.B is not None:\\n # Note that self.B is indeed B1, that is the matrix B without\\n # sigma**2.\\n logdet_B = numpy.log(numpy.linalg.det(self.B))\\n ell += -0.5*logdet_B\\n\\n # Store ell to member data (without sign-switch).\\n self.ell = ell\\n self.ell_hyperparam = hyperparam_\\n\\n # If ell is used in scipy.optimize.minimize, change the sign to obtain\\n # the minimum of -ell\\n if sign_switch:\\n ell = -ell\\n\\n self.timer.toc()\\n\\n return ell\",\n \"def addHyperparam(self, est, param, hyperParam):\\n self.hyperparams[param] = (est, hyperParam)\\n return self\",\n \"def lnprior(params, params_min, params_max):\\n inSpace = 1\\n for i, p in enumerate(params):\\n inSpace = inSpace * (params_max[i] > p > params_min[i])\\n if inSpace == 0:\\n return -np.inf\\n else:\\n return 0\",\n \"def on_stage_start(self, stage, epoch):\\n if stage != sb.Stage.TRAIN:\\n self.cer_metric = self.hparams.cer_computer()\\n self.wer_metric = self.hparams.error_rate_computer()\",\n \"def test_PredictionEnsemble_goddard(\\r\\n perfectModelEnsemble_initialized_control_1d_ym_cftime, smooth\\r\\n):\\r\\n pm = perfectModelEnsemble_initialized_control_1d_ym_cftime\\r\\n assert pm.smooth(smooth)\",\n \"def __init__(self, *args: Any, **kwargs: Any) -> None:\\n super(LaneInvasionsMetric, self).__init__(initial_value=0)\",\n \"def _perturbInPlaceSoft(self):\\n kevRandom = KevRandom()\\n if random.random() < 0.5:\\n newThreshold = -1\\n while newThreshold < 0 or newThreshold > 1:\\n newThreshold = self.threshold + kevRandom.laplacian() #* 0.1\\n self.threshold = newThreshold\\n else:\\n self.beta += kevRandom.laplacian() #* 0.1\",\n \"def warmup_step(ckpt_step: int) -> float:\\n return ckpt_step * 10\",\n \"def _simIncToPulses(self, speed_inc):\\n top_speed = self.__class__.SPEED_CODES[speed_inc]\\n self.sim_state['top_speed'] = top_speed\\n if self.sim_state['start_speed'] > top_speed:\\n self.sim_state['start_speed'] = top_speed\\n if self.sim_state['cutoff_speed'] > top_speed:\\n self.sim_state['cutoff_speed'] = top_speed\",\n \"def bias_prior(self):\",\n \"def begin_epoch(self, epoch, model):\\n super().begin_epoch(epoch, model)\\n if hasattr(self.criterion, \\\"set_epoch\\\"):\\n self.criterion.set_epoch(epoch)\",\n \"def __init__(self):\\n self.counts = [0] * 10\\n self.values = [0] * 10\\n self.softmaxvalues = [0] * 10\\n self.t = 0.3\",\n \"def test_early_stopping_init_decreasing():\\n early_stopping = learning.EarlyStopping(patience=PATIENCE, decreasing=True)\\n assert early_stopping.patience == PATIENCE\\n assert early_stopping.decreasing is True\\n assert early_stopping.best == float('inf')\\n assert early_stopping.num_bad == 0\",\n \"def __init__(self):\\n super(RobinBoundary, self).__init__()\\n self.value = RobinBoundary.value\\n RobinBoundary.value += 1\\n self.update(param=\\\"1\\\")\",\n \"def test_train_property():\\n atom = ATOMClassifier(X_bin, y_bin, random_state=1)\\n atom.run([\\\"MNB\\\", \\\"LR\\\"])\\n assert atom.train.equals(atom.mnb.train)\\n assert check_scaling(atom.lr.train)\",\n \"def advantage(cpu_dt, gpu_dt):\\n assert gpu_dt >= 0 and cpu_dt >= 0\\n if gpu_dt == 0 and cpu_dt == 0:\\n return numpy.nan\\n elif gpu_dt == 0:\\n return numpy.inf\\n else:\\n return cpu_dt / gpu_dt\",\n \"def witnessValue(self, value):\\n self.numVisits += 1\\n n = self.numVisits\\n self.value = (value + (n-1) * self.value) / n\",\n \"def test_foo(self):\\n self.ran = True\\n 1 / 0\",\n \"def with_cpu(ops, model):\\n ...\",\n \"def set_trial_param(\\n self,\\n trial_id: int,\\n param_name: str,\\n param_value_internal: float,\\n distribution: \\\"distributions.BaseDistribution\\\",\\n ) -> bool:\\n raise NotImplementedError\",\n \"def TrainOneStep(self):\\n pass\",\n \"def train_one_epoch(self):\\n raise NotImplementedError\",\n \"def objective(self, x):\\n pass\",\n \"def objective(self, x):\\n pass\",\n \"def condition(timestep, *_):\\n return tf.less(timestep, tf.shape(score)[1])\",\n \"def softClassify(self, inputValue):\\n result = 1.0 / (1 + math.e ** (-self.beta * (inputValue - self.threshold)))\\n logging.debug(\\\"Classification of %f on value %f for feature %d\\\" %(result, inputValue, self.feature))\\n return result\",\n \"def addAgility(self):\\t\\n\\t\\tself.agility += 1\\n\\t\\tif self.agility > 10:\\n\\t\\t\\tself.agility = 10\",\n \"def setMinValue(self, min_value):\\r\\n\\t\\tself.MinValue = min_value\\r\\n\\t\\tself.OutputValueIncrement = (self.MaxValue - self.MinValue)/(self.RampDuration/self.Ts)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.56833273","0.5587425","0.55274343","0.55222327","0.5340982","0.52688646","0.5254172","0.5253672","0.5252122","0.5175494","0.51732254","0.51373166","0.50936973","0.5061794","0.5060478","0.50589293","0.50571275","0.5055805","0.50344336","0.5032078","0.5024342","0.5020542","0.50141186","0.50141186","0.5005871","0.49992043","0.4996164","0.4994825","0.49861568","0.49849272","0.4981466","0.49803916","0.49782288","0.49639922","0.4959974","0.49276078","0.49232438","0.4920594","0.49128324","0.49116778","0.4909959","0.490721","0.4899213","0.489383","0.4893296","0.4889569","0.4887779","0.48870075","0.48866448","0.48836625","0.4865748","0.48594022","0.48508903","0.4849528","0.48432934","0.48331523","0.48288104","0.48254994","0.4822214","0.48194188","0.48193765","0.4818191","0.481227","0.48065057","0.48029298","0.47981754","0.4797961","0.4797694","0.4784479","0.47792625","0.4776043","0.4775664","0.47725168","0.47725096","0.47702783","0.4770093","0.4759655","0.4750187","0.47486722","0.47450367","0.47441456","0.47423795","0.4740493","0.4740324","0.47400904","0.47328666","0.47309366","0.47302425","0.4727114","0.4726134","0.47244394","0.47213483","0.4721209","0.47197744","0.47196627","0.47196627","0.4719108","0.47173238","0.4716889","0.47129917"],"string":"[\n \"0.56833273\",\n \"0.5587425\",\n \"0.55274343\",\n \"0.55222327\",\n \"0.5340982\",\n \"0.52688646\",\n \"0.5254172\",\n \"0.5253672\",\n \"0.5252122\",\n \"0.5175494\",\n \"0.51732254\",\n \"0.51373166\",\n \"0.50936973\",\n \"0.5061794\",\n \"0.5060478\",\n \"0.50589293\",\n \"0.50571275\",\n \"0.5055805\",\n \"0.50344336\",\n \"0.5032078\",\n \"0.5024342\",\n \"0.5020542\",\n \"0.50141186\",\n \"0.50141186\",\n \"0.5005871\",\n \"0.49992043\",\n \"0.4996164\",\n \"0.4994825\",\n \"0.49861568\",\n \"0.49849272\",\n \"0.4981466\",\n \"0.49803916\",\n \"0.49782288\",\n \"0.49639922\",\n \"0.4959974\",\n \"0.49276078\",\n \"0.49232438\",\n \"0.4920594\",\n \"0.49128324\",\n \"0.49116778\",\n \"0.4909959\",\n \"0.490721\",\n \"0.4899213\",\n \"0.489383\",\n \"0.4893296\",\n \"0.4889569\",\n \"0.4887779\",\n \"0.48870075\",\n \"0.48866448\",\n \"0.48836625\",\n \"0.4865748\",\n \"0.48594022\",\n \"0.48508903\",\n \"0.4849528\",\n \"0.48432934\",\n \"0.48331523\",\n \"0.48288104\",\n \"0.48254994\",\n \"0.4822214\",\n \"0.48194188\",\n \"0.48193765\",\n \"0.4818191\",\n \"0.481227\",\n \"0.48065057\",\n \"0.48029298\",\n \"0.47981754\",\n \"0.4797961\",\n \"0.4797694\",\n \"0.4784479\",\n \"0.47792625\",\n \"0.4776043\",\n \"0.4775664\",\n \"0.47725168\",\n \"0.47725096\",\n \"0.47702783\",\n \"0.4770093\",\n \"0.4759655\",\n \"0.4750187\",\n \"0.47486722\",\n \"0.47450367\",\n \"0.47441456\",\n \"0.47423795\",\n \"0.4740493\",\n \"0.4740324\",\n \"0.47400904\",\n \"0.47328666\",\n \"0.47309366\",\n \"0.47302425\",\n \"0.4727114\",\n \"0.4726134\",\n \"0.47244394\",\n \"0.47213483\",\n \"0.4721209\",\n \"0.47197744\",\n \"0.47196627\",\n \"0.47196627\",\n \"0.4719108\",\n \"0.47173238\",\n \"0.4716889\",\n \"0.47129917\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.48939082"},"document_rank":{"kind":"string","value":"43"}}},{"rowIdx":81982,"cells":{"query":{"kind":"string","value":"Mark a hyperparameter as having a simple monotonic decreasing relationship with both CPU time and the goodness of the model."},"document":{"kind":"string","value":"def inv_patience_param(x):\n # -- TODO: make this do something!\n return x"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def preformance(self, perf):\n self.perf = perf","def __init__(self, time_constant: float, sampling_time: float):\n self.alpha = sampling_time / (time_constant + sampling_time)\n self.state = None","def E_step_precompute(self, model_params, my_suff_stat, my_data):","def mark(self) -> None:\n self.zero = self._monotonic_ms()","def __init__(self):\n super().__init__()\n self.TERRAIN_VARIANCE = 0.0","def update_parameter(self):\n\n if self.testing: # 1. No random choice when testing\n self.epsilon = 0\n else: # 2. Update parameters when learning\n if self.epsilon > 0.:\n self.epsilon -= 0.01\n\n return self.epsilon","def cool(self):\n self.t = self.t - 1","def test_early_stopping_init_decreasing():\n early_stopping = learning.EarlyStopping(patience=PATIENCE, decreasing=True)\n assert early_stopping.patience == PATIENCE\n assert early_stopping.decreasing is True\n assert early_stopping.best == float('inf')\n assert early_stopping.num_bad == 0","def __init__(self, value):\n self.value = max(min(value,1.0),-1.0)","def __init__(self, value):\n self.value = max(min(value,1.0),-1.0)","def update_param(self, name):\n bounds = self.likelihood_param_bounds[name]\n weights = self.get_param_sample_weight(name)\n\n def calculate_nll(value, model, name, bounds, sample):\n if value < bounds[0] or value > bounds[1]:\n return np.inf\n setattr(model, name, value)\n nll = -model.calculate_expected_log_likelihood(sample)\n return nll\n\n value_before = getattr(self.model, name)\n elbo_before = self.model.calculate_expected_log_likelihood(np.ones((self.model.num_segments,), dtype=int))\n\n sample = self._create_sample(weights)\n\n result = scipy.optimize.brute(\n calculate_nll,\n args=(self.model, name, bounds, sample),\n ranges=[bounds],\n full_output=True,\n )\n\n elbo_after = self.model.calculate_expected_log_likelihood(np.ones((self.model.num_segments,), dtype=int))\n if elbo_after < elbo_before:\n print ('[{}] {} rejected, elbo before: {}, after: {}'.format(_gettime(), name, elbo_before, elbo_after))\n setattr(self.model, name, value_before)\n\n else:\n setattr(self.model, name, result[0])","def test_early_stopping_call_decreasing():\n early_stopping = learning.EarlyStopping(patience=PATIENCE, decreasing=True)\n assert not early_stopping(-1)\n for i in range(PATIENCE):\n assert not early_stopping(i)\n assert early_stopping(0)","def _weigh_object(self, host_state, weight_properties):\n return 1.0 * host_state.vcpus_total / max(host_state.vcpus_used, 1)","def prior_sample_parameter(self, parameter):\n pass","def _perturbInPlaceSoft(self):\n kevRandom = KevRandom()\n if random.random() < 0.5:\n newThreshold = -1\n while newThreshold < 0 or newThreshold > 1:\n newThreshold = self.threshold + kevRandom.laplacian() #* 0.1\n self.threshold = newThreshold\n else:\n self.beta += kevRandom.laplacian() #* 0.1","def scheduler(epoch):\n return alpha / (1 + decay_rate * epoch)","def test_early_stopping_init_increasing():\n early_stopping = learning.EarlyStopping(\n patience=PATIENCE,\n decreasing=False,\n )\n assert early_stopping.patience == PATIENCE\n assert early_stopping.decreasing is False\n assert early_stopping.best == float('-inf')\n assert early_stopping.num_bad == 0","def test_early_stopping_call_increasing():\n early_stopping = learning.EarlyStopping(\n patience=PATIENCE,\n decreasing=False,\n )\n assert not early_stopping(PATIENCE + 1)\n for i in range(PATIENCE):\n assert not early_stopping(i)\n assert early_stopping(0)","def test_xx1_thr(self):\n u_spec = leabra.UnitSpec()\n u_spec.act_thr = 0.25\n u = leabra.Unit(spec=u_spec)\n self.assertEqual(u_spec.xx1(-0.1), 0.0)\n self.assertTrue(0.0 < u_spec.xx1(0.1))\n self.assertEqual(u_spec.noisy_xx1(-0.1), 0.0)\n self.assertTrue(0.1 < u_spec.noisy_xx1(0.1))","def set_speed():\n pass","def update_alpha(model):\n a = model.params.alpha_prior[0]\n b = model.params.alpha_prior[1]\n\n alpha_old = model.params.alpha\n\n log_p_old = model.feat_alloc_dist.log_p(model.params)\n\n alpha_new = scipy.stats.gamma.rvs(a, scale=(1 / b))\n\n model.params.alpha = alpha_new\n\n log_p_new = model.feat_alloc_dist.log_p(model.params)\n\n if do_metropolis_hastings_accept_reject(log_p_new, log_p_old, 0, 0):\n model.params.alpha = alpha_new\n\n else:\n model.params.alpha = alpha_old","def lnprob_white(params, params_min, params_max, t, f, ferr, expTime):\n return lnlike_white(params, t, f, ferr, expTime) + lnprior(params, params_min, params_max)","def objective(self, param):\n self.__init__(param, self.data)\n # return self.rmse() + self.penalty()\n return self.rmse() + self.penalty()","def act(self, state, eps=0.):","def posterior_sample_parameter(self, parameter):\n pass","def test_get_hyperflex_feature_limit_external_by_moid(self):\n pass","def test_PredictionEnsemble_smooth_None(\r\n perfectModelEnsemble_initialized_control_1d_ym_cftime,\r\n):\r\n pm = perfectModelEnsemble_initialized_control_1d_ym_cftime\r\n pm_smoothed = pm.smooth(None)\r\n assert_PredictionEnsemble(pm, pm_smoothed)","def conditional_entropy_hyper(self) -> float:\n pass","def test_change_lower(self):\n instance = self.traits_instance\n instance.low = -4.0\n instance.value = -2\n self.assertAlmostEqual(instance.value, -2)","def __init__(self, \n input_var: tf.Variable, \n predictions_fn: Callable[[tf.Tensor], tf.Tensor], \n loss_fn: Callable[[tf.Tensor], tf.Tensor], \n name: str,\n damping_factor: float = 1.0, \n damping_update_factor: float = 0.999, \n damping_update_frequency: int = 5,\n update_cond_threshold_low: float = 0.5, \n update_cond_threshold_high: float = 1.5,\n damping_threshold_low: float = 1e-7,\n damping_threshold_high: float = 1e7,\n alpha_init: float = 1.0, \n squared_loss: bool = True) -> None:\n self._name = name\n self._input_var = input_var\n \n self._predictions_fn = predictions_fn\n self._loss_fn = loss_fn\n \n # Multiplicating factor to update the damping factor at the end of each cycle\n self._damping_update_factor = damping_update_factor\n self._damping_update_frequency = damping_update_frequency\n self._update_cond_threshold_low = update_cond_threshold_low\n self._update_cond_threshold_high = update_cond_threshold_high\n self._damping_threshold_low = damping_threshold_low\n self._damping_threshold_high = damping_threshold_high\n self._squared_loss = squared_loss\n self._alpha = alpha_init\n\n with tf.variable_scope(name):\n self._predictions_fn_tensor = self._predictions_fn(self._input_var)\n self._loss_fn_tensor = self._loss_fn(self._predictions_fn_tensor)\n \n self._damping_factor = tf.get_variable(\"lambda\", dtype=tf.float32, \n initializer=damping_factor)\n\n # Variable used for momentum-like updates\n self._z = tf.get_variable(\"z\", dtype=tf.float32, \n initializer=tf.zeros_like(self._input_var))\n\n self._dummy_var = tf.get_variable(\"dummy\", dtype=tf.float32, \n initializer=tf.zeros_like(self._predictions_fn_tensor))\n\n self._loss_before_update = tf.get_variable(\"loss_before_update\", dtype=tf.float32,\n initializer=0.)\n self._iteration = tf.get_variable(\"iteration\", shape=[], dtype=tf.int64,\n initializer=tf.zeros_initializer)\n self._expected_quadratic_change = tf.get_variable(\"expected_quadratic_change\", \n dtype=tf.float32,\n initializer=0.)\n\n # Set up the second order calculations\n self._second_order()","def advantage(cpu_dt, gpu_dt):\r\n assert gpu_dt >= 0 and cpu_dt >= 0\r\n if gpu_dt == 0 and cpu_dt == 0:\r\n return numpy.nan\r\n elif gpu_dt == 0:\r\n return numpy.inf\r\n else:\r\n return cpu_dt / gpu_dt","def lnprior(params):\n a, b, f = params\n if -10.0 < b < 0. and 0. < a < 10 and 0. < f:\n return 0.0\n\n return -np.inf","def test_get_hyperflex_feature_limit_internal_by_moid(self):\n pass","def _soft_update(self, active, target):\n\n for t_param, param in zip(target.parameters(), active.parameters()):\n t_param.data.copy_(self.tau*param.data + (1-self.tau)*t_param.data)","def _update(self, time_step, **train_kwargs):\n # training is implied here\n self.set_t_cutoff(self.cutoff_t + time_step, **train_kwargs)","def gain_opt(machine, T):\n res = (np.arange(T)+1)\n return res * np.amax(machine)","def __init__(self,\n weight_decay,\n learning_rate,\n momentum,\n use_locking=False,\n name=\"MomentumW\",\n use_nesterov=False):\n super(MomentumWOptimizer, self).__init__(\n weight_decay,\n learning_rate=learning_rate,\n momentum=momentum,\n use_locking=use_locking,\n name=name,\n use_nesterov=use_nesterov)","def set_probability_alpha(self, value):\n self.view_state.alpha = value / 100","def increase_learning(self, factor):\n pass","def set_value(self, name, val, **kwargs):\n try:\n assert self.__started\n val = float(val)\n except AssertionError:\n self.unknown_error(\"Start method must be called first!\")\n except (TypeError, ValueError):\n self.unknown_error(\"Performance measures must be numeric!\")\n\n val_dict = {'val': val, 'min': None, 'max': None, 'scale': None,\n 'threshold': 1, 'state': 'ok'}\n\n if 'lowest' in kwargs:\n val_dict['min'] = float(kwargs.get('lowest'))\n\n if 'highest' in kwargs:\n val_dict['max'] = float(kwargs.get('highest'))\n\n if 'threshold' in kwargs:\n val_dict['threshold'] = kwargs['threshold']\n\n # Nagios actually understands most byte and time oriented scales.\n # The developer docs also list a counter scale, but we're not certain\n # if any plugin has ever used that. Only accept known scales.\n\n if 'scale' in kwargs:\n scale = kwargs.get('scale')\n\n if scale.upper() in ('B', 'KB', 'MB', 'GB', 'TB'):\n val_dict['scale'] = scale.upper()\n elif scale.lower() in ('s', 'ms', 'us', 'ns', '%'):\n val_dict['scale'] = scale.lower()\n else:\n raise ValueError(\"\"\"Scale must be one of: B, KB, MB, GB,\n TB, s, ms, us, ns, or %.\"\"\")\n\n self.__perf[name] = val_dict\n\n # We'll use the opportunity to check the status ranges right when the\n # variable is set so we don't have to loop through all of them later.\n\n if len(self.__warning) > 0:\n self.__verbose_print(\"checking warning\")\n self.__check_range('warning', name)\n\n if len(self.__critical) > 0:\n self.__verbose_print(\"checking critical\")\n self.__check_range('critical', name)\n\n return self.__perf[name]['state']","def objective(hyperparams): \n global iteration #necessary with a global variable because of implementation from hyperopt. \n iteration += 1\n\n result = run_model(hyperparams, iteration)\n loss = -result #transform to loss in order to minimize\n\n return {'loss': loss, 'hyperparams': hyperparams, 'iteration': iteration, 'status': STATUS_OK}","def lapse(self):\n pass","def prior(old_params,params):\n \n for s in range(len(params)):\n if params[s] < 0.0 or params[s] > 2:\n return 0\n return 1","def advantage(cpu_dt, gpu_dt):\n assert gpu_dt >= 0 and cpu_dt >= 0\n if gpu_dt == 0 and cpu_dt == 0:\n return numpy.nan\n elif gpu_dt == 0:\n return numpy.inf\n else:\n return cpu_dt / gpu_dt","def log_prior(self, params):","def schedule_variant(epoch):\n\n def _linear_annealing(epoch):\n t = epoch / args.epochs\n lr_ratio = 0.01\n if t <= 0.5:\n factor = 1.0\n elif t <= 0.9:\n factor = 1.0 - (1.0 - lr_ratio) * (t - 0.5) / 0.4\n else:\n factor = lr_ratio\n return args.lr_init * factor\n\n lr_tmp = _linear_annealing(epoch)\n if args.swag:\n if (epoch > args.swag_start) or lr_tmp <= args.swag_lr:\n return _linear_annealing(args.swag_start)\n return lr_tmp","def __init__(self):\n super(SteklovBoundary, self).__init__()\n self.value = SteklovBoundary.value\n SteklovBoundary.value -= 1\n self.update(param=\"1\")","def likelihood(self, sign_switch, hyperparam):\n\n self.timer.tic()\n\n if numpy.isscalar(hyperparam):\n hyperparam_ = numpy.array([hyperparam], dtype=float)\n else:\n hyperparam_ = hyperparam\n\n # Check if likelihood is already computed for an identical hyperparam\n if (self.ell is not None) and \\\n (self.ell_hyperparam is not None) and \\\n (hyperparam_.size == self.ell_hyperparam.size) and \\\n numpy.allclose(hyperparam_, self.ell_hyperparam,\n atol=self.hyperparam_tol):\n\n if sign_switch:\n return -self.ell\n else:\n return self.ell\n\n # Get eta\n eta = self._hyperparam_to_eta(hyperparam_)\n\n # Extract scale from hyperparam\n if (not numpy.isscalar(hyperparam_)) and \\\n (hyperparam_.size > self.scale_index):\n\n # Set scale of the covariance object\n scale = self._hyperparam_to_scale(hyperparam_[self.scale_index:])\n self.mixed_cor.set_scale(scale)\n\n if numpy.abs(eta) >= self.max_eta:\n\n # Optimal sigma02 when eta is very large\n sigma02 = self._find_optimal_sigma02()\n\n # Log likelihood\n ell = -0.5*self.rdof * (numpy.log(2.0*numpy.pi) + 1.0 +\n numpy.log(sigma02))\n\n if self.B is None:\n Cinv = numpy.matmul(self.X.T, self.X)\n logdet_Cinv = numpy.log(numpy.linalg.det(Cinv))\n ell += - 0.5*logdet_Cinv\n # else:\n # logdet_B = numpy.log(numpy.linalg.det(self.B))\n # ell += 0.5*logdet_B\n\n else:\n\n # Update Y, C, Mz (all needed for computing optimal sigma2)\n self._update_Y_C_Mz(hyperparam_)\n\n # Find (or update) optimal sigma2\n sigma2 = self._find_optimal_sigma2(hyperparam_)\n\n logdet_Kn = self.mixed_cor.logdet(eta)\n logdet_Cinv = numpy.log(numpy.linalg.det(self.Cinv))\n\n if numpy.isnan(logdet_Kn):\n raise RuntimeError('Logdet of \"Kn\" is nan at eta: %0.3e.'\n % eta)\n\n # Log likelihood\n ell = -0.5*self.rdof * \\\n (numpy.log(2.0*numpy.pi) + 1.0 + numpy.log(sigma2)) \\\n - 0.5*logdet_Kn - 0.5*logdet_Cinv\n\n if self.B is not None:\n # Note that self.B is indeed B1, that is the matrix B without\n # sigma**2.\n logdet_B = numpy.log(numpy.linalg.det(self.B))\n ell += -0.5*logdet_B\n\n # Store ell to member data (without sign-switch).\n self.ell = ell\n self.ell_hyperparam = hyperparam_\n\n # If ell is used in scipy.optimize.minimize, change the sign to obtain\n # the minimum of -ell\n if sign_switch:\n ell = -ell\n\n self.timer.toc()\n\n return ell","def set_hyperparams(self, params):","def update(self, value):\n if self._in_concept_change:\n self.reset()\n\n self.miss_prob = self.miss_prob + (value - self.miss_prob) / float(self.sample_count)\n self.miss_std = np.sqrt(self.miss_prob * (1 - self.miss_prob) / float(self.sample_count))\n self.sample_count += 1\n\n self.estimation = self.miss_prob\n self._in_concept_change = False\n self._in_warning_zone = False\n self.delay = 0\n\n if self.sample_count < self.min_num_instances:\n return self._in_concept_change, self._in_warning_zone\n\n if self.miss_prob + self.miss_std <= self.miss_prob_sd_min:\n self.miss_prob_min = self.miss_prob\n self.miss_sd_min = self.miss_std\n self.miss_prob_sd_min = self.miss_prob + self.miss_std\n\n if self.miss_prob + self.miss_std > self.miss_prob_min + self.out_control_level \\\n * self.miss_sd_min:\n self._in_concept_change = True\n\n elif self.miss_prob + self.miss_std > self.miss_prob_min + self.warning_level \\\n * self.miss_sd_min:\n self._in_warning_zone = True\n\n else:\n self._in_warning_zone = False\n\n return self._in_concept_change, self._in_warning_zone","def test_PredictionEnsemble_goddard(\r\n perfectModelEnsemble_initialized_control_1d_ym_cftime, smooth\r\n):\r\n pm = perfectModelEnsemble_initialized_control_1d_ym_cftime\r\n assert pm.smooth(smooth)","def optim_func(params, model):\n if model.model == 'ARD':\n model.alpha, model.beta = params\n lik = model.pruning_algorithm()\n\n else:\n model.alpha = params[0]\n lik = model.pruning_algorithm()\n \n return -lik","def speed(self, value: int, /) -> None:","def _single_early_stopping_opt(study, trial):\n\n # Record first as best score\n if study.best_score is None:\n study.best_score = study.best_value\n\n # Record better value and reset count\n if study.best_value > study.best_score:\n study.best_score = study.best_value\n study.early_stop_count = 0\n\n # If count greater than user defined stop, raise error to stop\n else:\n if study.early_stop_count > study.early_stop:\n study.early_stop_count = 0\n raise optuna.exceptions.OptunaError\n else:\n study.early_stop_count = study.early_stop_count+1\n return","def patience_param(x):\n # -- TODO: make this do something!\n return x","def test_temporal_smoothing_how(perfectModelEnsemble_initialized_control_1d_ym_cftime):\r\n pm = perfectModelEnsemble_initialized_control_1d_ym_cftime\r\n pm_smoothed_mean = pm.smooth({\"lead\": 4}, how=\"mean\")\r\n pm_smoothed_sum = pm.smooth({\"lead\": 4}, how=\"sum\")\r\n assert (\r\n pm_smoothed_sum.get_initialized().mean()\r\n > pm_smoothed_mean.get_initialized().mean() * 2\r\n )","def test_param(self):\n Y, T, X, _ = ihdp_surface_B()\n est = AutomatedLinearDML(model_y=automl_model_reg(),\n model_t=GradientBoostingClassifier(),\n featurizer=None,\n discrete_treatment=True)\n est.fit(Y, T, X=X)\n _ = est.effect(X)","def test_update_hyperflex_feature_limit_internal(self):\n pass","def elasticnet(parameter, bias=None, reg=0.01, lr=0.1, gamma=1.0):\n if gamma < 0.0:\n print(\"Warning, gamma should be positive. Otherwise you are not shrinking.\")\n #TODO: Is gamma of 1.0 a good value?\n Norm = reg*lr*gamma\n l1(parameter, bias, reg, lr)\n update_w = (1.0/(1.0 + Norm))*parameter\n parameter.data = update_w\n if bias is not None:\n update_b = (1.0/(1.0 + Norm))*bias\n bias.data = update_b","def test_am_threshold(Simulator, plt, seed, rng):\n d = 64\n vocab = Vocabulary(d, pointer_gen=rng)\n vocab.populate('A; B; C; D')\n\n d2 = int(d / 2)\n vocab2 = Vocabulary(d2, pointer_gen=rng)\n vocab2.populate('A; B; C; D')\n\n def input_func(t):\n return '0.49 * A' if t < 0.1 else '0.8 * B'\n\n with spa.Network('model', seed=seed) as m:\n m.am = ThresholdingAssocMem(\n threshold=0.5, input_vocab=vocab, output_vocab=vocab2,\n function=filtered_step_fn, mapping='by-key')\n m.stimulus = spa.Transcode(input_func, output_vocab=vocab)\n m.stimulus >> m.am\n\n in_p = nengo.Probe(m.am.input)\n out_p = nengo.Probe(m.am.output, synapse=0.03)\n\n with Simulator(m) as sim:\n sim.run(0.3)\n t = sim.trange()\n below_th = t < 0.1\n above_th = t > 0.25\n\n plt.subplot(2, 1, 1)\n plt.plot(t, similarity(sim.data[in_p], vocab))\n plt.ylabel(\"Input\")\n plt.subplot(2, 1, 2)\n plt.plot(t, similarity(sim.data[out_p], vocab2))\n plt.plot(t[above_th], np.ones(t.shape)[above_th] * 0.9, c='g', lw=2)\n plt.ylabel(\"Output\")\n\n assert np.mean(sim.data[out_p][below_th]) < 0.01\n assert_sp_close(t, sim.data[out_p], vocab2['B'], skip=0.25, duration=0.05)","def __init__(self):\n self.counts = [0] * 10\n self.values = [0] * 10\n self.softmaxvalues = [0] * 10\n self.t = 0.3","def __call__(self, param):\n count = param.nbatch\n if self.last_count > count:\n self.init = False\n self.last_count = count\n\n if self.init:\n if count % self.frequent == 0:\n # #11504\n try:\n speed = self.frequent * self.batch_size / (time.time() - self.tic)\n except ZeroDivisionError:\n speed = float('inf')\n if param.eval_metric is not None:\n name_value = param.eval_metric.get_name_value()\n if self.auto_reset:\n param.eval_metric.reset()\n msg = 'Epoch[%d] Batch [%d-%d]\\tSpeed: %.2f samples/sec'\n msg += '\\t%s=%f'*len(name_value)\n logging.info(msg, param.epoch, count-self.frequent, count, speed, *sum(name_value, ()))\n else:\n msg = 'Epoch[%d] Batch [0-%d]\\tSpeed: %.2f samples/sec'\n msg += '\\t%s=%f'*len(name_value)\n logging.info(msg, param.epoch, count, speed, *sum(name_value, ()))\n else:\n logging.info(\"Iter[%d] Batch [%d]\\tSpeed: %.2f samples/sec\",\n param.epoch, count, speed)\n self.tic = time.time()\n else:\n self.init = True\n self.tic = time.time()","def obs_avoid(z):\n while regions['front'] < 8:\n speed.linear.x = 0\n speed.angular.z = z\n pub.publish(speed)\n rate.sleep()\n speed.linear.x = 1.3\n speed.angular.z = 0\n pub.publish(speed)\n rate.sleep()\n rospy.sleep(2)","def set_speed(self,value):\n if (value>self.get_max_speed()):\n print \"asked to set the speed to %f but the max speed is %f\\n\" % (value,self.get_max_speed())\n else:\n return self.put_par(\"slew_speed\",value)","def bernoulli_episode_scheduler(keep_probability: float) -> Scheduler:\n if keep_probability < 0.0 or keep_probability > 1.0:\n raise ValueError(\n f'keep_probability must be in [0,1], got: {keep_probability}')\n\n def f(data: step_data.StepData) -> bool:\n if data.timestep.last():\n f.current_p = np.random.random()\n return f.current_p < keep_probability\n\n f.current_p = np.random.random()\n\n return f","def update_learning_rate(self):\r\n self.scheduler.step(self.clock.epoch)","def __init__(self):\n super().__init__()\n self.dynamic = True # from base class, indicates time-dependence is handled internally\n self.numBins = None # integer number of bins to use in creating the duration curve. TODO default?\n self.targets = None # list of strings, variables to apply postprocessor to","def log_prob(self):","def __call__(self, param):\n count = param.nbatch\n if self.last_count > count:\n self.init = False\n self.last_count = count\n\n if self.init:\n if count % self.frequent == 0:\n speed = self.frequent * self.batch_size / (time.time() - self.tic)\n s = ''\n if param.eval_metric is not None:\n name, value = param.eval_metric.get()\n s = \"Epoch[%d] Batch [%d]\\tSpeed: %.2f samples/sec\\tTrain-\" % (param.epoch, count, speed)\n for n, v in zip(name, value):\n s += \"%s=%f,\\t\" % (n, v)\n else:\n s = \"Iter[%d] Batch [%d]\\tSpeed: %.2f samples/sec\" % (param.epoch, count, speed)\n\n logging.info(s)\n print(s)\n self.tic = time.time()\n else:\n self.init = True\n self.tic = time.time()","def testHrtPrior(self):\n attr = self.session.create_visit_attr()\n\n self.util.boolTypeTest(self, attr, \"prior\")\n\n self.util.boolPropertyTest(self, attr, \"prior\")","def __init__(self):\n super().__init__()\n self.nan_penalty = nan_penalty\n self.nan_tol = nan_tol","def stop(self, metric, model, metric_type='better_decrease', delta=0.03):\n self.delta = delta\n delta = self.delta * metric\n\n if self.best_score is None:\n self.best_score = metric\n self.save_model_state(metric, model)\n return False\n\n if abs(metric - self.best_score) < self.delta/3 * metric:\n self.num_const_scores += 1\n if self.num_const_scores >= self.wait_epochs + 1:\n print('\\nTraining stoped by EarlyStopping')\n return True\n else:\n self.num_const_scores = 0\n\n if metric_type == 'better_decrease':\n if metric > self.best_score + delta:\n self.num_bad_scores += 1\n elif metric > self.best_score:\n self.num_bad_scores = 0\n else:\n self.best_score = metric\n self.save_model_state(metric, model)\n self.num_bad_scores = 0\n\n else:\n if metric < self.best_score - delta:\n self.num_bad_scores += 1\n elif metric < self.best_score:\n self.num_bad_scores = 0\n else:\n self.best_score = metric\n self.save_model_state(metric, model)\n self.num_bad_scores = 0\n\n if self.num_bad_scores >= self.wait_epochs:\n print('\\nTraining stoped by EarlyStopping')\n return True\n\n\n return False","def bias_prior(self):","def training_policy(self, state):\n if self.epsilon > random.random():\n return random.randint(0, 1)\n return self.policy(state)","def test_soft_threshold():\n assert snet.soft_threshold(10, 100) == 0\n assert snet.soft_threshold(-10, 100) == 0\n assert snet.soft_threshold(10, 3) == 7\n assert snet.soft_threshold(-10, 3) == -7","def _onSetParameterLower(self, value):\n self._parameters['lower'] = min(value, self._parameters['upper']) # Limit at upper\n self._logger.info(\"Parameter 'lower' of function '{}' changed to {}\".format(self._function, value))\n self.functionChanged.emit(self._dim, self._function, self._parameters.copy())","def set_accuracy_95(num: float) -> float:\n ...","def is_artificial(self):\n\t\treturn 0","def ModifyInitialProperties(self):\n super().ModifyInitialProperties()\n for aux_process in self.project_parameters[\"processes\"][\"auxiliar_process_list\"]:\n if aux_process[\"python_module\"].GetString() == \"temporal_statistics_process\":\n aux_process[\"Parameters\"][\"statistics_start_point_control_value\"].SetDouble(self.project_parameters[\"problem_data\"][\"burnin_time\"].GetDouble())","def softClassify(self, inputValue):\n result = 1.0 / (1 + math.e ** (-self.beta * (inputValue - self.threshold)))\n logging.debug(\"Classification of %f on value %f for feature %d\" %(result, inputValue, self.feature))\n return result","def __call__(self, epoch):\n exp = np.floor((1 + epoch) / self.dropEvery)\n alpha = initAlpha * (self.factor ** exp)\n \n # return alpha \n return float(alpha)","def _momentum_update(self):\n for param_ol, param_tgt in zip(self.online_net.parameters(),\n self.target_net.parameters()):\n param_tgt.data = param_tgt.data * self.momentum + \\\n param_ol.data * (1. - self.momentum)","def test_fast_growth_default(model, reaction_id):\n reaction = model.reactions.get_by_id(reaction_id)\n model.objective = reaction\n try:\n model.slim_optimize()\n flux = reaction.flux\n except Infeasible:\n flux = np.nan\n assert flux <= 10.3972","def check_params(self, model_params):\n\n comm = self.comm\n for param, policy in self.noise_policy.items():\n low_bound, up_bound, absify, low_bound_diagonal = policy\n new_pvalue = model_params[param]\n if np.isscalar(new_pvalue): # Param to be noisified is scalar\n if comm.rank == 0:\n if new_pvalue < low_bound:\n print(\"check_params: Reset lower bound of %s\" % param)\n new_pvalue = low_bound\n if new_pvalue >= up_bound:\n print(\"check_params: Reset upper bound of %s\" % param)\n new_pvalue = up_bound\n if absify:\n print(\"check_params: Taking abs of %s\" % param)\n new_pvalue = np.abs(new_pvalue)\n if (\n low_bound_diagonal is not None\n ): # when using isotropic instead of full matrix\n if new_pvalue < low_bound_diagonal:\n print(\"check_params: Reset lower bound of %s (diagonal)\" % param)\n new_pvalue = low_bound_diagonal\n new_pvalue = comm.bcast(new_pvalue)\n else:\n if comm.rank == 0:\n if (new_pvalue < low_bound).any():\n print(\"check_params: Reset lower bound of %s\" % param)\n if (new_pvalue >= up_bound).any():\n print(\"check_params: Reset upper bound of %s\" % param)\n new_pvalue = np.maximum(low_bound, new_pvalue)\n new_pvalue = np.minimum(up_bound, new_pvalue)\n if absify:\n print(\"check_params: Taking abs of %s\" % param)\n new_pvalue = np.abs(new_pvalue)\n if low_bound_diagonal is not None:\n mask = np.diag(new_pvalue) < low_bound_diagonal\n if mask.any():\n print(\"check_params: Reset lower bound of %s (diagonal)\" % param)\n new_pvalue[np.diag(mask)] = low_bound_diagonal\n comm.Bcast([new_pvalue, MPI.DOUBLE])\n model_params[param] = new_pvalue\n\n return model_params","def freq_optimization(self):\n index = identify_scale(self.vz, True)\n # In case the patient is limping\n if index > 35:\n index = index / 2\n print(f\"Scale used is {index}\")","def update_threshold(self, activation_time):\n \n if self.model_type == 'linear':\n if(activation_time > 0):\n self.curr_threshold = (self.threshold +\n (1-self.threshold)*(1-activation_time/\n (self.t_max)))\n else:\n self.curr_threshold = self.threshold\n elif self.model_type == 'quadratic':\n if(activation_time > 0):\n self.curr_threshold = (self.threshold +\n (1-self.threshold)*(1-(activation_time/\n (self.t_max))**2))\n else:\n self.currthreshold = self.threshold","def on_epoch_start(self, state: _State):\n optimizer = self._optimizer\n\n if self.decouple_weight_decay:\n self._optimizer_wd = [\n group.get(\"weight_decay\", 0.0)\n for group in optimizer.param_groups\n ]\n for i in range(len(optimizer.param_groups)):\n optimizer.param_groups[i][\"weight_decay\"] = 0.0\n else:\n self._optimizer_wd = [0.0] * len(optimizer.param_groups)","def __init__(self,tau = 1e-3):\n self._tau = tau \n pass","def __init__(self, label, select_high_quality):\n self.label = label\n self.resource = max(0.1, np.random.random_sample()) # let's assume everyone has at least a tenth of the max resource\n\n # put x one in each team\n if select_high_quality and np.random.uniform(0,1) <= PERCENT_INITIAL_HIGH_QUALITY:\n self.state = np.random.uniform(HIGH_QUALITY_THRESHOLD, 1)\n else:\n self.state = np.random.uniform(0, AVERAGE_DOCUMENTATION_FEQUENCY)\n self.tasks_completed = 0","def warmup_step(ckpt_step: int) -> float:\n return ckpt_step * 10","def test_update_hyperflex_feature_limit_external(self):\n pass","def __call__(self, score, model):\n if self.best_score is None:\n # assign the best score and save the model at the end of the first epoch\n self.best_score = score\n self.save_checkpoint(model)\n elif score < self.best_score + self.delta:\n # if the score not increase of at least delta, increment the counter and if it reach the patience early stops\n self.counter += 1\n if self.counter >= self.patience:\n self.early_stop = True\n else:\n # otherwise the score is better that the saved one, so replace the best score and save the model\n self.best_score = score\n self.save_checkpoint(model)\n self.counter = 0","def constraint(arg: tp.Any) -> bool: # pylint: disable=unused-argument\n return bool(optimizer.parametrization.random_state.rand() > 0.8)","def _tune(acc_rate, proposed, step):\n if step.tune_scaling:\n # a and b after Muto & Beck 2008.\n a = 1 / 9\n b = 8 / 9\n step.scaling = (a + b * acc_rate) ** 2\n if step.tune_steps:\n acc_rate = max(1.0 / proposed, acc_rate)\n step.n_steps = min(step.max_steps, 1 + int(np.log(step.p_acc_rate) / np.log(1 - acc_rate)))","def bernoulli_step_scheduler(keep_probability: float) -> Scheduler:\n if keep_probability < 0.0 or keep_probability > 1.0:\n raise ValueError(\n f'keep_probability must be in [0,1], got: {keep_probability}')\n\n def f(unused_data: step_data.StepData) -> bool:\n return np.random.random() < keep_probability\n\n return f","def step(self):\n\n self.compute_lr()\n\n self.optimizer.param_groups[self.param_group]['lr'] = self.lr\n self.optimizer.param_groups[self.param_group]['momentum'] = self.momentum","def test_am_threshold(Simulator, plt, seed, rng):\n D = 64\n vocab = Vocabulary(D, rng=rng)\n vocab.parse('A+B+C+D')\n\n D2 = int(D / 2)\n vocab2 = Vocabulary(D2, rng=rng)\n vocab2.parse('A+B+C+D')\n\n def input_func(t):\n return vocab.parse('0.49*A').v if t < 0.1 else vocab.parse('0.8*A').v\n\n with nengo.Network('model', seed=seed) as m:\n am = AssociativeMemory(vocab, vocab2, threshold=0.5)\n in_node = nengo.Node(output=input_func, label='input')\n nengo.Connection(in_node, am.input)\n\n in_p = nengo.Probe(in_node)\n out_p = nengo.Probe(am.output, synapse=0.03)\n\n sim = Simulator(m)\n sim.run(0.3)\n t = sim.trange()\n below_th = t < 0.1\n above_th = t > 0.25\n\n plt.subplot(2, 1, 1)\n plt.plot(t, nengo.spa.similarity(sim.data[in_p], vocab))\n plt.ylabel(\"Input\")\n plt.legend(vocab.keys, loc='best')\n plt.subplot(2, 1, 2)\n plt.plot(t, nengo.spa.similarity(sim.data[out_p], vocab2))\n plt.plot(t[above_th], np.ones(t.shape)[above_th] * 0.8, c='g', lw=2)\n plt.ylabel(\"Output\")\n plt.legend(vocab.keys, loc='best')\n\n assert similarity(sim.data[in_p][below_th], vocab.parse(\"A\").v) > 0.48\n assert similarity(sim.data[in_p][above_th], vocab.parse(\"A\").v) > 0.79\n assert similarity(sim.data[out_p][below_th], vocab2.parse(\"0\").v) < 0.01\n assert similarity(sim.data[out_p][above_th], vocab2.parse(\"A\").v) > 0.79","def get_learning_rate():\n return 0.00001","def __init__(self, value=1.0):\n self.value = value","def schedule(epoch):\n return alpha / (1 + (decay_rate * epoch))","def visit_softmax_temperature_fn(self, trained_steps):\n if trained_steps < 0.5 * self.training_steps:\n return 1.0\n elif trained_steps < 0.75 * self.training_steps:\n return 0.5\n else:\n return 0.25"],"string":"[\n \"def preformance(self, perf):\\n self.perf = perf\",\n \"def __init__(self, time_constant: float, sampling_time: float):\\n self.alpha = sampling_time / (time_constant + sampling_time)\\n self.state = None\",\n \"def E_step_precompute(self, model_params, my_suff_stat, my_data):\",\n \"def mark(self) -> None:\\n self.zero = self._monotonic_ms()\",\n \"def __init__(self):\\n super().__init__()\\n self.TERRAIN_VARIANCE = 0.0\",\n \"def update_parameter(self):\\n\\n if self.testing: # 1. No random choice when testing\\n self.epsilon = 0\\n else: # 2. Update parameters when learning\\n if self.epsilon > 0.:\\n self.epsilon -= 0.01\\n\\n return self.epsilon\",\n \"def cool(self):\\n self.t = self.t - 1\",\n \"def test_early_stopping_init_decreasing():\\n early_stopping = learning.EarlyStopping(patience=PATIENCE, decreasing=True)\\n assert early_stopping.patience == PATIENCE\\n assert early_stopping.decreasing is True\\n assert early_stopping.best == float('inf')\\n assert early_stopping.num_bad == 0\",\n \"def __init__(self, value):\\n self.value = max(min(value,1.0),-1.0)\",\n \"def __init__(self, value):\\n self.value = max(min(value,1.0),-1.0)\",\n \"def update_param(self, name):\\n bounds = self.likelihood_param_bounds[name]\\n weights = self.get_param_sample_weight(name)\\n\\n def calculate_nll(value, model, name, bounds, sample):\\n if value < bounds[0] or value > bounds[1]:\\n return np.inf\\n setattr(model, name, value)\\n nll = -model.calculate_expected_log_likelihood(sample)\\n return nll\\n\\n value_before = getattr(self.model, name)\\n elbo_before = self.model.calculate_expected_log_likelihood(np.ones((self.model.num_segments,), dtype=int))\\n\\n sample = self._create_sample(weights)\\n\\n result = scipy.optimize.brute(\\n calculate_nll,\\n args=(self.model, name, bounds, sample),\\n ranges=[bounds],\\n full_output=True,\\n )\\n\\n elbo_after = self.model.calculate_expected_log_likelihood(np.ones((self.model.num_segments,), dtype=int))\\n if elbo_after < elbo_before:\\n print ('[{}] {} rejected, elbo before: {}, after: {}'.format(_gettime(), name, elbo_before, elbo_after))\\n setattr(self.model, name, value_before)\\n\\n else:\\n setattr(self.model, name, result[0])\",\n \"def test_early_stopping_call_decreasing():\\n early_stopping = learning.EarlyStopping(patience=PATIENCE, decreasing=True)\\n assert not early_stopping(-1)\\n for i in range(PATIENCE):\\n assert not early_stopping(i)\\n assert early_stopping(0)\",\n \"def _weigh_object(self, host_state, weight_properties):\\n return 1.0 * host_state.vcpus_total / max(host_state.vcpus_used, 1)\",\n \"def prior_sample_parameter(self, parameter):\\n pass\",\n \"def _perturbInPlaceSoft(self):\\n kevRandom = KevRandom()\\n if random.random() < 0.5:\\n newThreshold = -1\\n while newThreshold < 0 or newThreshold > 1:\\n newThreshold = self.threshold + kevRandom.laplacian() #* 0.1\\n self.threshold = newThreshold\\n else:\\n self.beta += kevRandom.laplacian() #* 0.1\",\n \"def scheduler(epoch):\\n return alpha / (1 + decay_rate * epoch)\",\n \"def test_early_stopping_init_increasing():\\n early_stopping = learning.EarlyStopping(\\n patience=PATIENCE,\\n decreasing=False,\\n )\\n assert early_stopping.patience == PATIENCE\\n assert early_stopping.decreasing is False\\n assert early_stopping.best == float('-inf')\\n assert early_stopping.num_bad == 0\",\n \"def test_early_stopping_call_increasing():\\n early_stopping = learning.EarlyStopping(\\n patience=PATIENCE,\\n decreasing=False,\\n )\\n assert not early_stopping(PATIENCE + 1)\\n for i in range(PATIENCE):\\n assert not early_stopping(i)\\n assert early_stopping(0)\",\n \"def test_xx1_thr(self):\\n u_spec = leabra.UnitSpec()\\n u_spec.act_thr = 0.25\\n u = leabra.Unit(spec=u_spec)\\n self.assertEqual(u_spec.xx1(-0.1), 0.0)\\n self.assertTrue(0.0 < u_spec.xx1(0.1))\\n self.assertEqual(u_spec.noisy_xx1(-0.1), 0.0)\\n self.assertTrue(0.1 < u_spec.noisy_xx1(0.1))\",\n \"def set_speed():\\n pass\",\n \"def update_alpha(model):\\n a = model.params.alpha_prior[0]\\n b = model.params.alpha_prior[1]\\n\\n alpha_old = model.params.alpha\\n\\n log_p_old = model.feat_alloc_dist.log_p(model.params)\\n\\n alpha_new = scipy.stats.gamma.rvs(a, scale=(1 / b))\\n\\n model.params.alpha = alpha_new\\n\\n log_p_new = model.feat_alloc_dist.log_p(model.params)\\n\\n if do_metropolis_hastings_accept_reject(log_p_new, log_p_old, 0, 0):\\n model.params.alpha = alpha_new\\n\\n else:\\n model.params.alpha = alpha_old\",\n \"def lnprob_white(params, params_min, params_max, t, f, ferr, expTime):\\n return lnlike_white(params, t, f, ferr, expTime) + lnprior(params, params_min, params_max)\",\n \"def objective(self, param):\\n self.__init__(param, self.data)\\n # return self.rmse() + self.penalty()\\n return self.rmse() + self.penalty()\",\n \"def act(self, state, eps=0.):\",\n \"def posterior_sample_parameter(self, parameter):\\n pass\",\n \"def test_get_hyperflex_feature_limit_external_by_moid(self):\\n pass\",\n \"def test_PredictionEnsemble_smooth_None(\\r\\n perfectModelEnsemble_initialized_control_1d_ym_cftime,\\r\\n):\\r\\n pm = perfectModelEnsemble_initialized_control_1d_ym_cftime\\r\\n pm_smoothed = pm.smooth(None)\\r\\n assert_PredictionEnsemble(pm, pm_smoothed)\",\n \"def conditional_entropy_hyper(self) -> float:\\n pass\",\n \"def test_change_lower(self):\\n instance = self.traits_instance\\n instance.low = -4.0\\n instance.value = -2\\n self.assertAlmostEqual(instance.value, -2)\",\n \"def __init__(self, \\n input_var: tf.Variable, \\n predictions_fn: Callable[[tf.Tensor], tf.Tensor], \\n loss_fn: Callable[[tf.Tensor], tf.Tensor], \\n name: str,\\n damping_factor: float = 1.0, \\n damping_update_factor: float = 0.999, \\n damping_update_frequency: int = 5,\\n update_cond_threshold_low: float = 0.5, \\n update_cond_threshold_high: float = 1.5,\\n damping_threshold_low: float = 1e-7,\\n damping_threshold_high: float = 1e7,\\n alpha_init: float = 1.0, \\n squared_loss: bool = True) -> None:\\n self._name = name\\n self._input_var = input_var\\n \\n self._predictions_fn = predictions_fn\\n self._loss_fn = loss_fn\\n \\n # Multiplicating factor to update the damping factor at the end of each cycle\\n self._damping_update_factor = damping_update_factor\\n self._damping_update_frequency = damping_update_frequency\\n self._update_cond_threshold_low = update_cond_threshold_low\\n self._update_cond_threshold_high = update_cond_threshold_high\\n self._damping_threshold_low = damping_threshold_low\\n self._damping_threshold_high = damping_threshold_high\\n self._squared_loss = squared_loss\\n self._alpha = alpha_init\\n\\n with tf.variable_scope(name):\\n self._predictions_fn_tensor = self._predictions_fn(self._input_var)\\n self._loss_fn_tensor = self._loss_fn(self._predictions_fn_tensor)\\n \\n self._damping_factor = tf.get_variable(\\\"lambda\\\", dtype=tf.float32, \\n initializer=damping_factor)\\n\\n # Variable used for momentum-like updates\\n self._z = tf.get_variable(\\\"z\\\", dtype=tf.float32, \\n initializer=tf.zeros_like(self._input_var))\\n\\n self._dummy_var = tf.get_variable(\\\"dummy\\\", dtype=tf.float32, \\n initializer=tf.zeros_like(self._predictions_fn_tensor))\\n\\n self._loss_before_update = tf.get_variable(\\\"loss_before_update\\\", dtype=tf.float32,\\n initializer=0.)\\n self._iteration = tf.get_variable(\\\"iteration\\\", shape=[], dtype=tf.int64,\\n initializer=tf.zeros_initializer)\\n self._expected_quadratic_change = tf.get_variable(\\\"expected_quadratic_change\\\", \\n dtype=tf.float32,\\n initializer=0.)\\n\\n # Set up the second order calculations\\n self._second_order()\",\n \"def advantage(cpu_dt, gpu_dt):\\r\\n assert gpu_dt >= 0 and cpu_dt >= 0\\r\\n if gpu_dt == 0 and cpu_dt == 0:\\r\\n return numpy.nan\\r\\n elif gpu_dt == 0:\\r\\n return numpy.inf\\r\\n else:\\r\\n return cpu_dt / gpu_dt\",\n \"def lnprior(params):\\n a, b, f = params\\n if -10.0 < b < 0. and 0. < a < 10 and 0. < f:\\n return 0.0\\n\\n return -np.inf\",\n \"def test_get_hyperflex_feature_limit_internal_by_moid(self):\\n pass\",\n \"def _soft_update(self, active, target):\\n\\n for t_param, param in zip(target.parameters(), active.parameters()):\\n t_param.data.copy_(self.tau*param.data + (1-self.tau)*t_param.data)\",\n \"def _update(self, time_step, **train_kwargs):\\n # training is implied here\\n self.set_t_cutoff(self.cutoff_t + time_step, **train_kwargs)\",\n \"def gain_opt(machine, T):\\n res = (np.arange(T)+1)\\n return res * np.amax(machine)\",\n \"def __init__(self,\\n weight_decay,\\n learning_rate,\\n momentum,\\n use_locking=False,\\n name=\\\"MomentumW\\\",\\n use_nesterov=False):\\n super(MomentumWOptimizer, self).__init__(\\n weight_decay,\\n learning_rate=learning_rate,\\n momentum=momentum,\\n use_locking=use_locking,\\n name=name,\\n use_nesterov=use_nesterov)\",\n \"def set_probability_alpha(self, value):\\n self.view_state.alpha = value / 100\",\n \"def increase_learning(self, factor):\\n pass\",\n \"def set_value(self, name, val, **kwargs):\\n try:\\n assert self.__started\\n val = float(val)\\n except AssertionError:\\n self.unknown_error(\\\"Start method must be called first!\\\")\\n except (TypeError, ValueError):\\n self.unknown_error(\\\"Performance measures must be numeric!\\\")\\n\\n val_dict = {'val': val, 'min': None, 'max': None, 'scale': None,\\n 'threshold': 1, 'state': 'ok'}\\n\\n if 'lowest' in kwargs:\\n val_dict['min'] = float(kwargs.get('lowest'))\\n\\n if 'highest' in kwargs:\\n val_dict['max'] = float(kwargs.get('highest'))\\n\\n if 'threshold' in kwargs:\\n val_dict['threshold'] = kwargs['threshold']\\n\\n # Nagios actually understands most byte and time oriented scales.\\n # The developer docs also list a counter scale, but we're not certain\\n # if any plugin has ever used that. Only accept known scales.\\n\\n if 'scale' in kwargs:\\n scale = kwargs.get('scale')\\n\\n if scale.upper() in ('B', 'KB', 'MB', 'GB', 'TB'):\\n val_dict['scale'] = scale.upper()\\n elif scale.lower() in ('s', 'ms', 'us', 'ns', '%'):\\n val_dict['scale'] = scale.lower()\\n else:\\n raise ValueError(\\\"\\\"\\\"Scale must be one of: B, KB, MB, GB,\\n TB, s, ms, us, ns, or %.\\\"\\\"\\\")\\n\\n self.__perf[name] = val_dict\\n\\n # We'll use the opportunity to check the status ranges right when the\\n # variable is set so we don't have to loop through all of them later.\\n\\n if len(self.__warning) > 0:\\n self.__verbose_print(\\\"checking warning\\\")\\n self.__check_range('warning', name)\\n\\n if len(self.__critical) > 0:\\n self.__verbose_print(\\\"checking critical\\\")\\n self.__check_range('critical', name)\\n\\n return self.__perf[name]['state']\",\n \"def objective(hyperparams): \\n global iteration #necessary with a global variable because of implementation from hyperopt. \\n iteration += 1\\n\\n result = run_model(hyperparams, iteration)\\n loss = -result #transform to loss in order to minimize\\n\\n return {'loss': loss, 'hyperparams': hyperparams, 'iteration': iteration, 'status': STATUS_OK}\",\n \"def lapse(self):\\n pass\",\n \"def prior(old_params,params):\\n \\n for s in range(len(params)):\\n if params[s] < 0.0 or params[s] > 2:\\n return 0\\n return 1\",\n \"def advantage(cpu_dt, gpu_dt):\\n assert gpu_dt >= 0 and cpu_dt >= 0\\n if gpu_dt == 0 and cpu_dt == 0:\\n return numpy.nan\\n elif gpu_dt == 0:\\n return numpy.inf\\n else:\\n return cpu_dt / gpu_dt\",\n \"def log_prior(self, params):\",\n \"def schedule_variant(epoch):\\n\\n def _linear_annealing(epoch):\\n t = epoch / args.epochs\\n lr_ratio = 0.01\\n if t <= 0.5:\\n factor = 1.0\\n elif t <= 0.9:\\n factor = 1.0 - (1.0 - lr_ratio) * (t - 0.5) / 0.4\\n else:\\n factor = lr_ratio\\n return args.lr_init * factor\\n\\n lr_tmp = _linear_annealing(epoch)\\n if args.swag:\\n if (epoch > args.swag_start) or lr_tmp <= args.swag_lr:\\n return _linear_annealing(args.swag_start)\\n return lr_tmp\",\n \"def __init__(self):\\n super(SteklovBoundary, self).__init__()\\n self.value = SteklovBoundary.value\\n SteklovBoundary.value -= 1\\n self.update(param=\\\"1\\\")\",\n \"def likelihood(self, sign_switch, hyperparam):\\n\\n self.timer.tic()\\n\\n if numpy.isscalar(hyperparam):\\n hyperparam_ = numpy.array([hyperparam], dtype=float)\\n else:\\n hyperparam_ = hyperparam\\n\\n # Check if likelihood is already computed for an identical hyperparam\\n if (self.ell is not None) and \\\\\\n (self.ell_hyperparam is not None) and \\\\\\n (hyperparam_.size == self.ell_hyperparam.size) and \\\\\\n numpy.allclose(hyperparam_, self.ell_hyperparam,\\n atol=self.hyperparam_tol):\\n\\n if sign_switch:\\n return -self.ell\\n else:\\n return self.ell\\n\\n # Get eta\\n eta = self._hyperparam_to_eta(hyperparam_)\\n\\n # Extract scale from hyperparam\\n if (not numpy.isscalar(hyperparam_)) and \\\\\\n (hyperparam_.size > self.scale_index):\\n\\n # Set scale of the covariance object\\n scale = self._hyperparam_to_scale(hyperparam_[self.scale_index:])\\n self.mixed_cor.set_scale(scale)\\n\\n if numpy.abs(eta) >= self.max_eta:\\n\\n # Optimal sigma02 when eta is very large\\n sigma02 = self._find_optimal_sigma02()\\n\\n # Log likelihood\\n ell = -0.5*self.rdof * (numpy.log(2.0*numpy.pi) + 1.0 +\\n numpy.log(sigma02))\\n\\n if self.B is None:\\n Cinv = numpy.matmul(self.X.T, self.X)\\n logdet_Cinv = numpy.log(numpy.linalg.det(Cinv))\\n ell += - 0.5*logdet_Cinv\\n # else:\\n # logdet_B = numpy.log(numpy.linalg.det(self.B))\\n # ell += 0.5*logdet_B\\n\\n else:\\n\\n # Update Y, C, Mz (all needed for computing optimal sigma2)\\n self._update_Y_C_Mz(hyperparam_)\\n\\n # Find (or update) optimal sigma2\\n sigma2 = self._find_optimal_sigma2(hyperparam_)\\n\\n logdet_Kn = self.mixed_cor.logdet(eta)\\n logdet_Cinv = numpy.log(numpy.linalg.det(self.Cinv))\\n\\n if numpy.isnan(logdet_Kn):\\n raise RuntimeError('Logdet of \\\"Kn\\\" is nan at eta: %0.3e.'\\n % eta)\\n\\n # Log likelihood\\n ell = -0.5*self.rdof * \\\\\\n (numpy.log(2.0*numpy.pi) + 1.0 + numpy.log(sigma2)) \\\\\\n - 0.5*logdet_Kn - 0.5*logdet_Cinv\\n\\n if self.B is not None:\\n # Note that self.B is indeed B1, that is the matrix B without\\n # sigma**2.\\n logdet_B = numpy.log(numpy.linalg.det(self.B))\\n ell += -0.5*logdet_B\\n\\n # Store ell to member data (without sign-switch).\\n self.ell = ell\\n self.ell_hyperparam = hyperparam_\\n\\n # If ell is used in scipy.optimize.minimize, change the sign to obtain\\n # the minimum of -ell\\n if sign_switch:\\n ell = -ell\\n\\n self.timer.toc()\\n\\n return ell\",\n \"def set_hyperparams(self, params):\",\n \"def update(self, value):\\n if self._in_concept_change:\\n self.reset()\\n\\n self.miss_prob = self.miss_prob + (value - self.miss_prob) / float(self.sample_count)\\n self.miss_std = np.sqrt(self.miss_prob * (1 - self.miss_prob) / float(self.sample_count))\\n self.sample_count += 1\\n\\n self.estimation = self.miss_prob\\n self._in_concept_change = False\\n self._in_warning_zone = False\\n self.delay = 0\\n\\n if self.sample_count < self.min_num_instances:\\n return self._in_concept_change, self._in_warning_zone\\n\\n if self.miss_prob + self.miss_std <= self.miss_prob_sd_min:\\n self.miss_prob_min = self.miss_prob\\n self.miss_sd_min = self.miss_std\\n self.miss_prob_sd_min = self.miss_prob + self.miss_std\\n\\n if self.miss_prob + self.miss_std > self.miss_prob_min + self.out_control_level \\\\\\n * self.miss_sd_min:\\n self._in_concept_change = True\\n\\n elif self.miss_prob + self.miss_std > self.miss_prob_min + self.warning_level \\\\\\n * self.miss_sd_min:\\n self._in_warning_zone = True\\n\\n else:\\n self._in_warning_zone = False\\n\\n return self._in_concept_change, self._in_warning_zone\",\n \"def test_PredictionEnsemble_goddard(\\r\\n perfectModelEnsemble_initialized_control_1d_ym_cftime, smooth\\r\\n):\\r\\n pm = perfectModelEnsemble_initialized_control_1d_ym_cftime\\r\\n assert pm.smooth(smooth)\",\n \"def optim_func(params, model):\\n if model.model == 'ARD':\\n model.alpha, model.beta = params\\n lik = model.pruning_algorithm()\\n\\n else:\\n model.alpha = params[0]\\n lik = model.pruning_algorithm()\\n \\n return -lik\",\n \"def speed(self, value: int, /) -> None:\",\n \"def _single_early_stopping_opt(study, trial):\\n\\n # Record first as best score\\n if study.best_score is None:\\n study.best_score = study.best_value\\n\\n # Record better value and reset count\\n if study.best_value > study.best_score:\\n study.best_score = study.best_value\\n study.early_stop_count = 0\\n\\n # If count greater than user defined stop, raise error to stop\\n else:\\n if study.early_stop_count > study.early_stop:\\n study.early_stop_count = 0\\n raise optuna.exceptions.OptunaError\\n else:\\n study.early_stop_count = study.early_stop_count+1\\n return\",\n \"def patience_param(x):\\n # -- TODO: make this do something!\\n return x\",\n \"def test_temporal_smoothing_how(perfectModelEnsemble_initialized_control_1d_ym_cftime):\\r\\n pm = perfectModelEnsemble_initialized_control_1d_ym_cftime\\r\\n pm_smoothed_mean = pm.smooth({\\\"lead\\\": 4}, how=\\\"mean\\\")\\r\\n pm_smoothed_sum = pm.smooth({\\\"lead\\\": 4}, how=\\\"sum\\\")\\r\\n assert (\\r\\n pm_smoothed_sum.get_initialized().mean()\\r\\n > pm_smoothed_mean.get_initialized().mean() * 2\\r\\n )\",\n \"def test_param(self):\\n Y, T, X, _ = ihdp_surface_B()\\n est = AutomatedLinearDML(model_y=automl_model_reg(),\\n model_t=GradientBoostingClassifier(),\\n featurizer=None,\\n discrete_treatment=True)\\n est.fit(Y, T, X=X)\\n _ = est.effect(X)\",\n \"def test_update_hyperflex_feature_limit_internal(self):\\n pass\",\n \"def elasticnet(parameter, bias=None, reg=0.01, lr=0.1, gamma=1.0):\\n if gamma < 0.0:\\n print(\\\"Warning, gamma should be positive. Otherwise you are not shrinking.\\\")\\n #TODO: Is gamma of 1.0 a good value?\\n Norm = reg*lr*gamma\\n l1(parameter, bias, reg, lr)\\n update_w = (1.0/(1.0 + Norm))*parameter\\n parameter.data = update_w\\n if bias is not None:\\n update_b = (1.0/(1.0 + Norm))*bias\\n bias.data = update_b\",\n \"def test_am_threshold(Simulator, plt, seed, rng):\\n d = 64\\n vocab = Vocabulary(d, pointer_gen=rng)\\n vocab.populate('A; B; C; D')\\n\\n d2 = int(d / 2)\\n vocab2 = Vocabulary(d2, pointer_gen=rng)\\n vocab2.populate('A; B; C; D')\\n\\n def input_func(t):\\n return '0.49 * A' if t < 0.1 else '0.8 * B'\\n\\n with spa.Network('model', seed=seed) as m:\\n m.am = ThresholdingAssocMem(\\n threshold=0.5, input_vocab=vocab, output_vocab=vocab2,\\n function=filtered_step_fn, mapping='by-key')\\n m.stimulus = spa.Transcode(input_func, output_vocab=vocab)\\n m.stimulus >> m.am\\n\\n in_p = nengo.Probe(m.am.input)\\n out_p = nengo.Probe(m.am.output, synapse=0.03)\\n\\n with Simulator(m) as sim:\\n sim.run(0.3)\\n t = sim.trange()\\n below_th = t < 0.1\\n above_th = t > 0.25\\n\\n plt.subplot(2, 1, 1)\\n plt.plot(t, similarity(sim.data[in_p], vocab))\\n plt.ylabel(\\\"Input\\\")\\n plt.subplot(2, 1, 2)\\n plt.plot(t, similarity(sim.data[out_p], vocab2))\\n plt.plot(t[above_th], np.ones(t.shape)[above_th] * 0.9, c='g', lw=2)\\n plt.ylabel(\\\"Output\\\")\\n\\n assert np.mean(sim.data[out_p][below_th]) < 0.01\\n assert_sp_close(t, sim.data[out_p], vocab2['B'], skip=0.25, duration=0.05)\",\n \"def __init__(self):\\n self.counts = [0] * 10\\n self.values = [0] * 10\\n self.softmaxvalues = [0] * 10\\n self.t = 0.3\",\n \"def __call__(self, param):\\n count = param.nbatch\\n if self.last_count > count:\\n self.init = False\\n self.last_count = count\\n\\n if self.init:\\n if count % self.frequent == 0:\\n # #11504\\n try:\\n speed = self.frequent * self.batch_size / (time.time() - self.tic)\\n except ZeroDivisionError:\\n speed = float('inf')\\n if param.eval_metric is not None:\\n name_value = param.eval_metric.get_name_value()\\n if self.auto_reset:\\n param.eval_metric.reset()\\n msg = 'Epoch[%d] Batch [%d-%d]\\\\tSpeed: %.2f samples/sec'\\n msg += '\\\\t%s=%f'*len(name_value)\\n logging.info(msg, param.epoch, count-self.frequent, count, speed, *sum(name_value, ()))\\n else:\\n msg = 'Epoch[%d] Batch [0-%d]\\\\tSpeed: %.2f samples/sec'\\n msg += '\\\\t%s=%f'*len(name_value)\\n logging.info(msg, param.epoch, count, speed, *sum(name_value, ()))\\n else:\\n logging.info(\\\"Iter[%d] Batch [%d]\\\\tSpeed: %.2f samples/sec\\\",\\n param.epoch, count, speed)\\n self.tic = time.time()\\n else:\\n self.init = True\\n self.tic = time.time()\",\n \"def obs_avoid(z):\\n while regions['front'] < 8:\\n speed.linear.x = 0\\n speed.angular.z = z\\n pub.publish(speed)\\n rate.sleep()\\n speed.linear.x = 1.3\\n speed.angular.z = 0\\n pub.publish(speed)\\n rate.sleep()\\n rospy.sleep(2)\",\n \"def set_speed(self,value):\\n if (value>self.get_max_speed()):\\n print \\\"asked to set the speed to %f but the max speed is %f\\\\n\\\" % (value,self.get_max_speed())\\n else:\\n return self.put_par(\\\"slew_speed\\\",value)\",\n \"def bernoulli_episode_scheduler(keep_probability: float) -> Scheduler:\\n if keep_probability < 0.0 or keep_probability > 1.0:\\n raise ValueError(\\n f'keep_probability must be in [0,1], got: {keep_probability}')\\n\\n def f(data: step_data.StepData) -> bool:\\n if data.timestep.last():\\n f.current_p = np.random.random()\\n return f.current_p < keep_probability\\n\\n f.current_p = np.random.random()\\n\\n return f\",\n \"def update_learning_rate(self):\\r\\n self.scheduler.step(self.clock.epoch)\",\n \"def __init__(self):\\n super().__init__()\\n self.dynamic = True # from base class, indicates time-dependence is handled internally\\n self.numBins = None # integer number of bins to use in creating the duration curve. TODO default?\\n self.targets = None # list of strings, variables to apply postprocessor to\",\n \"def log_prob(self):\",\n \"def __call__(self, param):\\n count = param.nbatch\\n if self.last_count > count:\\n self.init = False\\n self.last_count = count\\n\\n if self.init:\\n if count % self.frequent == 0:\\n speed = self.frequent * self.batch_size / (time.time() - self.tic)\\n s = ''\\n if param.eval_metric is not None:\\n name, value = param.eval_metric.get()\\n s = \\\"Epoch[%d] Batch [%d]\\\\tSpeed: %.2f samples/sec\\\\tTrain-\\\" % (param.epoch, count, speed)\\n for n, v in zip(name, value):\\n s += \\\"%s=%f,\\\\t\\\" % (n, v)\\n else:\\n s = \\\"Iter[%d] Batch [%d]\\\\tSpeed: %.2f samples/sec\\\" % (param.epoch, count, speed)\\n\\n logging.info(s)\\n print(s)\\n self.tic = time.time()\\n else:\\n self.init = True\\n self.tic = time.time()\",\n \"def testHrtPrior(self):\\n attr = self.session.create_visit_attr()\\n\\n self.util.boolTypeTest(self, attr, \\\"prior\\\")\\n\\n self.util.boolPropertyTest(self, attr, \\\"prior\\\")\",\n \"def __init__(self):\\n super().__init__()\\n self.nan_penalty = nan_penalty\\n self.nan_tol = nan_tol\",\n \"def stop(self, metric, model, metric_type='better_decrease', delta=0.03):\\n self.delta = delta\\n delta = self.delta * metric\\n\\n if self.best_score is None:\\n self.best_score = metric\\n self.save_model_state(metric, model)\\n return False\\n\\n if abs(metric - self.best_score) < self.delta/3 * metric:\\n self.num_const_scores += 1\\n if self.num_const_scores >= self.wait_epochs + 1:\\n print('\\\\nTraining stoped by EarlyStopping')\\n return True\\n else:\\n self.num_const_scores = 0\\n\\n if metric_type == 'better_decrease':\\n if metric > self.best_score + delta:\\n self.num_bad_scores += 1\\n elif metric > self.best_score:\\n self.num_bad_scores = 0\\n else:\\n self.best_score = metric\\n self.save_model_state(metric, model)\\n self.num_bad_scores = 0\\n\\n else:\\n if metric < self.best_score - delta:\\n self.num_bad_scores += 1\\n elif metric < self.best_score:\\n self.num_bad_scores = 0\\n else:\\n self.best_score = metric\\n self.save_model_state(metric, model)\\n self.num_bad_scores = 0\\n\\n if self.num_bad_scores >= self.wait_epochs:\\n print('\\\\nTraining stoped by EarlyStopping')\\n return True\\n\\n\\n return False\",\n \"def bias_prior(self):\",\n \"def training_policy(self, state):\\n if self.epsilon > random.random():\\n return random.randint(0, 1)\\n return self.policy(state)\",\n \"def test_soft_threshold():\\n assert snet.soft_threshold(10, 100) == 0\\n assert snet.soft_threshold(-10, 100) == 0\\n assert snet.soft_threshold(10, 3) == 7\\n assert snet.soft_threshold(-10, 3) == -7\",\n \"def _onSetParameterLower(self, value):\\n self._parameters['lower'] = min(value, self._parameters['upper']) # Limit at upper\\n self._logger.info(\\\"Parameter 'lower' of function '{}' changed to {}\\\".format(self._function, value))\\n self.functionChanged.emit(self._dim, self._function, self._parameters.copy())\",\n \"def set_accuracy_95(num: float) -> float:\\n ...\",\n \"def is_artificial(self):\\n\\t\\treturn 0\",\n \"def ModifyInitialProperties(self):\\n super().ModifyInitialProperties()\\n for aux_process in self.project_parameters[\\\"processes\\\"][\\\"auxiliar_process_list\\\"]:\\n if aux_process[\\\"python_module\\\"].GetString() == \\\"temporal_statistics_process\\\":\\n aux_process[\\\"Parameters\\\"][\\\"statistics_start_point_control_value\\\"].SetDouble(self.project_parameters[\\\"problem_data\\\"][\\\"burnin_time\\\"].GetDouble())\",\n \"def softClassify(self, inputValue):\\n result = 1.0 / (1 + math.e ** (-self.beta * (inputValue - self.threshold)))\\n logging.debug(\\\"Classification of %f on value %f for feature %d\\\" %(result, inputValue, self.feature))\\n return result\",\n \"def __call__(self, epoch):\\n exp = np.floor((1 + epoch) / self.dropEvery)\\n alpha = initAlpha * (self.factor ** exp)\\n \\n # return alpha \\n return float(alpha)\",\n \"def _momentum_update(self):\\n for param_ol, param_tgt in zip(self.online_net.parameters(),\\n self.target_net.parameters()):\\n param_tgt.data = param_tgt.data * self.momentum + \\\\\\n param_ol.data * (1. - self.momentum)\",\n \"def test_fast_growth_default(model, reaction_id):\\n reaction = model.reactions.get_by_id(reaction_id)\\n model.objective = reaction\\n try:\\n model.slim_optimize()\\n flux = reaction.flux\\n except Infeasible:\\n flux = np.nan\\n assert flux <= 10.3972\",\n \"def check_params(self, model_params):\\n\\n comm = self.comm\\n for param, policy in self.noise_policy.items():\\n low_bound, up_bound, absify, low_bound_diagonal = policy\\n new_pvalue = model_params[param]\\n if np.isscalar(new_pvalue): # Param to be noisified is scalar\\n if comm.rank == 0:\\n if new_pvalue < low_bound:\\n print(\\\"check_params: Reset lower bound of %s\\\" % param)\\n new_pvalue = low_bound\\n if new_pvalue >= up_bound:\\n print(\\\"check_params: Reset upper bound of %s\\\" % param)\\n new_pvalue = up_bound\\n if absify:\\n print(\\\"check_params: Taking abs of %s\\\" % param)\\n new_pvalue = np.abs(new_pvalue)\\n if (\\n low_bound_diagonal is not None\\n ): # when using isotropic instead of full matrix\\n if new_pvalue < low_bound_diagonal:\\n print(\\\"check_params: Reset lower bound of %s (diagonal)\\\" % param)\\n new_pvalue = low_bound_diagonal\\n new_pvalue = comm.bcast(new_pvalue)\\n else:\\n if comm.rank == 0:\\n if (new_pvalue < low_bound).any():\\n print(\\\"check_params: Reset lower bound of %s\\\" % param)\\n if (new_pvalue >= up_bound).any():\\n print(\\\"check_params: Reset upper bound of %s\\\" % param)\\n new_pvalue = np.maximum(low_bound, new_pvalue)\\n new_pvalue = np.minimum(up_bound, new_pvalue)\\n if absify:\\n print(\\\"check_params: Taking abs of %s\\\" % param)\\n new_pvalue = np.abs(new_pvalue)\\n if low_bound_diagonal is not None:\\n mask = np.diag(new_pvalue) < low_bound_diagonal\\n if mask.any():\\n print(\\\"check_params: Reset lower bound of %s (diagonal)\\\" % param)\\n new_pvalue[np.diag(mask)] = low_bound_diagonal\\n comm.Bcast([new_pvalue, MPI.DOUBLE])\\n model_params[param] = new_pvalue\\n\\n return model_params\",\n \"def freq_optimization(self):\\n index = identify_scale(self.vz, True)\\n # In case the patient is limping\\n if index > 35:\\n index = index / 2\\n print(f\\\"Scale used is {index}\\\")\",\n \"def update_threshold(self, activation_time):\\n \\n if self.model_type == 'linear':\\n if(activation_time > 0):\\n self.curr_threshold = (self.threshold +\\n (1-self.threshold)*(1-activation_time/\\n (self.t_max)))\\n else:\\n self.curr_threshold = self.threshold\\n elif self.model_type == 'quadratic':\\n if(activation_time > 0):\\n self.curr_threshold = (self.threshold +\\n (1-self.threshold)*(1-(activation_time/\\n (self.t_max))**2))\\n else:\\n self.currthreshold = self.threshold\",\n \"def on_epoch_start(self, state: _State):\\n optimizer = self._optimizer\\n\\n if self.decouple_weight_decay:\\n self._optimizer_wd = [\\n group.get(\\\"weight_decay\\\", 0.0)\\n for group in optimizer.param_groups\\n ]\\n for i in range(len(optimizer.param_groups)):\\n optimizer.param_groups[i][\\\"weight_decay\\\"] = 0.0\\n else:\\n self._optimizer_wd = [0.0] * len(optimizer.param_groups)\",\n \"def __init__(self,tau = 1e-3):\\n self._tau = tau \\n pass\",\n \"def __init__(self, label, select_high_quality):\\n self.label = label\\n self.resource = max(0.1, np.random.random_sample()) # let's assume everyone has at least a tenth of the max resource\\n\\n # put x one in each team\\n if select_high_quality and np.random.uniform(0,1) <= PERCENT_INITIAL_HIGH_QUALITY:\\n self.state = np.random.uniform(HIGH_QUALITY_THRESHOLD, 1)\\n else:\\n self.state = np.random.uniform(0, AVERAGE_DOCUMENTATION_FEQUENCY)\\n self.tasks_completed = 0\",\n \"def warmup_step(ckpt_step: int) -> float:\\n return ckpt_step * 10\",\n \"def test_update_hyperflex_feature_limit_external(self):\\n pass\",\n \"def __call__(self, score, model):\\n if self.best_score is None:\\n # assign the best score and save the model at the end of the first epoch\\n self.best_score = score\\n self.save_checkpoint(model)\\n elif score < self.best_score + self.delta:\\n # if the score not increase of at least delta, increment the counter and if it reach the patience early stops\\n self.counter += 1\\n if self.counter >= self.patience:\\n self.early_stop = True\\n else:\\n # otherwise the score is better that the saved one, so replace the best score and save the model\\n self.best_score = score\\n self.save_checkpoint(model)\\n self.counter = 0\",\n \"def constraint(arg: tp.Any) -> bool: # pylint: disable=unused-argument\\n return bool(optimizer.parametrization.random_state.rand() > 0.8)\",\n \"def _tune(acc_rate, proposed, step):\\n if step.tune_scaling:\\n # a and b after Muto & Beck 2008.\\n a = 1 / 9\\n b = 8 / 9\\n step.scaling = (a + b * acc_rate) ** 2\\n if step.tune_steps:\\n acc_rate = max(1.0 / proposed, acc_rate)\\n step.n_steps = min(step.max_steps, 1 + int(np.log(step.p_acc_rate) / np.log(1 - acc_rate)))\",\n \"def bernoulli_step_scheduler(keep_probability: float) -> Scheduler:\\n if keep_probability < 0.0 or keep_probability > 1.0:\\n raise ValueError(\\n f'keep_probability must be in [0,1], got: {keep_probability}')\\n\\n def f(unused_data: step_data.StepData) -> bool:\\n return np.random.random() < keep_probability\\n\\n return f\",\n \"def step(self):\\n\\n self.compute_lr()\\n\\n self.optimizer.param_groups[self.param_group]['lr'] = self.lr\\n self.optimizer.param_groups[self.param_group]['momentum'] = self.momentum\",\n \"def test_am_threshold(Simulator, plt, seed, rng):\\n D = 64\\n vocab = Vocabulary(D, rng=rng)\\n vocab.parse('A+B+C+D')\\n\\n D2 = int(D / 2)\\n vocab2 = Vocabulary(D2, rng=rng)\\n vocab2.parse('A+B+C+D')\\n\\n def input_func(t):\\n return vocab.parse('0.49*A').v if t < 0.1 else vocab.parse('0.8*A').v\\n\\n with nengo.Network('model', seed=seed) as m:\\n am = AssociativeMemory(vocab, vocab2, threshold=0.5)\\n in_node = nengo.Node(output=input_func, label='input')\\n nengo.Connection(in_node, am.input)\\n\\n in_p = nengo.Probe(in_node)\\n out_p = nengo.Probe(am.output, synapse=0.03)\\n\\n sim = Simulator(m)\\n sim.run(0.3)\\n t = sim.trange()\\n below_th = t < 0.1\\n above_th = t > 0.25\\n\\n plt.subplot(2, 1, 1)\\n plt.plot(t, nengo.spa.similarity(sim.data[in_p], vocab))\\n plt.ylabel(\\\"Input\\\")\\n plt.legend(vocab.keys, loc='best')\\n plt.subplot(2, 1, 2)\\n plt.plot(t, nengo.spa.similarity(sim.data[out_p], vocab2))\\n plt.plot(t[above_th], np.ones(t.shape)[above_th] * 0.8, c='g', lw=2)\\n plt.ylabel(\\\"Output\\\")\\n plt.legend(vocab.keys, loc='best')\\n\\n assert similarity(sim.data[in_p][below_th], vocab.parse(\\\"A\\\").v) > 0.48\\n assert similarity(sim.data[in_p][above_th], vocab.parse(\\\"A\\\").v) > 0.79\\n assert similarity(sim.data[out_p][below_th], vocab2.parse(\\\"0\\\").v) < 0.01\\n assert similarity(sim.data[out_p][above_th], vocab2.parse(\\\"A\\\").v) > 0.79\",\n \"def get_learning_rate():\\n return 0.00001\",\n \"def __init__(self, value=1.0):\\n self.value = value\",\n \"def schedule(epoch):\\n return alpha / (1 + (decay_rate * epoch))\",\n \"def visit_softmax_temperature_fn(self, trained_steps):\\n if trained_steps < 0.5 * self.training_steps:\\n return 1.0\\n elif trained_steps < 0.75 * self.training_steps:\\n return 0.5\\n else:\\n return 0.25\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5497046","0.5494867","0.5455038","0.53865165","0.5378648","0.53281236","0.532049","0.5289464","0.5282969","0.5282969","0.5274334","0.52491134","0.518313","0.51513946","0.5125276","0.51124686","0.50949377","0.50924283","0.5072421","0.5062427","0.5047174","0.5033257","0.5015129","0.50098974","0.5002547","0.49782076","0.49627754","0.49622938","0.4952892","0.49476257","0.49454874","0.49437505","0.49262682","0.49130216","0.49095142","0.49058768","0.49013045","0.48991305","0.48913902","0.48857123","0.48830962","0.48819858","0.48778796","0.4877613","0.48774773","0.48750567","0.48706096","0.48662564","0.4862762","0.4858032","0.48568505","0.4851154","0.4847703","0.4838249","0.48376548","0.4827941","0.48255402","0.48250097","0.48234406","0.48111156","0.48093873","0.4808321","0.47981372","0.47950888","0.47942916","0.47907633","0.47899574","0.47887498","0.47863322","0.47769135","0.47748592","0.47703812","0.47684607","0.47660604","0.47627598","0.47614157","0.47573683","0.47565812","0.47531387","0.47499302","0.4747993","0.47458842","0.47453716","0.47453263","0.47437394","0.47430092","0.47403044","0.4736629","0.47346452","0.47343582","0.4733467","0.4720795","0.47132584","0.4711955","0.471161","0.47074413","0.47074142","0.47064805","0.47058275","0.46918768","0.46872658"],"string":"[\n \"0.5497046\",\n \"0.5494867\",\n \"0.5455038\",\n \"0.53865165\",\n \"0.5378648\",\n \"0.53281236\",\n \"0.532049\",\n \"0.5289464\",\n \"0.5282969\",\n \"0.5282969\",\n \"0.5274334\",\n \"0.52491134\",\n \"0.518313\",\n \"0.51513946\",\n \"0.5125276\",\n \"0.51124686\",\n \"0.50949377\",\n \"0.50924283\",\n \"0.5072421\",\n \"0.5062427\",\n \"0.5047174\",\n \"0.5033257\",\n \"0.5015129\",\n \"0.50098974\",\n \"0.5002547\",\n \"0.49782076\",\n \"0.49627754\",\n \"0.49622938\",\n \"0.4952892\",\n \"0.49476257\",\n \"0.49454874\",\n \"0.49437505\",\n \"0.49262682\",\n \"0.49130216\",\n \"0.49095142\",\n \"0.49058768\",\n \"0.49013045\",\n \"0.48991305\",\n \"0.48913902\",\n \"0.48857123\",\n \"0.48830962\",\n \"0.48819858\",\n \"0.48778796\",\n \"0.4877613\",\n \"0.48774773\",\n \"0.48750567\",\n \"0.48706096\",\n \"0.48662564\",\n \"0.4862762\",\n \"0.4858032\",\n \"0.48568505\",\n \"0.4851154\",\n \"0.4847703\",\n \"0.4838249\",\n \"0.48376548\",\n \"0.4827941\",\n \"0.48255402\",\n \"0.48250097\",\n \"0.48234406\",\n \"0.48111156\",\n \"0.48093873\",\n \"0.4808321\",\n \"0.47981372\",\n \"0.47950888\",\n \"0.47942916\",\n \"0.47907633\",\n \"0.47899574\",\n \"0.47887498\",\n \"0.47863322\",\n \"0.47769135\",\n \"0.47748592\",\n \"0.47703812\",\n \"0.47684607\",\n \"0.47660604\",\n \"0.47627598\",\n \"0.47614157\",\n \"0.47573683\",\n \"0.47565812\",\n \"0.47531387\",\n \"0.47499302\",\n \"0.4747993\",\n \"0.47458842\",\n \"0.47453716\",\n \"0.47453263\",\n \"0.47437394\",\n \"0.47430092\",\n \"0.47403044\",\n \"0.4736629\",\n \"0.47346452\",\n \"0.47343582\",\n \"0.4733467\",\n \"0.4720795\",\n \"0.47132584\",\n \"0.4711955\",\n \"0.471161\",\n \"0.47074413\",\n \"0.47074142\",\n \"0.47064805\",\n \"0.47058275\",\n \"0.46918768\",\n \"0.46872658\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":81983,"cells":{"query":{"kind":"string","value":"The combination of penalty='l1' and loss='hinge' is not supported penalty='l2' and loss='hinge' is only supported when dual='true' penalty='l1' is only supported when dual='false'."},"document":{"kind":"string","value":"def _svm_loss_penalty_dual(name):\n return hp.choice(name, [\n ('hinge', 'l2', True),\n ('squared_hinge', 'l2', True),\n ('squared_hinge', 'l1', False),\n ('squared_hinge', 'l2', False)\n ])"},"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 l2_training_penalty(batched_out: base.Output):\n if isinstance(batched_out, base.OutputWithPrior):\n return 0.5 * jnp.mean(jnp.square(batched_out.train))\n else:\n logging.warning('L2 weight penalty only works for OutputWithPrior.')\n return 0.","def test_hinge_loss_backward():\n from your_code import HingeLoss\n X = np.array([[-1, 2, 1], [-3, 4, 1]])\n w = np.array([1, 2, 3])\n y = np.array([1, -1])\n\n loss = HingeLoss(regularization=None)\n\n _true = np.array([-1.5, 2, 0.5])\n _est = loss.backward(X, w, y)\n print(_est)","def loss(self, X, y=None):\n\n # In dev testing, the loss fnc stops at \"scores\" , unfollowed by \"softmax\" probability prediction.\n # In real testing, \"self.predict()\" needs to be implemented in Solver() class.\n \n if y is None:\n for bn_param in self.bn_params:\n bn_param[\"mode\"] = \"test\"\n\n\n W1, b1 = self.params['W1'], self.params['b1']\n gamma1, beta1 = self.params[\"sbnGamma1\"], self.params[\"sbnBeta1\"]\n bn_param1 = self.bn_params[0]\n\n W2, b2 = self.params['W2'], self.params['b2']\n gamma2, beta2 = self.params[\"sbnGamma2\"], self.params[\"sbnBeta2\"]\n bn_param2 = self.bn_params[1]\n\n W3, b3 = self.params['W3'], self.params['b3']\n gamma3, beta3 = self.params[\"bnGamma3\"], self.params[\"bnBeta3\"]\n bn_param3 = self.bn_params[2]\n\n W4, b4 = self.params['W4'], self.params['b4']\n \n # pass conv_param to the forward pass for the convolutional layer\n conv_param = self.conv_param\n\n # pass pool_param to the forward pass for the max-pooling layer\n pool_param = self.maxpool_params\n\n ############################################################################\n # TODO: Implement the forward pass for the three-layer convolutional net, #\n # computing the class scores for X and storing them in the scores #\n # variable. #\n ############################################################################\n \n scores = None \n cache = {}\n # def conv_sbn_relu_forward(x, w, b, gamma, beta, conv_param, bn_param): return out, cache;\n out, cache[\"layer1\"] = layer_utils.conv_sbn_relu_forward(X, W1, b1, gamma1, beta1, conv_param, bn_param1) \n out, cache[\"layer2\"] = layer_utils.conv_sbn_relu_forward(out, W2, b2, gamma2, beta2, conv_param, bn_param2)\n\n # def max_pool_forward_fast(x, pool_param): return out, cache;\n out, cache[\"maxpool\"] = fast_layers.max_pool_forward_fast(out, pool_param)\n\n # def affine_bn_relu_forward(x, w, b, gamma, beta, bn_param): return out, cache;\n \n out, cache[\"layer3\"] = layer_utils.affine_bn_relu_forward(out, W3, b3, gamma3, beta3, bn_param3)\n\n # def affine_forward(x, w, b): return out, cache;\n scores, cache[\"layer4\"] = layers.affine_forward(out, W4, b4)\n\n\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n \n if y is None:\n return scores\n \n ############################################################################\n # TODO: Implement the backward pass for the three-layer convolutional net, #\n # storing the loss and gradients in the loss and grads variables. Compute #\n # data loss using softmax, and make sure that grads[k] holds the gradients #\n # for self.params[k]. Don't forget to add L2 regularization! #\n ############################################################################\n \n loss, grads = 0, {}\n\n # def softmax_loss(x, y): return loss, dscore;\n loss, dscores = layers.softmax_loss(scores, y)\n loss += 0.5 * self.reg * (np.sum(W1 * W1) + np.sum(W2 * W2) + np.sum(W3 * W3) + np.sum(W4 * W4))\n\n # def affine_backward(dout, cache): return dx, dw, db;\n dout, dW4, db4 = layers.affine_backward(dscores, cache[\"layer4\"]) \n\n # def affine_bn_relu_backward(dout, cache): return dx, dw, db, dgamma, dbeta;\n dout, dW3, db3, dgamma3, dbeta3 = layer_utils.affine_bn_relu_backward(dout, cache[\"layer3\"])\n\n # print cache[\"layer3\"]\n\n # def max_pool_backward_fast(dout, cache): return max_pool_backward_im2col(dout, real_cache);\n # def max_pool_backward_im2col(dout, cache): return dx;\n dout = fast_layers.max_pool_backward_fast(dout, cache[\"maxpool\"])\n\n # def conv_sbn_relu_backward(dout, cache): return dx, dw, db, dgamma, dbeta;\n dout, dW2, db2, dgamma2, dbeta2 = layer_utils.conv_sbn_relu_backward(dout, cache[\"layer2\"])\n _, dW1, db1, dgamma1, dbeta1 = layer_utils.conv_sbn_relu_backward(dout, cache[\"layer1\"])\n\n # reg\n grads['W4'], grads['b4'] = dW4 + self.reg * W4, db4\n \n grads['W3'], grads['b3'] = dW3 + self.reg * W3, db3\n grads[\"bnGamma3\"], grads[\"bnBeta3\"] = dgamma3, dbeta3\n\n grads['W2'], grads['b2'] = dW2 + self.reg * W2, db2\n grads[\"sbnGamma2\"], grads[\"sbnBeta2\"] = dgamma2, dbeta2\n\n grads['W1'], grads['b1'] = dW1 + self.reg * W1, db1\n grads[\"sbnGamma1\"], grads[\"sbnBeta1\"] = dgamma1, dbeta1\n\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n \n return loss, grads","def _weight_boosting_loss(name: str):\n return hp.choice(name, [\"linear\", \"square\", \"exponential\"])","def compute_penalty(edge_1, edge_2):\n\n if edge_1 == edge_2:\n return 0\n elif {edge_1, edge_2} == {EdgeType.NONE, EdgeType.FORWARD}:\n return 1\n elif {edge_1, edge_2} == {EdgeType.NONE, EdgeType.BACKWARD}:\n return 1\n elif {edge_1, edge_2} == {EdgeType.NONE, EdgeType.UNDIRECTED}:\n return 1\n elif {edge_1, edge_2} == {EdgeType.FORWARD, EdgeType.BACKWARD}:\n return 1\n elif {edge_1, edge_2} == {EdgeType.FORWARD, EdgeType.UNDIRECTED}:\n return 1\n elif {edge_1, edge_2} == {EdgeType.BACKWARD, EdgeType.UNDIRECTED}:\n return 1\n else:\n raise ImpossibleEdgeConfiguration","def penalty(self):\n return 0","def second_order_defense(loss,\n params,\n data_obliterate,\n target_loss,\n data_keep = None,\n l2reg = 1e-1,\n lobpcg_maxiter = 20,\n ls_maxiter = 20):\n\n flat_params, unflatten = flatten_util.ravel_pytree(params)\n n_features = len(flat_params)\n\n def _loss_obliterate(x):\n pytree_x = unflatten(x)\n return jnp.mean(loss(pytree_x, data_obliterate))\n\n def _hessian_obliterate_matvec(x):\n # forward-over-reverse differentiation\n return jax.jvp(jax.grad(_loss_obliterate), (flat_params,), (x,))[1]\n\n eigenvalues, eigenvectors, _ = experimental_splinalg.lobpcg_standard(\n jax.vmap(_hessian_obliterate_matvec, in_axes=1, out_axes=1),\n flat_params.reshape((-1, 1)),\n m=lobpcg_maxiter)\n normalized_l2_reg = l2reg * eigenvalues[0]\n\n if data_keep is None:\n update_direction = eigenvectors.ravel()\n else:\n def _loss_keep(x):\n pytree_params = unflatten(x)\n regularization = normalized_l2_reg * jnp.linalg.norm(x)\n return jnp.mean(loss(pytree_params, data_keep)) + regularization\n\n def _hessian_keep_matvec(x):\n # forward-over-reverse differentiation\n return jax.jvp(jax.grad(_loss_keep), (flat_params,), (x,))[1]\n\n hessian_obliterate = splinalg.LinearOperator(\n (n_features, n_features), matvec=_hessian_obliterate_matvec)\n hessian_keep = splinalg.LinearOperator(\n (n_features, n_features), matvec=_hessian_keep_matvec)\n _, generalized_eigenvectors = splinalg.eigsh(\n hessian_obliterate, k=1, M=hessian_keep, v0=eigenvectors)\n update_direction = generalized_eigenvectors.ravel()\n\n # find the step-size by minimizing a 1D objective function (that is, by\n # exact line-search)\n def scalr_fun(step):\n candidate_params = flat_params + step * update_direction\n return (_loss_obliterate(candidate_params) - target_loss) ** 2\n step = optimize.minimize_scalar(scalr_fun, options={\"maxiter\": ls_maxiter}).x\n # there are two solutions of this problem, one positive and one\n # negative. Do we need to run it twice and get the smallest one?\n return tree_util.tree_add_scalar_mul(params, step,\n unflatten(update_direction))","def test_gt_grad():\r\n floatX = config.floatX\r\n T = theano.tensor\r\n\r\n input_ = T.vector(dtype=floatX)\r\n random_values = numpy.random.RandomState(1234).uniform(\r\n low=-1, high=1, size=(2, 2))\r\n W_values = numpy.asarray(random_values, dtype=floatX)\r\n W = theano.shared(value=W_values, name='weights')\r\n correct_score = T.dot(input_, W)\r\n wrong_input = T.vector(dtype=floatX)\r\n wrong_score = theano.clone(correct_score, {input_: wrong_input})\r\n # Hinge loss\r\n\r\n scores = T.ones_like(correct_score) - correct_score + wrong_score\r\n cost = (scores * (scores > 0)).sum()\r\n T.grad(cost, input_)","def gradient_penalty_loss(y_true, y_pred, averaged_samples):\n if K.backend()=='theano':\n J, _ = theano.scan(lambda i, y, x: T.square(T.grad(y[i].sum(), x[i])).sum() ** 0.5,\n sequences=T.arange(y_pred.shape[0]),\n non_sequences=[y_pred, averaged_samples])\n return GRADIENT_PENALTY_WEIGHT * K.square(1 - J)\n \n else:\n gradients = K.gradients(y_pred, averaged_samples)\n gradients = K.concatenate([K.flatten(tensor) for tensor in gradients])\n gradient_l2_norm = K.sqrt(K.sum(K.square(gradients)))\n gradient_penalty = GRADIENT_PENALTY_WEIGHT * K.square(1 - gradient_l2_norm)\n return gradient_penalty","def loss(self, X, y=None):\n scores = None\n ############################################################################\n # TODO: Implement the forward pass for the two-layer net, computing the #\n # class scores for X and storing them in the scores variable. #\n ############################################################################\n hid1, hid1cache = affine_relu_forward(X, self.params['W1'], self.params['b1'])\n scores, scorecache = affine_forward(hid1, self.params['W2'], self.params['b2'])\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n\n # If y is None then we are in test mode so just return scores\n if y is None:\n return scores\n\n loss, grads = 0, {}\n ############################################################################\n # TODO: Implement the backward pass for the two-layer net. Store the loss #\n # in the loss variable and gradients in the grads dictionary. Compute data #\n # loss using softmax, and make sure that grads[k] holds the gradients for #\n # self.params[k]. Don't forget to add L2 regularization! #\n # #\n # NOTE: To ensure that your implementation matches ours and you pass the #\n # automated tests, make sure that your L2 regularization includes a factor #\n # of 0.5 to simplify the expression for the gradient. #\n ############################################################################\n loss, dscores = softmax_loss(scores, y)\n loss += 0.5 * self.reg *( np.sum(self.params['W1']**2) + np.sum(self.params['W2']**2) )\n\n dhid1, grads['W2'], grads['b2'] = affine_backward(dscores, scorecache)\n dx, grads['W1'], grads['b1'] = affine_relu_backward(dhid1, hid1cache)\n\n grads['W1'] += self.reg * self.params['W1']\n grads['W2'] += self.reg * self.params['W2']\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n\n return loss, grads","def gradient_penalty_loss(y_true, y_pred, averaged_samples, gradient_penalty_weight):\n gradients = K.gradients(K.sum(y_pred), averaged_samples)\n gradient_l2_norm = K.sqrt(K.sum(K.square(gradients)))\n gradient_penalty = gradient_penalty_weight * K.square(1 - gradient_l2_norm)\n return gradient_penalty","def _compute_penalty(self):\n raise ValueError('Implement in a child class')","def TEM_loss(anchors_action,anchors_startend,\n Y_action,Y_startend,config): \n loss_action,num_sample_action = binary_logistic_loss(Y_action,anchors_action)\n loss_startend,num_sample_startend = binary_logistic_loss(Y_startend,anchors_startend)\n # print('loss_action', loss_action)\n # print('loss_startend', loss_startend)\n loss={\"loss_action\":loss_action,\"num_sample_action\":num_sample_action,\n \"loss_startend\":loss_startend,\"num_sample_startend\":num_sample_startend}\n return loss","def predict_boosting_example(x, h_ens):\r\n\r\n arr = []\r\n sum_alpha = 0\r\n\r\n for y in h_ens:\r\n # splitting hypothesis, weight pairs\r\n alpha, tree = h_ens[y]\r\n tst_pred = predict_example(x, tree)\r\n # appending prediction\r\n arr.append(tst_pred*alpha)\r\n sum_alpha += alpha\r\n predict_egz = np.sum(arr) / sum_alpha\r\n # weak learner\r\n if predict_egz >= 0.5:\r\n return 1\r\n else:\r\n return 0","def kp_l2_loss(kp_pred, kp_gt):\n criterion = torch.nn.MSELoss()\n\n vis = (kp_gt[:, :, 2, None] > 0).float()\n\n # This always has to be (output, target), not (target, output)\n return criterion(vis * kp_pred, vis * kp_gt[:, :, :2])","def binary_svm_loss(theta, X, y, C):\n\n m, d = X.shape\n grad = np.zeros(theta.shape)\n J = 0\n\n ############################################################################\n # TODO #\n # Implement the binary SVM hinge loss function here #\n # 4 - 5 lines of vectorized code expected #\n ############################################################################\n J=0.5*np.sum(theta**2)/m\n J=J+C*np.sum(np.maximum(0,1-np.multiply(y,(np.dot(X,theta)))))/m\n \n grad=theta/m\n temp_1=np.dot(X,theta)\n temp_2=np.multiply(y,temp_1)\n\n temp_3=y[temp_2<1]\n temp_4=X[temp_2<1,:]\n temp_5=np.dot(temp_4.T,temp_3)\n grad=grad-temp_5*C/m\n\n\n# for j in range(d):\n# \tgrad[j]=float(theta[j]/m)\n# \tfor k in range(m):\n#\t \tif (y[k]*(np.dot(theta,X[k,:]))<1):\n#\t \t\tgrad[j]=grad[j]-float(C*y[k]*X[k,j]/m)\n\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################\n\n return J, grad","def _create_loss(self):\n\n with tf.name_scope(\"loss\"):\n \n # gini=(tf.nn.l2_loss( self.score))/100000\n gini = tf.losses.softmax_cross_entropy(self.score, 0*self.score)\n \n promo_prob=tf.reduce_sum(tf.multiply(self.score, self.cohort_weight),\n axis=1)\n inc_value = tf.reduce_mean(tf.multiply(promo_prob, self.value))- self.control_value\n inc_cost = tf.reduce_mean( tf.multiply(promo_prob, self.cost)) - self.control_cost\n \n\n\n # determine loss function based on self.obj_rule\n if self.obj_rule == 'cpiv':\n self.objective = inc_cost / inc_value\n\n elif self.obj_rule == 'ivc':\n # maximize ivc\n self.objective = - inc_value / inc_cost\n\n elif self.obj_rule == 'lagrangian':\n assert self.shadow is not None, 'Need to pass in shadow value if use lagrangian as obj_rule.'\n self.objective = inc_cost - self.shadow * inc_value\n\n elif self.obj_rule == 'value':\n # maximize delta values\n self.objective = - inc_value\n\n # use only cost as objective\n elif self.obj_rule == 'cost':\n # maximize delta cost\n self.objective = - inc_cost\n\n else:\n raise Exception('Invalid obj_rule!')\n\n # regularization\n reg_loss = tf.reduce_sum(tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))\n # weights = tf.trainable_variables() # all vars of your graph\n # reg_loss = tf.norm( weights,ord=1)\n\n # final loss\n self.loss = self.objective +reg_loss+.1*gini","def test_error_rate(self):\n # For the penalty, the default loss is hinge.\n expected_signed_penalty_labels = (self._penalty_labels > 0.0) * 2.0 - 1.0\n expected_penalty_numerator = np.sum(\n np.maximum(\n 0.0,\n 1.0 - expected_signed_penalty_labels * self._penalty_predictions) *\n self._penalty_weights * self._penalty_predicate)\n expected_penalty_denominator = np.sum(\n self._penalty_weights * self._penalty_predicate)\n expected_penalty_value = (\n expected_penalty_numerator / expected_penalty_denominator)\n\n # For the constraint, the default loss is zero-one.\n expected_signed_constraint_labels = (\n (self._constraint_labels > 0.0) * 2.0 - 1.0)\n expected_constraint_numerator = np.sum(\n (0.5 * (1.0 - expected_signed_constraint_labels * np.sign(\n self._constraint_predictions))) * self._constraint_weights *\n self._constraint_predicate)\n expected_constraint_denominator = np.sum(\n self._constraint_weights * self._constraint_predicate)\n expected_constraint_value = (\n expected_constraint_numerator / expected_constraint_denominator)\n\n actual_expression = binary_rates.error_rate(self.context)\n self.check_rates(expected_penalty_value, expected_constraint_value,\n actual_expression)","def loss_fn(model):\n with flax.nn.stateful(state) as new_state:\n with flax.nn.stochastic(prng_key):\n logits = model(batch['image'])\n loss = cross_entropy_loss(logits, batch['label'])\n # TODO(britefury): check if applying L2 regularization to weights but\n # *not* biases improves results\n weight_penalty_params = jax.tree_leaves(model.params)\n weight_l2 = sum([jnp.sum(x ** 2)\n for x in weight_penalty_params\n if x.ndim > 1])\n weight_penalty = l2_reg * 0.5 * weight_l2\n loss = loss + weight_penalty\n return loss, (new_state, logits)","def optimization(logits, y, population, embedding, alpha):\n if FLAGS.uniform_weights:\n weights = tf.ones(shape=tf.shape(population))\n else:\n weights = tf.where(\n tf.greater(population, 0.01), tf.fill(tf.shape(population), 0.16),\n tf.fill(tf.shape(population), 2.5))\n if not FLAGS.propensity_weights:\n weights = tf.sigmoid(tf.matmul(embedding, alpha)) * weights\n weights /= tf.reduce_mean(weights)\n loss = tf.losses.hinge_loss(labels=y, logits=logits, weights=weights)\n optimizer = tf.train.AdamOptimizer(LEARNING_RATE).minimize(loss)\n return optimizer, loss","def loss_and_metrics_one_pair(self, params, rng):\n key_pq, key_samples = jax.random.split(rng)\n p_logits, q_logits = self.logit_pair_distribution_fn(key_pq)\n\n def sample_loss(key_sample):\n \"\"\"Computes loss for a single sample of a relaxed pair of outcomes.\"\"\"\n q_kwargs = dict(transpose=True) if self.use_transpose else {}\n soft_p = self.model.apply(\n params, p_logits, key_sample, method=self.model.sample_relaxed)\n soft_q = self.model.apply(\n params,\n q_logits,\n key_sample,\n method=self.model.sample_relaxed,\n **q_kwargs)\n coupling_loss_matrix = self.coupling_loss_matrix_fn(p_logits, q_logits)\n coupling_loss = jnp.sum(soft_p[:, None] * soft_q[None, :] *\n coupling_loss_matrix)\n\n return coupling_loss\n\n loss_samples = jax.vmap(sample_loss)(\n jax.random.split(key_samples, self.inner_num_samples))\n loss = jnp.mean(loss_samples)\n return loss, {\"loss\": loss}","def cost(self, x, y):\n return self.cross_entropy_error(x,y) + self.l2_regularization_penalty()","def weighted_bce(y_hat, target, labels, weight_multiplier):\n weight = labels.clone()\n weight.requires_grad = False\n weight[weight < 1] = 2\n weight[weight == 3] = 4\n weight = 2 / weight\n\n # apply mask\n weight = weight * weight_multiplier\n return F.binary_cross_entropy(y_hat, target, weight)","def hinge_loss(self, y_true=None, y_pred=None, decimal=5, **kwargs):\n y_true, y_pred, binary, representor, decimal = self.get_processed_data2(y_true, y_pred, decimal)\n if binary:\n # replacing 0 = -1\n y_true[y_true == 0] = -1\n y_pred[y_pred == 0] = -1\n res = np.mean([max(0, 1 - x * y) ** 2 for x, y in zip(y_true, y_pred)])\n return np.round(res, decimal)\n else:\n # Convert y_true to one-hot encoded array\n num_classes = len(np.unique(y_true))\n y_true = np.eye(num_classes)[y_true]\n neg = np.max((1 - y_true) * y_pred, axis=1)\n pos = np.sum(y_true * y_pred, axis=1)\n temp = neg - pos + 1\n temp[temp < 0] = 0\n return np.round(np.mean(temp), decimal)","def get_l2_penalty(nnet, include_bias=False, pow=2):\n\n l2_penalty = 0\n\n # do not include OC-SVM layer in regularization\n if Cfg.ocsvm_loss:\n if include_bias:\n for layer in nnet.trainable_layers:\n if not layer.issvm:\n if layer.b is not None:\n l2_penalty = (l2_penalty + T.sum(abs(layer.W) ** pow)\n + T.sum(abs(layer.b) ** pow))\n else:\n l2_penalty = l2_penalty + T.sum(abs(layer.W) ** pow)\n else:\n for layer in nnet.trainable_layers:\n if not layer.issvm:\n l2_penalty = l2_penalty + T.sum(abs(layer.W) ** pow)\n else:\n if include_bias:\n for layer in nnet.trainable_layers:\n if layer.b is not None:\n l2_penalty = (l2_penalty + T.sum(abs(layer.W) ** pow)\n + T.sum(abs(layer.b) ** pow))\n else:\n l2_penalty = l2_penalty + T.sum(abs(layer.W) ** pow)\n else:\n for layer in nnet.trainable_layers:\n l2_penalty = l2_penalty + T.sum(abs(layer.W) ** pow)\n\n return T.cast(l2_penalty, dtype='floatX')","def _pairwise_loss(self, pairwise_logits):\n raise NotImplementedError('Calling an abstract method.')","def objective(self):\n hinge_loss = tf.losses.hinge_loss(self.labels, self.predictions)\n\n return hinge_loss","def loss(loss_name):\n \n def contrastive_loss(y_true, y_pred, margin = 1):\n \"\"\"Implementation of the triplet loss function\n\n\n Contrastive loss = 0.5 * mean( (1-true_value) * square(distance) + true_value * square( max(margin-distance, 0) ))\n\n Args:\n y_true (int): true label, positive pair (same class) -> 0, \n negative pair (different class) -> 1\n \n y_pred (list): python list containing two objects in a pair of tensors:\n left : the encodings for one image data in a pair\n right : the encodings for the other image data in a pair\n margin (float, optional): m > 0 determines how far the embeddings of \n a negative pair should be pushed apart. Defaults to 1.\n\n\n Returns:\n loss (float): real number, value of the loss\n \"\"\"\n\n left = y_pred[0]\n right = y_pred[1]\n\n distance = tf.math.sqrt(tf.math.reduce_sum(tf.math.square(left - right), axis=-1))\n\n loss_positive = tf.math.square(distance)\n loss_negative = tf.math.square(tf.maximum(0., margin - distance))\n \n loss = y_true * loss_negative + (1 - y_true) * loss_positive\n loss = 0.5 * tf.math.reduce_mean(loss)\n\n return loss\n\n def triplet_loss(y_true, y_pred, margin = 1):\n \"\"\"Implementation of the triplet loss function\n\n Arguments:\n y_true : true labels, required when you define a loss in Keras, \n not applied in this function.\n\n y_pred (list): python list containing three objects:\n anchor : the encodings for the anchor data\n positive : the encodings for the positive data (similar to anchor)\n negative : the encodings for the negative data (different from anchor)\n \n margin (float, optional): m > 0 determines how far the embeddings of \n a negative data should be pushed apart. Defaults to 1.\n\n Returns:\n loss (float): real number, value of the loss\n \"\"\"\n\n anchor = y_pred[0]\n positive = y_pred[1]\n negative = y_pred[2]\n\n # squared distance between the anchor and the positive\n pos_dist = tf.math.reduce_sum(tf.math.square(anchor - positive), axis=-1)\n\n # squared distance between the anchor and the negative\n neg_dist = tf.math.reduce_sum(tf.math.square(anchor - negative), axis=-1)\n\n # compute loss\n basic_loss = margin + pos_dist - neg_dist\n loss = tf.math.maximum(basic_loss,0.0)\n loss = tf.math.reduce_mean(loss)\n return loss\n\n \n if loss_name == 'contrastive_loss':\n return contrastive_loss\n \n if loss_name == 'triplet_loss':\n return triplet_loss","def test_PoissonRegression_penalty_C(self):\n for penalty in PoissonRegression._penalties.keys():\n if penalty != 'none':\n if penalty == 'binarsity':\n learner = PoissonRegression(\n penalty=penalty, C=self.float_1, blocks_start=[0],\n blocks_length=[1])\n else:\n learner = PoissonRegression(penalty=penalty,\n C=self.float_1)\n self.assertEqual(learner.C, self.float_1)\n self.assertEqual(learner._prox_obj.strength, 1. / self.float_1)\n learner.C = self.float_2\n self.assertEqual(learner.C, self.float_2)\n self.assertEqual(learner._prox_obj.strength, 1. / self.float_2)\n\n msg = '^``C`` must be positive, got -1$'\n with self.assertRaisesRegex(ValueError, msg):\n if penalty == 'binarsity':\n PoissonRegression(penalty=penalty, C=-1,\n blocks_start=[0], blocks_length=[1])\n else:\n PoissonRegression(penalty=penalty, C=-1)\n else:\n msg = '^You cannot set C for penalty \"%s\"$' % penalty\n with self.assertWarnsRegex(RuntimeWarning, msg):\n PoissonRegression(penalty=penalty, C=self.float_1)\n\n learner = PoissonRegression(penalty=penalty)\n with self.assertWarnsRegex(RuntimeWarning, msg):\n learner.C = self.float_1\n\n msg = '^``C`` must be positive, got -2$'\n with self.assertRaisesRegex(ValueError, msg):\n learner.C = -2","def test_penalty_compute(self):\n objective = {'G': numpy.zeros((9)),\n 'H': numpy.diag((1,)*9),\n 'X': 1}\n for penalty in self.penalties:\n result = penalty.compute([1]*self.np, objective)\n assert isinstance(result,tuple)\n # more tests go here","def get_penalty(state, action, winrate_predictor):\n if violate_rule(state, action):\n return -1 \n return 0","def multiclass_hinge(\n x: ArrayLike,\n y_true: ArrayLike,\n hinge: float = 1.0,\n *,\n constant: Optional[bool] = None\n) -> Tensor:\n return Tensor._op(MulticlassHinge, x, op_args=(y_true, hinge), constant=constant)","def model_loss(\n model, true_vals, logit_pred_vals, epoch_num, avg_class_loss,\n att_prior_loss_weight, att_prior_loss_weight_anneal_type,\n att_prior_loss_weight_anneal_speed, att_prior_grad_smooth_sigma,\n fourier_att_prior_freq_limit, fourier_att_prior_freq_limit_softness,\n att_prior_loss_only, l2_reg_loss_weight, input_grads=None, status=None\n):\n corr_loss = model.correctness_loss(\n true_vals, logit_pred_vals, avg_class_loss\n )\n final_loss = corr_loss\n \n if att_prior_loss_weight > 0:\n att_prior_loss = model.fourier_att_prior_loss(\n status, input_grads, fourier_att_prior_freq_limit,\n fourier_att_prior_freq_limit_softness, att_prior_grad_smooth_sigma\n )\n\n # att_prior_loss = model.smoothness_att_prior_loss(status, input_grads)\n # att_prior_loss = model.sparsity_att_prior_loss(status, input_grads)\n \n if att_prior_loss_weight_anneal_type is None:\n weight = att_prior_loss_weight\n elif att_prior_loss_weight_anneal_type == \"inflate\":\n exp = np.exp(-att_prior_loss_weight_anneal_speed * epoch_num)\n weight = att_prior_loss_weight * ((2 / (1 + exp)) - 1)\n elif att_prior_loss_weight_anneal_type == \"deflate\":\n exp = np.exp(-att_prior_loss_weight_anneal_speed * epoch_num)\n weight = att_prior_loss_weight * exp\n\n if att_prior_loss_only:\n final_loss = att_prior_loss\n else:\n final_loss = final_loss + (weight * att_prior_loss)\n else:\n att_prior_loss = torch.zeros(1)\n\n # If necessary, add the L2 penalty\n if l2_reg_loss_weight > 0:\n l2_loss = util.place_tensor(torch.tensor(0).float())\n for param in model.parameters():\n if param.requires_grad_:\n l2_loss = l2_loss + torch.sum(param * param)\n final_loss = final_loss + (l2_reg_loss_weight * l2_loss)\n\n return final_loss, (corr_loss, att_prior_loss)","def loss(L, S, A, R, Y, alpha, beta, gamma, delta):\n return alpha*load_imbalance(Y,L,A) + beta*constraints(Y,A) + gamma*transfers(Y,R,S) + delta*choice(Y)","def multiclass_hinge_loss(predictions, targets, delta=1):\n num_cls = predictions.shape[1]\n if targets.ndim == predictions.ndim - 1:\n targets = theano.tensor.extra_ops.to_one_hot(targets, num_cls)\n elif targets.ndim != predictions.ndim:\n raise TypeError('rank mismatch between targets and predictions')\n corrects = predictions[targets.nonzero()]\n rest = theano.tensor.reshape(predictions[(1-targets).nonzero()],\n (-1, num_cls-1))\n rest = theano.tensor.max(rest, axis=1)\n return theano.tensor.nnet.relu(rest - corrects + delta)","def l2_loss(params):\n \"\"\" It is a vec for each branch\"\"\"\n loss_branches_vec = []\n # TODO This is hardcoded but all our cases rigth now uses four branches\n for i in range(len(params['branches']) -1):\n loss_branches_vec.append(((params['branches'][i] - params['targets']) **2\n * params['controls_mask'][i])\n * params['branch_weights'][i])\n \"\"\" The last branch is a speed branch\"\"\"\n # TODO: Activate or deactivate speed branch loss\n loss_branches_vec.append((params['branches'][-1] - params['inputs']) ** 2\n * params['branch_weights'][-1])\n return loss_branches_vec, {}","def __init__(self, target_real_label=1.0, target_fake_label=0.0):\n super(GANLocalLoss, self).__init__()\n # self.pooling = nn.MaxPool2d(kernel_size=4, stride=2, padding=1)\n self.adaptivepooling = nn.AdaptiveAvgPool2d(64)","def l2_loss(inputs, reduction='mean', **kwargs):\n args = ArgHelper.parse(locals())\n args['reduction'] = reduction.upper()\n op_lib = loss_ops_lib.L2Loss\n if context.executing_eagerly():\n return op_lib \\\n .instantiate(reduction=args['reduction']) \\\n .apply(inputs)\n else:\n return op_lib.blend(**args)","def test_PoissonRegression_penalty_elastic_net_ratio(self):\n ratio_1 = 0.6\n ratio_2 = 0.3\n for penalty in PoissonRegression._penalties.keys():\n if penalty == 'elasticnet':\n learner = PoissonRegression(penalty=penalty, C=self.float_1,\n elastic_net_ratio=ratio_1)\n self.assertEqual(learner.C, self.float_1)\n self.assertEqual(learner.elastic_net_ratio, ratio_1)\n self.assertEqual(learner._prox_obj.strength, 1. / self.float_1)\n self.assertEqual(learner._prox_obj.ratio, ratio_1)\n\n learner.elastic_net_ratio = ratio_2\n self.assertEqual(learner.C, self.float_1)\n self.assertEqual(learner.elastic_net_ratio, ratio_2)\n self.assertEqual(learner._prox_obj.ratio, ratio_2)\n\n else:\n msg = '^Penalty \"%s\" has no elastic_net_ratio attribute$$' % \\\n penalty\n with self.assertWarnsRegex(RuntimeWarning, msg):\n if penalty == 'binarsity':\n PoissonRegression(penalty=penalty,\n elastic_net_ratio=0.8,\n blocks_start=[0], blocks_length=[1])\n else:\n PoissonRegression(penalty=penalty,\n elastic_net_ratio=0.8)\n\n if penalty == 'binarsity':\n learner = PoissonRegression(\n penalty=penalty, blocks_start=[0], blocks_length=[1])\n else:\n learner = PoissonRegression(penalty=penalty)\n\n with self.assertWarnsRegex(RuntimeWarning, msg):\n learner.elastic_net_ratio = ratio_1","def l2_regularization_penalty(self):\n return self.l2 * (np.linalg.norm(self.weights)**2)","def binary_svm_loss(theta, X, y, C):\n\n m, d = X.shape\n grad = np.zeros(theta.shape)\n J = 0\n\n ############################################################################\n # TODO #\n # Implement the binary SVM hinge loss function here #\n # 4 - 5 lines of vectorized code expected #\n ############################################################################\n h = np.dot(X, theta)\n J = 1.0 / 2 / m * np.sum(theta**2) + 1.0 * C / m * np.sum(np.max([np.zeros(m), 1 - y * h], axis = 0))\n\n grad = 1.0 / m * theta + 1.0 * C / m * np.dot(X.T, -y * (y * h < 1))\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################\n\n return J, grad","def loss_opt_metric(self):\n self.loss = tf.keras.losses.SparseCategoricalCrossentropy()\n self.optimizer = tf.keras.optimizers.Adam(learning_rate=self.init_lr)\n self.metric_loss = tf.keras.metrics.Mean()\n self.accuracy = tf.keras.metrics.SparseCategoricalAccuracy()","def create_loss_and_optimizer(net, learning_rate=0.01):\n loss = nn.CrossEntropyLoss()\n optimizer = optim.SGD(net.parameters(), lr=learning_rate, momentum=0.99, weight_decay=5 * 1e-4)\n return loss, optimizer","def policy_loss(sal_box_prob, oracle_action, sample_weights):\n loss = tf.nn.softmax_cross_entropy_with_logits(logits=sal_box_prob, labels=oracle_action)\n \n return tf.reduce_mean(loss) * (1.0 - sample_weights / 10.0)","def compute_loss(self):","def hinge(d_real_logits, d_fake_logits, d_real=None, d_fake=None):\n with tf.name_scope(\"hinge_loss\"):\n check_dimensions(d_real, d_fake, d_real_logits, d_fake_logits)\n d_loss_real = tf.reduce_mean(tf.nn.relu(1.0 - d_real_logits))\n d_loss_fake = tf.reduce_mean(tf.nn.relu(1.0 + d_fake_logits))\n d_loss = d_loss_real + d_loss_fake\n g_loss = - tf.reduce_mean(d_fake_logits)\n return d_loss, d_loss_real, d_loss_fake, g_loss","def _default_config(self):\n return {\n 'penalty': 'l1',\n 'solver': 'liblinear'\n }","def penalty(obs, player_x, player_y):\n def environment_fits(obs, player_x, player_y):\n \"\"\" environment fits constraints \"\"\"\n # it is penalty game mode\n if obs['game_mode'] == GameMode.Penalty:\n return True\n return False\n \n def get_action(obs, player_x, player_y):\n \"\"\" get action of this memory pattern \"\"\"\n if (random.random() < 0.5 and\n Action.TopRight not in obs[\"sticky_actions\"] and\n Action.BottomRight not in obs[\"sticky_actions\"]):\n return Action.TopRight\n else:\n if Action.BottomRight not in obs[\"sticky_actions\"]:\n return Action.BottomRight\n return Action.Shot\n \n return {\"environment_fits\": environment_fits, \"get_action\": get_action}","def learnign_rate_examples():\n #######\n bad_larning_rate = 0.1\n not_bad_learning_rate = 1e-4\n good_learning_rate = 1e-3\n #######\n return bad_larning_rate, not_bad_learning_rate, good_learning_rate","def model_loss(inp, fake, real_label, fake_label):\n \n \n Dreal,realcls,R1 = gradpen(inp)\n [Dfake,fakecls] = D(fake)\n # 1. Adversarial loss\n \n glabel = tf.ones_like(Dfake)#tf.random.uniform((Dfake.shape), 1-LN, 1)\n dlabelr = tf.ones_like(Dreal)#tf.random.uniform((Dreal.shape), 1-LN, 1)\n dlabelf = tf.zeros_like(Dfake)#tf.random.uniform((Dfake.shape), 0, LN)\n \n \n \n # D has no sigmoid activation: \"from_logits=True\"\n real_loss = tf.keras.losses.binary_crossentropy(\n dlabelr, Dreal, from_logits=True)\n real_loss = tf.reduce_mean(real_loss)\n \n fake_loss = tf.keras.losses.binary_crossentropy(\n dlabelf, Dfake, from_logits=True)\n fake_loss = tf.reduce_mean(fake_loss)\n \n Dadv = 0.5*(real_loss+fake_loss)\n \n Gadv = tf.keras.losses.binary_crossentropy(\n glabel, Dfake, from_logits=True)\n Gadv = tf.reduce_mean(Gadv)\n \n # 2. Classification loss\n \n Dcls = tf.keras.losses.binary_crossentropy(real_label, realcls, from_logits=True)\n Dcls = tf.reduce_mean(Dcls)\n \n Gcls = tf.keras.losses.binary_crossentropy(fake_label, fakecls, from_logits=True)\n Gcls = tf.reduce_mean(Gcls)\n \n # 3. Total loss\n \n Dloss = Dadv + (GAMMA/2)*R1 + LAMBDA_CLS*Dcls\n \n Gloss = Gadv + LAMBDA_CLS*Gcls\n \n return (Dloss, Dadv, Dcls, R1), (Gloss, Gadv, Gcls)","def add_loss(self):\n \n raise RuntimeError(\"Must define function add_loss(self)\")","def lgb_hyperopt(data, labels, num_evals=1000, n_folds=5, diagnostic=False):\r\n LGBM_MAX_LEAVES = 2**11 #maximum number of leaves per tree for LightGBM\r\n LGBM_MAX_DEPTH = 25 #maximum tree depth for LightGBM \r\n EVAL_METRIC_LGBM_CLASS = 'f1'\r\n\r\n def lgb_f1_score(y_hat, data):\r\n y_true = data.get_label()\r\n y_hat = np.round(y_hat)\r\n return 'f1', f1_score(y_true, y_hat), True\r\n\r\n print('Running {} rounds of LightGBM parameter optimisation:'.format(num_evals))\r\n #clear space\r\n \r\n integer_params = ['max_depth',\r\n 'num_leaves',\r\n 'max_bin',\r\n 'min_data_in_leaf',\r\n 'min_data_in_bin']\r\n \r\n def objective(space_params):\r\n \r\n #cast integer params from float to int\r\n for param in integer_params:\r\n space_params[param] = int(space_params[param])\r\n \r\n #extract nested conditional parameters\r\n if space_params['boosting']['boosting'] == 'goss':\r\n top_rate = space_params['boosting'].get('top_rate')\r\n other_rate = space_params['boosting'].get('other_rate')\r\n #0 <= top_rate + other_rate <= 1\r\n top_rate = max(top_rate, 0)\r\n top_rate = min(top_rate, 0.5)\r\n other_rate = max(other_rate, 0)\r\n other_rate = min(other_rate, 0.5)\r\n space_params['top_rate'] = top_rate\r\n space_params['other_rate'] = other_rate\r\n \r\n subsample = space_params['boosting'].get('subsample', 1.0)\r\n space_params['boosting'] = space_params['boosting']['boosting']\r\n space_params['subsample'] = subsample\r\n \r\n cv_results = lgb.cv(space_params, train, nfold = n_folds, stratified=True,\r\n early_stopping_rounds=100, seed=42, feval=lgb_f1_score)\r\n \r\n best_loss = -cv_results['f1-mean'][-1]\r\n\r\n return{'loss':best_loss, 'status': STATUS_OK }\r\n \r\n train = lgb.Dataset(data, labels)\r\n \r\n #integer and string parameters, used with hp.choice()\r\n boosting_list = [{'boosting': 'gbdt',\r\n 'subsample': hp.uniform('subsample', 0.5, 1)},\r\n {'boosting': 'goss',\r\n 'subsample': 1.0,\r\n 'top_rate': hp.uniform('top_rate', 0, 0.5),\r\n 'other_rate': hp.uniform('other_rate', 0, 0.5)}] #if including 'dart', make sure to set 'n_estimators'\r\n\r\n objective_list_reg = ['huber', 'gamma', 'fair', 'tweedie']\r\n objective_list_class = ['binary', 'cross_entropy']\r\n objective_list = objective_list_class\r\n is_unbalance_list = [True]\r\n\r\n space ={'boosting' : hp.choice('boosting', boosting_list),\r\n 'num_leaves' : hp.quniform('num_leaves', 2, LGBM_MAX_LEAVES, 1),\r\n 'max_depth': hp.quniform('max_depth', 2, LGBM_MAX_DEPTH, 1),\r\n 'max_bin': hp.quniform('max_bin', 32, 255, 1),\r\n 'min_data_in_leaf': hp.quniform('min_data_in_leaf', 1, 256, 1),\r\n 'min_data_in_bin': hp.quniform('min_data_in_bin', 1, 256, 1),\r\n 'min_gain_to_split' : hp.quniform('min_gain_to_split', 0.1, 5, 0.01),\r\n 'lambda_l1' : hp.uniform('lambda_l1', 0, 5),\r\n 'lambda_l2' : hp.uniform('lambda_l2', 0, 5),\r\n 'learning_rate' : hp.loguniform('learning_rate', np.log(0.005), np.log(0.2)),\r\n 'metric' : None, \r\n 'objective' : hp.choice('objective', objective_list),\r\n 'feature_fraction' : hp.quniform('feature_fraction', 0.5, 1, 0.01),\r\n 'bagging_fraction' : hp.quniform('bagging_fraction', 0.5, 1, 0.01),\r\n 'is_unbalance' : hp.choice('is_unbalance', is_unbalance_list)\r\n }\r\n\r\n trials = Trials()\r\n best = fmin(fn=objective,\r\n space=space,\r\n algo=tpe.suggest,\r\n max_evals=num_evals, \r\n trials=trials)\r\n \r\n #fmin() will return the index of values chosen from the lists/arrays in 'space'\r\n #to obtain actual values, index values are used to subset the original lists/arrays\r\n #extract nested conditional parameters\r\n try:\r\n if best['boosting']['boosting'] == 'goss':\r\n top_rate = best['boosting'].get('top_rate')\r\n other_rate = best['boosting'].get('other_rate')\r\n #0 <= top_rate + other_rate <= 1\r\n top_rate = max(top_rate, 0)\r\n top_rate = min(top_rate, 0.5)\r\n other_rate = max(other_rate, 0)\r\n other_rate = min(other_rate, 0.5)\r\n best['top_rate'] = top_rate\r\n best['other_rate'] = other_rate\r\n except:\r\n if boosting_list[best['boosting']]['boosting'] == 'goss':\r\n top_rate = best['top_rate']\r\n other_rate = best['other_rate']\r\n #0 <= top_rate + other_rate <= 1\r\n top_rate = max(top_rate, 0)\r\n top_rate = min(top_rate, 0.5)\r\n other_rate = max(other_rate, 0)\r\n other_rate = min(other_rate, 0.5)\r\n best['top_rate'] = top_rate\r\n best['other_rate'] = other_rate\r\n best['boosting'] = boosting_list[best['boosting']]['boosting']#nested dict, index twice\r\n best['metric'] = metric_list[best['metric']]\r\n best['objective'] = objective_list[best['objective']]\r\n best['is_unbalance'] = is_unbalance_list[best['is_unbalance']]\r\n \r\n #cast floats of integer params to int\r\n for param in integer_params:\r\n best[param] = int(best[param])\r\n \r\n print('{' + '\\n'.join('{}: {}'.format(k, v) for k, v in best.items()) + '}')\r\n if diagnostic:\r\n return(best, trials)\r\n else:\r\n return(best)","def combined_loss(prediction, target, max_value, ssim_weight=0.5):\n ssim_l = ssim_loss(prediction, target, max_value)\n nmse_l = nmse_loss(prediction, target)\n total_loss = nmse_l + (ssim_l * ssim_weight)\n return total_loss","def verbose_loss(self, feedback: _Feedback, extra_info) -> Dict[str, _Array]:\n hint_preds, diff_logits, gt_diffs = extra_info\n\n for inp in feedback.features.inputs:\n if inp.location in [_Location.NODE, _Location.EDGE]:\n nb_nodes = inp.data.shape[1]\n break\n\n total_loss = 0.0\n lengths = feedback.features.lengths\n\n losses = {}\n if self.decode_diffs:\n for loc in _Location:\n for i in range(len(gt_diffs)):\n is_not_done = _is_not_done_broadcast(lengths, i, gt_diffs[i][loc])\n diff_loss = (\n jnp.maximum(diff_logits[i][loc], 0) -\n diff_logits[i][loc] * gt_diffs[i][loc] +\n jnp.log1p(jnp.exp(-jnp.abs(diff_logits[i][loc]))) * is_not_done)\n losses[loc.name + '_diff_%d' % i] = jnp.mean(diff_loss)\n\n if self.decode_hints:\n for truth in feedback.features.hints:\n for i in range(truth.data.shape[0] - 1):\n assert truth.name in hint_preds[i]\n pred = hint_preds[i][truth.name]\n is_not_done = _is_not_done_broadcast(lengths, i, truth.data[i + 1])\n if truth.type_ == _Type.SCALAR:\n if self.decode_diffs:\n total_loss = jnp.mean((pred - truth.data[i + 1])**2 *\n gt_diffs[i][truth.location] * is_not_done)\n else:\n total_loss = jnp.mean((pred - truth.data[i + 1])**2 * is_not_done)\n elif truth.type_ == _Type.MASK:\n if self.decode_diffs:\n total_loss = jnp.mean(\n jnp.maximum(pred, 0) - pred * truth.data[i + 1] +\n jnp.log1p(jnp.exp(-jnp.abs(pred))) *\n gt_diffs[i][truth.location] * is_not_done)\n else:\n total_loss = jnp.mean(\n jnp.maximum(pred, 0) - pred * truth.data[i + 1] +\n jnp.log1p(jnp.exp(-jnp.abs(pred))) * is_not_done)\n elif truth.type_ == _Type.MASK_ONE:\n if self.decode_diffs:\n total_loss = jnp.mean(\n -jnp.sum(\n truth.data[i + 1] * jax.nn.log_softmax(\n pred) * is_not_done, axis=-1, keepdims=True) *\n gt_diffs[i][truth.location])\n else:\n total_loss = jnp.mean(-jnp.sum(\n truth.data[i + 1] * jax.nn.log_softmax(\n pred) * is_not_done, axis=-1))\n elif truth.type_ == _Type.CATEGORICAL:\n if self.decode_diffs:\n total_loss = jnp.mean(\n -jnp.sum(\n truth.data[i + 1] * jax.nn.log_softmax(\n pred), axis=-1, keepdims=True) *\n jnp.expand_dims(gt_diffs[i][truth.location], -1) *\n is_not_done)\n else:\n total_loss = jnp.mean(-jnp.sum(\n truth.data[i + 1] * jax.nn.log_softmax(pred), axis=-1) *\n is_not_done)\n elif truth.type_ == _Type.POINTER:\n if self.decode_diffs:\n total_loss = jnp.mean(-jnp.sum(\n hk.one_hot(truth.data[i + 1], nb_nodes) *\n jax.nn.log_softmax(pred),\n axis=-1) * gt_diffs[i][truth.location] * is_not_done)\n else:\n total_loss = jnp.mean(-jnp.sum(\n hk.one_hot(truth.data[i + 1], nb_nodes) *\n jax.nn.log_softmax(pred),\n axis=-1) * is_not_done)\n else:\n raise ValueError('Incorrect type')\n losses[truth.name + '_%d' % i] = total_loss\n return losses","def get_loss(self, xs, y):\n \"*** YOUR CODE HERE question 4 ***\"\n return nn.SoftmaxLoss(self.run(xs), y)","def l2_loss(input, target):\n pos_inds = torch.nonzero(target > 0.0).squeeze(1)\n if pos_inds.shape[0] > 0:\n cond = torch.abs(input[pos_inds] - target[pos_inds])\n loss = 0.5 * cond**2 / pos_inds.shape[0]\n else:\n loss = input * 0.0\n return loss.sum()","def L2Learning(**kwargs):\n past_task_params = kwargs['past_task_params']\n dataloader = kwargs['dataloader']\n epochs = kwargs['epochs']\n optim = kwargs['optim']\n crit = kwargs['crit']\n net = kwargs['net']\n ld = kwargs['ld']\n\n for epoch in range(epochs):\n running_loss = 0.0\n for x, y in dataloader:\n if torch.cuda.is_available():\n x = x.cuda()\n y = y.cuda()\n\n optim.zero_grad()\n outputs = net(x)\n loss = crit(outputs, y)\n\n reg = 0.0\n for past_param in past_task_params:\n for i, param in enumerate(net.parameters()):\n penalty = (past_param[i] - param) ** 2\n reg += penalty.sum()\n loss += reg * (ld / 2)\n\n loss.backward()\n optim.step()\n running_loss += loss.item()\n\n if epoch % 10 == 9:\n print(\"[Epoch %d/%d] Loss: %.3f\"%(epoch+1, epochs, running_loss))\n\n ### Save parameters to use next task learning\n tensor_param = []\n for params in net.parameters():\n tensor_param.append(params.detach().clone())\n '''\n tensor_param = torch.stack(tensor_param)\n\n if past_task_params.nelement() > 0:\n past_task_params = torch.cat((past_task_params, tensor_param.unsqueeze(0)))\n else:\n past_task_params = tensor_param.unsqueeze(0)\n '''\n past_task_params.append(tensor_param)","def human_policy_kl_loss(student_logits, teacher_logits, action_type_kl_cost):\n # student_logits: list of ArgsActionLogits\n action_type_loss = kl(student_logits, teacher_logits, 1)\n kl_loss = action_type_kl_cost * torch.mean(action_type_loss)\n\n return kl_loss","def get_loss(self, xs, y):\n \"*** YOUR CODE HERE ***\"\n predictedY = self.run(xs)\n return nn.SoftmaxLoss(predictedY, y)\n # return nn.SquareLoss(predictedY, y)","def target_multi_objective2(\n config: Configuration,\n seed: int,\n # instance: str,\n # budget: float,\n) -> dict[str, float]:\n return {\"cost1\": seed, \"cost2\": seed}","def test_get_hyperflex_auto_support_policy_by_moid(self):\n pass","def init_loss(config):\n if config.loss == 'cross_entropy':\n criterion = nn.CrossEntropyLoss()\n elif config.loss == 'label_smoothing':\n class LabelSmoothingLoss(nn.Module):\n def __init__(self, smoothing=0.0):\n super(LabelSmoothingLoss, self).__init__()\n self.smoothing = smoothing\n\n def forward(self, prediction, target):\n assert 0 <= self.smoothing < 1\n neglog_softmaxPrediction = -prediction.log_softmax(dim=1)\n\n with torch.no_grad():\n smoothedLabels = self.smoothing / (prediction.size(1) - 1) * torch.ones_like(prediction)\n smoothedLabels.scatter_(1, target.data.unsqueeze(1), 1 - self.smoothing)\n return torch.mean(torch.sum(smoothedLabels * neglog_softmaxPrediction, dim=1))\n criterion = LabelSmoothingLoss(smoothing=config.ls_smoothing)\n elif config.loss == 'maxup':\n return None\n return criterion","def lp_reg(x, y, critic):\n batch_size = x.size()[0]\n \n t = torch.rand(batch_size, 1)\n t = t.expand(x.size())\n t_ = t*x + (1-t)*y\n t_ = torch.autograd.Variable(t_, requires_grad=True)\n \n t_grad = critic(t_)\n grad = torch.autograd.grad(t_grad, t_, grad_outputs=torch.ones(t_grad.size()),\n create_graph=True, retain_graph=True)[0]\n \n zeros = torch.zeros(batch_size, 1)\n penalty = torch.max((torch.norm(grad, dim=1)-1), zeros)\n return (penalty**2).mean()","def calculate_kg_loss(self, interaction):\n\n if self.restore_user_e is not None or self.restore_entity_e is not None:\n self.restore_user_e, self.restore_entity_e = None, None\n\n # get loss for training kg\n h = interaction[self.HEAD_ENTITY_ID]\n r = interaction[self.RELATION_ID]\n pos_t = interaction[self.TAIL_ENTITY_ID]\n neg_t = interaction[self.NEG_TAIL_ENTITY_ID]\n\n h_e, r_e, pos_t_e, neg_t_e = self._get_kg_embedding(h, r, pos_t, neg_t)\n pos_tail_score = ((h_e + r_e - pos_t_e) ** 2).sum(dim=1)\n neg_tail_score = ((h_e + r_e - neg_t_e) ** 2).sum(dim=1)\n kg_loss = F.softplus(pos_tail_score - neg_tail_score).mean()\n kg_reg_loss = self.reg_loss(h_e, r_e, pos_t_e, neg_t_e)\n loss = kg_loss + self.reg_weight * kg_reg_loss\n\n return loss","def loss(self, X, y=None, reg=0.0):\n\n self.layers = []\n layers = self.layers\n layers.append(X)\n\n # Unpack variables from the params dictionary\n W1, b1 = self.params['W1'], self.params['b1']\n W2, b2 = self.params['W2'], self.params['b2']\n N, D = X.shape\n H, C = W2.shape\n\n # Compute the forward pass\n scores = None\n #############################################################################\n # TODO: Perform the forward pass, computing the class scores for the input. #\n # Store the result in the scores variable, which should be an array of #\n # shape (N, C). #\n #############################################################################\n mid = np.maximum(0, X.dot(W1) + b1.reshape(1, -1)) # activation\n scores = mid.dot(W2) + b2.reshape(1, -1)\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################\n\n # If the targets are not given then jump out, we're done\n if y is None:\n return scores\n\n # Compute the loss\n loss = None\n #############################################################################\n # TODO: Finish the forward pass, and compute the loss. This should include #\n # both the data loss and L2 regularization for W1 and W2. Store the result #\n # in the variable loss, which should be a scalar. Use the Softmax #\n # classifier loss. So that your results match ours, multiply the #\n # regularization loss by 0.5 #\n #############################################################################\n exp_score = np.exp(scores)\n exp_score_sum = exp_score.sum(axis=1)\n correct_score = exp_score[np.arange(N), y]\n probability = (correct_score / exp_score_sum).reshape(-1, 1)\n loss = -np.log(probability).sum()\n\n loss /= N\n loss += 0.5 * reg * (np.sum(W1 * W1) + np.sum(W2 * W2))\n\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################\n\n # Backward pass: compute gradients\n grads = {}\n #############################################################################\n # TODO: Compute the backward pass, computing the derivatives of the weights #\n # and biases. Store the results in the grads dictionary. For example, #\n # grads['W1'] should store the gradient on W1, and be a matrix of same size #\n #############################################################################\n des = np.tile((-correct_score / np.square(exp_score_sum)).reshape(-1, 1), (1, C))\n des[np.arange(N), y] += 1.0 / exp_score_sum\n dsoftmax = des * (-np.ones((mid.shape[0], 1)) / probability) * np.exp(scores)\n\n # W2\n grads['W2'] = mid.T.dot(dsoftmax)\n grads['W2'] /= N\n grads['W2'] += reg * W2\n\n # b2\n grads['b2'] = np.ones_like(b2.reshape(1, -1)) * dsoftmax\n grads['b2'] = np.mean(grads['b2'], axis=0).reshape(-1)\n\n # W1\n binary = np.zeros_like(mid)\n binary[mid > 0] = 1\n grads['W1'] = X.T.dot(binary * dsoftmax.dot(W2.T)) # chain rule, compute dmid/dW1 * dscore/dmid * dsoftmax\n grads['W1'] /= N\n grads['W1'] += reg * W1\n\n # b1\n grads['b1'] = np.ones_like(b1.reshape(1, -1)) * binary * dsoftmax.dot(W2.T)\n grads['b1'] = np.mean(grads['b1'], axis=0).reshape(-1)\n\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################\n\n return loss, grads","def compile_update_default(nnet, inputs, targets):\n\n floatX = Cfg.floatX\n C = Cfg.C\n\n if len(nnet.all_layers) > 1:\n feature_layer = nnet.all_layers[-2]\n else:\n feature_layer = nnet.input_layer\n final_layer = nnet.svm_layer\n trainable_params = lasagne.layers.get_all_params(final_layer,\n trainable=True)\n\n # Regularization\n if Cfg.weight_decay:\n l2_penalty = (floatX(0.5) / C) * get_l2_penalty(nnet, Cfg.include_bias)\n else:\n l2_penalty = T.cast(0, dtype='floatX')\n\n # Backpropagation\n prediction = lasagne.layers.get_output(final_layer, inputs=inputs,\n deterministic=False)\n objective, train_acc = final_layer.objective(prediction, targets)\n train_loss = T.cast((objective) / targets.shape[0], dtype='floatX')\n train_acc = T.cast(train_acc * 1. / targets.shape[0], dtype='floatX')\n train_obj = l2_penalty + train_loss\n updates = get_updates(nnet, train_obj, trainable_params, solver=nnet.solver)\n nnet.backprop = theano.function([inputs, targets],\n [train_obj, train_acc],\n updates=updates)\n\n # Hinge loss\n nnet.hinge_loss = theano.function([inputs, targets],\n [train_loss, train_acc])\n\n # Forwardpropagation\n test_prediction = lasagne.layers.get_output(final_layer, inputs=inputs,\n deterministic=True)\n if nnet.data.n_classes == 2:\n scores = test_prediction[:, 1] - test_prediction[:, 0]\n else:\n scores = T.zeros_like(targets)\n objective, test_acc = final_layer.objective(test_prediction, targets)\n test_loss = T.cast(objective / targets.shape[0], dtype='floatX')\n test_acc = T.cast(test_acc * 1. / targets.shape[0], dtype='floatX')\n test_obj = l2_penalty + test_loss\n # get network feature representation\n test_rep = lasagne.layers.get_output(feature_layer, inputs=inputs,\n deterministic=True)\n test_rep_norm = test_rep.norm(L=2, axis=1)\n nnet.forward = theano.function([inputs, targets],\n [test_obj, test_acc, scores, l2_penalty,\n test_rep_norm, test_loss])","def loss(self, X, y=None):\r\n mode = 'test' if y is None else 'train'\r\n\r\n if self.dropout_param is not None:\r\n self.dropout_param['mode'] = mode\r\n if self.use_batchnorm:\r\n for bn_param in self.bn_params:\r\n bn_param[mode] = mode\r\n\r\n\r\n W1, b1 = self.params['W1'], self.params['b1']\r\n W2, b2 = self.params['W2'], self.params['b2']\r\n W3, b3 = self.params['W3'], self.params['b3']\r\n gamma1, beta1 = self.params['gamma1'], self.params['beta1']\r\n gamma2, beta2 = self.params['gamma2'], self.params['beta2']\r\n # pass conv_param to the forward pass for the convolutional layer\r\n filter_size = W1.shape[2]\r\n conv_param = {'stride': 1, 'pad': int((filter_size - 1) / 2)}\r\n\r\n # pass pool_param to the forward pass for the max-pooling layer\r\n pool_param = {'pool_height': 2, 'pool_width': 2, 'stride': 2}\r\n\r\n scores = None\r\n ############################################################################\r\n # TODO: Implement the forward pass for the three-layer convolutional net, #\r\n # computing the class scores for X and storing them in the scores #\r\n # variable. #\r\n ############################################################################\r\n alpha = 0.1\r\n csrp1, csrp1_cache = conv_sbn_lrelu_pool_forward(X, W1, b1, gamma1, beta1, self.bn_params[0], conv_param, pool_param, alpha)\r\n abr1, abr1_cache = affine_bn_lrelu_forward(csrp1, W2, b2, gamma2, beta2, self.bn_params[1], alpha)\r\n scores, out_cache = affine_forward(abr1, W3, b3)\r\n ############################################################################\r\n # END OF YOUR CODE #\r\n ############################################################################\r\n\r\n if y is None:\r\n return scores\r\n\r\n loss, grads = 0, {}\r\n ############################################################################\r\n # TODO: Implement the backward pass for the three-layer convolutional net, #\r\n # storing the loss and gradients in the loss and grads variables. Compute #\r\n # data loss using softmax, and make sure that grads[k] holds the gradients #\r\n # for self.params[k]. Don't forget to add L2 regularization! #\r\n ############################################################################\r\n loss, dp = softmax_loss(scores, y)\r\n loss += 0.5 * self.reg * np.sum(\r\n np.sum(W1 ** 2) + np.sum(W2 ** 2) + np.sum(W3 ** 2)\r\n )\r\n dp, dw3, db3 = affine_backward(dp, out_cache)\r\n dp, dw2, db2, dgamma2, dbeta2 = affine_bn_lrelu_backward(dp, abr1_cache)\r\n dp, dw1, db1, dgamma1, dbeta1 = conv_sbn_lrelu_pool_backward(dp, csrp1_cache)\r\n grads['W1'] = dw1 + self.reg * W1\r\n grads['W2'] = dw2 + self.reg * W2\r\n grads['W3'] = dw3 + self.reg * W3\r\n grads['b1'] = db1\r\n grads['b2'] = db2\r\n grads['b3'] = db3\r\n grads['gamma2'] = dgamma2\r\n grads['gamma1'] = dgamma1\r\n grads['beta2'] = dbeta2\r\n grads['beta1'] = dbeta1\r\n \r\n ############################################################################\r\n # END OF YOUR CODE #\r\n ############################################################################\r\n\r\n return loss, grads","def test_gradient_descent_blobs():\n features, _, targets, _ = load_data('blobs')\n\n hinge = make_predictions(features, targets, 'hinge', None)\n # assert np.all(hinge == targets)\n\n # l1_hinge = make_predictions(features, targets, 'hinge', 'l1')\n # # assert np.all(l1_hinge == targets)\n #\n # l2_hinge = make_predictions(features, targets, 'hinge', 'l2')\n # # assert np.all(l2_hinge == targets)\n #\n # squared = make_predictions(features, targets, 'squared', None)\n # # assert np.all(squared == targets)\n #\n # l1_squared = make_predictions(features, targets, 'squared', 'l1')\n #\n # l2_squared = make_predictions(features, targets, 'squared', 'l2')","def train(self, use_mini=False, use_mse=False):\n # decide whether to use MSE as the keypoint loss function\n if use_mse: # to use MSE loss\n loss_fn = squared_l2_norm\n else: # to use KL divergence loss\n loss_fn = kl_divergence\n\n # generate model\n if not use_mini:\n keypoint_inter, silhouette_inter, keypoint_output, silhouette_output = self.model()\n else:\n keypoint_inter, silhouette_inter, keypoint_output, silhouette_output = self.mini_model()\n keypoint_summary = tf.summary.histogram('keypoint_summary', keypoint_output)\n silhouette_summary = tf.summary.histogram('silhouette_summary', silhouette_output)\n\n with tf.variable_scope(name_or_scope='human2d_optimizer'):\n # loss functions\n if not use_mini:\n keypoint_loss = tf.reduce_mean(tf.concat(\n [tf.reduce_sum(loss_fn(self._keypoint, keypoint_inter), axis=[1, 2]),\n tf.reduce_sum(loss_fn(self._keypoint, keypoint_output), axis=[1, 2])], axis=-1),\n name='keypoint_loss')\n silhouette_loss = tf.reduce_mean(tf.concat(\n [tf.reduce_sum(cross_entropy(self._silhouette, silhouette_inter), axis=[1, 2]),\n tf.reduce_sum(cross_entropy(self._silhouette, silhouette_output), axis=[1, 2])], axis=-1),\n name='silhouette_loss')\n else:\n keypoint_loss = tf.reduce_mean(tf.reduce_sum(loss_fn(self._keypoint, keypoint_output),\n axis=[1, 2]), name='keypoint_loss')\n silhouette_loss = tf.reduce_mean(tf.reduce_sum(cross_entropy(self._silhouette, silhouette_output),\n axis=[1, 2]), name='silhouette_loss')\n total_loss = 100 * keypoint_loss + silhouette_loss\n loss_summary = tf.summary.scalar('loss_summary', total_loss)\n\n # optimizer\n optimizer = tf.train.AdamOptimizer(learning_rate=self.learning_rate)\n update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\n with tf.control_dependencies(update_ops):\n train_ops = optimizer.minimize(total_loss)\n # unfrozen = [var for var in tf.trainable_variables() if not var.name.startswith('')]\n # grads_and_vars = optimizer.compute_gradients(total_loss, var_list=unfrozen)\n # capped_grads_and_vars = [(tf.clip_by_value(grad, -1., 1.), var) for grad, var in grads_and_vars]\n # train_ops = optimizer.apply_gradients(capped_grads_and_vars)\n\n # configuration\n if not os.path.isdir('model'):\n os.mkdir('model')\n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True\n config.gpu_options.per_process_gpu_memory_fraction = 0.5\n config.allow_soft_placement = True\n config.log_device_placement = False\n\n print('Start training Human2D')\n with tf.Session(config=config) as sess:\n # initialization\n sess.run(tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()))\n\n # saver\n saver = tf.train.Saver(max_to_keep=5)\n\n # store the network graph for tensorboard visualization\n writer = tf.summary.FileWriter('model/network_graph', sess.graph)\n merge_op = tf.summary.merge([keypoint_summary, silhouette_summary, loss_summary])\n\n # dataset\n data = Reader(filenames=self.filenames, image_size=self.image_size,\n batch_size=self.batch_size, num_epochs=self.num_epochs).feed()\n try:\n for i in range(self.iterations):\n # input\n _input, _silhouette, _keypoint, _, _ = sess.run(data)\n _, k_out, s_out, k_loss, s_loss, sm = sess.run([train_ops, keypoint_output, silhouette_output,\n keypoint_loss, silhouette_loss, merge_op],\n feed_dict={self.training: True, self._input: _input,\n self._silhouette: _silhouette,\n self._keypoint: _keypoint})\n if i % 10 == 0:\n print('iteration %d: keypoint loss = %f, silhouette loss = %f' % (i, k_loss, s_loss))\n if i % 200 == 0:\n writer.add_summary(sm, i)\n writer.flush()\n cv.imwrite('visual/input.jpg', _input[0, :, :, ::-1])\n cv.imwrite('visual/silhouette.jpg', Human2D.generate_silhouette(s_out[0]))\n for j in range(14):\n cv.imwrite('visual/keypoint_%d.jpg' % j, 255 * k_out[0, :, :, j])\n if i % 500 == 0 and i != 0:\n print('save at iteration %d' % i)\n saver.save(sess, 'model/%s/human2d' %\n (time.strftime('%Y-%m-%d_%H-%M-%S', time.localtime(time.time()))))\n # time.sleep(1)\n except tf.errors.OutOfRangeError:\n print('Done training -- epoch limit reached')\n writer.close()","def configure_loss(self) -> nn.Module:\n branch_losses = {}\n for branch, loss in self.branch_losses.items():\n if loss not in JOINT_SEG_LOSSES:\n raise ValueError(\n f\"Illegal joint loss given. Got: {loss}. Allowed are all the \"\n f\"permutations of: {list(SEG_LOSS_LOOKUP.keys())}\"\n )\n\n try:\n losses = loss.split(\"_\")\n except Exception:\n losses = [loss]\n\n loss_kwargs = {\"k\": None}\n if self.branch_loss_params is not None:\n loss_kwargs = self.branch_loss_params[branch]\n\n # set joint losses for each branch\n branch_losses[branch] = JointLoss(\n [Loss(loss_name, **loss_kwargs) for loss_name in losses]\n )\n\n return MultiTaskLoss(branch_losses=branch_losses)","def get_loss(self, x, y):\n \"*** YOUR CODE HERE question 3 ***\"\n return nn.SoftmaxLoss(self.run(x), y)","def setup_loss(self, h_s, h_e):\n with vs.variable_scope(\"loss\"):\n # masked_h_s = tf.boolean_mask(h_s, self.context_mask_placeholder)\n # masked_h_e = tf.boolean_mask(h_e, self.context_mask_placeholder)\n # loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(h_s, self.start_span_placeholder) +\n # tf.nn.softmax_cross_entropy_with_logits(h_e, self.end_span_placeholder))\n masked_h_s = tf.add(h_s, (1 - tf.cast(self.context_mask_placeholder, 'float')) * (-1e30))\n masked_h_e = tf.add(h_e, (1 - tf.cast(self.context_mask_placeholder, 'float')) * (-1e30))\n loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(masked_h_s, self.start_span_placeholder) +\n tf.nn.softmax_cross_entropy_with_logits(masked_h_e, self.end_span_placeholder))\n total_loss = loss\n return total_loss, masked_h_s, masked_h_e","def calculate_and_choose_additional_loss(segm: torch.Tensor, sam_output: torch.Tensor, sam_criterion,\n sam_criterion_outer):\n return choose_add_loss(*calculate_additional_loss(segm, sam_output, sam_criterion, sam_criterion_outer))","def get_spectral_penalty(nnet, include_bias=False):\n\n penalty = 0\n\n for layer in nnet.trainable_layers:\n if not layer.issvm:\n eigenvalues, eigvec = T.nlinalg.eigh(T.dot(layer.W, layer.W.T))\n eig_max = T.max(eigenvalues)\n penalty = penalty + eig_max\n\n if include_bias:\n for layer in nnet.trainable_layers:\n if (not layer.issvm) and (layer.b is not None):\n penalty = penalty + T.sum(abs(layer.b) ** 2)\n\n return T.cast(penalty, dtype='floatX')","def binary_hinge_loss(predictions, targets, delta=1, log_odds=None,\n binary=True):\n if log_odds is None: # pragma: no cover\n raise FutureWarning(\n \"The `log_odds` argument to `binary_hinge_loss` will change \"\n \"its default to `False` in a future version. Explicitly give \"\n \"`log_odds=True` to retain current behavior in your code, \"\n \"but also check the documentation if this is what you want.\")\n log_odds = True\n if not log_odds:\n predictions = theano.tensor.log(predictions / (1 - predictions))\n if binary:\n targets = 2 * targets - 1\n predictions, targets = align_targets(predictions, targets)\n return theano.tensor.nnet.relu(delta - predictions * targets)","def get_sparsity_penalty(nnet, inputs, sparsity, mode=\"mean\",\n deterministic=False):\n\n assert mode in (\"mean\", \"l1\")\n\n rho = sparsity\n penalty = 0\n eps = 0.0001 # for numerical stability\n\n for layer in nnet.all_layers:\n if layer.isactivation:\n\n activation = lasagne.layers.get_output(layer, inputs=inputs,\n deterministic=deterministic)\n\n if mode == \"mean\":\n if layer.isrelu:\n avg_activation = T.mean(T.gt(activation,\n T.zeros_like(activation)),\n axis=0, dtype='floatX')\n if layer.issigmoid:\n avg_activation = T.mean(activation, axis=0, dtype='floatX')\n\n KL_div = T.sum((rho+eps) *\n (T.log(rho+eps) - T.log(avg_activation+eps)) +\n (1-rho+eps) *\n (T.log(1-rho+eps) - T.log(1-avg_activation+eps)),\n dtype='floatX')\n penalty = penalty + KL_div\n\n if mode == \"l1\":\n penalty = penalty + T.sum(abs(activation), dtype='floatX')\n\n return T.cast(penalty, dtype='floatX')","def test_true_negative_rate(self):\n # For the penalty, the default loss is hinge.\n expected_penalty_numerator = np.sum(\n np.maximum(0.0, 1.0 - self._penalty_predictions) *\n (self._penalty_labels <= 0.0) * self._penalty_weights *\n self._penalty_predicate)\n expected_penalty_denominator = np.sum(\n (self._penalty_labels <= 0.0) * self._penalty_weights *\n self._penalty_predicate)\n expected_penalty_value = (\n expected_penalty_numerator / expected_penalty_denominator)\n\n # For the constraint, the default loss is zero-one.\n expected_constraint_numerator = np.sum(\n (0.5 * (1.0 - np.sign(self._constraint_predictions))) *\n (self._constraint_labels <= 0.0) * self._constraint_weights *\n self._constraint_predicate)\n expected_constraint_denominator = np.sum(\n (self._constraint_labels <= 0.0) * self._constraint_weights *\n self._constraint_predicate)\n expected_constraint_value = (\n expected_constraint_numerator / expected_constraint_denominator)\n\n actual_expression = binary_rates.true_negative_rate(self.context)\n self.check_rates(expected_penalty_value, expected_constraint_value,\n actual_expression)","def custom_asymmetric_objective(y_true, y_pred):\n residual = (y_true - y_pred).astype(\"float\")\n grad = np.where(residual < 0, -2 * 10.0 * residual, -2 * residual)\n hess = np.where(residual < 0, 2 * 10.0, 2.0)\n return grad, hess","def setup_loss(self):\n self.loss = nn.CrossEntropyLoss(weight = self.to_device(self.datasetManager.class_weights))\n #self.loss = nn.CrossEntropyLoss()","def lfads_training_loss(params, lfads_hps, key, x_bxt, kl_scale, keep_rate):\n losses = lfads_losses(params, lfads_hps, key, x_bxt, kl_scale, keep_rate)\n return losses['total']","def custom_loss(y_true, y_pred):\n #print(K.int_shape(y_pred))\n sr = y_pred[:,:,:,0]\n sr_clear = y_pred[:,:,:,1]\n hr = y_true[:,:,:,0]\n hr_clear = y_true[:,:,:,1]\n dim = 384 #K.int_shape(y_pred)[1]\n diff = hr - sr\n denominateur = K.sum(hr_clear, axis=(1,2))\n\n b = K.sum( diff * hr_clear, axis=(1,2))/denominateur #batchsize dim\n #print(K.int_shape(y_pred), K.int_shape(y_pred[:,:,:]))\n b = K.expand_dims(b, axis=-1)\n b = K.expand_dims(b, axis=-1)\n b = K.repeat_elements(b, dim, axis=1 )\n b = K.repeat_elements(b, dim, axis=-1 )\n \n cMSE = K.sum(np.square( (diff-b)*hr_clear), axis=(1,2))/denominateur\n\n #cMSE = K.sum(np.square( (diff)*hr_clear), axis=(1,2))/denominateur\n cPSNR = -10*K.log(cMSE)/K.log(10.0)\n loss1 = 46.5 / cPSNR\n ce = binary_crossentropy(K.reshape(hr_clear, (-1, dim*dim)), K.reshape(sr_clear, (-1, dim*dim)))\n \n #print(K.int_shape(loss1), K.int_shape(ce))\n return loss1 + 0.5*ce","def hinge(y_true, y_pred):\n y_pred = tensor_conversion.convert_to_tensor_v2_with_dispatch(y_pred)\n y_true = math_ops.cast(y_true, y_pred.dtype)\n y_true = _maybe_convert_labels(y_true)\n return backend.mean(math_ops.maximum(1. - y_true * y_pred, 0.), axis=-1)","def __init__(self, generator, tgt_vocab,\n normalization=\"sents\",\n label_smoothing=0.0,\n use_kl_annealing=False,\n use_kl_freebits=False,\n kl_freebits_margin=0.0,\n kl_annealing_current=0.0,\n kl_annealing_increment=0.0001,\n kl_annealing_warmup_steps=1000,\n image_loss_type='logprob',\n use_local_image_features=False,\n two_step_image_prediction=False\n ):\n self.multimodal_model_type = 'vi-model1'\n\n super(NMTVIModel1LossCompute, self).__init__(generator, tgt_vocab,\n normalization, label_smoothing)\n\n # kl annealing parameters\n self.n_model_updates = 0\n self.use_kl_annealing = use_kl_annealing\n if use_kl_annealing:\n self.kl_annealing_current = kl_annealing_current\n self.kl_annealing_increment = kl_annealing_increment\n self.kl_annealing_warmup_steps = kl_annealing_warmup_steps\n else:\n self.kl_annealing_current = 1.0\n self.kl_annealing_increment = 0.0\n self.kl_annealing_warmup_steps = 0\n\n self.use_kl_freebits = use_kl_freebits\n if use_kl_freebits:\n self.kl_freebits_margin = kl_freebits_margin\n else:\n self.kl_freebits_margin = 0.0\n\n self.image_loss_type = image_loss_type\n self.use_local_image_features = use_local_image_features\n self.two_step_image_prediction = two_step_image_prediction\n self._statistics = onmt.VIStatistics\n\n if image_loss_type == 'categorical':\n self.image_loss_criterion = nn.NLLLoss2d()","def test_negative_sampling_self_adversarial_loss(self):\n loss_fct = NSSALoss(margin=1.0, adversarial_temperature=1.0)\n self.assertIs(loss_fct._reduction_method, torch.mean)\n\n pos_scores = torch.tensor([0.0, 0.0, -0.5, -0.5])\n neg_scores = torch.tensor([0.0, 0.0, -1.0, -1.0])\n\n # ≈ result of softmax\n weights = torch.tensor([0.37, 0.37, 0.13, 0.13])\n\n # neg_distances - margin = [-1., -1., 0., 0.]\n # sigmoids ≈ [0.27, 0.27, 0.5, 0.5]\n log_sigmoids = torch.tensor([-1.31, -1.31, -0.69, -0.69])\n intermediate = weights * log_sigmoids\n # sum over the softmax dim as weights sum up to 1\n neg_loss = torch.sum(intermediate, dim=-1)\n\n # pos_distances = [0., 0., 0.5, 0.5]\n # margin - pos_distances = [1. 1., 0.5, 0.5]\n # ≈ result of sigmoid\n # sigmoids ≈ [0.73, 0.73, 0.62, 0.62]\n log_sigmoids = torch.tensor([-0.31, -0.31, -0.48, -0.48])\n pos_loss = torch.mean(log_sigmoids)\n\n # expected_loss ≈ 0.34\n expected_loss = (-pos_loss - neg_loss) / 2.0\n\n loss = loss_fct(pos_scores, neg_scores, weights).item()\n\n self.assertAlmostEqual(expected_loss, 0.77, delta=0.02)\n self.assertAlmostEqual(expected_loss, loss, delta=0.02)","def weighted_mse_loss(yt, yp) -> Any:\n from keras import backend as K\n\n total = K.sum(K.ones_like(yt))\n neg_loss = total * K.sum(K.square(yp * (1 - yt))) / K.sum(1 - yt)\n pos_loss = total * K.sum(K.square(1. - (yp * yt))) / K.sum(yt)\n\n return LOSS_BIAS * neg_loss + (1. - LOSS_BIAS) * pos_loss","def test_negative_prediction_rate(self):\n # For the penalty, the default loss is hinge.\n expected_penalty_numerator = np.sum(\n np.maximum(0.0, 1.0 - self._penalty_predictions) * self._penalty_weights\n * self._penalty_predicate)\n expected_penalty_denominator = np.sum(\n self._penalty_weights * self._penalty_predicate)\n expected_penalty_value = (\n expected_penalty_numerator / expected_penalty_denominator)\n\n # For the constraint, the default loss is zero-one.\n expected_constraint_numerator = np.sum(\n (0.5 * (1.0 - np.sign(self._constraint_predictions))) *\n self._constraint_weights * self._constraint_predicate)\n expected_constraint_denominator = np.sum(\n self._constraint_weights * self._constraint_predicate)\n expected_constraint_value = (\n expected_constraint_numerator / expected_constraint_denominator)\n\n actual_expression = binary_rates.negative_prediction_rate(self.context)\n self.check_rates(expected_penalty_value, expected_constraint_value,\n actual_expression)","def l1_loss(params):\n \"\"\" It is a vec for each branch\"\"\"\n loss_branches_vec = []\n # TODO This is hardcoded but all our cases rigth now uses four branches\n for i in range(len(params['branches']) -1):\n loss_branches_vec.append(torch.abs((params['branches'][i] - params['targets'])\n * params['controls_mask'][i])\n * params['branch_weights'][i])\n \"\"\" The last branch is a speed branch\"\"\"\n # TODO: Activate or deactivate speed branch loss\n loss_branches_vec.append(torch.abs(params['branches'][-1] - params['inputs'])\n * params['branch_weights'][-1])\n return loss_branches_vec, {}","def train_policy_network(policy_model, old_policy_model, A_hat, j, state_part_mean, state_part_std, config = PPO_config):\n \n # TODO: How to implement KL early stopping? \n \n learning_rate = np.amax([0.01, 1-j/config['J']]) * config['LR_policy']\n #PPO_loss = compute_surr_objective(A_hat, old_policy_model, policy_model, j, PPO_config) \n policy_optimizer = torch.optim.Adam(policy_model.parameters(), lr = learning_rate)\n policy_scheduler = torch.optim.lr_scheduler.StepLR(policy_optimizer, step_size=config['step'], gamma=config['gamma'])\n\n \n for epoch in range(config['num_epochs_policy']):\n \n # we shuffle the A_hat entries and divide them into batches\n # full size of A_hat = K = num Monte Carlo sims\n random.shuffle(A_hat)\n \n batch_size = config['batch_size_policy']\n \n for batch in range(math.ceil(len(A_hat) / batch_size)):\n\n policy_optimizer.zero_grad()\n\n l2_norm = sum(pp.pow(2.0).sum() for pp in [p for p in policy_model.parameters()][0])\n\n\n loss_unreg, kl_estimate = compute_surr_objective(A_hat[(batch*batch_size):((batch+1)*batch_size)], old_policy_model.to(device), policy_model.to(device), j, state_part_mean, state_part_std, PPO_config)\n wandb.log({\"kl_estimate\": kl_estimate.cpu()})\n print(\"kl_estimate for batch {}: {}\".format(batch, kl_estimate))\n if kl_estimate < config['target_KL']:\n # stop training -- is this right?\n break\n loss = -loss_unreg + l2_norm* config['L2_coeff'] \n loss.backward(retain_graph = True)\n policy_optimizer.step()\n policy_scheduler.step()\n print(\"policy loss in batch{} epoch{}: {}\".format(batch, epoch, loss))\n\n wandb.log({\"loss_policy_network\": loss.cpu()})\n \n return policy_model","def hinge_gan_losses(discriminator_real_outputs, discriminator_fake_outputs):\n generator_loss = -tf.reduce_mean(discriminator_fake_outputs)\n discriminator_loss = (\n tf.reduce_mean(tf.nn.relu(1. - discriminator_real_outputs))\n + tf.reduce_mean(tf.nn.relu(1. + discriminator_fake_outputs)))\n return generator_loss, discriminator_loss","def loss_wd(model, input_x, input_y, alpha):\n out_x = model(input_x)\n out_y = model(input_y)\n\n obj = ( torch.sum(out_x) - torch.sum(out_y) )/ batch_size\n\n a = torch.rand( (input_x.size(0),1) )\n input_z = a * input_x + (1-a) * input_y\n input_z.requires_grad_(True)\n\n out_z = model(input_z)\n gradient_z = autograd.grad(out_z.sum(), input_z, create_graph=True)[0]\n\n norm_gradient = torch.norm(gradient_z, dim=1)\n\n penalty = ( torch.sum((norm_gradient - 1).pow(2)) )/ batch_size\n\n obj = obj - alpha * penalty\n\n loss = - obj\n return loss","def l1_loss(inputs, reduction='mean', **kwargs):\n args = ArgHelper.parse(locals())\n args['reduction'] = reduction.upper()\n op_lib = loss_ops_lib.L1Loss\n if context.executing_eagerly():\n return op_lib \\\n .instantiate(reduction=args['reduction']) \\\n .apply(inputs)\n else:\n return op_lib.blend(**args)","def test_penalty_compute(self):\n objective = {'G': numpy.zeros((9)),\n 'H': numpy.diag((1,)*9),\n 'X': 1}\n for penalty in self.penalties:\n result=penalty.compute([1]*self.np, objective)\n self.assertEqual(tuple, type(result))\n # more tests go here","def penalty_calc(self):\n self.p_budget = (self.tx_oma_min - self.rx_unstressed_sensitivity - self.fiber_conn_loss)*self.l_1\n\n # fiber attenuation,\n self.p_atten = self.alpha*self.length # column B\n\n # calculate bandwidth for RIN test (exclude transmitter)\n rin_inverse_bw = np.sqrt(np.square(1.0/self.bw_cd) + np.square(1.0/self.bw_md) + (0.477/(self.rx_bw**2))*self.l_1)\n rin_bw = 1.0 / rin_inverse_bw\n\n # see FC-MSQS-2 equation B.47 in Annex B.4 for the following k_rin = math.sqrt(2.0/math.pi)*erfinv(0.8)\n k_rin = 0.7\n\n # v_rin,\n self.v_rin = (k_rin*1E6*(self.rin_test_isi**2)*rin_bw*\n math.pow(10.0,0.1*self.rin)) # column AK\n\n # Prin,\n print('v_rin: ', self.v_rin)\n print('Q: ',self.Q)\n print('isi_dj_refl_closed :', self.isi_dj_refl_closed)\n self.p_rin = -10.0*np.log10(np.sqrt(1.0-np.multiply(self.v_rin, np.square(self.Q/self.isi_dj_refl_closed)))) # column R\n print(\"P_rin : \", self.p_rin)\n self.beta = (3.14159E-6*self.speedup*self.br_nominal *self.delta_lambda*self.d1*self.length) # column O\n self.sigma_mpn = (self.k_mpn/math.sqrt(2.0)*(self.l_1 -np.exp(-np.square(self.beta)))) # column P\n self.p_mpn = (-10.0*np.log10(np.sqrt(self.l_1 - (self.Q**2)*np.square(self.sigma_mpn)))) # column Q\n self.p_blw = (-10.0*math.log10(math.sqrt(1.0- ((self.Q*self.sigma_blw)/ self.isi_tp4_rx)**2))*self.l_1) # cell T13\n self.p_reflection = -10.0*np.log10(self.isi_reflection) # column N\n self.v_mn = (((1.0-math.pow(10.0,-0.2*self.pmn))/ (self.Q)**2)*self.l_1) # cell AG7\n print(\"isi_center : \", self.isi_center)\n\n self.p_isi_center = -10.0*np.log10(self.isi_center) # column J\n\n self.p_isi_corners = (-10.0*np.log10(self.isi_corners) - self.p_isi_center) # column K\n self.p_isi_dj_center = (-10.0*np.log10(self.isi_dj_refl_closed) - self.p_isi_center) # column L\n self.p_isi_dj_corners = (-10.0*np.log10(self.isi_dj_corners) -self.p_isi_center -self.p_isi_corners) # column M\n\n\n # calculate the \"cross\" penalty contribution, column S\n arg1 = ((self.sigma_blw**2 + self.v_rin)/ np.square(self.isi_dj_refl_closed))\n arg2 = self.l_1 - (self.Q**2)*(arg1 + self.v_mn + np.square(self.sigma_mpn))\n arg3 = (-10.0*np.log10(np.multiply(self.isi_dj_refl_closed, np.sqrt(arg2))))\n self.p_cross_center = ( # column S\n arg3\n - self.p_blw # cell T13\n - self.p_isi_center # column J\n - self.p_isi_dj_center # column L\n - self.p_mpn # column Q\n - self.p_reflection # column N\n - self.p_rin # column R\n - self.pmn*self.l_1) # cell G13\n print('p_isi_center: ', self.p_isi_center)\n\n # calculate the total power budget evaluated at the center of the eye\n self.p_total_center = ( # column T\n self.p_isi_center # column J\n + self.p_isi_dj_center # column L\n + self.p_atten # column B\n + self.p_mpn # column Q\n + self.p_reflection # column N\n + self.p_rin # column R\n + self.p_cross_center # column S\n + self.pmn*self.l_1) # cell G13\n # calculate the total power budget evaluated at the corner of the eye\n self.p_total_corners = (\n self.p_isi_center # column J\n + self.p_isi_corners # column K\n + self.p_atten # column B\n + self.p_mpn # column Q\n + self.p_reflection # column N\n + self.p_rin # column R\n + self.p_cross_center # column S\n + self.pmn*self.l_1 # cell G13\n + self.p_isi_dj_corners)# column M\n\n # receiver stressed sensitivity\n self.margin = ( self.p_budget\n - self.p_total_center) # column W\n\n self.rx_stressed_sensitivity = (\n self.tx_oma_min*self.l_1\n - self.chil\n - self.p_mpn\n - self.p_reflection\n - self.p_rin\n - 0.5*self.p_cross_center\n - self.pmn*self.l_1\n - self.margin[self.lnum//2]*self.l_1)\n\n\n # end of GbE10.penalty_calc\n #======================================================================+","def L2(yhat, y):\n loss = np.dot((y - yhat).T,(y - yhat))\n \n return loss","def l2_learning(self, msg):\n pass","def halo_loss(predicted, labels, weights, obj, k_neg=7.):\n\n global_loss = torch.FloatTensor([0]).to(device)\n x_lsm = F.log_softmax(predicted, dim=1)\n x_sm = F.softmax(predicted, dim=1)\n\n v_weights = weights\n v_labels = labels\n\n for i in range(predicted.size(0)): # Foreach sample\n\n # predicted[0] is preserved for background\n bg = v_weights[i, 0] * v_labels[i, 0]\n global_loss += -torch.sum(bg * x_lsm[i, 0]) / torch.sum(bg)\n\n if 0 == len(obj[i][1:]):\n continue\n\n indexes = torch.LongTensor(obj[i][1:]).to(device) # One is for labels\n\n valid_labels = v_labels[i].index_select(0, indexes)\n valid_weights = v_weights[i].index_select(0, indexes)\n\n target_pos = valid_labels * valid_weights\n target_neg = (1. - valid_labels) * valid_weights\n\n positive = -torch.mm(flatten(x_lsm[i, 1:]),\n flatten(target_pos).transpose(1, 0)) / torch.sum(target_pos)\n\n negative = -torch.mm(flatten(torch.log(1. - x_sm[i, 1:] + 1e-12)),\n flatten(target_neg).transpose(1, 0)) / torch.sum(target_neg)\n\n values, indices = torch.min(positive + k_neg * negative, 0)\n global_loss += torch.sum(positive[indices, torch.arange(0, positive.size(1)).long().to(device)])\n\n # Normalize w.r.t. image size\n return global_loss * (1000. / (predicted.size(2) * predicted.size(3)))","def backward_G(self):\n # Calculate regularzation loss to make transformed feature and target image feature in the same latent space\n self.loss_reg_gen = self.loss_reg * self.opt.lambda_regularization\n\n # Calculate l1 loss \n loss_app_gen = self.L1loss(self.img_gen, self.input_P2)\n self.loss_app_gen = loss_app_gen * self.opt.lambda_rec \n \n # parsing loss\n label_P2 = self.label_P2.squeeze(1).long()\n #print(self.input_SPL2.min(), self.input_SPL2.max(), self.parsav.min(), self.parsav.max())\n self.loss_par = self.parLoss(self.parsav,label_P2)# * 20. \n self.loss_par1 = self.L1loss(self.parsav, self.input_SPL2) * 100 \n\n # Calculate GAN loss\n base_function._freeze(self.net_D)\n D_fake = self.net_D(self.img_gen)\n self.loss_ad_gen = self.GANloss(D_fake, True, False) * self.opt.lambda_g\n\n # Calculate perceptual loss\n loss_content_gen, loss_style_gen = self.Vggloss(self.img_gen, self.input_P2) \n self.loss_style_gen = loss_style_gen*self.opt.lambda_style\n self.loss_content_gen = loss_content_gen*self.opt.lambda_content\n\n total_loss = 0\n\n for name in self.loss_names:\n if name != 'dis_img_gen':\n #print(getattr(self, \"loss_\" + name))\n total_loss += getattr(self, \"loss_\" + name)\n total_loss.backward()","def nt_transfer_loss(self, student_net_params, masks, teacher_net_params, x, density_level): \n\n masked_student_net_params = get_sparse_params_filtered_by_masks(student_net_params, masks)\n\n # split inputs into two collections, x1 and x2.\n x1 = x[:int(len(x)/2)]\n x2 = x[int(len(x)/2):]\n \n # student network prediction\n student_prediction = self.apply_fn(masked_student_net_params, x) \n \n # teacher network prediction\n teacher_prediction = self.apply_fn(teacher_net_params, x)\n\n # student network's NTK evaluated on x1 and x2\n student_ntk_mat = self.emp_ntk_fn(x1, x2, masked_student_net_params) \n\n # teacher network's NTK evaluated on x1 and x2\n teacher_ntk_mat = self.emp_ntk_fn(x1, x2, teacher_net_params) \n\n # compute kernel, target, and paramter l2 loss\n ker_dist, target_dist, param_squared_norm = self.kernel_dist_target_dist_l2_loss(student_ntk_mat, student_prediction, teacher_ntk_mat, teacher_prediction, masked_student_net_params)\n\n # weight these losses to get the transfer loss\n transfer_loss = self.LAMBDA_KER_DIST * ker_dist + target_dist + (self.LAMBDA_L2_REG / density_level) * param_squared_norm \n\n return transfer_loss","def compute_loss(\n self,\n x: torch.Tensor,\n y: torch.Tensor,\n y_hat: torch.Tensor,\n extras: List[torch.Tensor],\n train_context: TrainContext,\n ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:","def test_false_negative_rate(self):\n # For the penalty, the default loss is hinge.\n expected_penalty_numerator = np.sum(\n np.maximum(\n 0.0, 1.0 - self._penalty_predictions) * (self._penalty_labels > 0.0)\n * self._penalty_weights * self._penalty_predicate)\n expected_penalty_denominator = np.sum(\n (self._penalty_labels > 0.0) * self._penalty_weights *\n self._penalty_predicate)\n expected_penalty_value = (\n expected_penalty_numerator / expected_penalty_denominator)\n\n # For the constraint, the default loss is zero-one.\n expected_constraint_numerator = np.sum(\n (0.5 * (1.0 - np.sign(self._constraint_predictions))) *\n (self._constraint_labels > 0.0) * self._constraint_weights *\n self._constraint_predicate)\n expected_constraint_denominator = np.sum(\n (self._constraint_labels > 0.0) * self._constraint_weights *\n self._constraint_predicate)\n expected_constraint_value = (\n expected_constraint_numerator / expected_constraint_denominator)\n\n actual_expression = binary_rates.false_negative_rate(self.context)\n self.check_rates(expected_penalty_value, expected_constraint_value,\n actual_expression)"],"string":"[\n \"def l2_training_penalty(batched_out: base.Output):\\n if isinstance(batched_out, base.OutputWithPrior):\\n return 0.5 * jnp.mean(jnp.square(batched_out.train))\\n else:\\n logging.warning('L2 weight penalty only works for OutputWithPrior.')\\n return 0.\",\n \"def test_hinge_loss_backward():\\n from your_code import HingeLoss\\n X = np.array([[-1, 2, 1], [-3, 4, 1]])\\n w = np.array([1, 2, 3])\\n y = np.array([1, -1])\\n\\n loss = HingeLoss(regularization=None)\\n\\n _true = np.array([-1.5, 2, 0.5])\\n _est = loss.backward(X, w, y)\\n print(_est)\",\n \"def loss(self, X, y=None):\\n\\n # In dev testing, the loss fnc stops at \\\"scores\\\" , unfollowed by \\\"softmax\\\" probability prediction.\\n # In real testing, \\\"self.predict()\\\" needs to be implemented in Solver() class.\\n \\n if y is None:\\n for bn_param in self.bn_params:\\n bn_param[\\\"mode\\\"] = \\\"test\\\"\\n\\n\\n W1, b1 = self.params['W1'], self.params['b1']\\n gamma1, beta1 = self.params[\\\"sbnGamma1\\\"], self.params[\\\"sbnBeta1\\\"]\\n bn_param1 = self.bn_params[0]\\n\\n W2, b2 = self.params['W2'], self.params['b2']\\n gamma2, beta2 = self.params[\\\"sbnGamma2\\\"], self.params[\\\"sbnBeta2\\\"]\\n bn_param2 = self.bn_params[1]\\n\\n W3, b3 = self.params['W3'], self.params['b3']\\n gamma3, beta3 = self.params[\\\"bnGamma3\\\"], self.params[\\\"bnBeta3\\\"]\\n bn_param3 = self.bn_params[2]\\n\\n W4, b4 = self.params['W4'], self.params['b4']\\n \\n # pass conv_param to the forward pass for the convolutional layer\\n conv_param = self.conv_param\\n\\n # pass pool_param to the forward pass for the max-pooling layer\\n pool_param = self.maxpool_params\\n\\n ############################################################################\\n # TODO: Implement the forward pass for the three-layer convolutional net, #\\n # computing the class scores for X and storing them in the scores #\\n # variable. #\\n ############################################################################\\n \\n scores = None \\n cache = {}\\n # def conv_sbn_relu_forward(x, w, b, gamma, beta, conv_param, bn_param): return out, cache;\\n out, cache[\\\"layer1\\\"] = layer_utils.conv_sbn_relu_forward(X, W1, b1, gamma1, beta1, conv_param, bn_param1) \\n out, cache[\\\"layer2\\\"] = layer_utils.conv_sbn_relu_forward(out, W2, b2, gamma2, beta2, conv_param, bn_param2)\\n\\n # def max_pool_forward_fast(x, pool_param): return out, cache;\\n out, cache[\\\"maxpool\\\"] = fast_layers.max_pool_forward_fast(out, pool_param)\\n\\n # def affine_bn_relu_forward(x, w, b, gamma, beta, bn_param): return out, cache;\\n \\n out, cache[\\\"layer3\\\"] = layer_utils.affine_bn_relu_forward(out, W3, b3, gamma3, beta3, bn_param3)\\n\\n # def affine_forward(x, w, b): return out, cache;\\n scores, cache[\\\"layer4\\\"] = layers.affine_forward(out, W4, b4)\\n\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n \\n if y is None:\\n return scores\\n \\n ############################################################################\\n # TODO: Implement the backward pass for the three-layer convolutional net, #\\n # storing the loss and gradients in the loss and grads variables. Compute #\\n # data loss using softmax, and make sure that grads[k] holds the gradients #\\n # for self.params[k]. Don't forget to add L2 regularization! #\\n ############################################################################\\n \\n loss, grads = 0, {}\\n\\n # def softmax_loss(x, y): return loss, dscore;\\n loss, dscores = layers.softmax_loss(scores, y)\\n loss += 0.5 * self.reg * (np.sum(W1 * W1) + np.sum(W2 * W2) + np.sum(W3 * W3) + np.sum(W4 * W4))\\n\\n # def affine_backward(dout, cache): return dx, dw, db;\\n dout, dW4, db4 = layers.affine_backward(dscores, cache[\\\"layer4\\\"]) \\n\\n # def affine_bn_relu_backward(dout, cache): return dx, dw, db, dgamma, dbeta;\\n dout, dW3, db3, dgamma3, dbeta3 = layer_utils.affine_bn_relu_backward(dout, cache[\\\"layer3\\\"])\\n\\n # print cache[\\\"layer3\\\"]\\n\\n # def max_pool_backward_fast(dout, cache): return max_pool_backward_im2col(dout, real_cache);\\n # def max_pool_backward_im2col(dout, cache): return dx;\\n dout = fast_layers.max_pool_backward_fast(dout, cache[\\\"maxpool\\\"])\\n\\n # def conv_sbn_relu_backward(dout, cache): return dx, dw, db, dgamma, dbeta;\\n dout, dW2, db2, dgamma2, dbeta2 = layer_utils.conv_sbn_relu_backward(dout, cache[\\\"layer2\\\"])\\n _, dW1, db1, dgamma1, dbeta1 = layer_utils.conv_sbn_relu_backward(dout, cache[\\\"layer1\\\"])\\n\\n # reg\\n grads['W4'], grads['b4'] = dW4 + self.reg * W4, db4\\n \\n grads['W3'], grads['b3'] = dW3 + self.reg * W3, db3\\n grads[\\\"bnGamma3\\\"], grads[\\\"bnBeta3\\\"] = dgamma3, dbeta3\\n\\n grads['W2'], grads['b2'] = dW2 + self.reg * W2, db2\\n grads[\\\"sbnGamma2\\\"], grads[\\\"sbnBeta2\\\"] = dgamma2, dbeta2\\n\\n grads['W1'], grads['b1'] = dW1 + self.reg * W1, db1\\n grads[\\\"sbnGamma1\\\"], grads[\\\"sbnBeta1\\\"] = dgamma1, dbeta1\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n \\n return loss, grads\",\n \"def _weight_boosting_loss(name: str):\\n return hp.choice(name, [\\\"linear\\\", \\\"square\\\", \\\"exponential\\\"])\",\n \"def compute_penalty(edge_1, edge_2):\\n\\n if edge_1 == edge_2:\\n return 0\\n elif {edge_1, edge_2} == {EdgeType.NONE, EdgeType.FORWARD}:\\n return 1\\n elif {edge_1, edge_2} == {EdgeType.NONE, EdgeType.BACKWARD}:\\n return 1\\n elif {edge_1, edge_2} == {EdgeType.NONE, EdgeType.UNDIRECTED}:\\n return 1\\n elif {edge_1, edge_2} == {EdgeType.FORWARD, EdgeType.BACKWARD}:\\n return 1\\n elif {edge_1, edge_2} == {EdgeType.FORWARD, EdgeType.UNDIRECTED}:\\n return 1\\n elif {edge_1, edge_2} == {EdgeType.BACKWARD, EdgeType.UNDIRECTED}:\\n return 1\\n else:\\n raise ImpossibleEdgeConfiguration\",\n \"def penalty(self):\\n return 0\",\n \"def second_order_defense(loss,\\n params,\\n data_obliterate,\\n target_loss,\\n data_keep = None,\\n l2reg = 1e-1,\\n lobpcg_maxiter = 20,\\n ls_maxiter = 20):\\n\\n flat_params, unflatten = flatten_util.ravel_pytree(params)\\n n_features = len(flat_params)\\n\\n def _loss_obliterate(x):\\n pytree_x = unflatten(x)\\n return jnp.mean(loss(pytree_x, data_obliterate))\\n\\n def _hessian_obliterate_matvec(x):\\n # forward-over-reverse differentiation\\n return jax.jvp(jax.grad(_loss_obliterate), (flat_params,), (x,))[1]\\n\\n eigenvalues, eigenvectors, _ = experimental_splinalg.lobpcg_standard(\\n jax.vmap(_hessian_obliterate_matvec, in_axes=1, out_axes=1),\\n flat_params.reshape((-1, 1)),\\n m=lobpcg_maxiter)\\n normalized_l2_reg = l2reg * eigenvalues[0]\\n\\n if data_keep is None:\\n update_direction = eigenvectors.ravel()\\n else:\\n def _loss_keep(x):\\n pytree_params = unflatten(x)\\n regularization = normalized_l2_reg * jnp.linalg.norm(x)\\n return jnp.mean(loss(pytree_params, data_keep)) + regularization\\n\\n def _hessian_keep_matvec(x):\\n # forward-over-reverse differentiation\\n return jax.jvp(jax.grad(_loss_keep), (flat_params,), (x,))[1]\\n\\n hessian_obliterate = splinalg.LinearOperator(\\n (n_features, n_features), matvec=_hessian_obliterate_matvec)\\n hessian_keep = splinalg.LinearOperator(\\n (n_features, n_features), matvec=_hessian_keep_matvec)\\n _, generalized_eigenvectors = splinalg.eigsh(\\n hessian_obliterate, k=1, M=hessian_keep, v0=eigenvectors)\\n update_direction = generalized_eigenvectors.ravel()\\n\\n # find the step-size by minimizing a 1D objective function (that is, by\\n # exact line-search)\\n def scalr_fun(step):\\n candidate_params = flat_params + step * update_direction\\n return (_loss_obliterate(candidate_params) - target_loss) ** 2\\n step = optimize.minimize_scalar(scalr_fun, options={\\\"maxiter\\\": ls_maxiter}).x\\n # there are two solutions of this problem, one positive and one\\n # negative. Do we need to run it twice and get the smallest one?\\n return tree_util.tree_add_scalar_mul(params, step,\\n unflatten(update_direction))\",\n \"def test_gt_grad():\\r\\n floatX = config.floatX\\r\\n T = theano.tensor\\r\\n\\r\\n input_ = T.vector(dtype=floatX)\\r\\n random_values = numpy.random.RandomState(1234).uniform(\\r\\n low=-1, high=1, size=(2, 2))\\r\\n W_values = numpy.asarray(random_values, dtype=floatX)\\r\\n W = theano.shared(value=W_values, name='weights')\\r\\n correct_score = T.dot(input_, W)\\r\\n wrong_input = T.vector(dtype=floatX)\\r\\n wrong_score = theano.clone(correct_score, {input_: wrong_input})\\r\\n # Hinge loss\\r\\n\\r\\n scores = T.ones_like(correct_score) - correct_score + wrong_score\\r\\n cost = (scores * (scores > 0)).sum()\\r\\n T.grad(cost, input_)\",\n \"def gradient_penalty_loss(y_true, y_pred, averaged_samples):\\n if K.backend()=='theano':\\n J, _ = theano.scan(lambda i, y, x: T.square(T.grad(y[i].sum(), x[i])).sum() ** 0.5,\\n sequences=T.arange(y_pred.shape[0]),\\n non_sequences=[y_pred, averaged_samples])\\n return GRADIENT_PENALTY_WEIGHT * K.square(1 - J)\\n \\n else:\\n gradients = K.gradients(y_pred, averaged_samples)\\n gradients = K.concatenate([K.flatten(tensor) for tensor in gradients])\\n gradient_l2_norm = K.sqrt(K.sum(K.square(gradients)))\\n gradient_penalty = GRADIENT_PENALTY_WEIGHT * K.square(1 - gradient_l2_norm)\\n return gradient_penalty\",\n \"def loss(self, X, y=None):\\n scores = None\\n ############################################################################\\n # TODO: Implement the forward pass for the two-layer net, computing the #\\n # class scores for X and storing them in the scores variable. #\\n ############################################################################\\n hid1, hid1cache = affine_relu_forward(X, self.params['W1'], self.params['b1'])\\n scores, scorecache = affine_forward(hid1, self.params['W2'], self.params['b2'])\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n\\n # If y is None then we are in test mode so just return scores\\n if y is None:\\n return scores\\n\\n loss, grads = 0, {}\\n ############################################################################\\n # TODO: Implement the backward pass for the two-layer net. Store the loss #\\n # in the loss variable and gradients in the grads dictionary. Compute data #\\n # loss using softmax, and make sure that grads[k] holds the gradients for #\\n # self.params[k]. Don't forget to add L2 regularization! #\\n # #\\n # NOTE: To ensure that your implementation matches ours and you pass the #\\n # automated tests, make sure that your L2 regularization includes a factor #\\n # of 0.5 to simplify the expression for the gradient. #\\n ############################################################################\\n loss, dscores = softmax_loss(scores, y)\\n loss += 0.5 * self.reg *( np.sum(self.params['W1']**2) + np.sum(self.params['W2']**2) )\\n\\n dhid1, grads['W2'], grads['b2'] = affine_backward(dscores, scorecache)\\n dx, grads['W1'], grads['b1'] = affine_relu_backward(dhid1, hid1cache)\\n\\n grads['W1'] += self.reg * self.params['W1']\\n grads['W2'] += self.reg * self.params['W2']\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n\\n return loss, grads\",\n \"def gradient_penalty_loss(y_true, y_pred, averaged_samples, gradient_penalty_weight):\\n gradients = K.gradients(K.sum(y_pred), averaged_samples)\\n gradient_l2_norm = K.sqrt(K.sum(K.square(gradients)))\\n gradient_penalty = gradient_penalty_weight * K.square(1 - gradient_l2_norm)\\n return gradient_penalty\",\n \"def _compute_penalty(self):\\n raise ValueError('Implement in a child class')\",\n \"def TEM_loss(anchors_action,anchors_startend,\\n Y_action,Y_startend,config): \\n loss_action,num_sample_action = binary_logistic_loss(Y_action,anchors_action)\\n loss_startend,num_sample_startend = binary_logistic_loss(Y_startend,anchors_startend)\\n # print('loss_action', loss_action)\\n # print('loss_startend', loss_startend)\\n loss={\\\"loss_action\\\":loss_action,\\\"num_sample_action\\\":num_sample_action,\\n \\\"loss_startend\\\":loss_startend,\\\"num_sample_startend\\\":num_sample_startend}\\n return loss\",\n \"def predict_boosting_example(x, h_ens):\\r\\n\\r\\n arr = []\\r\\n sum_alpha = 0\\r\\n\\r\\n for y in h_ens:\\r\\n # splitting hypothesis, weight pairs\\r\\n alpha, tree = h_ens[y]\\r\\n tst_pred = predict_example(x, tree)\\r\\n # appending prediction\\r\\n arr.append(tst_pred*alpha)\\r\\n sum_alpha += alpha\\r\\n predict_egz = np.sum(arr) / sum_alpha\\r\\n # weak learner\\r\\n if predict_egz >= 0.5:\\r\\n return 1\\r\\n else:\\r\\n return 0\",\n \"def kp_l2_loss(kp_pred, kp_gt):\\n criterion = torch.nn.MSELoss()\\n\\n vis = (kp_gt[:, :, 2, None] > 0).float()\\n\\n # This always has to be (output, target), not (target, output)\\n return criterion(vis * kp_pred, vis * kp_gt[:, :, :2])\",\n \"def binary_svm_loss(theta, X, y, C):\\n\\n m, d = X.shape\\n grad = np.zeros(theta.shape)\\n J = 0\\n\\n ############################################################################\\n # TODO #\\n # Implement the binary SVM hinge loss function here #\\n # 4 - 5 lines of vectorized code expected #\\n ############################################################################\\n J=0.5*np.sum(theta**2)/m\\n J=J+C*np.sum(np.maximum(0,1-np.multiply(y,(np.dot(X,theta)))))/m\\n \\n grad=theta/m\\n temp_1=np.dot(X,theta)\\n temp_2=np.multiply(y,temp_1)\\n\\n temp_3=y[temp_2<1]\\n temp_4=X[temp_2<1,:]\\n temp_5=np.dot(temp_4.T,temp_3)\\n grad=grad-temp_5*C/m\\n\\n\\n# for j in range(d):\\n# \\tgrad[j]=float(theta[j]/m)\\n# \\tfor k in range(m):\\n#\\t \\tif (y[k]*(np.dot(theta,X[k,:]))<1):\\n#\\t \\t\\tgrad[j]=grad[j]-float(C*y[k]*X[k,j]/m)\\n\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\\n\\n return J, grad\",\n \"def _create_loss(self):\\n\\n with tf.name_scope(\\\"loss\\\"):\\n \\n # gini=(tf.nn.l2_loss( self.score))/100000\\n gini = tf.losses.softmax_cross_entropy(self.score, 0*self.score)\\n \\n promo_prob=tf.reduce_sum(tf.multiply(self.score, self.cohort_weight),\\n axis=1)\\n inc_value = tf.reduce_mean(tf.multiply(promo_prob, self.value))- self.control_value\\n inc_cost = tf.reduce_mean( tf.multiply(promo_prob, self.cost)) - self.control_cost\\n \\n\\n\\n # determine loss function based on self.obj_rule\\n if self.obj_rule == 'cpiv':\\n self.objective = inc_cost / inc_value\\n\\n elif self.obj_rule == 'ivc':\\n # maximize ivc\\n self.objective = - inc_value / inc_cost\\n\\n elif self.obj_rule == 'lagrangian':\\n assert self.shadow is not None, 'Need to pass in shadow value if use lagrangian as obj_rule.'\\n self.objective = inc_cost - self.shadow * inc_value\\n\\n elif self.obj_rule == 'value':\\n # maximize delta values\\n self.objective = - inc_value\\n\\n # use only cost as objective\\n elif self.obj_rule == 'cost':\\n # maximize delta cost\\n self.objective = - inc_cost\\n\\n else:\\n raise Exception('Invalid obj_rule!')\\n\\n # regularization\\n reg_loss = tf.reduce_sum(tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))\\n # weights = tf.trainable_variables() # all vars of your graph\\n # reg_loss = tf.norm( weights,ord=1)\\n\\n # final loss\\n self.loss = self.objective +reg_loss+.1*gini\",\n \"def test_error_rate(self):\\n # For the penalty, the default loss is hinge.\\n expected_signed_penalty_labels = (self._penalty_labels > 0.0) * 2.0 - 1.0\\n expected_penalty_numerator = np.sum(\\n np.maximum(\\n 0.0,\\n 1.0 - expected_signed_penalty_labels * self._penalty_predictions) *\\n self._penalty_weights * self._penalty_predicate)\\n expected_penalty_denominator = np.sum(\\n self._penalty_weights * self._penalty_predicate)\\n expected_penalty_value = (\\n expected_penalty_numerator / expected_penalty_denominator)\\n\\n # For the constraint, the default loss is zero-one.\\n expected_signed_constraint_labels = (\\n (self._constraint_labels > 0.0) * 2.0 - 1.0)\\n expected_constraint_numerator = np.sum(\\n (0.5 * (1.0 - expected_signed_constraint_labels * np.sign(\\n self._constraint_predictions))) * self._constraint_weights *\\n self._constraint_predicate)\\n expected_constraint_denominator = np.sum(\\n self._constraint_weights * self._constraint_predicate)\\n expected_constraint_value = (\\n expected_constraint_numerator / expected_constraint_denominator)\\n\\n actual_expression = binary_rates.error_rate(self.context)\\n self.check_rates(expected_penalty_value, expected_constraint_value,\\n actual_expression)\",\n \"def loss_fn(model):\\n with flax.nn.stateful(state) as new_state:\\n with flax.nn.stochastic(prng_key):\\n logits = model(batch['image'])\\n loss = cross_entropy_loss(logits, batch['label'])\\n # TODO(britefury): check if applying L2 regularization to weights but\\n # *not* biases improves results\\n weight_penalty_params = jax.tree_leaves(model.params)\\n weight_l2 = sum([jnp.sum(x ** 2)\\n for x in weight_penalty_params\\n if x.ndim > 1])\\n weight_penalty = l2_reg * 0.5 * weight_l2\\n loss = loss + weight_penalty\\n return loss, (new_state, logits)\",\n \"def optimization(logits, y, population, embedding, alpha):\\n if FLAGS.uniform_weights:\\n weights = tf.ones(shape=tf.shape(population))\\n else:\\n weights = tf.where(\\n tf.greater(population, 0.01), tf.fill(tf.shape(population), 0.16),\\n tf.fill(tf.shape(population), 2.5))\\n if not FLAGS.propensity_weights:\\n weights = tf.sigmoid(tf.matmul(embedding, alpha)) * weights\\n weights /= tf.reduce_mean(weights)\\n loss = tf.losses.hinge_loss(labels=y, logits=logits, weights=weights)\\n optimizer = tf.train.AdamOptimizer(LEARNING_RATE).minimize(loss)\\n return optimizer, loss\",\n \"def loss_and_metrics_one_pair(self, params, rng):\\n key_pq, key_samples = jax.random.split(rng)\\n p_logits, q_logits = self.logit_pair_distribution_fn(key_pq)\\n\\n def sample_loss(key_sample):\\n \\\"\\\"\\\"Computes loss for a single sample of a relaxed pair of outcomes.\\\"\\\"\\\"\\n q_kwargs = dict(transpose=True) if self.use_transpose else {}\\n soft_p = self.model.apply(\\n params, p_logits, key_sample, method=self.model.sample_relaxed)\\n soft_q = self.model.apply(\\n params,\\n q_logits,\\n key_sample,\\n method=self.model.sample_relaxed,\\n **q_kwargs)\\n coupling_loss_matrix = self.coupling_loss_matrix_fn(p_logits, q_logits)\\n coupling_loss = jnp.sum(soft_p[:, None] * soft_q[None, :] *\\n coupling_loss_matrix)\\n\\n return coupling_loss\\n\\n loss_samples = jax.vmap(sample_loss)(\\n jax.random.split(key_samples, self.inner_num_samples))\\n loss = jnp.mean(loss_samples)\\n return loss, {\\\"loss\\\": loss}\",\n \"def cost(self, x, y):\\n return self.cross_entropy_error(x,y) + self.l2_regularization_penalty()\",\n \"def weighted_bce(y_hat, target, labels, weight_multiplier):\\n weight = labels.clone()\\n weight.requires_grad = False\\n weight[weight < 1] = 2\\n weight[weight == 3] = 4\\n weight = 2 / weight\\n\\n # apply mask\\n weight = weight * weight_multiplier\\n return F.binary_cross_entropy(y_hat, target, weight)\",\n \"def hinge_loss(self, y_true=None, y_pred=None, decimal=5, **kwargs):\\n y_true, y_pred, binary, representor, decimal = self.get_processed_data2(y_true, y_pred, decimal)\\n if binary:\\n # replacing 0 = -1\\n y_true[y_true == 0] = -1\\n y_pred[y_pred == 0] = -1\\n res = np.mean([max(0, 1 - x * y) ** 2 for x, y in zip(y_true, y_pred)])\\n return np.round(res, decimal)\\n else:\\n # Convert y_true to one-hot encoded array\\n num_classes = len(np.unique(y_true))\\n y_true = np.eye(num_classes)[y_true]\\n neg = np.max((1 - y_true) * y_pred, axis=1)\\n pos = np.sum(y_true * y_pred, axis=1)\\n temp = neg - pos + 1\\n temp[temp < 0] = 0\\n return np.round(np.mean(temp), decimal)\",\n \"def get_l2_penalty(nnet, include_bias=False, pow=2):\\n\\n l2_penalty = 0\\n\\n # do not include OC-SVM layer in regularization\\n if Cfg.ocsvm_loss:\\n if include_bias:\\n for layer in nnet.trainable_layers:\\n if not layer.issvm:\\n if layer.b is not None:\\n l2_penalty = (l2_penalty + T.sum(abs(layer.W) ** pow)\\n + T.sum(abs(layer.b) ** pow))\\n else:\\n l2_penalty = l2_penalty + T.sum(abs(layer.W) ** pow)\\n else:\\n for layer in nnet.trainable_layers:\\n if not layer.issvm:\\n l2_penalty = l2_penalty + T.sum(abs(layer.W) ** pow)\\n else:\\n if include_bias:\\n for layer in nnet.trainable_layers:\\n if layer.b is not None:\\n l2_penalty = (l2_penalty + T.sum(abs(layer.W) ** pow)\\n + T.sum(abs(layer.b) ** pow))\\n else:\\n l2_penalty = l2_penalty + T.sum(abs(layer.W) ** pow)\\n else:\\n for layer in nnet.trainable_layers:\\n l2_penalty = l2_penalty + T.sum(abs(layer.W) ** pow)\\n\\n return T.cast(l2_penalty, dtype='floatX')\",\n \"def _pairwise_loss(self, pairwise_logits):\\n raise NotImplementedError('Calling an abstract method.')\",\n \"def objective(self):\\n hinge_loss = tf.losses.hinge_loss(self.labels, self.predictions)\\n\\n return hinge_loss\",\n \"def loss(loss_name):\\n \\n def contrastive_loss(y_true, y_pred, margin = 1):\\n \\\"\\\"\\\"Implementation of the triplet loss function\\n\\n\\n Contrastive loss = 0.5 * mean( (1-true_value) * square(distance) + true_value * square( max(margin-distance, 0) ))\\n\\n Args:\\n y_true (int): true label, positive pair (same class) -> 0, \\n negative pair (different class) -> 1\\n \\n y_pred (list): python list containing two objects in a pair of tensors:\\n left : the encodings for one image data in a pair\\n right : the encodings for the other image data in a pair\\n margin (float, optional): m > 0 determines how far the embeddings of \\n a negative pair should be pushed apart. Defaults to 1.\\n\\n\\n Returns:\\n loss (float): real number, value of the loss\\n \\\"\\\"\\\"\\n\\n left = y_pred[0]\\n right = y_pred[1]\\n\\n distance = tf.math.sqrt(tf.math.reduce_sum(tf.math.square(left - right), axis=-1))\\n\\n loss_positive = tf.math.square(distance)\\n loss_negative = tf.math.square(tf.maximum(0., margin - distance))\\n \\n loss = y_true * loss_negative + (1 - y_true) * loss_positive\\n loss = 0.5 * tf.math.reduce_mean(loss)\\n\\n return loss\\n\\n def triplet_loss(y_true, y_pred, margin = 1):\\n \\\"\\\"\\\"Implementation of the triplet loss function\\n\\n Arguments:\\n y_true : true labels, required when you define a loss in Keras, \\n not applied in this function.\\n\\n y_pred (list): python list containing three objects:\\n anchor : the encodings for the anchor data\\n positive : the encodings for the positive data (similar to anchor)\\n negative : the encodings for the negative data (different from anchor)\\n \\n margin (float, optional): m > 0 determines how far the embeddings of \\n a negative data should be pushed apart. Defaults to 1.\\n\\n Returns:\\n loss (float): real number, value of the loss\\n \\\"\\\"\\\"\\n\\n anchor = y_pred[0]\\n positive = y_pred[1]\\n negative = y_pred[2]\\n\\n # squared distance between the anchor and the positive\\n pos_dist = tf.math.reduce_sum(tf.math.square(anchor - positive), axis=-1)\\n\\n # squared distance between the anchor and the negative\\n neg_dist = tf.math.reduce_sum(tf.math.square(anchor - negative), axis=-1)\\n\\n # compute loss\\n basic_loss = margin + pos_dist - neg_dist\\n loss = tf.math.maximum(basic_loss,0.0)\\n loss = tf.math.reduce_mean(loss)\\n return loss\\n\\n \\n if loss_name == 'contrastive_loss':\\n return contrastive_loss\\n \\n if loss_name == 'triplet_loss':\\n return triplet_loss\",\n \"def test_PoissonRegression_penalty_C(self):\\n for penalty in PoissonRegression._penalties.keys():\\n if penalty != 'none':\\n if penalty == 'binarsity':\\n learner = PoissonRegression(\\n penalty=penalty, C=self.float_1, blocks_start=[0],\\n blocks_length=[1])\\n else:\\n learner = PoissonRegression(penalty=penalty,\\n C=self.float_1)\\n self.assertEqual(learner.C, self.float_1)\\n self.assertEqual(learner._prox_obj.strength, 1. / self.float_1)\\n learner.C = self.float_2\\n self.assertEqual(learner.C, self.float_2)\\n self.assertEqual(learner._prox_obj.strength, 1. / self.float_2)\\n\\n msg = '^``C`` must be positive, got -1$'\\n with self.assertRaisesRegex(ValueError, msg):\\n if penalty == 'binarsity':\\n PoissonRegression(penalty=penalty, C=-1,\\n blocks_start=[0], blocks_length=[1])\\n else:\\n PoissonRegression(penalty=penalty, C=-1)\\n else:\\n msg = '^You cannot set C for penalty \\\"%s\\\"$' % penalty\\n with self.assertWarnsRegex(RuntimeWarning, msg):\\n PoissonRegression(penalty=penalty, C=self.float_1)\\n\\n learner = PoissonRegression(penalty=penalty)\\n with self.assertWarnsRegex(RuntimeWarning, msg):\\n learner.C = self.float_1\\n\\n msg = '^``C`` must be positive, got -2$'\\n with self.assertRaisesRegex(ValueError, msg):\\n learner.C = -2\",\n \"def test_penalty_compute(self):\\n objective = {'G': numpy.zeros((9)),\\n 'H': numpy.diag((1,)*9),\\n 'X': 1}\\n for penalty in self.penalties:\\n result = penalty.compute([1]*self.np, objective)\\n assert isinstance(result,tuple)\\n # more tests go here\",\n \"def get_penalty(state, action, winrate_predictor):\\n if violate_rule(state, action):\\n return -1 \\n return 0\",\n \"def multiclass_hinge(\\n x: ArrayLike,\\n y_true: ArrayLike,\\n hinge: float = 1.0,\\n *,\\n constant: Optional[bool] = None\\n) -> Tensor:\\n return Tensor._op(MulticlassHinge, x, op_args=(y_true, hinge), constant=constant)\",\n \"def model_loss(\\n model, true_vals, logit_pred_vals, epoch_num, avg_class_loss,\\n att_prior_loss_weight, att_prior_loss_weight_anneal_type,\\n att_prior_loss_weight_anneal_speed, att_prior_grad_smooth_sigma,\\n fourier_att_prior_freq_limit, fourier_att_prior_freq_limit_softness,\\n att_prior_loss_only, l2_reg_loss_weight, input_grads=None, status=None\\n):\\n corr_loss = model.correctness_loss(\\n true_vals, logit_pred_vals, avg_class_loss\\n )\\n final_loss = corr_loss\\n \\n if att_prior_loss_weight > 0:\\n att_prior_loss = model.fourier_att_prior_loss(\\n status, input_grads, fourier_att_prior_freq_limit,\\n fourier_att_prior_freq_limit_softness, att_prior_grad_smooth_sigma\\n )\\n\\n # att_prior_loss = model.smoothness_att_prior_loss(status, input_grads)\\n # att_prior_loss = model.sparsity_att_prior_loss(status, input_grads)\\n \\n if att_prior_loss_weight_anneal_type is None:\\n weight = att_prior_loss_weight\\n elif att_prior_loss_weight_anneal_type == \\\"inflate\\\":\\n exp = np.exp(-att_prior_loss_weight_anneal_speed * epoch_num)\\n weight = att_prior_loss_weight * ((2 / (1 + exp)) - 1)\\n elif att_prior_loss_weight_anneal_type == \\\"deflate\\\":\\n exp = np.exp(-att_prior_loss_weight_anneal_speed * epoch_num)\\n weight = att_prior_loss_weight * exp\\n\\n if att_prior_loss_only:\\n final_loss = att_prior_loss\\n else:\\n final_loss = final_loss + (weight * att_prior_loss)\\n else:\\n att_prior_loss = torch.zeros(1)\\n\\n # If necessary, add the L2 penalty\\n if l2_reg_loss_weight > 0:\\n l2_loss = util.place_tensor(torch.tensor(0).float())\\n for param in model.parameters():\\n if param.requires_grad_:\\n l2_loss = l2_loss + torch.sum(param * param)\\n final_loss = final_loss + (l2_reg_loss_weight * l2_loss)\\n\\n return final_loss, (corr_loss, att_prior_loss)\",\n \"def loss(L, S, A, R, Y, alpha, beta, gamma, delta):\\n return alpha*load_imbalance(Y,L,A) + beta*constraints(Y,A) + gamma*transfers(Y,R,S) + delta*choice(Y)\",\n \"def multiclass_hinge_loss(predictions, targets, delta=1):\\n num_cls = predictions.shape[1]\\n if targets.ndim == predictions.ndim - 1:\\n targets = theano.tensor.extra_ops.to_one_hot(targets, num_cls)\\n elif targets.ndim != predictions.ndim:\\n raise TypeError('rank mismatch between targets and predictions')\\n corrects = predictions[targets.nonzero()]\\n rest = theano.tensor.reshape(predictions[(1-targets).nonzero()],\\n (-1, num_cls-1))\\n rest = theano.tensor.max(rest, axis=1)\\n return theano.tensor.nnet.relu(rest - corrects + delta)\",\n \"def l2_loss(params):\\n \\\"\\\"\\\" It is a vec for each branch\\\"\\\"\\\"\\n loss_branches_vec = []\\n # TODO This is hardcoded but all our cases rigth now uses four branches\\n for i in range(len(params['branches']) -1):\\n loss_branches_vec.append(((params['branches'][i] - params['targets']) **2\\n * params['controls_mask'][i])\\n * params['branch_weights'][i])\\n \\\"\\\"\\\" The last branch is a speed branch\\\"\\\"\\\"\\n # TODO: Activate or deactivate speed branch loss\\n loss_branches_vec.append((params['branches'][-1] - params['inputs']) ** 2\\n * params['branch_weights'][-1])\\n return loss_branches_vec, {}\",\n \"def __init__(self, target_real_label=1.0, target_fake_label=0.0):\\n super(GANLocalLoss, self).__init__()\\n # self.pooling = nn.MaxPool2d(kernel_size=4, stride=2, padding=1)\\n self.adaptivepooling = nn.AdaptiveAvgPool2d(64)\",\n \"def l2_loss(inputs, reduction='mean', **kwargs):\\n args = ArgHelper.parse(locals())\\n args['reduction'] = reduction.upper()\\n op_lib = loss_ops_lib.L2Loss\\n if context.executing_eagerly():\\n return op_lib \\\\\\n .instantiate(reduction=args['reduction']) \\\\\\n .apply(inputs)\\n else:\\n return op_lib.blend(**args)\",\n \"def test_PoissonRegression_penalty_elastic_net_ratio(self):\\n ratio_1 = 0.6\\n ratio_2 = 0.3\\n for penalty in PoissonRegression._penalties.keys():\\n if penalty == 'elasticnet':\\n learner = PoissonRegression(penalty=penalty, C=self.float_1,\\n elastic_net_ratio=ratio_1)\\n self.assertEqual(learner.C, self.float_1)\\n self.assertEqual(learner.elastic_net_ratio, ratio_1)\\n self.assertEqual(learner._prox_obj.strength, 1. / self.float_1)\\n self.assertEqual(learner._prox_obj.ratio, ratio_1)\\n\\n learner.elastic_net_ratio = ratio_2\\n self.assertEqual(learner.C, self.float_1)\\n self.assertEqual(learner.elastic_net_ratio, ratio_2)\\n self.assertEqual(learner._prox_obj.ratio, ratio_2)\\n\\n else:\\n msg = '^Penalty \\\"%s\\\" has no elastic_net_ratio attribute$$' % \\\\\\n penalty\\n with self.assertWarnsRegex(RuntimeWarning, msg):\\n if penalty == 'binarsity':\\n PoissonRegression(penalty=penalty,\\n elastic_net_ratio=0.8,\\n blocks_start=[0], blocks_length=[1])\\n else:\\n PoissonRegression(penalty=penalty,\\n elastic_net_ratio=0.8)\\n\\n if penalty == 'binarsity':\\n learner = PoissonRegression(\\n penalty=penalty, blocks_start=[0], blocks_length=[1])\\n else:\\n learner = PoissonRegression(penalty=penalty)\\n\\n with self.assertWarnsRegex(RuntimeWarning, msg):\\n learner.elastic_net_ratio = ratio_1\",\n \"def l2_regularization_penalty(self):\\n return self.l2 * (np.linalg.norm(self.weights)**2)\",\n \"def binary_svm_loss(theta, X, y, C):\\n\\n m, d = X.shape\\n grad = np.zeros(theta.shape)\\n J = 0\\n\\n ############################################################################\\n # TODO #\\n # Implement the binary SVM hinge loss function here #\\n # 4 - 5 lines of vectorized code expected #\\n ############################################################################\\n h = np.dot(X, theta)\\n J = 1.0 / 2 / m * np.sum(theta**2) + 1.0 * C / m * np.sum(np.max([np.zeros(m), 1 - y * h], axis = 0))\\n\\n grad = 1.0 / m * theta + 1.0 * C / m * np.dot(X.T, -y * (y * h < 1))\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\\n\\n return J, grad\",\n \"def loss_opt_metric(self):\\n self.loss = tf.keras.losses.SparseCategoricalCrossentropy()\\n self.optimizer = tf.keras.optimizers.Adam(learning_rate=self.init_lr)\\n self.metric_loss = tf.keras.metrics.Mean()\\n self.accuracy = tf.keras.metrics.SparseCategoricalAccuracy()\",\n \"def create_loss_and_optimizer(net, learning_rate=0.01):\\n loss = nn.CrossEntropyLoss()\\n optimizer = optim.SGD(net.parameters(), lr=learning_rate, momentum=0.99, weight_decay=5 * 1e-4)\\n return loss, optimizer\",\n \"def policy_loss(sal_box_prob, oracle_action, sample_weights):\\n loss = tf.nn.softmax_cross_entropy_with_logits(logits=sal_box_prob, labels=oracle_action)\\n \\n return tf.reduce_mean(loss) * (1.0 - sample_weights / 10.0)\",\n \"def compute_loss(self):\",\n \"def hinge(d_real_logits, d_fake_logits, d_real=None, d_fake=None):\\n with tf.name_scope(\\\"hinge_loss\\\"):\\n check_dimensions(d_real, d_fake, d_real_logits, d_fake_logits)\\n d_loss_real = tf.reduce_mean(tf.nn.relu(1.0 - d_real_logits))\\n d_loss_fake = tf.reduce_mean(tf.nn.relu(1.0 + d_fake_logits))\\n d_loss = d_loss_real + d_loss_fake\\n g_loss = - tf.reduce_mean(d_fake_logits)\\n return d_loss, d_loss_real, d_loss_fake, g_loss\",\n \"def _default_config(self):\\n return {\\n 'penalty': 'l1',\\n 'solver': 'liblinear'\\n }\",\n \"def penalty(obs, player_x, player_y):\\n def environment_fits(obs, player_x, player_y):\\n \\\"\\\"\\\" environment fits constraints \\\"\\\"\\\"\\n # it is penalty game mode\\n if obs['game_mode'] == GameMode.Penalty:\\n return True\\n return False\\n \\n def get_action(obs, player_x, player_y):\\n \\\"\\\"\\\" get action of this memory pattern \\\"\\\"\\\"\\n if (random.random() < 0.5 and\\n Action.TopRight not in obs[\\\"sticky_actions\\\"] and\\n Action.BottomRight not in obs[\\\"sticky_actions\\\"]):\\n return Action.TopRight\\n else:\\n if Action.BottomRight not in obs[\\\"sticky_actions\\\"]:\\n return Action.BottomRight\\n return Action.Shot\\n \\n return {\\\"environment_fits\\\": environment_fits, \\\"get_action\\\": get_action}\",\n \"def learnign_rate_examples():\\n #######\\n bad_larning_rate = 0.1\\n not_bad_learning_rate = 1e-4\\n good_learning_rate = 1e-3\\n #######\\n return bad_larning_rate, not_bad_learning_rate, good_learning_rate\",\n \"def model_loss(inp, fake, real_label, fake_label):\\n \\n \\n Dreal,realcls,R1 = gradpen(inp)\\n [Dfake,fakecls] = D(fake)\\n # 1. Adversarial loss\\n \\n glabel = tf.ones_like(Dfake)#tf.random.uniform((Dfake.shape), 1-LN, 1)\\n dlabelr = tf.ones_like(Dreal)#tf.random.uniform((Dreal.shape), 1-LN, 1)\\n dlabelf = tf.zeros_like(Dfake)#tf.random.uniform((Dfake.shape), 0, LN)\\n \\n \\n \\n # D has no sigmoid activation: \\\"from_logits=True\\\"\\n real_loss = tf.keras.losses.binary_crossentropy(\\n dlabelr, Dreal, from_logits=True)\\n real_loss = tf.reduce_mean(real_loss)\\n \\n fake_loss = tf.keras.losses.binary_crossentropy(\\n dlabelf, Dfake, from_logits=True)\\n fake_loss = tf.reduce_mean(fake_loss)\\n \\n Dadv = 0.5*(real_loss+fake_loss)\\n \\n Gadv = tf.keras.losses.binary_crossentropy(\\n glabel, Dfake, from_logits=True)\\n Gadv = tf.reduce_mean(Gadv)\\n \\n # 2. Classification loss\\n \\n Dcls = tf.keras.losses.binary_crossentropy(real_label, realcls, from_logits=True)\\n Dcls = tf.reduce_mean(Dcls)\\n \\n Gcls = tf.keras.losses.binary_crossentropy(fake_label, fakecls, from_logits=True)\\n Gcls = tf.reduce_mean(Gcls)\\n \\n # 3. Total loss\\n \\n Dloss = Dadv + (GAMMA/2)*R1 + LAMBDA_CLS*Dcls\\n \\n Gloss = Gadv + LAMBDA_CLS*Gcls\\n \\n return (Dloss, Dadv, Dcls, R1), (Gloss, Gadv, Gcls)\",\n \"def add_loss(self):\\n \\n raise RuntimeError(\\\"Must define function add_loss(self)\\\")\",\n \"def lgb_hyperopt(data, labels, num_evals=1000, n_folds=5, diagnostic=False):\\r\\n LGBM_MAX_LEAVES = 2**11 #maximum number of leaves per tree for LightGBM\\r\\n LGBM_MAX_DEPTH = 25 #maximum tree depth for LightGBM \\r\\n EVAL_METRIC_LGBM_CLASS = 'f1'\\r\\n\\r\\n def lgb_f1_score(y_hat, data):\\r\\n y_true = data.get_label()\\r\\n y_hat = np.round(y_hat)\\r\\n return 'f1', f1_score(y_true, y_hat), True\\r\\n\\r\\n print('Running {} rounds of LightGBM parameter optimisation:'.format(num_evals))\\r\\n #clear space\\r\\n \\r\\n integer_params = ['max_depth',\\r\\n 'num_leaves',\\r\\n 'max_bin',\\r\\n 'min_data_in_leaf',\\r\\n 'min_data_in_bin']\\r\\n \\r\\n def objective(space_params):\\r\\n \\r\\n #cast integer params from float to int\\r\\n for param in integer_params:\\r\\n space_params[param] = int(space_params[param])\\r\\n \\r\\n #extract nested conditional parameters\\r\\n if space_params['boosting']['boosting'] == 'goss':\\r\\n top_rate = space_params['boosting'].get('top_rate')\\r\\n other_rate = space_params['boosting'].get('other_rate')\\r\\n #0 <= top_rate + other_rate <= 1\\r\\n top_rate = max(top_rate, 0)\\r\\n top_rate = min(top_rate, 0.5)\\r\\n other_rate = max(other_rate, 0)\\r\\n other_rate = min(other_rate, 0.5)\\r\\n space_params['top_rate'] = top_rate\\r\\n space_params['other_rate'] = other_rate\\r\\n \\r\\n subsample = space_params['boosting'].get('subsample', 1.0)\\r\\n space_params['boosting'] = space_params['boosting']['boosting']\\r\\n space_params['subsample'] = subsample\\r\\n \\r\\n cv_results = lgb.cv(space_params, train, nfold = n_folds, stratified=True,\\r\\n early_stopping_rounds=100, seed=42, feval=lgb_f1_score)\\r\\n \\r\\n best_loss = -cv_results['f1-mean'][-1]\\r\\n\\r\\n return{'loss':best_loss, 'status': STATUS_OK }\\r\\n \\r\\n train = lgb.Dataset(data, labels)\\r\\n \\r\\n #integer and string parameters, used with hp.choice()\\r\\n boosting_list = [{'boosting': 'gbdt',\\r\\n 'subsample': hp.uniform('subsample', 0.5, 1)},\\r\\n {'boosting': 'goss',\\r\\n 'subsample': 1.0,\\r\\n 'top_rate': hp.uniform('top_rate', 0, 0.5),\\r\\n 'other_rate': hp.uniform('other_rate', 0, 0.5)}] #if including 'dart', make sure to set 'n_estimators'\\r\\n\\r\\n objective_list_reg = ['huber', 'gamma', 'fair', 'tweedie']\\r\\n objective_list_class = ['binary', 'cross_entropy']\\r\\n objective_list = objective_list_class\\r\\n is_unbalance_list = [True]\\r\\n\\r\\n space ={'boosting' : hp.choice('boosting', boosting_list),\\r\\n 'num_leaves' : hp.quniform('num_leaves', 2, LGBM_MAX_LEAVES, 1),\\r\\n 'max_depth': hp.quniform('max_depth', 2, LGBM_MAX_DEPTH, 1),\\r\\n 'max_bin': hp.quniform('max_bin', 32, 255, 1),\\r\\n 'min_data_in_leaf': hp.quniform('min_data_in_leaf', 1, 256, 1),\\r\\n 'min_data_in_bin': hp.quniform('min_data_in_bin', 1, 256, 1),\\r\\n 'min_gain_to_split' : hp.quniform('min_gain_to_split', 0.1, 5, 0.01),\\r\\n 'lambda_l1' : hp.uniform('lambda_l1', 0, 5),\\r\\n 'lambda_l2' : hp.uniform('lambda_l2', 0, 5),\\r\\n 'learning_rate' : hp.loguniform('learning_rate', np.log(0.005), np.log(0.2)),\\r\\n 'metric' : None, \\r\\n 'objective' : hp.choice('objective', objective_list),\\r\\n 'feature_fraction' : hp.quniform('feature_fraction', 0.5, 1, 0.01),\\r\\n 'bagging_fraction' : hp.quniform('bagging_fraction', 0.5, 1, 0.01),\\r\\n 'is_unbalance' : hp.choice('is_unbalance', is_unbalance_list)\\r\\n }\\r\\n\\r\\n trials = Trials()\\r\\n best = fmin(fn=objective,\\r\\n space=space,\\r\\n algo=tpe.suggest,\\r\\n max_evals=num_evals, \\r\\n trials=trials)\\r\\n \\r\\n #fmin() will return the index of values chosen from the lists/arrays in 'space'\\r\\n #to obtain actual values, index values are used to subset the original lists/arrays\\r\\n #extract nested conditional parameters\\r\\n try:\\r\\n if best['boosting']['boosting'] == 'goss':\\r\\n top_rate = best['boosting'].get('top_rate')\\r\\n other_rate = best['boosting'].get('other_rate')\\r\\n #0 <= top_rate + other_rate <= 1\\r\\n top_rate = max(top_rate, 0)\\r\\n top_rate = min(top_rate, 0.5)\\r\\n other_rate = max(other_rate, 0)\\r\\n other_rate = min(other_rate, 0.5)\\r\\n best['top_rate'] = top_rate\\r\\n best['other_rate'] = other_rate\\r\\n except:\\r\\n if boosting_list[best['boosting']]['boosting'] == 'goss':\\r\\n top_rate = best['top_rate']\\r\\n other_rate = best['other_rate']\\r\\n #0 <= top_rate + other_rate <= 1\\r\\n top_rate = max(top_rate, 0)\\r\\n top_rate = min(top_rate, 0.5)\\r\\n other_rate = max(other_rate, 0)\\r\\n other_rate = min(other_rate, 0.5)\\r\\n best['top_rate'] = top_rate\\r\\n best['other_rate'] = other_rate\\r\\n best['boosting'] = boosting_list[best['boosting']]['boosting']#nested dict, index twice\\r\\n best['metric'] = metric_list[best['metric']]\\r\\n best['objective'] = objective_list[best['objective']]\\r\\n best['is_unbalance'] = is_unbalance_list[best['is_unbalance']]\\r\\n \\r\\n #cast floats of integer params to int\\r\\n for param in integer_params:\\r\\n best[param] = int(best[param])\\r\\n \\r\\n print('{' + '\\\\n'.join('{}: {}'.format(k, v) for k, v in best.items()) + '}')\\r\\n if diagnostic:\\r\\n return(best, trials)\\r\\n else:\\r\\n return(best)\",\n \"def combined_loss(prediction, target, max_value, ssim_weight=0.5):\\n ssim_l = ssim_loss(prediction, target, max_value)\\n nmse_l = nmse_loss(prediction, target)\\n total_loss = nmse_l + (ssim_l * ssim_weight)\\n return total_loss\",\n \"def verbose_loss(self, feedback: _Feedback, extra_info) -> Dict[str, _Array]:\\n hint_preds, diff_logits, gt_diffs = extra_info\\n\\n for inp in feedback.features.inputs:\\n if inp.location in [_Location.NODE, _Location.EDGE]:\\n nb_nodes = inp.data.shape[1]\\n break\\n\\n total_loss = 0.0\\n lengths = feedback.features.lengths\\n\\n losses = {}\\n if self.decode_diffs:\\n for loc in _Location:\\n for i in range(len(gt_diffs)):\\n is_not_done = _is_not_done_broadcast(lengths, i, gt_diffs[i][loc])\\n diff_loss = (\\n jnp.maximum(diff_logits[i][loc], 0) -\\n diff_logits[i][loc] * gt_diffs[i][loc] +\\n jnp.log1p(jnp.exp(-jnp.abs(diff_logits[i][loc]))) * is_not_done)\\n losses[loc.name + '_diff_%d' % i] = jnp.mean(diff_loss)\\n\\n if self.decode_hints:\\n for truth in feedback.features.hints:\\n for i in range(truth.data.shape[0] - 1):\\n assert truth.name in hint_preds[i]\\n pred = hint_preds[i][truth.name]\\n is_not_done = _is_not_done_broadcast(lengths, i, truth.data[i + 1])\\n if truth.type_ == _Type.SCALAR:\\n if self.decode_diffs:\\n total_loss = jnp.mean((pred - truth.data[i + 1])**2 *\\n gt_diffs[i][truth.location] * is_not_done)\\n else:\\n total_loss = jnp.mean((pred - truth.data[i + 1])**2 * is_not_done)\\n elif truth.type_ == _Type.MASK:\\n if self.decode_diffs:\\n total_loss = jnp.mean(\\n jnp.maximum(pred, 0) - pred * truth.data[i + 1] +\\n jnp.log1p(jnp.exp(-jnp.abs(pred))) *\\n gt_diffs[i][truth.location] * is_not_done)\\n else:\\n total_loss = jnp.mean(\\n jnp.maximum(pred, 0) - pred * truth.data[i + 1] +\\n jnp.log1p(jnp.exp(-jnp.abs(pred))) * is_not_done)\\n elif truth.type_ == _Type.MASK_ONE:\\n if self.decode_diffs:\\n total_loss = jnp.mean(\\n -jnp.sum(\\n truth.data[i + 1] * jax.nn.log_softmax(\\n pred) * is_not_done, axis=-1, keepdims=True) *\\n gt_diffs[i][truth.location])\\n else:\\n total_loss = jnp.mean(-jnp.sum(\\n truth.data[i + 1] * jax.nn.log_softmax(\\n pred) * is_not_done, axis=-1))\\n elif truth.type_ == _Type.CATEGORICAL:\\n if self.decode_diffs:\\n total_loss = jnp.mean(\\n -jnp.sum(\\n truth.data[i + 1] * jax.nn.log_softmax(\\n pred), axis=-1, keepdims=True) *\\n jnp.expand_dims(gt_diffs[i][truth.location], -1) *\\n is_not_done)\\n else:\\n total_loss = jnp.mean(-jnp.sum(\\n truth.data[i + 1] * jax.nn.log_softmax(pred), axis=-1) *\\n is_not_done)\\n elif truth.type_ == _Type.POINTER:\\n if self.decode_diffs:\\n total_loss = jnp.mean(-jnp.sum(\\n hk.one_hot(truth.data[i + 1], nb_nodes) *\\n jax.nn.log_softmax(pred),\\n axis=-1) * gt_diffs[i][truth.location] * is_not_done)\\n else:\\n total_loss = jnp.mean(-jnp.sum(\\n hk.one_hot(truth.data[i + 1], nb_nodes) *\\n jax.nn.log_softmax(pred),\\n axis=-1) * is_not_done)\\n else:\\n raise ValueError('Incorrect type')\\n losses[truth.name + '_%d' % i] = total_loss\\n return losses\",\n \"def get_loss(self, xs, y):\\n \\\"*** YOUR CODE HERE question 4 ***\\\"\\n return nn.SoftmaxLoss(self.run(xs), y)\",\n \"def l2_loss(input, target):\\n pos_inds = torch.nonzero(target > 0.0).squeeze(1)\\n if pos_inds.shape[0] > 0:\\n cond = torch.abs(input[pos_inds] - target[pos_inds])\\n loss = 0.5 * cond**2 / pos_inds.shape[0]\\n else:\\n loss = input * 0.0\\n return loss.sum()\",\n \"def L2Learning(**kwargs):\\n past_task_params = kwargs['past_task_params']\\n dataloader = kwargs['dataloader']\\n epochs = kwargs['epochs']\\n optim = kwargs['optim']\\n crit = kwargs['crit']\\n net = kwargs['net']\\n ld = kwargs['ld']\\n\\n for epoch in range(epochs):\\n running_loss = 0.0\\n for x, y in dataloader:\\n if torch.cuda.is_available():\\n x = x.cuda()\\n y = y.cuda()\\n\\n optim.zero_grad()\\n outputs = net(x)\\n loss = crit(outputs, y)\\n\\n reg = 0.0\\n for past_param in past_task_params:\\n for i, param in enumerate(net.parameters()):\\n penalty = (past_param[i] - param) ** 2\\n reg += penalty.sum()\\n loss += reg * (ld / 2)\\n\\n loss.backward()\\n optim.step()\\n running_loss += loss.item()\\n\\n if epoch % 10 == 9:\\n print(\\\"[Epoch %d/%d] Loss: %.3f\\\"%(epoch+1, epochs, running_loss))\\n\\n ### Save parameters to use next task learning\\n tensor_param = []\\n for params in net.parameters():\\n tensor_param.append(params.detach().clone())\\n '''\\n tensor_param = torch.stack(tensor_param)\\n\\n if past_task_params.nelement() > 0:\\n past_task_params = torch.cat((past_task_params, tensor_param.unsqueeze(0)))\\n else:\\n past_task_params = tensor_param.unsqueeze(0)\\n '''\\n past_task_params.append(tensor_param)\",\n \"def human_policy_kl_loss(student_logits, teacher_logits, action_type_kl_cost):\\n # student_logits: list of ArgsActionLogits\\n action_type_loss = kl(student_logits, teacher_logits, 1)\\n kl_loss = action_type_kl_cost * torch.mean(action_type_loss)\\n\\n return kl_loss\",\n \"def get_loss(self, xs, y):\\n \\\"*** YOUR CODE HERE ***\\\"\\n predictedY = self.run(xs)\\n return nn.SoftmaxLoss(predictedY, y)\\n # return nn.SquareLoss(predictedY, y)\",\n \"def target_multi_objective2(\\n config: Configuration,\\n seed: int,\\n # instance: str,\\n # budget: float,\\n) -> dict[str, float]:\\n return {\\\"cost1\\\": seed, \\\"cost2\\\": seed}\",\n \"def test_get_hyperflex_auto_support_policy_by_moid(self):\\n pass\",\n \"def init_loss(config):\\n if config.loss == 'cross_entropy':\\n criterion = nn.CrossEntropyLoss()\\n elif config.loss == 'label_smoothing':\\n class LabelSmoothingLoss(nn.Module):\\n def __init__(self, smoothing=0.0):\\n super(LabelSmoothingLoss, self).__init__()\\n self.smoothing = smoothing\\n\\n def forward(self, prediction, target):\\n assert 0 <= self.smoothing < 1\\n neglog_softmaxPrediction = -prediction.log_softmax(dim=1)\\n\\n with torch.no_grad():\\n smoothedLabels = self.smoothing / (prediction.size(1) - 1) * torch.ones_like(prediction)\\n smoothedLabels.scatter_(1, target.data.unsqueeze(1), 1 - self.smoothing)\\n return torch.mean(torch.sum(smoothedLabels * neglog_softmaxPrediction, dim=1))\\n criterion = LabelSmoothingLoss(smoothing=config.ls_smoothing)\\n elif config.loss == 'maxup':\\n return None\\n return criterion\",\n \"def lp_reg(x, y, critic):\\n batch_size = x.size()[0]\\n \\n t = torch.rand(batch_size, 1)\\n t = t.expand(x.size())\\n t_ = t*x + (1-t)*y\\n t_ = torch.autograd.Variable(t_, requires_grad=True)\\n \\n t_grad = critic(t_)\\n grad = torch.autograd.grad(t_grad, t_, grad_outputs=torch.ones(t_grad.size()),\\n create_graph=True, retain_graph=True)[0]\\n \\n zeros = torch.zeros(batch_size, 1)\\n penalty = torch.max((torch.norm(grad, dim=1)-1), zeros)\\n return (penalty**2).mean()\",\n \"def calculate_kg_loss(self, interaction):\\n\\n if self.restore_user_e is not None or self.restore_entity_e is not None:\\n self.restore_user_e, self.restore_entity_e = None, None\\n\\n # get loss for training kg\\n h = interaction[self.HEAD_ENTITY_ID]\\n r = interaction[self.RELATION_ID]\\n pos_t = interaction[self.TAIL_ENTITY_ID]\\n neg_t = interaction[self.NEG_TAIL_ENTITY_ID]\\n\\n h_e, r_e, pos_t_e, neg_t_e = self._get_kg_embedding(h, r, pos_t, neg_t)\\n pos_tail_score = ((h_e + r_e - pos_t_e) ** 2).sum(dim=1)\\n neg_tail_score = ((h_e + r_e - neg_t_e) ** 2).sum(dim=1)\\n kg_loss = F.softplus(pos_tail_score - neg_tail_score).mean()\\n kg_reg_loss = self.reg_loss(h_e, r_e, pos_t_e, neg_t_e)\\n loss = kg_loss + self.reg_weight * kg_reg_loss\\n\\n return loss\",\n \"def loss(self, X, y=None, reg=0.0):\\n\\n self.layers = []\\n layers = self.layers\\n layers.append(X)\\n\\n # Unpack variables from the params dictionary\\n W1, b1 = self.params['W1'], self.params['b1']\\n W2, b2 = self.params['W2'], self.params['b2']\\n N, D = X.shape\\n H, C = W2.shape\\n\\n # Compute the forward pass\\n scores = None\\n #############################################################################\\n # TODO: Perform the forward pass, computing the class scores for the input. #\\n # Store the result in the scores variable, which should be an array of #\\n # shape (N, C). #\\n #############################################################################\\n mid = np.maximum(0, X.dot(W1) + b1.reshape(1, -1)) # activation\\n scores = mid.dot(W2) + b2.reshape(1, -1)\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\\n\\n # If the targets are not given then jump out, we're done\\n if y is None:\\n return scores\\n\\n # Compute the loss\\n loss = None\\n #############################################################################\\n # TODO: Finish the forward pass, and compute the loss. This should include #\\n # both the data loss and L2 regularization for W1 and W2. Store the result #\\n # in the variable loss, which should be a scalar. Use the Softmax #\\n # classifier loss. So that your results match ours, multiply the #\\n # regularization loss by 0.5 #\\n #############################################################################\\n exp_score = np.exp(scores)\\n exp_score_sum = exp_score.sum(axis=1)\\n correct_score = exp_score[np.arange(N), y]\\n probability = (correct_score / exp_score_sum).reshape(-1, 1)\\n loss = -np.log(probability).sum()\\n\\n loss /= N\\n loss += 0.5 * reg * (np.sum(W1 * W1) + np.sum(W2 * W2))\\n\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\\n\\n # Backward pass: compute gradients\\n grads = {}\\n #############################################################################\\n # TODO: Compute the backward pass, computing the derivatives of the weights #\\n # and biases. Store the results in the grads dictionary. For example, #\\n # grads['W1'] should store the gradient on W1, and be a matrix of same size #\\n #############################################################################\\n des = np.tile((-correct_score / np.square(exp_score_sum)).reshape(-1, 1), (1, C))\\n des[np.arange(N), y] += 1.0 / exp_score_sum\\n dsoftmax = des * (-np.ones((mid.shape[0], 1)) / probability) * np.exp(scores)\\n\\n # W2\\n grads['W2'] = mid.T.dot(dsoftmax)\\n grads['W2'] /= N\\n grads['W2'] += reg * W2\\n\\n # b2\\n grads['b2'] = np.ones_like(b2.reshape(1, -1)) * dsoftmax\\n grads['b2'] = np.mean(grads['b2'], axis=0).reshape(-1)\\n\\n # W1\\n binary = np.zeros_like(mid)\\n binary[mid > 0] = 1\\n grads['W1'] = X.T.dot(binary * dsoftmax.dot(W2.T)) # chain rule, compute dmid/dW1 * dscore/dmid * dsoftmax\\n grads['W1'] /= N\\n grads['W1'] += reg * W1\\n\\n # b1\\n grads['b1'] = np.ones_like(b1.reshape(1, -1)) * binary * dsoftmax.dot(W2.T)\\n grads['b1'] = np.mean(grads['b1'], axis=0).reshape(-1)\\n\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\\n\\n return loss, grads\",\n \"def compile_update_default(nnet, inputs, targets):\\n\\n floatX = Cfg.floatX\\n C = Cfg.C\\n\\n if len(nnet.all_layers) > 1:\\n feature_layer = nnet.all_layers[-2]\\n else:\\n feature_layer = nnet.input_layer\\n final_layer = nnet.svm_layer\\n trainable_params = lasagne.layers.get_all_params(final_layer,\\n trainable=True)\\n\\n # Regularization\\n if Cfg.weight_decay:\\n l2_penalty = (floatX(0.5) / C) * get_l2_penalty(nnet, Cfg.include_bias)\\n else:\\n l2_penalty = T.cast(0, dtype='floatX')\\n\\n # Backpropagation\\n prediction = lasagne.layers.get_output(final_layer, inputs=inputs,\\n deterministic=False)\\n objective, train_acc = final_layer.objective(prediction, targets)\\n train_loss = T.cast((objective) / targets.shape[0], dtype='floatX')\\n train_acc = T.cast(train_acc * 1. / targets.shape[0], dtype='floatX')\\n train_obj = l2_penalty + train_loss\\n updates = get_updates(nnet, train_obj, trainable_params, solver=nnet.solver)\\n nnet.backprop = theano.function([inputs, targets],\\n [train_obj, train_acc],\\n updates=updates)\\n\\n # Hinge loss\\n nnet.hinge_loss = theano.function([inputs, targets],\\n [train_loss, train_acc])\\n\\n # Forwardpropagation\\n test_prediction = lasagne.layers.get_output(final_layer, inputs=inputs,\\n deterministic=True)\\n if nnet.data.n_classes == 2:\\n scores = test_prediction[:, 1] - test_prediction[:, 0]\\n else:\\n scores = T.zeros_like(targets)\\n objective, test_acc = final_layer.objective(test_prediction, targets)\\n test_loss = T.cast(objective / targets.shape[0], dtype='floatX')\\n test_acc = T.cast(test_acc * 1. / targets.shape[0], dtype='floatX')\\n test_obj = l2_penalty + test_loss\\n # get network feature representation\\n test_rep = lasagne.layers.get_output(feature_layer, inputs=inputs,\\n deterministic=True)\\n test_rep_norm = test_rep.norm(L=2, axis=1)\\n nnet.forward = theano.function([inputs, targets],\\n [test_obj, test_acc, scores, l2_penalty,\\n test_rep_norm, test_loss])\",\n \"def loss(self, X, y=None):\\r\\n mode = 'test' if y is None else 'train'\\r\\n\\r\\n if self.dropout_param is not None:\\r\\n self.dropout_param['mode'] = mode\\r\\n if self.use_batchnorm:\\r\\n for bn_param in self.bn_params:\\r\\n bn_param[mode] = mode\\r\\n\\r\\n\\r\\n W1, b1 = self.params['W1'], self.params['b1']\\r\\n W2, b2 = self.params['W2'], self.params['b2']\\r\\n W3, b3 = self.params['W3'], self.params['b3']\\r\\n gamma1, beta1 = self.params['gamma1'], self.params['beta1']\\r\\n gamma2, beta2 = self.params['gamma2'], self.params['beta2']\\r\\n # pass conv_param to the forward pass for the convolutional layer\\r\\n filter_size = W1.shape[2]\\r\\n conv_param = {'stride': 1, 'pad': int((filter_size - 1) / 2)}\\r\\n\\r\\n # pass pool_param to the forward pass for the max-pooling layer\\r\\n pool_param = {'pool_height': 2, 'pool_width': 2, 'stride': 2}\\r\\n\\r\\n scores = None\\r\\n ############################################################################\\r\\n # TODO: Implement the forward pass for the three-layer convolutional net, #\\r\\n # computing the class scores for X and storing them in the scores #\\r\\n # variable. #\\r\\n ############################################################################\\r\\n alpha = 0.1\\r\\n csrp1, csrp1_cache = conv_sbn_lrelu_pool_forward(X, W1, b1, gamma1, beta1, self.bn_params[0], conv_param, pool_param, alpha)\\r\\n abr1, abr1_cache = affine_bn_lrelu_forward(csrp1, W2, b2, gamma2, beta2, self.bn_params[1], alpha)\\r\\n scores, out_cache = affine_forward(abr1, W3, b3)\\r\\n ############################################################################\\r\\n # END OF YOUR CODE #\\r\\n ############################################################################\\r\\n\\r\\n if y is None:\\r\\n return scores\\r\\n\\r\\n loss, grads = 0, {}\\r\\n ############################################################################\\r\\n # TODO: Implement the backward pass for the three-layer convolutional net, #\\r\\n # storing the loss and gradients in the loss and grads variables. Compute #\\r\\n # data loss using softmax, and make sure that grads[k] holds the gradients #\\r\\n # for self.params[k]. Don't forget to add L2 regularization! #\\r\\n ############################################################################\\r\\n loss, dp = softmax_loss(scores, y)\\r\\n loss += 0.5 * self.reg * np.sum(\\r\\n np.sum(W1 ** 2) + np.sum(W2 ** 2) + np.sum(W3 ** 2)\\r\\n )\\r\\n dp, dw3, db3 = affine_backward(dp, out_cache)\\r\\n dp, dw2, db2, dgamma2, dbeta2 = affine_bn_lrelu_backward(dp, abr1_cache)\\r\\n dp, dw1, db1, dgamma1, dbeta1 = conv_sbn_lrelu_pool_backward(dp, csrp1_cache)\\r\\n grads['W1'] = dw1 + self.reg * W1\\r\\n grads['W2'] = dw2 + self.reg * W2\\r\\n grads['W3'] = dw3 + self.reg * W3\\r\\n grads['b1'] = db1\\r\\n grads['b2'] = db2\\r\\n grads['b3'] = db3\\r\\n grads['gamma2'] = dgamma2\\r\\n grads['gamma1'] = dgamma1\\r\\n grads['beta2'] = dbeta2\\r\\n grads['beta1'] = dbeta1\\r\\n \\r\\n ############################################################################\\r\\n # END OF YOUR CODE #\\r\\n ############################################################################\\r\\n\\r\\n return loss, grads\",\n \"def test_gradient_descent_blobs():\\n features, _, targets, _ = load_data('blobs')\\n\\n hinge = make_predictions(features, targets, 'hinge', None)\\n # assert np.all(hinge == targets)\\n\\n # l1_hinge = make_predictions(features, targets, 'hinge', 'l1')\\n # # assert np.all(l1_hinge == targets)\\n #\\n # l2_hinge = make_predictions(features, targets, 'hinge', 'l2')\\n # # assert np.all(l2_hinge == targets)\\n #\\n # squared = make_predictions(features, targets, 'squared', None)\\n # # assert np.all(squared == targets)\\n #\\n # l1_squared = make_predictions(features, targets, 'squared', 'l1')\\n #\\n # l2_squared = make_predictions(features, targets, 'squared', 'l2')\",\n \"def train(self, use_mini=False, use_mse=False):\\n # decide whether to use MSE as the keypoint loss function\\n if use_mse: # to use MSE loss\\n loss_fn = squared_l2_norm\\n else: # to use KL divergence loss\\n loss_fn = kl_divergence\\n\\n # generate model\\n if not use_mini:\\n keypoint_inter, silhouette_inter, keypoint_output, silhouette_output = self.model()\\n else:\\n keypoint_inter, silhouette_inter, keypoint_output, silhouette_output = self.mini_model()\\n keypoint_summary = tf.summary.histogram('keypoint_summary', keypoint_output)\\n silhouette_summary = tf.summary.histogram('silhouette_summary', silhouette_output)\\n\\n with tf.variable_scope(name_or_scope='human2d_optimizer'):\\n # loss functions\\n if not use_mini:\\n keypoint_loss = tf.reduce_mean(tf.concat(\\n [tf.reduce_sum(loss_fn(self._keypoint, keypoint_inter), axis=[1, 2]),\\n tf.reduce_sum(loss_fn(self._keypoint, keypoint_output), axis=[1, 2])], axis=-1),\\n name='keypoint_loss')\\n silhouette_loss = tf.reduce_mean(tf.concat(\\n [tf.reduce_sum(cross_entropy(self._silhouette, silhouette_inter), axis=[1, 2]),\\n tf.reduce_sum(cross_entropy(self._silhouette, silhouette_output), axis=[1, 2])], axis=-1),\\n name='silhouette_loss')\\n else:\\n keypoint_loss = tf.reduce_mean(tf.reduce_sum(loss_fn(self._keypoint, keypoint_output),\\n axis=[1, 2]), name='keypoint_loss')\\n silhouette_loss = tf.reduce_mean(tf.reduce_sum(cross_entropy(self._silhouette, silhouette_output),\\n axis=[1, 2]), name='silhouette_loss')\\n total_loss = 100 * keypoint_loss + silhouette_loss\\n loss_summary = tf.summary.scalar('loss_summary', total_loss)\\n\\n # optimizer\\n optimizer = tf.train.AdamOptimizer(learning_rate=self.learning_rate)\\n update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\\n with tf.control_dependencies(update_ops):\\n train_ops = optimizer.minimize(total_loss)\\n # unfrozen = [var for var in tf.trainable_variables() if not var.name.startswith('')]\\n # grads_and_vars = optimizer.compute_gradients(total_loss, var_list=unfrozen)\\n # capped_grads_and_vars = [(tf.clip_by_value(grad, -1., 1.), var) for grad, var in grads_and_vars]\\n # train_ops = optimizer.apply_gradients(capped_grads_and_vars)\\n\\n # configuration\\n if not os.path.isdir('model'):\\n os.mkdir('model')\\n config = tf.ConfigProto()\\n config.gpu_options.allow_growth = True\\n config.gpu_options.per_process_gpu_memory_fraction = 0.5\\n config.allow_soft_placement = True\\n config.log_device_placement = False\\n\\n print('Start training Human2D')\\n with tf.Session(config=config) as sess:\\n # initialization\\n sess.run(tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()))\\n\\n # saver\\n saver = tf.train.Saver(max_to_keep=5)\\n\\n # store the network graph for tensorboard visualization\\n writer = tf.summary.FileWriter('model/network_graph', sess.graph)\\n merge_op = tf.summary.merge([keypoint_summary, silhouette_summary, loss_summary])\\n\\n # dataset\\n data = Reader(filenames=self.filenames, image_size=self.image_size,\\n batch_size=self.batch_size, num_epochs=self.num_epochs).feed()\\n try:\\n for i in range(self.iterations):\\n # input\\n _input, _silhouette, _keypoint, _, _ = sess.run(data)\\n _, k_out, s_out, k_loss, s_loss, sm = sess.run([train_ops, keypoint_output, silhouette_output,\\n keypoint_loss, silhouette_loss, merge_op],\\n feed_dict={self.training: True, self._input: _input,\\n self._silhouette: _silhouette,\\n self._keypoint: _keypoint})\\n if i % 10 == 0:\\n print('iteration %d: keypoint loss = %f, silhouette loss = %f' % (i, k_loss, s_loss))\\n if i % 200 == 0:\\n writer.add_summary(sm, i)\\n writer.flush()\\n cv.imwrite('visual/input.jpg', _input[0, :, :, ::-1])\\n cv.imwrite('visual/silhouette.jpg', Human2D.generate_silhouette(s_out[0]))\\n for j in range(14):\\n cv.imwrite('visual/keypoint_%d.jpg' % j, 255 * k_out[0, :, :, j])\\n if i % 500 == 0 and i != 0:\\n print('save at iteration %d' % i)\\n saver.save(sess, 'model/%s/human2d' %\\n (time.strftime('%Y-%m-%d_%H-%M-%S', time.localtime(time.time()))))\\n # time.sleep(1)\\n except tf.errors.OutOfRangeError:\\n print('Done training -- epoch limit reached')\\n writer.close()\",\n \"def configure_loss(self) -> nn.Module:\\n branch_losses = {}\\n for branch, loss in self.branch_losses.items():\\n if loss not in JOINT_SEG_LOSSES:\\n raise ValueError(\\n f\\\"Illegal joint loss given. Got: {loss}. Allowed are all the \\\"\\n f\\\"permutations of: {list(SEG_LOSS_LOOKUP.keys())}\\\"\\n )\\n\\n try:\\n losses = loss.split(\\\"_\\\")\\n except Exception:\\n losses = [loss]\\n\\n loss_kwargs = {\\\"k\\\": None}\\n if self.branch_loss_params is not None:\\n loss_kwargs = self.branch_loss_params[branch]\\n\\n # set joint losses for each branch\\n branch_losses[branch] = JointLoss(\\n [Loss(loss_name, **loss_kwargs) for loss_name in losses]\\n )\\n\\n return MultiTaskLoss(branch_losses=branch_losses)\",\n \"def get_loss(self, x, y):\\n \\\"*** YOUR CODE HERE question 3 ***\\\"\\n return nn.SoftmaxLoss(self.run(x), y)\",\n \"def setup_loss(self, h_s, h_e):\\n with vs.variable_scope(\\\"loss\\\"):\\n # masked_h_s = tf.boolean_mask(h_s, self.context_mask_placeholder)\\n # masked_h_e = tf.boolean_mask(h_e, self.context_mask_placeholder)\\n # loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(h_s, self.start_span_placeholder) +\\n # tf.nn.softmax_cross_entropy_with_logits(h_e, self.end_span_placeholder))\\n masked_h_s = tf.add(h_s, (1 - tf.cast(self.context_mask_placeholder, 'float')) * (-1e30))\\n masked_h_e = tf.add(h_e, (1 - tf.cast(self.context_mask_placeholder, 'float')) * (-1e30))\\n loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(masked_h_s, self.start_span_placeholder) +\\n tf.nn.softmax_cross_entropy_with_logits(masked_h_e, self.end_span_placeholder))\\n total_loss = loss\\n return total_loss, masked_h_s, masked_h_e\",\n \"def calculate_and_choose_additional_loss(segm: torch.Tensor, sam_output: torch.Tensor, sam_criterion,\\n sam_criterion_outer):\\n return choose_add_loss(*calculate_additional_loss(segm, sam_output, sam_criterion, sam_criterion_outer))\",\n \"def get_spectral_penalty(nnet, include_bias=False):\\n\\n penalty = 0\\n\\n for layer in nnet.trainable_layers:\\n if not layer.issvm:\\n eigenvalues, eigvec = T.nlinalg.eigh(T.dot(layer.W, layer.W.T))\\n eig_max = T.max(eigenvalues)\\n penalty = penalty + eig_max\\n\\n if include_bias:\\n for layer in nnet.trainable_layers:\\n if (not layer.issvm) and (layer.b is not None):\\n penalty = penalty + T.sum(abs(layer.b) ** 2)\\n\\n return T.cast(penalty, dtype='floatX')\",\n \"def binary_hinge_loss(predictions, targets, delta=1, log_odds=None,\\n binary=True):\\n if log_odds is None: # pragma: no cover\\n raise FutureWarning(\\n \\\"The `log_odds` argument to `binary_hinge_loss` will change \\\"\\n \\\"its default to `False` in a future version. Explicitly give \\\"\\n \\\"`log_odds=True` to retain current behavior in your code, \\\"\\n \\\"but also check the documentation if this is what you want.\\\")\\n log_odds = True\\n if not log_odds:\\n predictions = theano.tensor.log(predictions / (1 - predictions))\\n if binary:\\n targets = 2 * targets - 1\\n predictions, targets = align_targets(predictions, targets)\\n return theano.tensor.nnet.relu(delta - predictions * targets)\",\n \"def get_sparsity_penalty(nnet, inputs, sparsity, mode=\\\"mean\\\",\\n deterministic=False):\\n\\n assert mode in (\\\"mean\\\", \\\"l1\\\")\\n\\n rho = sparsity\\n penalty = 0\\n eps = 0.0001 # for numerical stability\\n\\n for layer in nnet.all_layers:\\n if layer.isactivation:\\n\\n activation = lasagne.layers.get_output(layer, inputs=inputs,\\n deterministic=deterministic)\\n\\n if mode == \\\"mean\\\":\\n if layer.isrelu:\\n avg_activation = T.mean(T.gt(activation,\\n T.zeros_like(activation)),\\n axis=0, dtype='floatX')\\n if layer.issigmoid:\\n avg_activation = T.mean(activation, axis=0, dtype='floatX')\\n\\n KL_div = T.sum((rho+eps) *\\n (T.log(rho+eps) - T.log(avg_activation+eps)) +\\n (1-rho+eps) *\\n (T.log(1-rho+eps) - T.log(1-avg_activation+eps)),\\n dtype='floatX')\\n penalty = penalty + KL_div\\n\\n if mode == \\\"l1\\\":\\n penalty = penalty + T.sum(abs(activation), dtype='floatX')\\n\\n return T.cast(penalty, dtype='floatX')\",\n \"def test_true_negative_rate(self):\\n # For the penalty, the default loss is hinge.\\n expected_penalty_numerator = np.sum(\\n np.maximum(0.0, 1.0 - self._penalty_predictions) *\\n (self._penalty_labels <= 0.0) * self._penalty_weights *\\n self._penalty_predicate)\\n expected_penalty_denominator = np.sum(\\n (self._penalty_labels <= 0.0) * self._penalty_weights *\\n self._penalty_predicate)\\n expected_penalty_value = (\\n expected_penalty_numerator / expected_penalty_denominator)\\n\\n # For the constraint, the default loss is zero-one.\\n expected_constraint_numerator = np.sum(\\n (0.5 * (1.0 - np.sign(self._constraint_predictions))) *\\n (self._constraint_labels <= 0.0) * self._constraint_weights *\\n self._constraint_predicate)\\n expected_constraint_denominator = np.sum(\\n (self._constraint_labels <= 0.0) * self._constraint_weights *\\n self._constraint_predicate)\\n expected_constraint_value = (\\n expected_constraint_numerator / expected_constraint_denominator)\\n\\n actual_expression = binary_rates.true_negative_rate(self.context)\\n self.check_rates(expected_penalty_value, expected_constraint_value,\\n actual_expression)\",\n \"def custom_asymmetric_objective(y_true, y_pred):\\n residual = (y_true - y_pred).astype(\\\"float\\\")\\n grad = np.where(residual < 0, -2 * 10.0 * residual, -2 * residual)\\n hess = np.where(residual < 0, 2 * 10.0, 2.0)\\n return grad, hess\",\n \"def setup_loss(self):\\n self.loss = nn.CrossEntropyLoss(weight = self.to_device(self.datasetManager.class_weights))\\n #self.loss = nn.CrossEntropyLoss()\",\n \"def lfads_training_loss(params, lfads_hps, key, x_bxt, kl_scale, keep_rate):\\n losses = lfads_losses(params, lfads_hps, key, x_bxt, kl_scale, keep_rate)\\n return losses['total']\",\n \"def custom_loss(y_true, y_pred):\\n #print(K.int_shape(y_pred))\\n sr = y_pred[:,:,:,0]\\n sr_clear = y_pred[:,:,:,1]\\n hr = y_true[:,:,:,0]\\n hr_clear = y_true[:,:,:,1]\\n dim = 384 #K.int_shape(y_pred)[1]\\n diff = hr - sr\\n denominateur = K.sum(hr_clear, axis=(1,2))\\n\\n b = K.sum( diff * hr_clear, axis=(1,2))/denominateur #batchsize dim\\n #print(K.int_shape(y_pred), K.int_shape(y_pred[:,:,:]))\\n b = K.expand_dims(b, axis=-1)\\n b = K.expand_dims(b, axis=-1)\\n b = K.repeat_elements(b, dim, axis=1 )\\n b = K.repeat_elements(b, dim, axis=-1 )\\n \\n cMSE = K.sum(np.square( (diff-b)*hr_clear), axis=(1,2))/denominateur\\n\\n #cMSE = K.sum(np.square( (diff)*hr_clear), axis=(1,2))/denominateur\\n cPSNR = -10*K.log(cMSE)/K.log(10.0)\\n loss1 = 46.5 / cPSNR\\n ce = binary_crossentropy(K.reshape(hr_clear, (-1, dim*dim)), K.reshape(sr_clear, (-1, dim*dim)))\\n \\n #print(K.int_shape(loss1), K.int_shape(ce))\\n return loss1 + 0.5*ce\",\n \"def hinge(y_true, y_pred):\\n y_pred = tensor_conversion.convert_to_tensor_v2_with_dispatch(y_pred)\\n y_true = math_ops.cast(y_true, y_pred.dtype)\\n y_true = _maybe_convert_labels(y_true)\\n return backend.mean(math_ops.maximum(1. - y_true * y_pred, 0.), axis=-1)\",\n \"def __init__(self, generator, tgt_vocab,\\n normalization=\\\"sents\\\",\\n label_smoothing=0.0,\\n use_kl_annealing=False,\\n use_kl_freebits=False,\\n kl_freebits_margin=0.0,\\n kl_annealing_current=0.0,\\n kl_annealing_increment=0.0001,\\n kl_annealing_warmup_steps=1000,\\n image_loss_type='logprob',\\n use_local_image_features=False,\\n two_step_image_prediction=False\\n ):\\n self.multimodal_model_type = 'vi-model1'\\n\\n super(NMTVIModel1LossCompute, self).__init__(generator, tgt_vocab,\\n normalization, label_smoothing)\\n\\n # kl annealing parameters\\n self.n_model_updates = 0\\n self.use_kl_annealing = use_kl_annealing\\n if use_kl_annealing:\\n self.kl_annealing_current = kl_annealing_current\\n self.kl_annealing_increment = kl_annealing_increment\\n self.kl_annealing_warmup_steps = kl_annealing_warmup_steps\\n else:\\n self.kl_annealing_current = 1.0\\n self.kl_annealing_increment = 0.0\\n self.kl_annealing_warmup_steps = 0\\n\\n self.use_kl_freebits = use_kl_freebits\\n if use_kl_freebits:\\n self.kl_freebits_margin = kl_freebits_margin\\n else:\\n self.kl_freebits_margin = 0.0\\n\\n self.image_loss_type = image_loss_type\\n self.use_local_image_features = use_local_image_features\\n self.two_step_image_prediction = two_step_image_prediction\\n self._statistics = onmt.VIStatistics\\n\\n if image_loss_type == 'categorical':\\n self.image_loss_criterion = nn.NLLLoss2d()\",\n \"def test_negative_sampling_self_adversarial_loss(self):\\n loss_fct = NSSALoss(margin=1.0, adversarial_temperature=1.0)\\n self.assertIs(loss_fct._reduction_method, torch.mean)\\n\\n pos_scores = torch.tensor([0.0, 0.0, -0.5, -0.5])\\n neg_scores = torch.tensor([0.0, 0.0, -1.0, -1.0])\\n\\n # ≈ result of softmax\\n weights = torch.tensor([0.37, 0.37, 0.13, 0.13])\\n\\n # neg_distances - margin = [-1., -1., 0., 0.]\\n # sigmoids ≈ [0.27, 0.27, 0.5, 0.5]\\n log_sigmoids = torch.tensor([-1.31, -1.31, -0.69, -0.69])\\n intermediate = weights * log_sigmoids\\n # sum over the softmax dim as weights sum up to 1\\n neg_loss = torch.sum(intermediate, dim=-1)\\n\\n # pos_distances = [0., 0., 0.5, 0.5]\\n # margin - pos_distances = [1. 1., 0.5, 0.5]\\n # ≈ result of sigmoid\\n # sigmoids ≈ [0.73, 0.73, 0.62, 0.62]\\n log_sigmoids = torch.tensor([-0.31, -0.31, -0.48, -0.48])\\n pos_loss = torch.mean(log_sigmoids)\\n\\n # expected_loss ≈ 0.34\\n expected_loss = (-pos_loss - neg_loss) / 2.0\\n\\n loss = loss_fct(pos_scores, neg_scores, weights).item()\\n\\n self.assertAlmostEqual(expected_loss, 0.77, delta=0.02)\\n self.assertAlmostEqual(expected_loss, loss, delta=0.02)\",\n \"def weighted_mse_loss(yt, yp) -> Any:\\n from keras import backend as K\\n\\n total = K.sum(K.ones_like(yt))\\n neg_loss = total * K.sum(K.square(yp * (1 - yt))) / K.sum(1 - yt)\\n pos_loss = total * K.sum(K.square(1. - (yp * yt))) / K.sum(yt)\\n\\n return LOSS_BIAS * neg_loss + (1. - LOSS_BIAS) * pos_loss\",\n \"def test_negative_prediction_rate(self):\\n # For the penalty, the default loss is hinge.\\n expected_penalty_numerator = np.sum(\\n np.maximum(0.0, 1.0 - self._penalty_predictions) * self._penalty_weights\\n * self._penalty_predicate)\\n expected_penalty_denominator = np.sum(\\n self._penalty_weights * self._penalty_predicate)\\n expected_penalty_value = (\\n expected_penalty_numerator / expected_penalty_denominator)\\n\\n # For the constraint, the default loss is zero-one.\\n expected_constraint_numerator = np.sum(\\n (0.5 * (1.0 - np.sign(self._constraint_predictions))) *\\n self._constraint_weights * self._constraint_predicate)\\n expected_constraint_denominator = np.sum(\\n self._constraint_weights * self._constraint_predicate)\\n expected_constraint_value = (\\n expected_constraint_numerator / expected_constraint_denominator)\\n\\n actual_expression = binary_rates.negative_prediction_rate(self.context)\\n self.check_rates(expected_penalty_value, expected_constraint_value,\\n actual_expression)\",\n \"def l1_loss(params):\\n \\\"\\\"\\\" It is a vec for each branch\\\"\\\"\\\"\\n loss_branches_vec = []\\n # TODO This is hardcoded but all our cases rigth now uses four branches\\n for i in range(len(params['branches']) -1):\\n loss_branches_vec.append(torch.abs((params['branches'][i] - params['targets'])\\n * params['controls_mask'][i])\\n * params['branch_weights'][i])\\n \\\"\\\"\\\" The last branch is a speed branch\\\"\\\"\\\"\\n # TODO: Activate or deactivate speed branch loss\\n loss_branches_vec.append(torch.abs(params['branches'][-1] - params['inputs'])\\n * params['branch_weights'][-1])\\n return loss_branches_vec, {}\",\n \"def train_policy_network(policy_model, old_policy_model, A_hat, j, state_part_mean, state_part_std, config = PPO_config):\\n \\n # TODO: How to implement KL early stopping? \\n \\n learning_rate = np.amax([0.01, 1-j/config['J']]) * config['LR_policy']\\n #PPO_loss = compute_surr_objective(A_hat, old_policy_model, policy_model, j, PPO_config) \\n policy_optimizer = torch.optim.Adam(policy_model.parameters(), lr = learning_rate)\\n policy_scheduler = torch.optim.lr_scheduler.StepLR(policy_optimizer, step_size=config['step'], gamma=config['gamma'])\\n\\n \\n for epoch in range(config['num_epochs_policy']):\\n \\n # we shuffle the A_hat entries and divide them into batches\\n # full size of A_hat = K = num Monte Carlo sims\\n random.shuffle(A_hat)\\n \\n batch_size = config['batch_size_policy']\\n \\n for batch in range(math.ceil(len(A_hat) / batch_size)):\\n\\n policy_optimizer.zero_grad()\\n\\n l2_norm = sum(pp.pow(2.0).sum() for pp in [p for p in policy_model.parameters()][0])\\n\\n\\n loss_unreg, kl_estimate = compute_surr_objective(A_hat[(batch*batch_size):((batch+1)*batch_size)], old_policy_model.to(device), policy_model.to(device), j, state_part_mean, state_part_std, PPO_config)\\n wandb.log({\\\"kl_estimate\\\": kl_estimate.cpu()})\\n print(\\\"kl_estimate for batch {}: {}\\\".format(batch, kl_estimate))\\n if kl_estimate < config['target_KL']:\\n # stop training -- is this right?\\n break\\n loss = -loss_unreg + l2_norm* config['L2_coeff'] \\n loss.backward(retain_graph = True)\\n policy_optimizer.step()\\n policy_scheduler.step()\\n print(\\\"policy loss in batch{} epoch{}: {}\\\".format(batch, epoch, loss))\\n\\n wandb.log({\\\"loss_policy_network\\\": loss.cpu()})\\n \\n return policy_model\",\n \"def hinge_gan_losses(discriminator_real_outputs, discriminator_fake_outputs):\\n generator_loss = -tf.reduce_mean(discriminator_fake_outputs)\\n discriminator_loss = (\\n tf.reduce_mean(tf.nn.relu(1. - discriminator_real_outputs))\\n + tf.reduce_mean(tf.nn.relu(1. + discriminator_fake_outputs)))\\n return generator_loss, discriminator_loss\",\n \"def loss_wd(model, input_x, input_y, alpha):\\n out_x = model(input_x)\\n out_y = model(input_y)\\n\\n obj = ( torch.sum(out_x) - torch.sum(out_y) )/ batch_size\\n\\n a = torch.rand( (input_x.size(0),1) )\\n input_z = a * input_x + (1-a) * input_y\\n input_z.requires_grad_(True)\\n\\n out_z = model(input_z)\\n gradient_z = autograd.grad(out_z.sum(), input_z, create_graph=True)[0]\\n\\n norm_gradient = torch.norm(gradient_z, dim=1)\\n\\n penalty = ( torch.sum((norm_gradient - 1).pow(2)) )/ batch_size\\n\\n obj = obj - alpha * penalty\\n\\n loss = - obj\\n return loss\",\n \"def l1_loss(inputs, reduction='mean', **kwargs):\\n args = ArgHelper.parse(locals())\\n args['reduction'] = reduction.upper()\\n op_lib = loss_ops_lib.L1Loss\\n if context.executing_eagerly():\\n return op_lib \\\\\\n .instantiate(reduction=args['reduction']) \\\\\\n .apply(inputs)\\n else:\\n return op_lib.blend(**args)\",\n \"def test_penalty_compute(self):\\n objective = {'G': numpy.zeros((9)),\\n 'H': numpy.diag((1,)*9),\\n 'X': 1}\\n for penalty in self.penalties:\\n result=penalty.compute([1]*self.np, objective)\\n self.assertEqual(tuple, type(result))\\n # more tests go here\",\n \"def penalty_calc(self):\\n self.p_budget = (self.tx_oma_min - self.rx_unstressed_sensitivity - self.fiber_conn_loss)*self.l_1\\n\\n # fiber attenuation,\\n self.p_atten = self.alpha*self.length # column B\\n\\n # calculate bandwidth for RIN test (exclude transmitter)\\n rin_inverse_bw = np.sqrt(np.square(1.0/self.bw_cd) + np.square(1.0/self.bw_md) + (0.477/(self.rx_bw**2))*self.l_1)\\n rin_bw = 1.0 / rin_inverse_bw\\n\\n # see FC-MSQS-2 equation B.47 in Annex B.4 for the following k_rin = math.sqrt(2.0/math.pi)*erfinv(0.8)\\n k_rin = 0.7\\n\\n # v_rin,\\n self.v_rin = (k_rin*1E6*(self.rin_test_isi**2)*rin_bw*\\n math.pow(10.0,0.1*self.rin)) # column AK\\n\\n # Prin,\\n print('v_rin: ', self.v_rin)\\n print('Q: ',self.Q)\\n print('isi_dj_refl_closed :', self.isi_dj_refl_closed)\\n self.p_rin = -10.0*np.log10(np.sqrt(1.0-np.multiply(self.v_rin, np.square(self.Q/self.isi_dj_refl_closed)))) # column R\\n print(\\\"P_rin : \\\", self.p_rin)\\n self.beta = (3.14159E-6*self.speedup*self.br_nominal *self.delta_lambda*self.d1*self.length) # column O\\n self.sigma_mpn = (self.k_mpn/math.sqrt(2.0)*(self.l_1 -np.exp(-np.square(self.beta)))) # column P\\n self.p_mpn = (-10.0*np.log10(np.sqrt(self.l_1 - (self.Q**2)*np.square(self.sigma_mpn)))) # column Q\\n self.p_blw = (-10.0*math.log10(math.sqrt(1.0- ((self.Q*self.sigma_blw)/ self.isi_tp4_rx)**2))*self.l_1) # cell T13\\n self.p_reflection = -10.0*np.log10(self.isi_reflection) # column N\\n self.v_mn = (((1.0-math.pow(10.0,-0.2*self.pmn))/ (self.Q)**2)*self.l_1) # cell AG7\\n print(\\\"isi_center : \\\", self.isi_center)\\n\\n self.p_isi_center = -10.0*np.log10(self.isi_center) # column J\\n\\n self.p_isi_corners = (-10.0*np.log10(self.isi_corners) - self.p_isi_center) # column K\\n self.p_isi_dj_center = (-10.0*np.log10(self.isi_dj_refl_closed) - self.p_isi_center) # column L\\n self.p_isi_dj_corners = (-10.0*np.log10(self.isi_dj_corners) -self.p_isi_center -self.p_isi_corners) # column M\\n\\n\\n # calculate the \\\"cross\\\" penalty contribution, column S\\n arg1 = ((self.sigma_blw**2 + self.v_rin)/ np.square(self.isi_dj_refl_closed))\\n arg2 = self.l_1 - (self.Q**2)*(arg1 + self.v_mn + np.square(self.sigma_mpn))\\n arg3 = (-10.0*np.log10(np.multiply(self.isi_dj_refl_closed, np.sqrt(arg2))))\\n self.p_cross_center = ( # column S\\n arg3\\n - self.p_blw # cell T13\\n - self.p_isi_center # column J\\n - self.p_isi_dj_center # column L\\n - self.p_mpn # column Q\\n - self.p_reflection # column N\\n - self.p_rin # column R\\n - self.pmn*self.l_1) # cell G13\\n print('p_isi_center: ', self.p_isi_center)\\n\\n # calculate the total power budget evaluated at the center of the eye\\n self.p_total_center = ( # column T\\n self.p_isi_center # column J\\n + self.p_isi_dj_center # column L\\n + self.p_atten # column B\\n + self.p_mpn # column Q\\n + self.p_reflection # column N\\n + self.p_rin # column R\\n + self.p_cross_center # column S\\n + self.pmn*self.l_1) # cell G13\\n # calculate the total power budget evaluated at the corner of the eye\\n self.p_total_corners = (\\n self.p_isi_center # column J\\n + self.p_isi_corners # column K\\n + self.p_atten # column B\\n + self.p_mpn # column Q\\n + self.p_reflection # column N\\n + self.p_rin # column R\\n + self.p_cross_center # column S\\n + self.pmn*self.l_1 # cell G13\\n + self.p_isi_dj_corners)# column M\\n\\n # receiver stressed sensitivity\\n self.margin = ( self.p_budget\\n - self.p_total_center) # column W\\n\\n self.rx_stressed_sensitivity = (\\n self.tx_oma_min*self.l_1\\n - self.chil\\n - self.p_mpn\\n - self.p_reflection\\n - self.p_rin\\n - 0.5*self.p_cross_center\\n - self.pmn*self.l_1\\n - self.margin[self.lnum//2]*self.l_1)\\n\\n\\n # end of GbE10.penalty_calc\\n #======================================================================+\",\n \"def L2(yhat, y):\\n loss = np.dot((y - yhat).T,(y - yhat))\\n \\n return loss\",\n \"def l2_learning(self, msg):\\n pass\",\n \"def halo_loss(predicted, labels, weights, obj, k_neg=7.):\\n\\n global_loss = torch.FloatTensor([0]).to(device)\\n x_lsm = F.log_softmax(predicted, dim=1)\\n x_sm = F.softmax(predicted, dim=1)\\n\\n v_weights = weights\\n v_labels = labels\\n\\n for i in range(predicted.size(0)): # Foreach sample\\n\\n # predicted[0] is preserved for background\\n bg = v_weights[i, 0] * v_labels[i, 0]\\n global_loss += -torch.sum(bg * x_lsm[i, 0]) / torch.sum(bg)\\n\\n if 0 == len(obj[i][1:]):\\n continue\\n\\n indexes = torch.LongTensor(obj[i][1:]).to(device) # One is for labels\\n\\n valid_labels = v_labels[i].index_select(0, indexes)\\n valid_weights = v_weights[i].index_select(0, indexes)\\n\\n target_pos = valid_labels * valid_weights\\n target_neg = (1. - valid_labels) * valid_weights\\n\\n positive = -torch.mm(flatten(x_lsm[i, 1:]),\\n flatten(target_pos).transpose(1, 0)) / torch.sum(target_pos)\\n\\n negative = -torch.mm(flatten(torch.log(1. - x_sm[i, 1:] + 1e-12)),\\n flatten(target_neg).transpose(1, 0)) / torch.sum(target_neg)\\n\\n values, indices = torch.min(positive + k_neg * negative, 0)\\n global_loss += torch.sum(positive[indices, torch.arange(0, positive.size(1)).long().to(device)])\\n\\n # Normalize w.r.t. image size\\n return global_loss * (1000. / (predicted.size(2) * predicted.size(3)))\",\n \"def backward_G(self):\\n # Calculate regularzation loss to make transformed feature and target image feature in the same latent space\\n self.loss_reg_gen = self.loss_reg * self.opt.lambda_regularization\\n\\n # Calculate l1 loss \\n loss_app_gen = self.L1loss(self.img_gen, self.input_P2)\\n self.loss_app_gen = loss_app_gen * self.opt.lambda_rec \\n \\n # parsing loss\\n label_P2 = self.label_P2.squeeze(1).long()\\n #print(self.input_SPL2.min(), self.input_SPL2.max(), self.parsav.min(), self.parsav.max())\\n self.loss_par = self.parLoss(self.parsav,label_P2)# * 20. \\n self.loss_par1 = self.L1loss(self.parsav, self.input_SPL2) * 100 \\n\\n # Calculate GAN loss\\n base_function._freeze(self.net_D)\\n D_fake = self.net_D(self.img_gen)\\n self.loss_ad_gen = self.GANloss(D_fake, True, False) * self.opt.lambda_g\\n\\n # Calculate perceptual loss\\n loss_content_gen, loss_style_gen = self.Vggloss(self.img_gen, self.input_P2) \\n self.loss_style_gen = loss_style_gen*self.opt.lambda_style\\n self.loss_content_gen = loss_content_gen*self.opt.lambda_content\\n\\n total_loss = 0\\n\\n for name in self.loss_names:\\n if name != 'dis_img_gen':\\n #print(getattr(self, \\\"loss_\\\" + name))\\n total_loss += getattr(self, \\\"loss_\\\" + name)\\n total_loss.backward()\",\n \"def nt_transfer_loss(self, student_net_params, masks, teacher_net_params, x, density_level): \\n\\n masked_student_net_params = get_sparse_params_filtered_by_masks(student_net_params, masks)\\n\\n # split inputs into two collections, x1 and x2.\\n x1 = x[:int(len(x)/2)]\\n x2 = x[int(len(x)/2):]\\n \\n # student network prediction\\n student_prediction = self.apply_fn(masked_student_net_params, x) \\n \\n # teacher network prediction\\n teacher_prediction = self.apply_fn(teacher_net_params, x)\\n\\n # student network's NTK evaluated on x1 and x2\\n student_ntk_mat = self.emp_ntk_fn(x1, x2, masked_student_net_params) \\n\\n # teacher network's NTK evaluated on x1 and x2\\n teacher_ntk_mat = self.emp_ntk_fn(x1, x2, teacher_net_params) \\n\\n # compute kernel, target, and paramter l2 loss\\n ker_dist, target_dist, param_squared_norm = self.kernel_dist_target_dist_l2_loss(student_ntk_mat, student_prediction, teacher_ntk_mat, teacher_prediction, masked_student_net_params)\\n\\n # weight these losses to get the transfer loss\\n transfer_loss = self.LAMBDA_KER_DIST * ker_dist + target_dist + (self.LAMBDA_L2_REG / density_level) * param_squared_norm \\n\\n return transfer_loss\",\n \"def compute_loss(\\n self,\\n x: torch.Tensor,\\n y: torch.Tensor,\\n y_hat: torch.Tensor,\\n extras: List[torch.Tensor],\\n train_context: TrainContext,\\n ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:\",\n \"def test_false_negative_rate(self):\\n # For the penalty, the default loss is hinge.\\n expected_penalty_numerator = np.sum(\\n np.maximum(\\n 0.0, 1.0 - self._penalty_predictions) * (self._penalty_labels > 0.0)\\n * self._penalty_weights * self._penalty_predicate)\\n expected_penalty_denominator = np.sum(\\n (self._penalty_labels > 0.0) * self._penalty_weights *\\n self._penalty_predicate)\\n expected_penalty_value = (\\n expected_penalty_numerator / expected_penalty_denominator)\\n\\n # For the constraint, the default loss is zero-one.\\n expected_constraint_numerator = np.sum(\\n (0.5 * (1.0 - np.sign(self._constraint_predictions))) *\\n (self._constraint_labels > 0.0) * self._constraint_weights *\\n self._constraint_predicate)\\n expected_constraint_denominator = np.sum(\\n (self._constraint_labels > 0.0) * self._constraint_weights *\\n self._constraint_predicate)\\n expected_constraint_value = (\\n expected_constraint_numerator / expected_constraint_denominator)\\n\\n actual_expression = binary_rates.false_negative_rate(self.context)\\n self.check_rates(expected_penalty_value, expected_constraint_value,\\n actual_expression)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6574107","0.58923316","0.57923156","0.57098234","0.5634288","0.56300277","0.55809635","0.5567596","0.5531175","0.55264515","0.55053544","0.5501286","0.54875517","0.54657626","0.546015","0.54392153","0.5435707","0.5426929","0.54195803","0.5418796","0.5388802","0.5388012","0.53734803","0.53726405","0.5372353","0.53583735","0.5351796","0.53485185","0.53381586","0.53372777","0.53295183","0.53098994","0.5307954","0.53015584","0.5294116","0.52918005","0.5278759","0.5278246","0.527502","0.5274499","0.52728635","0.5272529","0.52694976","0.5260131","0.525613","0.5255836","0.5250536","0.52499825","0.52498245","0.5248788","0.524491","0.5238126","0.523397","0.5232622","0.52268493","0.52260536","0.52223676","0.52223104","0.52153665","0.52091396","0.52051955","0.5197573","0.5196997","0.51867336","0.5185234","0.51797575","0.5179614","0.5178407","0.5173406","0.51679856","0.514987","0.51443","0.5140091","0.5134376","0.51322025","0.51320744","0.5119394","0.51159424","0.51096886","0.5107219","0.5105783","0.51036423","0.51014584","0.51006526","0.51001346","0.5097797","0.50937563","0.5092312","0.5089434","0.5089007","0.50878894","0.50848126","0.50797766","0.50732493","0.5070346","0.50666916","0.5063175","0.5058811","0.5056465","0.5056082"],"string":"[\n \"0.6574107\",\n \"0.58923316\",\n \"0.57923156\",\n \"0.57098234\",\n \"0.5634288\",\n \"0.56300277\",\n \"0.55809635\",\n \"0.5567596\",\n \"0.5531175\",\n \"0.55264515\",\n \"0.55053544\",\n \"0.5501286\",\n \"0.54875517\",\n \"0.54657626\",\n \"0.546015\",\n \"0.54392153\",\n \"0.5435707\",\n \"0.5426929\",\n \"0.54195803\",\n \"0.5418796\",\n \"0.5388802\",\n \"0.5388012\",\n \"0.53734803\",\n \"0.53726405\",\n \"0.5372353\",\n \"0.53583735\",\n \"0.5351796\",\n \"0.53485185\",\n \"0.53381586\",\n \"0.53372777\",\n \"0.53295183\",\n \"0.53098994\",\n \"0.5307954\",\n \"0.53015584\",\n \"0.5294116\",\n \"0.52918005\",\n \"0.5278759\",\n \"0.5278246\",\n \"0.527502\",\n \"0.5274499\",\n \"0.52728635\",\n \"0.5272529\",\n \"0.52694976\",\n \"0.5260131\",\n \"0.525613\",\n \"0.5255836\",\n \"0.5250536\",\n \"0.52499825\",\n \"0.52498245\",\n \"0.5248788\",\n \"0.524491\",\n \"0.5238126\",\n \"0.523397\",\n \"0.5232622\",\n \"0.52268493\",\n \"0.52260536\",\n \"0.52223676\",\n \"0.52223104\",\n \"0.52153665\",\n \"0.52091396\",\n \"0.52051955\",\n \"0.5197573\",\n \"0.5196997\",\n \"0.51867336\",\n \"0.5185234\",\n \"0.51797575\",\n \"0.5179614\",\n \"0.5178407\",\n \"0.5173406\",\n \"0.51679856\",\n \"0.514987\",\n \"0.51443\",\n \"0.5140091\",\n \"0.5134376\",\n \"0.51322025\",\n \"0.51320744\",\n \"0.5119394\",\n \"0.51159424\",\n \"0.51096886\",\n \"0.5107219\",\n \"0.5105783\",\n \"0.51036423\",\n \"0.51014584\",\n \"0.51006526\",\n \"0.51001346\",\n \"0.5097797\",\n \"0.50937563\",\n \"0.5092312\",\n \"0.5089434\",\n \"0.5089007\",\n \"0.50878894\",\n \"0.50848126\",\n \"0.50797766\",\n \"0.50732493\",\n \"0.5070346\",\n \"0.50666916\",\n \"0.5063175\",\n \"0.5058811\",\n \"0.5056465\",\n \"0.5056082\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.75576925"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81984,"cells":{"query":{"kind":"string","value":"Return a pyll graph with hyperparamters that will construct a sklearn.svm.SVC model with a user specified kernel. See help(hpsklearn.components._svm_hp_space) for info on additional SVM arguments."},"document":{"kind":"string","value":"def svc_kernel(name, kernel, random_state=None, probability=False, **kwargs):\n def _name(msg):\n return '%s.%s_%s' % (name, kernel, msg)\n\n hp_space = _svm_hp_space(_name, kernel=kernel, **kwargs)\n hp_space.update(_svc_hp_space(_name, random_state, probability))\n return scope.sklearn_SVC(**hp_space)"},"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 find_svm_hyperparams():\n NUM_ITERS = 10\n # coefs = np.arange(-5, 5).astype(np.float)\n coefs = np.linspace(0.25, 1, 10)\n Cs = np.power(2, coefs)\n results = []\n\n for _ in range(NUM_ITERS):\n data = FaceDataset(\"embeddings/dev\", n=50)\n train_data, train_labels = data.train()\n test_data, test_labels = data.test()\n accs = []\n for c in tqdm(Cs):\n clf = svm.SVC(kernel=\"linear\", C=c)\n clf, _ = train(clf, train_data, train_labels)\n acc, _ = test(clf, test_data, test_labels)\n accs.append(acc)\n results.append(accs)\n\n results = np.mean(results, axis=0)\n s = plotly.graph_objs.Scatter(x=Cs, y=results)\n plotly.offline.plot([s], filename=\"svm_linear.html\")\n print(\"C={}\".format(Cs[np.argmax(results)]))","def find_linear_svm_hyperparams():\n NUM_ITERS = 10\n # coefs = np.arange(-5, 5).astype(np.float)\n coefs = np.linspace(0.25, 1, 10)\n Cs = np.power(2, coefs)\n results = []\n\n for _ in range(NUM_ITERS):\n data = FaceDataset(\"embeddings/dev\", n=50)\n train_data, train_labels = data.train()\n test_data, test_labels = data.test()\n accs = []\n for c in tqdm(Cs):\n clf = svm.SVC(kernel=\"linear\", C=c)\n clf, _ = train(clf, train_data, train_labels)\n acc, _ = test(clf, test_data, test_labels)\n accs.append(acc)\n results.append(accs)\n\n results = np.mean(results, axis=0)\n s = plotly.graph_objs.Scatter(x=Cs, y=results)\n plotly.offline.plot([s], filename=\"svm_linear.html\")\n print(\"C={}\".format(Cs[np.argmax(results)]))","def svm():","def svc_model(params):\n\n if (params['random']):\n params['C'] = random.randrange(1, 13, step=1) * 0.1\n params['degree'] = random.choice([2, 3, 4, 5])\n params['kernel'] = random.choice(['linear', 'rbf', 'poly', 'sigmoid'])\n \n model = svm.SVC(\n decision_function_shape='ovo',\n C=params['C'],\n degree=params['degree'],\n kernel=params['kernel']\n )\n\n return model","def __init__(self, kernel='poly', degree=3, verbose=False, gamma='auto', reg=1/1000, random_state=0):\n print(\"Initialize model SVM\")\n # Check if gamma='auto' is useful\n self.kernel = kernel\n self.random_state = random_state\n self.model = SVC(gamma=gamma, kernel=kernel, degree=degree, verbose=verbose, C=reg, random_state=random_state)","def train_model(kernel, label):\n clf = svm.SVC(kernel='precomputed')\n clf.fit(kernel,label)\n return clf","def modelKSVM():\n\n list_kernel_type = ['linear', 'poly', 'rbf']\n random_state = 20 # Do not change this random_state\n\n objs_KSVM = []\n\n # Create a list of objects for the classifier for each of the above \"kernel\" types\n for kernel in list_kernel_type:\n svm = SVC(kernel=kernel, random_state=random_state)\n objs_KSVM.append(svm)\n\n return objs_KSVM","def svr_kernel(name, kernel, epsilon=None, **kwargs):\n def _name(msg):\n return '%s.%s_%s' % (name, kernel, msg)\n\n hp_space = _svm_hp_space(_name, kernel=kernel, **kwargs)\n hp_space.update(_svr_hp_space(_name, epsilon))\n return scope.sklearn_SVR(**hp_space)","def SVM():\n x1, x2 = generate_training_data_2D()\n Y = np.concatenate([np.zeros(x1.shape[0], dtype=np.int32),\n np.ones(x2.shape[0], dtype=np.int32)])\n X = np.concatenate([x1, x2], axis=0)\n rng = np.random.get_state()\n np.random.shuffle(X)\n # Set the random state back to previous to shuffle X & Y similarly\n np.random.set_state(rng)\n np.random.shuffle(Y)\n\n models, titles = get_fitted_svm(X, Y)\n\n plot_decision_boundary(X, Y, models, titles)","def SVM(x_train, x_test, y_train, kernel):\n svc_model = SVC(kernel=kernel)\n svc_model.fit(x_train, y_train)\n y_pred = svc_model.predict(x_test)\n return y_pred","def train_svm(data, labels, kernel, C, gamma, degree, coef0):\n if kernel == 'linear':\n model = SVC(kernel=kernel, C=C)\n elif kernel == 'poly':\n model = SVC(kernel=kernel, C=C, degree=degree, coef0=coef0)\n elif kernel == 'rbf':\n model = SVC(kernel=kernel, C=C, gamma=gamma)\n else:\n raise ArgumentError(\"Unknown kernel function: %s\" % kernel)\n model.fit(data, labels)\n return model","def convert(context, cm_node, inputs, outputs):\n kernel_enum = {'linearKernel': 'LINEAR', 'polyKernel': 'POLY',\n 'rbfKernel': 'RBF', 'sigmoidKernel': 'SIGMOID', 'precomputedKernel': 'PRECOMPUTED'}\n kernel = cm_node.supportVectorClassifier.kernel\n kernel_val = kernel.WhichOneof('kernel')\n svc_kernel = kernel_enum[kernel_val]\n\n if kernel_val == 'rbfKernel':\n svc_kernel_params = [kernel.rbfKernel.gamma, 0.0, 0.0]\n elif kernel_val == 'polyKernel':\n svc_kernel_params = [kernel.polyKernel.gamma,\n kernel.polyKernel.coef0, kernel.polyKernel.degree]\n elif kernel_val == 'sigmoidKernel':\n svc_kernel_params = [kernel.sigmoidKernel.gamma,\n kernel.sigmoidKernel.coef0, 0.0]\n elif kernel_val == 'linearKernel':\n svc_kernel_params = [0.0, 0.0, 0.0]\n\n prob_a = cm_node.supportVectorClassifier.probA\n prob_b = cm_node.supportVectorClassifier.probB\n svc_vectors_per_class = cm_node.supportVectorClassifier.numberOfSupportVectorsPerClass\n n_supports, svc_support_vectors = extract_support_vectors_as_dense_tensor(cm_node.supportVectorClassifier)\n chain_coef = list(itertools.chain.from_iterable(\n [coef.alpha for coef in cm_node.supportVectorClassifier.coefficients]))\n svc_coefficients = chain_coef\n svc_rho = [-x for x in cm_node.supportVectorClassifier.rho]\n\n nb = NodeBuilder(context, 'SVMClassifier', op_domain='ai.onnx.ml')\n nb.add_attribute('kernel_type', svc_kernel)\n nb.add_attribute('kernel_params', svc_kernel_params)\n if prob_a:\n nb.add_attribute('prob_a', prob_a)\n if prob_b:\n nb.add_attribute('prob_b', prob_b)\n nb.add_attribute('vectors_per_class', svc_vectors_per_class)\n nb.add_attribute('support_vectors', svc_support_vectors)\n nb.add_attribute('coefficients', svc_coefficients)\n nb.add_attribute('rho', svc_rho)\n svc_classes = cm_node.supportVectorClassifier.WhichOneof('ClassLabels')\n if svc_classes == 'int64ClassLabels':\n class_labels = list(int(i) for i in cm_node.supportVectorClassifier.int64ClassLabels.vector)\n nb.add_attribute('classlabels_ints', class_labels)\n elif svc_classes == 'stringClassLabels':\n class_labels = list(str(s) for s in cm_node.supportVectorClassifier.stringClassLabels.vector)\n nb.add_attribute('classlabels_strings', class_labels)\n\n nb.extend_inputs(inputs)\n\n # Find the ONNX name for the predicted label in CoreML\n predicted_label_name = context.get_onnx_name(cm_node.description.predictedFeatureName)\n nb.add_output(predicted_label_name)\n\n # The variable used to store the class probabilities produced by ONNX linear classifier\n probability_tensor_name = context.get_unique_name('probability_tensor')\n nb.add_output(probability_tensor_name)\n\n nodes = [nb.make_node()]\n\n if cm_node.description.predictedProbabilitiesName != '':\n # Find the corresponding ONNX name for CoreML's probability output (a dictionary)\n predicted_probability_name = context.get_onnx_name(cm_node.description.predictedProbabilitiesName)\n # Create a ZipMap to connect probability tensor and probability dictionary\n nodes.append(model_util.make_zipmap_node(context, probability_tensor_name,\n predicted_probability_name, class_labels))\n\n return nodes","def __init__(self):\n self.svclassifier = SVC(kernel='linear')","def __init__(self, train_x, train_y, test_x, test_y, Tunning_Cs=[0.001, 0.01, 0.1, 1, 10]): \n self.Cs = Tunning_Cs\n self.train_x = train_x\n self.train_y = train_y\n self.test_x = test_x \n self.test_y = test_y\n self.model = svm.SVR(kernel='rbf', gamma='auto')","def svmtrain(x,y,w=None):\n # xl = x.tolist() \n # yl = y.tolist()\n clf = svm.SVC(kernel='linear', C=1000) # apparently C param here really matters\n clf.fit(x,y)\n return({'w':clf.coef_, 'b':clf.intercept_,'clf':clf, 'n_support':clf.support_vectors_.shape[0]})","def classical_kernel_estimation(in_train, in_test, labels):\n X_train = []\n Y_train = []\n X_test = []\n Y_test = []\n for lab in labels:\n for datum in in_train[lab]:\n X_train.append(datum)\n Y_train.append(lab)\n for datum in in_test[lab]:\n X_test.append(datum)\n Y_test.append(lab)\n clf = svm.SVC(gamma='auto')\n clf.fit(X_train, Y_train)\n print(clf.score(X_test, Y_test))","def train_svm(X, y):\n svm = SVC(C=1000000.0, gamma=0.0, kernel='rbf')\n svm.fit(X, y)\n return svm","def svm_clf_training(max_features, data):\r\n X_train, y_train, X_test, y_test = data\r\n clf = Pipeline([('feature_selection', SelectKBest(score_func=chi2, k=max_features)),\r\n ('clf', svm.SVC(C=1., kernel='linear'))])\r\n\r\n vectorizer = CountVectorizer(ngram_range=(1, 2), lowercase=True) # unigrams and bigrams\r\n X_matrix_tr = vectorizer.fit_transform(X_train)\r\n # parameters = [{'clf__kernel': ['linear'], 'clf__C': [0.1, 1, 10, 100]},\r\n # {'clf__kernel': ['rbf'], 'clf__C': [0.1, 1, 10, 100], 'clf__gamma': [0.001, 0.01, 0.1]},\r\n # {'clf__kernel': ['poly'], 'clf__C': [0.1, 1, 10, 100], 'clf__degree': [2, 3, 4, 5]}]\r\n # clf = GridSearchCV(svc, parameters, scoring='accuracy')\r\n clf.fit(X_matrix_tr, y_train)\r\n # print(\"Best parameters set found on development set:\")\r\n # print()\r\n # print(clf.best_estimator_)\r\n # print()\r\n # print(\"Grid scores on development set:\")\r\n # print()\r\n # for params, mean_score, scores in clf.grid_scores_:\r\n # print(\"%0.3f (+/-%0.03f) for %r\"\r\n # % (mean_score, scores.std() / 2, params))\r\n # print()\r\n voc = vectorizer.get_feature_names()\r\n # vectorizer1 = CountVectorizer(ngram_range=(1, 2), lowercase=True, vocabulary=voc)\r\n # X_matrix_val = vectorizer1.fit_transform(X_test)\r\n # y_pred = clf.predict(X_matrix_val)\r\n\r\n # for i in range(len(X_test)):\r\n # if y_test[i] != y_pred[i]:\r\n # print(X_test[i], y_test[i], y_pred[i])\r\n # print(classification_report(y_test, y_pred))\r\n return clf, voc","def __init__(self,training_data,default_kernel=\"rbf\"):\n my_data = genfromtxt(training_data, delimiter='\\t',skip_header=0)\n n_col = my_data.shape[1]\n n_features=n_col-1 #assuming that the latest column\n #contains the the outputs \n #preprocessing data\n X = preprocessing.scale(np.hsplit(my_data,[n_features,n_col])[0])\n Y = np.squeeze(np.asarray(np.hsplit(my_data,[n_features,n_col])[1]))\n #defining scaling\n self.scaler = preprocessing.Scaler()\n self.scaler.fit(np.hsplit(my_data,[n_features,n_col])[0])\n #define classifier\n self.classifier = svm.SVC(class_weight='auto',cache_size=DEFAULT_CACHE_SIZE, kernel=default_kernel)\n self.classifier.fit(X, Y)","def __init__(self, **kwargs):\n super(SVM, self).__init__()\n\n # initialize some default values for the SVM backend\n self.max_iter = kwargs.pop('max_iter', 1e6)\n\n # parameters for k cross validation / hyper-parameter tuning\n self.params = [{\n 'kernel': ['rbf', 'sigmoid', 'poly'],\n 'C': [1e1, 1e2, 1e3, 1e4],\n 'gamma': [1e4, 1e3, 1e2, 1, 1e-1, 1e-2],\n 'degree': [2,3,4]}]\n self.k_cross_val = kwargs.pop('k_cross_val', 5)\n\n # initialize the classifier using grid search to find optimal parameters\n # via cross validation\n if kwargs.pop('cross_validation', True):\n self.clf = GridSearchCV(_SVC(max_iter=self.max_iter, **kwargs),\n self.params,\n cv=self.k_cross_val)\n else:\n probability = kwargs.pop('probability', True)\n self.clf = _SVC(max_iter=self.max_iter, probability=probability, **kwargs)","def build_svm_pipeline():\n svm_pipeline = None\n\n svm_pipeline = Pipeline([\n ('vect', CountVectorizer()),\n ('clf', SGDClassifier()),\n ])\n\n return svm_pipeline","def select_hyperparams(\n df,\n kfold_params,\n tfidf_path,\n model_path,\n code_col,\n target_col,\n n_trials,\n hyperparam_space,\n default_hyperparams,\n):\n\n study = optuna.create_study(direction=\"maximize\", study_name=\"svm with kernels\")\n objective = Objective(df, kfold_params, code_col, target_col, **hyperparam_space)\n\n if n_trials > 0:\n study.optimize(objective, n_trials=n_trials)\n params = study.best_params\n else:\n params = default_hyperparams\n\n best_tfidf_params = {\n \"smooth_idf\": True,\n }\n best_svm_params = {\n \"random_state\": RANDOM_STATE,\n \"max_iter\": MAX_ITER,\n }\n for key, value in params.items():\n model_name, param_name = key.split(\"__\")\n if model_name == \"tfidf\":\n best_tfidf_params[param_name] = value\n elif model_name == \"svm\":\n best_svm_params[param_name] = value\n\n code_blocks_tfidf = tfidf_fit_transform(df[code_col], best_tfidf_params, tfidf_path)\n X, y = code_blocks_tfidf, df[target_col].values\n clf = SVC(**best_svm_params)\n\n f1_mean, f1_std, accuracy_mean, accuracy_std, preds = cross_val_predict(\n objective.kf, clf, X, y\n )\n if model_path is not None:\n clf.fit(X, y)\n pickle.dump(clf, open(model_path, \"wb\"))\n\n metrics = dict(\n test_f1_score=f1_mean,\n test_accuracy=accuracy_mean,\n test_f1_std=f1_std,\n test_accuracy_std=accuracy_std,\n )\n\n return best_tfidf_params, best_svm_params, metrics, preds","def spkernel(*args,\n node_label='atom',\n edge_weight=None,\n node_kernels=None,\n n_jobs=None,\n verbose=True):\n # pre-process\n Gn = args[0] if len(args) == 1 else [args[0], args[1]]\n Gn = [g.copy() for g in Gn]\n weight = None\n if edge_weight is None:\n if verbose:\n print('\\n None edge weight specified. Set all weight to 1.\\n')\n else:\n try:\n some_weight = list(\n nx.get_edge_attributes(Gn[0], edge_weight).values())[0]\n if isinstance(some_weight, (float, int)):\n weight = edge_weight\n else:\n if verbose:\n print(\n '\\n Edge weight with name %s is not float or integer. Set all weight to 1.\\n'\n % edge_weight)\n except:\n if verbose:\n print(\n '\\n Edge weight with name \"%s\" is not found in the edge attributes. Set all weight to 1.\\n'\n % edge_weight)\n ds_attrs = get_dataset_attributes(\n Gn,\n attr_names=['node_labeled', 'node_attr_dim', 'is_directed'],\n node_label=node_label)\n\n # remove graphs with no edges, as no sp can be found in their structures, \n # so the kernel between such a graph and itself will be zero.\n len_gn = len(Gn)\n Gn = [(idx, G) for idx, G in enumerate(Gn) if nx.number_of_edges(G) != 0]\n idx = [G[0] for G in Gn]\n Gn = [G[1] for G in Gn]\n if len(Gn) != len_gn:\n if verbose:\n print('\\n %d graphs are removed as they don\\'t contain edges.\\n' %\n (len_gn - len(Gn)))\n\n start_time = time.time()\n\n pool = Pool(n_jobs)\n # get shortest path graphs of Gn\n getsp_partial = partial(wrapper_getSPGraph, weight)\n itr = zip(Gn, range(0, len(Gn)))\n if len(Gn) < 100 * n_jobs:\n# # use default chunksize as pool.map when iterable is less than 100\n# chunksize, extra = divmod(len(Gn), n_jobs * 4)\n# if extra:\n# chunksize += 1\n chunksize = int(len(Gn) / n_jobs) + 1\n else:\n chunksize = 100\n if verbose:\n iterator = tqdm(pool.imap_unordered(getsp_partial, itr, chunksize),\n desc='getting sp graphs', file=sys.stdout)\n else:\n iterator = pool.imap_unordered(getsp_partial, itr, chunksize)\n for i, g in iterator:\n Gn[i] = g\n pool.close()\n pool.join()\n \n# # ---- direct running, normally use single CPU core. ----\n# for i in tqdm(range(len(Gn)), desc='getting sp graphs', file=sys.stdout):\n# i, Gn[i] = wrapper_getSPGraph(weight, (Gn[i], i))\n\n # # ---- use pool.map to parallel ----\n # result_sp = pool.map(getsp_partial, range(0, len(Gn)))\n # for i in result_sp:\n # Gn[i[0]] = i[1]\n # or\n # getsp_partial = partial(wrap_getSPGraph, Gn, weight)\n # for i, g in tqdm(\n # pool.map(getsp_partial, range(0, len(Gn))),\n # desc='getting sp graphs',\n # file=sys.stdout):\n # Gn[i] = g\n\n # # ---- only for the Fast Computation of Shortest Path Kernel (FCSP)\n # sp_ml = [0] * len(Gn) # shortest path matrices\n # for i in result_sp:\n # sp_ml[i[0]] = i[1]\n # edge_x_g = [[] for i in range(len(sp_ml))]\n # edge_y_g = [[] for i in range(len(sp_ml))]\n # edge_w_g = [[] for i in range(len(sp_ml))]\n # for idx, item in enumerate(sp_ml):\n # for i1 in range(len(item)):\n # for i2 in range(i1 + 1, len(item)):\n # if item[i1, i2] != np.inf:\n # edge_x_g[idx].append(i1)\n # edge_y_g[idx].append(i2)\n # edge_w_g[idx].append(item[i1, i2])\n # print(len(edge_x_g[0]))\n # print(len(edge_y_g[0]))\n # print(len(edge_w_g[0]))\n\n Kmatrix = np.zeros((len(Gn), len(Gn)))\n\n # ---- use pool.imap_unordered to parallel and track progress. ----\n def init_worker(gn_toshare):\n global G_gn\n G_gn = gn_toshare\n do_partial = partial(wrapper_sp_do, ds_attrs, node_label, node_kernels) \n parallel_gm(do_partial, Kmatrix, Gn, init_worker=init_worker, \n glbv=(Gn,), n_jobs=n_jobs, verbose=verbose)\n\n\n # # ---- use pool.map to parallel. ----\n # # result_perf = pool.map(do_partial, itr)\n # do_partial = partial(spkernel_do, Gn, ds_attrs, node_label, node_kernels)\n # itr = combinations_with_replacement(range(0, len(Gn)), 2)\n # for i, j, kernel in tqdm(\n # pool.map(do_partial, itr), desc='calculating kernels',\n # file=sys.stdout):\n # Kmatrix[i][j] = kernel\n # Kmatrix[j][i] = kernel\n # pool.close()\n # pool.join()\n\n # # ---- use joblib.Parallel to parallel and track progress. ----\n # result_perf = Parallel(\n # n_jobs=n_jobs, verbose=10)(\n # delayed(do_partial)(ij)\n # for ij in combinations_with_replacement(range(0, len(Gn)), 2))\n # result_perf = [\n # do_partial(ij)\n # for ij in combinations_with_replacement(range(0, len(Gn)), 2)\n # ]\n # for i in result_perf:\n # Kmatrix[i[0]][i[1]] = i[2]\n # Kmatrix[i[1]][i[0]] = i[2]\n\n# # ---- direct running, normally use single CPU core. ----\n# from itertools import combinations_with_replacement\n# itr = combinations_with_replacement(range(0, len(Gn)), 2)\n# for i, j in tqdm(itr, desc='calculating kernels', file=sys.stdout):\n# kernel = spkernel_do(Gn[i], Gn[j], ds_attrs, node_label, node_kernels)\n# Kmatrix[i][j] = kernel\n# Kmatrix[j][i] = kernel\n\n run_time = time.time() - start_time\n if verbose:\n print(\n \"\\n --- shortest path kernel matrix of size %d built in %s seconds ---\"\n % (len(Gn), run_time))\n\n return Kmatrix, run_time, idx","def ex_1_a(x, y):\n ###########\n ## Train an SVM with a linear kernel\n ## and plot the decision boundary and support vectors using 'plot_svm_decision_boundary' function\n ###########\n\n clf = svm.SVC(kernel='linear')\n clf.fit(x, y)\n plot_svm_decision_boundary(clf, x, y)\n pass","def ex_2_c(x_train, y_train, x_test, y_test):\n ###########\n ## TODO:\n ## Train SVMs with RBF kernels for different values of the gamma\n ## and plot the variation of the test and training scores with gamma using 'plot_score_vs_gamma' function.\n ## Plot the decision boundary and support vectors for the best value of gamma\n ## using 'plot_svm_decision_boundary' function\n ###########\n gammas = np.arange(0.01, 2, 0.02)\n\n test_scores = np.array([])\n train_scores = np.array([])\n best_svm = None\n best_test_score = 0\n\n for gamma in gammas:\n clf = svm.SVC(kernel='rbf', gamma=gamma)\n clf.fit(x_train, y_train)\n\n test_score = clf.score(x_test, y_test)\n\n if test_score > best_test_score:\n best_test_score = test_score\n best_svm = clf\n\n test_scores = np.append(test_scores, test_score)\n train_scores = np.append(train_scores, clf.score(x_train, y_train))\n\n plot_score_vs_gamma(train_scores, test_scores, gammas)\n\n plot_svm_decision_boundary(clf, x_train, y_train, x_test, y_test)","def ex_2_b(x_train, y_train, x_test, y_test):\n ###########\n ## TODO:\n ## Train SVMs with polynomial kernels for different values of the degree\n ## (Remember to set the 'coef0' parameter to 1)\n ## and plot the variation of the training and test scores with polynomial degree using 'plot_score_vs_degree' func.\n ## Plot the decision boundary and support vectors for the best value of degree\n ## using 'plot_svm_decision_boundary' function\n ###########\n degrees = range(1, 21)\n\n test_scores = np.array([])\n train_scores = np.array([])\n best_svm = None\n best_test_score = 0\n\n for deg in degrees:\n clf = svm.SVC(kernel='poly', degree=deg, coef0=1)\n clf.fit(x_train, y_train)\n\n test_score = clf.score(x_test, y_test)\n\n if test_score > best_test_score:\n best_test_score = test_score\n best_svm = clf\n\n test_scores = np.append(test_scores, test_score)\n train_scores = np.append(train_scores, clf.score(x_train, y_train))\n\n plot_score_vs_degree(train_scores, test_scores, degrees)\n\n plot_svm_decision_boundary(clf, x_train, y_train, x_test, y_test)","def svm_model_fn(features, labels, mode, params):\n\n feature_columns = [layers.real_valued_column(i) for i in features.keys()]\n example_id_column(features)\n\n weight_column_name = params.get(\"weight_column_name\")\n\n head = head_lib.binary_svm_head(\n weight_column_name=weight_column_name,\n enable_centered_bias=False)\n\n optimizer = sdca_optimizer.SDCAOptimizer(\n example_id_column=\"index\",\n num_loss_partitions=params[\"num_loss_partitions\"],\n symmetric_l1_regularization=params[\"l1_regularization\"],\n symmetric_l2_regularization=params[\"l2_regularization\"])\n\n chief_hook = linear._SdcaUpdateWeightsHook()\n update_weights_hook = chief_hook\n\n if not isinstance(optimizer, sdca_optimizer.SDCAOptimizer):\n raise ValueError(\"Optimizer must be of type SDCAOptimizer\")\n\n if isinstance(head,\n head_lib._BinarySvmHead): # pylint: disable=protected-access\n loss_type = \"hinge_loss\"\n elif isinstance(head,\n head_lib._BinaryLogisticHead): # pylint:\n # disable=protected-access\n loss_type = \"logistic_loss\"\n elif isinstance(head,\n head_lib._RegressionHead): # pylint:\n # disable=protected-access\n assert head.logits_dimension == 1, (\"SDCA only applies for \"\n \"logits_dimension=1.\")\n loss_type = \"squared_loss\"\n else:\n raise ValueError(\"Unsupported head type: {}\".format(head))\n\n parent_scope = \"linear\"\n\n with variable_scope.variable_op_scope(\n features.values(), parent_scope) as scope:\n features = features.copy()\n features.update(layers.transform_features(features, feature_columns))\n logits, columns_to_variables, bias = (\n layers.weighted_sum_from_feature_columns(\n columns_to_tensors=features,\n feature_columns=feature_columns,\n num_outputs=1,\n scope=scope))\n\n linear._add_bias_column(feature_columns, features, bias,\n columns_to_variables)\n\n def _train_op_fn(unused_loss):\n global_step = contrib_variables.get_global_step()\n sdca_model, train_op = optimizer.get_train_step(columns_to_variables,\n weight_column_name,\n loss_type, features,\n labels, global_step)\n if update_weights_hook is not None:\n update_weights_hook.set_parameters(sdca_model, train_op)\n return train_op\n\n model_fn_ops = head.create_model_fn_ops(\n features=features,\n labels=labels,\n mode=mode,\n train_op_fn=_train_op_fn,\n logits=logits)\n if update_weights_hook is not None:\n return model_fn_ops._replace(\n training_chief_hooks=(model_fn_ops.training_chief_hooks +\n [update_weights_hook]))\n return model_fn_ops","def get_hyperparams(self):","def custom_training(nb_tweet_sample, randomised, equal_pos_neg, language, name_kernel, Resource, keep_null_vector):\n m_features, m_labels = get_characteristic_label_vectors(nb_tweet_sample, randomised, equal_pos_neg, Resource,\n keep_null_vector, language)\n\n kernel = Kernel.get_correct_kernel(name_kernel)\n custom_SVM = SVM(kernel)\n custom_SVM.fit(m_features, m_labels)\n\n return custom_SVM","def __init__(self, foundVariables, trainingData, trainingClasses, trainingWeights, testingData, testingClasses):\n self.clf = svm.SVC(probability=True)\n self.foundVariables = foundVariables\n self.trainingData = trainingData\n self.trainingClasses = trainingClasses\n self.testingData = testingData\n self.testingClasses = testingClasses\n self.trainingWeights = trainingWeights","def ex_1_a(x, y):\n ###########\n ## TODO:\n ## Train an SVM with a linear kernel\n ## and plot the decision boundary and support vectors using 'plot_svm_decision_boundary' function\n ###########\n\n clf = svm.SVC(kernel='linear')\n clf.fit(x, y)\n\n plot_svm_decision_boundary(clf, x, y)","def _find_svm_rbf_params(df, metrics, kernel):\n context = ramp.DataContext(data=df)\n config = ramp.Configuration(target=\"target\",\n features=[ramp.BaseFeature(x) for x in metrics])\n x, y = ramp.models.get_xy(config, context)\n\n if kernel == \"linear\":\n param_grid = dict(C=10.0 ** np.arange(-2, 5))\n else:\n param_grid = dict(gamma=10.0 ** np.arange(-5, 4),\n C=10.0 ** np.arange(-2, 9))\n grid = sklearn.grid_search.GridSearchCV(sklearn.svm.SVC(kernel=kernel),\n param_grid=param_grid,\n cv=sklearn.cross_validation.StratifiedKFold(y=y, k=3),\n verbose=True)\n grid.fit(x, y)\n print grid.best_estimator_\n out = {}\n for attr in param_grid.keys():\n out[attr] = getattr(grid.best_estimator_, attr)\n return out","def train(self, prob: SvmProblem):\n # Define variables\n self.prob = prob\n c = prob.C\n c2 = prob.gamma\n xkern = prob.xkernel\n xsk = prob.xskernel\n\n # Swap params, so SVM solves X* with correct params\n prob.C = c2\n prob.xkernel = xsk\n\n # Find SVM solution in X*\n svm = SVM()\n priv_clf = svm.train(prob.Xstar, prob)\n\n # Replace swapped out params so modified SVM solves X with correct params\n prob.C = c\n prob.xkernel = xkern\n\n # Get the 'frames of knowledge' - Get the kernel distance from each\n # privileged training data-point to the privileged support vectors\n frames = np.zeros((prob.num, len(priv_clf.support_vectors)))\n for i in range(prob.num):\n for j in range(len(priv_clf.support_vectors)):\n frames[i][j] = prob.xkernel((priv_clf.support_vectors[j]), prob.Xstar[i])\n\n # Form pairs so that each training point is matched against each 'frame of knowledge'\n training_pairs = np.zeros((prob.num, len(priv_clf.support_vectors)), dtype=object)\n for i in range(prob.num):\n for j in range(len(priv_clf.support_vectors)):\n training_pairs[i][j] = [prob.X[i], frames[i][j]]\n training_pairs = np.array(training_pairs)\n\n regr_pairs = np.zeros((len(priv_clf.support_vectors), prob.num), dtype=object)\n for i in range(prob.num):\n for j in range(len(priv_clf.support_vectors)):\n regr_pairs[j][i] = training_pairs[i][j]\n\n # Learn a regression based on above pairs\n self.models = []\n for dataSet in regr_pairs:\n regr = SVR(kernel='rbf')\n xs = []\n ys = []\n for i in range(prob.num):\n xs.append(dataSet[i][0].flatten())\n ys.append(dataSet[i][1])\n xs = np.array(xs)\n ys = np.array(ys)\n self.models.append(regr.fit(xs, ys))\n\n # Transform data from X using learned regression\n new_xs = []\n new_ys = []\n for i in range(prob.num):\n new_xs.append(self.transform(prob.X[i].reshape(1, -1)).flatten())\n new_ys.append(priv_clf.predict(prob.Xstar[i]))\n new_x = np.asarray(new_xs)\n new_y = np.array(new_ys)\n\n # Form a new problem and learn an SVMd+ solution for it\n new_prob = SvmProblem(new_x, prob.Xstar, new_y)\n new_svm = SVMdp()\n self.clf = new_svm.train(new_prob)","def setup_svm(self, classifier_name=\"SVM\", **kwargs):\n if not classifier_name in self.classifiers:\n clf = svm.SVC(**kwargs)\n clf.fit(self.X_train, self.y_train)\n self.classifiers[classifier_name] = clf","def svm(xtrain, ytrain, xtest, ytest,labels_mapping, scaled = False):\n if not scaled :\n scaler = StandardScaler()\n xtrain = scaler.fit_transform(xtrain)\n xtest = scaler.transform(xtest)\n\n svm = SVC(C=10, cache_size=1500, class_weight='balanced')\n svm = __train_and_test(svm, xtrain, ytrain, xtest, ytest,labels_mapping)\n return svm","def train_svm_model(self, X_train, X_test, y_train, y_test):\r\n clf = Pipeline([('vect', CountVectorizer()), ('tfidf', TfidfTransformer()),\r\n ('clf', LinearSVC())])\r\n clf = clf.fit(X_train, y_train)\r\n pred = clf.predict(X_test)\r\n print('Confusion matrix\\n',confusion_matrix(y_test,pred))\r\n print('Classification_report\\n',classification_report(y_test,pred))\r\n return clf","def train(prob: SvmProblem):\n # Define variables\n x = prob.X\n y = prob.Y\n C = prob.C\n C2 = prob.gamma\n\n # Swap params, so SVM solves X* with correct params\n xk = prob.xkernel\n xsk = prob.xskernel\n\n prob.C = C2\n prob.xkernel = xsk\n\n svm = SVM()\n xstar_clf = svm.train(prob.Xstar, prob)\n\n # Get distance to decision boundary\n xi_star = np.zeros(prob.num)\n for i in range(prob.num):\n output = (1 - prob.Y[i] * (xstar_clf.f(prob.Xstar[i])))\n xi_star[i] = max(0, output)\n\n # Replace swapped out params so modified SVM solves X with correct params\n prob.C = C\n prob.xkernel = xk\n\n # Define the inputs to CVXOPT - See Appendix G.4\n P = prob.yi_yj * prob.xi_xj\n q = -np.ones((prob.num, 1))\n G1 = -np.eye(prob.num)\n G2 = np.eye(prob.num)\n G3 = xi_star.reshape(1, -1)\n G = np.vstack((G1, G2))\n G = np.vstack((G, G3))\n h1 = np.zeros(prob.num).reshape(-1, 1)\n h2 = np.repeat((1 + prob.delta) * C, prob.num).reshape(-1, 1)\n h3 = sum(xi_star) * C\n h = np.vstack((h1, h2))\n h = np.vstack((h, h3))\n A = y.reshape(1, -1)\n b = np.zeros(1)\n\n P = matrix(P, tc='d')\n q = matrix(q, tc='d')\n G = matrix(G, tc='d')\n h = matrix(h, tc='d')\n A = matrix(A, tc='d')\n b = matrix(b, tc='d')\n\n # Solve optimization problem using CVXOPT\n solvers.options['show_progress'] = False\n sol = solvers.qp(P, q, G, h, A, b)\n alphas = np.array(sol['x'])\n\n # Get the bias\n bacond1 = (alphas > 1e-8)\n bacond2 = (alphas <= (1 + prob.delta) * C)\n bcond = np.array([a and b for a, b in zip(bacond1, bacond2)]).flatten()\n\n yS = y[bcond]\n xS = x[bcond]\n aS = alphas[bcond]\n\n sum_total = 0\n for s in range(len(yS)):\n inner_total = 0\n for m in range(len(yS)):\n am = aS[m]\n ym = yS[m]\n xm_xs = prob.xkernel(xS[m], xS[s])\n inner_total += am * ym * xm_xs\n sum_total += yS[s] - inner_total\n\n bias = sum_total / len(yS)\n\n # Populate Classifier object to be returned\n clf = Classifier()\n clf.b = bias\n clf.alphas = alphas\n clf.xs = x\n clf.ys = y\n clf.kern = prob.xkernel\n return clf","def search_ksvm_hyperparams(model, x, y, kernel, C_list, eps_list, folds=3):#C_list,\n # divide data into training and validation sets:\n N = x.shape[0]\n\n # get random indices for dataset folds\n indices = torch.randperm(N)\n length = N // folds\n\n max_acc = 0.0\n max_C = 0.0\n max_eps = 0.0\n for C in C_list:\n for eps in eps_list:\n acc = torch.zeros(folds)\n for k in range(folds):\n x_train = torch.cat((x[indices[0:k*length]],x[indices[(k+1)*length:]]),dim = 0)\n y_train = torch.cat((y[indices[0:k*length]],y[indices[(k+1)*length:]]),dim = 0)\n x_val = x[indices[k*length:(k+1)*length]]\n y_val = y[indices[k*length:(k+1)*length]]\n\n model.__init__(kernel, C, eps)\n model.train(x_train, y_train, print_progress = False)\n y_pred = model.predict(x_val)\n acc[k] = ((y_val==y_pred).sum()) / float(y_val.shape[0])\n acc_mean = acc.mean()\n if(acc_mean > max_acc):\n max_acc = acc_mean\n max_C = C\n max_eps = eps\n\n print(\"at C = {} and eps = {} we get acc = {}\" .format(C, eps, acc_mean))\n\n\n print(\"Max we get at: C: {} and eps = {} we get acc = {}\" .format(max_C, max_eps, max_acc))\n return max_acc, max_C, max_eps","def SVM_train(X, y, cv):\r\n rev = 10000\r\n start_time = time.time()\r\n print('\\n'+ '# '*10+'[Training] Support Vector Machine (SVM) (max_iter='+str(rev)+'):'+ ' #'*10)\r\n parameters = {\r\n 'kernel':('linear', 'poly', 'rbf'),\r\n 'C':(1, 5, 10),\r\n 'gamma':('scale', 'auto')\r\n }\r\n print('-'*2+'Grid Search Parameters:')\r\n print(parameters)\r\n clf = svm.SVC(random_state=rstate, probability=True, max_iter=rev) # Max_iter infinite as default, stuck on large datasets > 10^4.\r\n clf = GridSearchCV(clf, parameters, cv=cv, scoring='f1')\r\n clf.fit(X, y)\r\n print('-'*2+'GridSearch Results:')\r\n with pd.option_context('display.max_rows', None, 'display.max_columns', None):\r\n print(pd.DataFrame(clf.cv_results_))\r\n print('> '*2+'Training time: %.4f seconds.'%(time.time()-start_time))\r\n return clf","def train_SVM(data: np.array, labels: np.array)->None:\n print(\"SVM is not implemented yet!\")","def hyperparameter_cv(X_data, y_data, hyperparameters):\n\n # Create Grid of hyperparameters\n grid = cartesian_product(hyperparameters)\n\n # Loop through hyperparameters \n best_score = 0\n for hyperparameter in grid:\n # Initialize Modle\n model = svm.SVC(kernel='linear', **hyperparameter)\n\n # Train and Get Accuracy\n print(f\"Training using hyperparameters: {hyperparameter}\")\n score = cross_validation_score(X_data, y_data, model, folds=5)\n print(f\"Accuracy Score: {score}\")\n\n if score > best_score:\n best_score = score\n best_parameters = hyperparameter\n \n return best_score, best_parameters","def train_linear_SVM(X_train_input, y_train_input, C=1):\r\n from sklearn.svm import SVC\r\n svc_clf = SVC(kernel='linear', probability=True, C=C)\r\n svc_clf.fit(X_train_input, y_train_input)\r\n return svc_clf","def ex_1_b(x, y):\n ###########\n ## Add a point (4,0) with label 1 to the data set and then\n ## train an SVM with a linear kernel\n ## and plot the decision boundary and support vectors using 'plot_svm_decision_boundary' function\n ###########\n new_x = np.vstack((x, np.array([4,0])))\n new_y = np.hstack((y, np.array((1))))\n\n clf = svm.SVC(kernel='linear')\n clf.fit(new_x, new_y)\n plot_svm_decision_boundary(clf, new_x, new_y)\n pass","def extract_svm_parameters(clf):\n\n return {\n 'n_support': clf.__dict__['n_support_'].tolist(),\n 'support_vectors': clf.__dict__['support_vectors_'].tolist(),\n 'dual_coef': clf.__dict__['_dual_coef_'].tolist(),\n 'intercept': clf.__dict__['_intercept_'].tolist(),\n 'classes': clf.__dict__['classes_'].tolist(),\n }","def ex_1_c(x, y):\n ###########\n ## Add a point (4,0) with label 1 to the data set and then\n ## train an SVM with a linear kernel with different values of C\n ## and plot the decision boundary and support vectors for each using 'plot_svm_decision_boundary' function\n ###########\n Cs = [1e6, 1, 0.1, 0.001]\n new_x = np.vstack((x, np.array([4,0])))\n new_y = np.hstack((y, np.array((1))))\n\n for c in Cs:\n clf = svm.SVC(kernel='linear', C=c)\n clf.fit(new_x, new_y)\n plot_svm_decision_boundary(clf, new_x, new_y)\n return","def define_kernel(self, *args, **kwargs):\n base_kernel = self.base_kernel\n if base_kernel is None:\n base_kernel = 'VertexHistogram'\n k = getattr(kernels, self.kernel_name)\n k_base = getattr(kernels, base_kernel)\n kernel = k(base_graph_kernel=k_base, *args, **kwargs)\n return kernel","def svm_train(c, g, v, dname):\n if sys.platform != 'win32':\n # grid_py = '../tools/grid.py'\n # gnuplot_exe = '/usr/bin/gnuplot'\n svmtrain_exe = './PromoterSVM/libsvm/windows/my-svm-train'\n else:\n # grid_py = r\"D:\\LiYuan\\Data_Science\\libsvm-3.21\\windows\\grid.py\"\n # gnuplot_exe = r\"D:\\Program Files\\gnuplot\\bin\\gnuplot.exe\"\n svmtrain_exe = r'D:\\LiYuan\\\"Bioinformatic Research\"\\IMU\\zuo\\Tasks\\\"20160206-Promoter SVM\"\\biopromoter_script\\PromoterSVM\\libsvm\\windows\\my-svm-train.exe'\n\n df_model = dname + \".model\"\n cmd = '{0} -c {1} -g {2} -v {3} \"{4}\" \"{5}\"'.format(svmtrain_exe, c, g, v, dname, df_model)\n Popen(cmd, shell=True, stdout=PIPE).communicate()","def ex_2_c(x_train, y_train, x_test, y_test):\n ###########\n ## TODO:\n ## Train SVMs with RBF kernels for different values of the gamma\n ## and plot the variation of the test and training scores with gamma using 'plot_score_vs_gamma' function.\n ## Plot the decision boundary and support vectors for the best value of gamma\n ## using 'plot_svm_decision_boundary' function\n ###########\n gammas = np.arange(0.01, 2, 0.02)\n machines = [svm.SVC(kernel='rbf', gamma=g, coef0=1.0) for g in gammas]\n\n for machine in machines:\n machine.fit(x_train, y_train)\n\n trainScores = [machine.score(x_train, y_train) for machine in machines]\n testScores = [machine.score(x_test, y_test) for machine in machines]\n\n plot_score_vs_gamma(trainScores, testScores, gammas)\n\n bestGamma = np.argmax(testScores)\n print('Score of best rbf gamma ({}): {}'.format(gammas[bestGamma], testScores[bestGamma]))\n plot_svm_decision_boundary(machines[bestGamma], x_train, y_train, x_test, y_test)","def train(self, trainingData, trainingLabels, validationData, validationLabels):\n from sklearn import svm\n \n \"*** YOUR CODE HERE ***\"\n self.sklearn_svm = svm.SVC(C=5, kernel='rbf', gamma=0.005, decision_function_shape='ovo')\n self.sklearn_svm.fit(trainingData, trainingLabels)","def main():\n\n if len(sys.argv) < 4 or len(sys.argv) > 5:\n print 'Usage: classifier.py data_dimension train_set_path test_set_path [option: add_bias]'; \n return; \n\n # create sets of possible hyperparameter values\n setC = {0.001, 0.01, 0.1, 1, 10, 25, 100}; # trade off regularizer and error minimization\n setRho = {0.001, 0.01, 0.1, 1}; # learning rate for gradient descent \n hyperparams = [setC, setRho];\n \n # create svm classifier for selected data\n dataDim = int(sys.argv[1]);\n trainPath = str(sys.argv[2]);\n testPath = str(sys.argv[3]);\n if len(sys.argv) == 5:\n c = Classifier('svm', hyperparams, dataDim, testPath, trainPath, addBias=True);\n else:\n c = Classifier('svm', hyperparams, dataDim, testPath, trainPath);\n \n print 'Classifier type: ', c.type, \\\n '\\nTraining set: ', trainPath, \\\n '\\nTest set: ', testPath;\n \n print 'Determining hyperparameters to use...';\n c.learnHyperparams(report=1);\n \n print 'Training classifier...';\n c.train();\n \n print 'Performing inference on test set...';\n c.test(); \n \n print '\\nREPORT:', \\\n '\\nUsing hyperparameters: ', c.theta, \\\n '\\nLearned weight vector: ', c.w, \\\n '\\nPrediction accuracy on test set: ', c.accuracy * 100, ' percent';","def ex_2_b(x_train, y_train, x_test, y_test):\n ###########\n ## TODO:\n ## Train SVMs with polynomial kernels for different values of the degree\n ## (Remember to set the 'coef0' parameter to 1)\n ## and plot the variation of the test and training scores with polynomial degree using 'plot_score_vs_degree' func.\n ## Plot the decision boundary and support vectors for the best value of degree\n ## using 'plot_svm_decision_boundary' function\n ###########\n\n degrees = range(1, 21)\n machines = [svm.SVC(kernel='poly', degree=d, coef0=1.0) for d in degrees]\n\n for machine in machines:\n machine.fit(x_train, y_train)\n\n trainScores = [machine.score(x_train, y_train) for machine in machines]\n testScores = [machine.score(x_test, y_test) for machine in machines]\n\n plot_score_vs_degree(trainScores, testScores, degrees)\n\n bestDegree = testScores.index(max(testScores))\n print('Score of best polynomial degree ({}): {}'.format(bestDegree + 1, testScores[bestDegree]))\n plot_svm_decision_boundary(machines[bestDegree], x_train, y_train, x_test, y_test)","def SVM_train(Ktrain,y,lbda_vec):\r\n n = Ktrain.shape[0]\r\n for idx, lbda in enumerate(lbda_vec): \r\n C = 1/(2*lbda*n)\r\n P = matrix(Ktrain, tc=\"d\")\r\n q = - matrix(y,tc=\"d\")\r\n G = matrix( np.concatenate( (np.diagflat(y) , -np.diagflat(y) ), axis=0 ),tc=\"d\" )\r\n h1 = C * np.ones((n,1))\r\n h2 = np.zeros((n,1)) \r\n h = matrix(np.concatenate((h1,h2),axis=0))\r\n\r\n solvers.options['show_progress'] = False\r\n \r\n sol = solvers.qp(P,q,G,h) \r\n a = np.asarray(sol['x'])\r\n\r\n #alpha is sparse\r\n a[np.where(np.abs(a) < 1e-4)] = 0\r\n y_svm = np.dot(Ktrain,a)\r\n\r\n print(\"Précision pour lambda = \" + str(lbda) + \" :\", accuracy(y_svm,y))","def __init__(self, x, y, method='svm', n_cv=5, **kwargs):\n self.x = x\n self.y = y\n self.rf_stat = None\n self.summary = {}\n self.n_cv = n_cv\n self.method = method\n if 'kernel' in kwargs.keys(): self.kernel = kwargs['kernel']\n\n self.print_flag = kwargs.get('print_flag', 'off')\n self.stat = {'train': None, 'test': None}\n # self.direct = kwargs[''] # TODO more generic here","def __init__(self):\n super().__init__()\n import sklearn\n import sklearn.svm\n self.model = sklearn.svm.LinearSVR","def thundersvm_load_svm_model(input_svm_model_file):\n \n svm_model = SVC()\n svm_model.load_from_file(input_svm_model_file)\n \n return svm_model","def get_kernel_hps(self):\n raise NotImplementedError('Abstract Method.')","def ex_2_a(x_train, y_train, x_test, y_test):\n ###########\n ## TODO:\n ## Train an SVM with a linear kernel for the given dataset\n ## and plot the decision boundary and support vectors for each using 'plot_svm_decision_boundary' function\n ###########\n\n machine = svm.SVC(kernel='linear')\n machine.fit(x_train, y_train)\n plot_svm_decision_boundary(machine, x_train, y_train, x_test, y_test)\n\n print('Linear SVM score: {}'.format(machine.score(x_test, y_test)))","def Train_SVC(train_X, train_Y, test_X, test_Y, Accuracy):\r\n clf = SVC(probability=True, C=5, gamma='auto', kernel='linear')\r\n clf.fit(train_X, train_Y)\r\n y_predict = clf.predict(test_X)\r\n Accuracy[\"SVM\"] = metrics.accuracy_score(test_Y, y_predict)\r\n print(\"Accuracy of SVM: %.2f%%\" % (Accuracy[\"SVM\"] * 100))\r\n # Confusion Matrix\r\n cm_rf = confusion_matrix(test_Y, y_predict)\r\n rf_cm = pd.DataFrame(cm_rf, range(3), range(3))\r\n sn.set(font_scale=1.7)\r\n sn.heatmap(rf_cm, annot=True, annot_kws={\"size\": 15}, fmt='g', cmap=\"Greens\")","def get_model_5(parameters):\n # Generate model\n model = svm.LinearSVC(max_iter=100000)\n \n # Return the model\n return model","def default_feature_hp_kernel_config(defn):\n defn = _validate_definition(defn)\n\n # hyperparams\n hparams = {}\n for i, hp in enumerate(defn.hyperpriors()):\n if not hp:\n continue\n # XXX(stephentu): we are arbitrarily picking w=0.1\n hparams[i] = {k: (fn, 0.1) for k, fn in hp.iteritems()}\n\n if not hparams:\n return []\n else:\n return [('slice_feature_hp', {'hparams': hparams})]","def get_model_4(parameters):\n # Generate model\n model = svm.SVC(C=parameters['C'], gamma='scale', probability=True,\n class_weight='balanced',\n decision_function_shape='ovr')\n \n # Return the model\n return model","def hyper_parameter_tuning(X, y, classifier, models, sntypes_map, feature_names, fig_dir='.', remove_models=(), name=''):\n\n # Hyperparameter grid\n n_estimators = [int(x) for x in np.linspace(start=200, stop=2000, num=10)]\n max_features = ['auto', 'sqrt']\n max_depth = [int(x) for x in np.linspace(10, 110, num=11)]\n max_depth.append(None)\n min_samples_split = [2, 5, 10]\n min_samples_leaf = [1, 2, 4]\n bootstrap = [True, False]\n random_grid = {'n_estimators': n_estimators,\n 'max_features': max_features,\n 'max_depth': max_depth,\n 'min_samples_split': min_samples_split,\n 'min_samples_leaf': min_samples_leaf,\n 'bootstrap': bootstrap}\n\n # Get data\n num_features = X.shape[1]\n model_names = [sntypes_map[model] for model in models]\n X, y, models, remove_models = remove_redundant_classes(X, y, models, remove_models)\n\n # Get best features\n n = 50\n num_features, feature_names, X = get_n_best_features(n, X, y, classifier, feature_names, num_features, fig_dir, name, models, model_names)\n\n # Randomised Search\n clf_random = RandomizedSearchCV(estimator=classifier, param_distributions=random_grid, n_iter=7, cv=3, verbose=2,\n random_state=42, n_jobs=2)\n clf_random.fit(X, y)\n print(clf_random.best_params_)\n\n def evaluate(model, test_features, test_labels):\n predictions = model.predict(test_features)\n errors = abs(predictions - test_labels)\n mape = 100 * np.mean(errors / test_labels)\n accuracy = 100 - mape\n print('Model Performance')\n print('Average Error: {:0.4f} degrees.'.format(np.mean(errors)))\n print('Accuracy = {:0.2f}%.'.format(accuracy))\n\n return accuracy\n\n best_random = clf_random.best_estimator_\n # random_accuracy = evaluate(best_random, test_features, test_labels)","def get_vertex_vek(*args, data_dir=None, **kwargs):\n\n annots = _apply_vek_prob(data_dir=data_dir)\n vertex_labels, parcel_labels = [], []\n for hemi in ('lh', 'rh'):\n vc = _convert_vek_to_classes(getattr(annots, hemi), data_dir=data_dir)\n vertex_labels.append(vc)\n parcel_labels.append(np.unique(vc))\n return NETWORKS(np.hstack(vertex_labels), np.hstack(parcel_labels))","def build_model():\n # build pipeline with count vecotrizer, tfidf and support vector machine\n pipeline_SVC = Pipeline([\n ('vect', CountVectorizer(tokenizer = tokenize)),\n ('tfidf', TfidfTransformer()),\n ('multi-clf', MultiOutputClassifier(LinearSVC()))\n ])\n\n # define parameters for gridsearch\n parameters_SVC = {\n 'vect__max_df': (.6, 1),\n 'tfidf__norm': ('l1', 'l2'),\n 'multi-clf__estimator__C': (.1, 1, 100)\n }\n\n # build parameter grid and fit data\n model = GridSearchCV(pipeline_SVC, parameters_SVC)\n\n return model","def _get_current_hyperparameters(self):","def __init__(self,training_data):\n my_data = genfromtxt(training_data, delimiter='\\t',skip_header=0)\n n_col = my_data.shape[1]\n n_features=n_col-1 #assuming that the latest column\n #contains the the outputs \n #preprocessing data\n X = preprocessing.scale(np.hsplit(my_data,[n_features,n_col])[0])\n Y = np.squeeze(np.asarray(np.hsplit(my_data,[n_features,n_col])[1]))\n #defining scaling\n self.scaler = preprocessing.Scaler()\n self.scaler.fit(np.hsplit(my_data,[n_features,n_col])[0])\n #define classifier\n self.classifier = svm.LinearSVC(class_weight='auto',C=1.0)\n self.classifier.fit(X, Y)","def svm_fit(self, c: float = 1.0):\r\n self.svmModel = SVC(C=c, gamma='auto').fit(self.x, self.y)","def __init__(self,\n gridsearch='half',\n n_components=3,\n classifier='svm',\n cv=5,\n min_resources='smallest',\n factor=3,\n score_func=metrics.f1_score,\n average='weighted',\n random_state=None,\n n_jobs=-1,\n **kwargs,\n ):\n\n freq_thres = helpers.FREQ_THRES(freq_thres=0)\n\n log = helpers.LOG(log=False)\n\n if classifier == 'svm':\n\n classifier = SVC(random_state=random_state)\n\n mapper = umap.UMAP(random_state=random_state,\n n_components=n_components)\n\n scorer = metrics.make_scorer(score_func=score_func,\n average=average,\n )\n\n pipeline = Pipeline([('freq', freq_thres),\n ('log', log),\n ('umap', mapper),\n ('classifier', classifier),\n ])\n\n params_grid_pipeline = {**kwargs}\n\n if gridsearch == 'full':\n self.clf_pipeline = GridSearchCV(pipeline,\n params_grid_pipeline,\n cv=cv,\n scoring=scorer,\n n_jobs=n_jobs,\n )\n elif gridsearch == 'half':\n self.clf_pipeline = \\\n HalvingGridSearchCV(pipeline,\n params_grid_pipeline,\n cv=cv,\n scoring=scorer,\n n_jobs=n_jobs,\n min_resources=min_resources,\n factor=factor,\n random_state=random_state\n )","def __init__(self):\n super().__init__()\n import sklearn\n import sklearn.svm\n self.model = sklearn.svm.NuSVR","def create_SVM_profile(size_sample, randomness, pos_equal_neg, kernel, Resource, m_features=None,\n m_labels=None, language='en'):\n if m_features is None and m_labels is None:\n m_features, m_labels = get_characteristic_label_vectors(size_sample, randomness, pos_equal_neg, Resource, False,\n language)\n\n Classifier = SVM(kernel)\n Classifier.fit(m_features, m_labels)\n\n name_file = construct_name_file(size_sample, randomness, pos_equal_neg, str(kernel).split('.')[1])\n\n Classifier.save_to_file(name_file)","def test_SVM_test_C_parameter(params, X_train, X_test, y_train, y_test):","def train_svm(data: np.ndarray, test_labels: list, test_samples: list, train_labels: list,\n train_samples: list) -> np.ndarray:\n model = svm.SVC(kernel=\"rbf\", C=1024, gamma=2)\n model.fit(get_data_by_indexes(train_samples, data), train_labels)\n prediction = model.predict(get_data_by_indexes(test_samples, data))\n print(\"SVM fitness score {0:5.2f}%\".format(\n model.score(get_data_by_indexes(test_samples, data), test_labels) * float(100)))\n return prediction","def ex_3_a(x_train, y_train, x_test, y_test):\n ###########\n ## Train multi-class SVMs with one-versus-rest strategy with\n ## - linear kernel\n ## - rbf kernel with gamma going from 10**-5 to 10**5\n ## - plot the scores with varying gamma using the function plot_score_versus_gamma\n ## - Mind that the chance level is not .5 anymore and add the score obtained with the linear kernel as optional argument of this function\n ###########\n dfs = 'ovr'\n c = 10\n\n linear = svm.SVC(kernel='linear', C=c, decision_function_shape=dfs)\n linear.fit(x_train, y_train)\n lin_score_train = linear.score(x_train, y_train)\n lin_score_test = linear.score(x_test, y_test)\n\n gammas = [pow(10, i) for i in range(-5, 6)]\n rbfs = [svm.SVC(kernel='rbf', gamma=gamma, C=c, decision_function_shape=dfs) for gamma in gammas]\n for rbf in rbfs:\n rbf.fit(x_train, y_train)\n\n train_scores = [rbf.score(x_train, y_train) for rbf in rbfs]\n test_scores = [rbf.score(x_test, y_test) for rbf in rbfs]\n\n plot_score_vs_gamma(train_scores, test_scores, gammas, lin_score_train, lin_score_test, .2)","def ex_1_c(x, y):\n ###########\n ## TODO:\n ## Add a point (4,0) with label 1 to the data set and then\n ## train an SVM with a linear kernel with different values of C\n ## and plot the decision boundary and support vectors for each using 'plot_svm_decision_boundary' function\n ###########\n Cs = [1e6, 1, 0.1, 0.001]\n\n new_x = (4, 0)\n new_y = 1\n\n x = np.vstack([x, new_x])\n y = np.hstack([y, new_y])\n\n for C in Cs:\n clf = svm.SVC(kernel='linear', C=C)\n clf.fit(x, y)\n plot_svm_decision_boundary(clf, x, y)","def __init__(self, estimator, target_language='java',\n target_method='predict', **kwargs):\n super(SVC, self).__init__(estimator, target_language=target_language,\n target_method=target_method, **kwargs)\n self.estimator = estimator","def get_kernel_vector(name, kernel, x, d_1, hyps,\n cutoffs=None, hyps_mask=None,\n n_cpus=1, n_sample=100):\n\n size = len(_global_training_data[name])\n\n if (n_cpus is None):\n n_cpus = mp.cpu_count()\n if (n_cpus == 1):\n return get_kernel_vector_unit(\n name, 0, size, x, d_1, kernel, hyps,\n cutoffs, hyps_mask)\n\n block_id, nbatch = partition_c(n_sample, size, n_cpus)\n\n result_queue = mp.Queue()\n children = []\n for wid in range(nbatch):\n s, e = block_id[wid]\n children.append(\n mp.Process(\n target=queue_wrapper,\n args=(result_queue, wid,\n get_kernel_vector_unit,\n (name, s, e, x, d_1, kernel, hyps,\n cutoffs, hyps_mask\n )\n )\n )\n )\n\n # Run child processes.\n for c in children:\n c.start()\n\n # Wait for all results to arrive.\n k12_v = np.zeros(size*3)\n for _ in range(nbatch):\n wid, result_chunk = result_queue.get(block=True)\n s, e = block_id[wid]\n k12_v[s*3:e*3] = result_chunk\n\n # Join child processes (clean up zombies).\n for c in children:\n c.join()\n\n return k12_v","def plot_svm(N=5, std=0.60, kernel='linear'):\n X, y = make_blobs(n_samples=200, centers=2, random_state=0,\n cluster_std=std)\n\n X_train, y_train = X[:N], y[:N]\n X_test, y_test = X[N:], y[N:]\n\n clf = SVC(kernel=str(kernel))\n clf.fit(X_train, y_train)\n\n plt.scatter(X_train[:, 0], X_train[:, 1], c=y_train, s=50, cmap='spring')\n plt.scatter(X_test[:, 0], X_test[:, 1], c=y_test, s=50, cmap='spring',\n alpha=0.2)\n plt.xlim(-1, 4)\n plt.ylim(-1, 6)\n plot_svc_decision_function(clf, plt.gca())\n plt.scatter(clf.support_vectors_[:, 0], clf.support_vectors_[:, 1],\n s=200, facecolors='none')\n\n train_score = clf.score(X_train, y_train)\n test_score = clf.score(X_test, y_test) if len(X_test) > 0 else 'NA'\n plt.title('Train Accuracy = {0}; Test Accuracy = {1}'.format(train_score,\n test_score))","def train(K, labels, C):\n K= sparse.hstack((1+np.arange(len(labels))[:,None], K)).A\n prob = svm_problem(labels, K, isKernel=True)\n param = svm_parameter('-t 4 -c ' + str(C))\n return svm_train(prob, param)","def svm_classify(train_image_feats, train_labels, test_image_feats, kernel_type):\r\n\r\n categories = np.unique(train_labels)\r\n # [Desc] make 15 different SVM solver (one(each category) vs. the other(14 other category))\r\n svc_list = []\r\n num_categories = len(categories)\r\n for cat_i in tqdm(range(num_categories)):\r\n category = categories[cat_i]\r\n if kernel_type == 'RBF':\r\n svc = svm.SVC(kernel='rbf', probability=True)\r\n elif kernel_type == 'linear':\r\n svc = svm.SVC(kernel='linear', probability=True)\r\n new_label_for_svm = np.where(train_labels == category, 1, 0)\r\n\r\n svc.fit(train_image_feats, new_label_for_svm)\r\n svc_list.append(svc)\r\n\r\n # [Desc] get test images' class using trained svm\r\n probability_list = []\r\n for cat_i in range(num_categories):\r\n svc = svc_list[cat_i]\r\n logit = svc.decision_function(test_image_feats)\r\n probability = logit\r\n probability_list.append(probability)\r\n probability_mat = np.array(probability_list)\r\n probability_mat = np.transpose(probability_mat)\r\n # [Desc] get each class to argmax each logit value.\r\n argmax_class = np.argmax(probability_mat, axis=1)\r\n\r\n return categories[argmax_class]","def SVMRegression(trainingObs,trainingParam,Obs):\n svr = SVR(C=1.0, cache_size=2000, coef0=0.0, degree=3, epsilon=0.1, gamma=0., kernel='rbf', probability=False, shrinking=True, tol=0.00001)\n nparam=trainingParam.shape[1]\n vparam = []\n for i in range(0,nparam):\n print i\n svr.fit(trainingObs,trainingParam[:,i])\n vparam.append(svr.predict(Obs))\n vparam = np.array(vparam)\n return vparam.T","def cross_validation(feature_train, help_rank_train, model_name):\n clf = svm.SVC(kernel='linear', C=1).fit(feature_train, help_rank_train)\n clf_model = open(model_name,'wb')\n dump(clf, clf_model, -1)\n return","def add_model_parameter_ui(clf_name):\n params = dict()\n if clf_name == 'KNN':\n K = st.sidebar.slider(\"K\", 1, 5)\n params[\"K\"] = K\n\n elif clf_name == 'SVM':\n C = st.sidebar.slider(\"C\", 0.01, 10.0)\n params[\"C\"] = C\n\n elif clf_name == 'Random Forest':\n max_depth = st.sidebar.slider(\"max_depth\", 2, 15)\n n_estimators = st.sidebar.slider(\"n_estimators\", 1, 100)\n params[\"max_depth\"] = max_depth\n params[\"n_estimators\"] = n_estimators\n\n else:\n pass\n\n return params","def hyperparams():\n H = 6\n return Munch(N=500, H=H, D=(H // 2) ** 2, batch_size=10, precision=to.float32)","def find_knn_hyperparams():\n n_neighbors = np.arange(5, 10)\n ps = np.arange(1, 10)\n results = []\n\n for p in ps:\n result = []\n for _ in range(10):\n data = FaceDataset(\"embeddings/known\", n=50)\n train_data, train_labels = data.train()\n test_data, test_labels = data.test()\n accs = []\n for n in n_neighbors:\n clf = KNeighborsClassifier(n_neighbors=n, weights=\"distance\", p=p)\n clf, _ = train(clf, train_data, train_labels)\n acc, _ = test(clf, test_data, test_labels)\n accs.append(acc)\n result.append(accs)\n result = np.mean(result, axis=0)\n results.append(result)\n\n plots = []\n for i in range(len(ps)):\n p = plotly.graph_objs.Scatter(x=n_neighbors, y=results[i], name=\"p={}\".format(ps[i]))\n plots.append(p)\n\n plotly.offline.plot(plots, filename=\"knn.html\")\n print(\"C={}\".format(n_neighbors[np.argmax(results)]))","def ex_2_a(x_train, y_train, x_test, y_test):\n ###########\n ## Train an SVM with a linear kernel for the given dataset\n ## and plot the decision boundary and support vectors for each using 'plot_svm_decision_boundary' function\n ###########\n\n clf = svm.SVC(kernel='linear')\n clf.fit(x_train, y_train)\n plot_svm_decision_boundary(clf, x_train, y_train, x_test, y_test)\n print(\"ex_2_a score:\", clf.score(x_test, y_test))\n\n pass","def esvm(encs_test, encs_train, C=1000):\n\n\n # set up labels\n # TODO\n encs_test=np.array(encs_test).squeeze(1)\n encs_train=np.array(encs_train).squeeze(1)\n\n label=np.ones((encs_train.shape[0]+1,1))\n label[-1,0]=-1\n label *=-1\n label=label.ravel()\n print(label.shape)\n print(label)\n def loop(i):\n # compute SVM \n # and make feature transformation\n # TODO\n svc = LinearSVC(C=C,class_weight='balanced')\n test_added=encs_test[i].reshape(1,-1)\n encs_train_new=np.concatenate((encs_train,test_added),axis=0)\n svc.fit(encs_train_new, label)\n\n return svc.coef_\n\n # let's do that in parallel: \n # if that doesn't work for you, just exchange 'parmap' with 'map'\n # Even better: use DASK arrays instead, then everything should be\n # parallelized\n new_encs = list(map( loop, tqdm(range(len(encs_test)))))\n new_encs = np.concatenate(new_encs, axis=0)\n # return new encodings\n\n return new_encs","def soft_margin_hyperplane(svc, X, y):\n assert isinstance(svc, sklearn.svm.classes.SVC)\n assert X.shape[1] == 2, 'X must be of shape (n_samples, 2)'\n x_min = X[:, 0].min()\n x_max = X[:, 0].max()\n w = svc.coef_[0]\n a = -w[0] / w[1]\n xx = np.linspace(x_min * 2, x_max * 2)\n yy = a * xx - (svc.intercept_[0]) / w[1]\n margin = 1 / np.sqrt(np.sum(svc.coef_ ** 2))\n yy_down = yy + a * margin\n yy_up = yy - a * margin\n plt.plot(xx, yy, color='DimGray', linestyle='-')\n plt.plot(xx, yy_down, color='DimGray', linestyle=':')\n plt.plot(xx, yy_up, color='DimGray', linestyle=':')","def train(self, trainingData, trainingLabels, validationData, validationLabels ):\n import sklearn\n from sklearn import svm\n\n \"*** YOUR CODE HERE ***\"\n self.sklearn_classifier = svm.SVC(C=2, gamma=0.025, decision_function_shape='ovo', tol=0.015)\n self.sklearn_classifier.fit(trainingData, trainingLabels)","def _binary_svm_head(\n label_name=None,\n weight_column_name=None,\n enable_centered_bias=False,\n head_name=None,\n thresholds=None,):\n return _BinarySvmHead(\n label_name=label_name,\n weight_column_name=weight_column_name,\n enable_centered_bias=enable_centered_bias,\n head_name=head_name,\n thresholds=thresholds)","def __call__(self, X):\n\t\t\n\t\tif (self.classifier == None):\n\t\t\t# reinit\n\t\t\tclf = svm.SVC(C = self.C, cache_size = self.cache_size, gamma = self.gamma, kernel = self.kernel,\n\t\t\t\tclass_weight = None, coef0=0.0, degree=3,\n\t\t\t\tmax_iter = -1, probability=False, random_state=None,\n\t\t\t\tshrinking = True, tol=0.001, verbose=False)\n\t\t\tclf.set_params(self.params)\n\t\t\tself.classifier = clf\n\t\t\t\n\t\tpredictions = self.classifier.predict(X)\n\t\treturn predictions","def test_svm(x, y, tune):\n if tune:\n params = {'clf__C': stats.uniform(0, 100),\n 'clf__gamma': stats.uniform(0, 1)}\n\n # Perform hyperparameter tuning on C and gamma using randomized searching\n rand_search = RandomizedSearchCV(create_pipeline(SVC()),\n n_iter=20,\n param_distributions=params,\n n_jobs=-1,\n cv=5,\n random_state=2017)\n rand_search.fit(x, y)\n print(\"best_params: {0}\".format(rand_search.best_params_))\n return rand_search.best_score_ * 100\n else:\n # Perform classification without tuning\n svc = SVC(\n gamma=0.93121875826256051,\n C=70.331975797816796\n )\n pipeline = create_pipeline(svc)\n return accuracy(pipeline, x, y)","def __init__(self,training_data):\n my_data = genfromtxt(training_data, delimiter='\\t',skip_header=0)\n n_col = my_data.shape[1]\n self.n_features=n_col-1 #assuming that the latest column\n #contains the the outputs \n #pre-processing data\n X = preprocessing.scale(np.hsplit(my_data,[self.n_features,n_col])[0])\n Y = np.squeeze(np.asarray(np.hsplit(my_data,[self.n_features,n_col])[1]))\n #defining scaling\n self.scaler = preprocessing.Scaler()\n self.scaler.fit(np.hsplit(my_data,[self.n_features,n_col])[0])\n #define classifier\n self.classifier = svm.SVR(kernel='linear', C=1e3, cache_size=DEFAULT_CACHE_SIZE)\n #self.classifier = svm.SVR(kernel='rbf', C=1e3, gamma=0.1, cache_size=DEFAULT_CACHE_SIZE)\n self.classifier.fit(X, Y)","def set_hyperparams(self, params):","def losd_cnn_svm_model(num_class=8, num_flow_channel=10, cnn_svm_model_id=1, feature_pool='max', device=torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")):\n# feature_dimension = 2048 # change this according to which layer's feature you want\n num_gpu_device = torch.cuda.device_count()\n\n # load spatial cnn net\n input_spatial_cnn_model_file = ''.join(['model/cnn_net/spatial_lucid_08_split_no_', str(cnn_svm_model_id).zfill(2), '_nfch_10_nepochs_500_lr_0.0005_ss_model_best.pth.tar'])\n print('loading spatial cnn trained model from: {}' .format(input_spatial_cnn_model_file))\n spatial_cnn_model = load_resnet_cnn_net_model(input_spatial_cnn_model_file, num_class=num_class, num_channel=3, device=device)\n print('----------------------------------------------------------------------------------------')\n\n # load motion cnn net\n input_motion_cnn_model_file = ''.join(['model/cnn_net/motion_lucid_08_split_no_', str(cnn_svm_model_id).zfill(2), '_nfch_10_nepochs_500_lr_0.01_ss_model_best.pth.tar'])\n print('loading motion cnn trained model from: {}' .format(input_motion_cnn_model_file))\n motion_cnn_model = load_resnet_cnn_net_model(input_motion_cnn_model_file, num_class=num_class, num_channel=2*num_flow_channel, device=device)\n print('----------------------------------------------------------------------------------------')\n\n # for svm model\n input_spatial_motion_svm_model_path = ''.join(['model/svm/spatial_motion_lucid_08_split_no_', str(cnn_svm_model_id).zfill(2), '_nfch_10_nepochs_500_slr_0.0005_mlr_0.01_network_resnet101_', str(feature_pool), '_pooling_thundersvm_1v1/'])\n input_spatial_motion_svm_model_file = ''.join([input_spatial_motion_svm_model_path, 'best_model_basedon_train_val_data_nclass_12_kernel_linear_int_c_0.1_max_c_1000.0_num_div_c_46_int_g_0.1_max_g_1.0_num_div_g_10'])\n print('loading spatial and motion net svm model from: \"{}\"' .format(input_spatial_motion_svm_model_file))\n spatial_motion_svm_model = thundersvm_load_svm_model(input_spatial_motion_svm_model_file)\n print('----------------------------------------------------------------------------------------')\n \n # model paralization (if you have multiple gpus)\n print('model will use \"{}\" GPUs' .format(num_gpu_device))\n if num_gpu_device > 1:\n spatial_cnn_model = nn.DataParallel(spatial_cnn_model)\n motion_cnn_model = nn.DataParallel(motion_cnn_model)\n \n return spatial_cnn_model, motion_cnn_model, spatial_motion_svm_model","def build_model():\n pipeline = Pipeline(\n [\n (\"vect\", CountVectorizer(tokenizer=tokenize)),\n (\"tfidf\", TfidfTransformer()),\n (\"clf\", MultiOutputClassifier(LinearSVC(dual=False))),\n ]\n )\n\n # use grid search to optimize the pipeline parameters\n parameters = {\"tfidf__use_idf\": (True, False), \"clf__estimator__C\": [1, 100]}\n cv = GridSearchCV(pipeline, param_grid=parameters)\n\n return cv","def CalculateSVM(data=None):\n vectorizer = TfidfVectorizer(tokenizer=pre_process)\n classifier = LinearSVC()\n train, test = train_test_split([(i['text'], i['stars']) for i in data],\n test_size=.2,\n random_state=10)\n x_train = vectorizer.fit_transform(i[0] for i in train)\n x_test = vectorizer.transform(i[0] for i in test)\n classifier.fit(x_train, [i[1] for i in train])\n score = classifier.score(x_test, [i[1] for i in test])\n print score","def train_all(self, dataset, mu=None):\n\n\t\tX = dataset.X #get_design_matrix()\n\t\ty = dataset.y\n\n\t\tclf = svm.SVC(C = self.C, cache_size = self.cache_size, gamma = self.gamma, kernel = self.kernel,\n\t\t\t\tclass_weight = None, coef0=0.0, degree=3,\n\t\t\t\tmax_iter = -1, probability=False, random_state=None,\n\t\t\t\tshrinking = True, tol=0.001, verbose=False)\n\t\tclf.fit (X, y)\n\t\t\n\t\t# save the last classifier\n\t\tself.classifier = clf\n\n\t\t# get model parameter\n\t\tself.alpha = clf.dual_coef_\n\t\tself.bias = clf.intercept_\n\t\t# TODO\n\t\tself.params = clf.get_params (deep=True)\n\n\n\t\t#TODO:self.mu = sharedX(mu)?\n\t\tself._params = [self.alpha, self.bias]\n\t\tprint(self._params)","def hyper(self, input):\n return","def clf_svm(vector_col:str,\n df_train:pd.DataFrame,\n model:LinearSVC,\n return_ranking=False) -> list:\n\n if return_ranking: return list(model.decision_function(df_train[vector_col].to_list()))\n \n return list(model.predict(df_train[vector_col].to_list()))","def cv_lsvm(x_data, y_data, n_class, n_feats):\n\n # Do standard scaling to all data (should do train and project unto test)\n #sample_scaler = StandardScaler()\n #x_scaled = sample_scaler.fit_transform(x_data)\n\n # Grid search CV to search for optimal model parameter C\n #C_range = np.logspace(-2, 10, 13)\n C_range = np.logspace(-2, 10, 5)\n param_grid = dict(C = C_range)\n cv = StratifiedShuffleSplit(y_data, n_iter = 3, test_size = 0.2, random_state = 0)\n grid = GridSearchCV(SVC(kernel = \"linear\"), param_grid = param_grid, cv = cv)\n grid.fit(x_data, y_data)\n\n return grid"],"string":"[\n \"def find_svm_hyperparams():\\n NUM_ITERS = 10\\n # coefs = np.arange(-5, 5).astype(np.float)\\n coefs = np.linspace(0.25, 1, 10)\\n Cs = np.power(2, coefs)\\n results = []\\n\\n for _ in range(NUM_ITERS):\\n data = FaceDataset(\\\"embeddings/dev\\\", n=50)\\n train_data, train_labels = data.train()\\n test_data, test_labels = data.test()\\n accs = []\\n for c in tqdm(Cs):\\n clf = svm.SVC(kernel=\\\"linear\\\", C=c)\\n clf, _ = train(clf, train_data, train_labels)\\n acc, _ = test(clf, test_data, test_labels)\\n accs.append(acc)\\n results.append(accs)\\n\\n results = np.mean(results, axis=0)\\n s = plotly.graph_objs.Scatter(x=Cs, y=results)\\n plotly.offline.plot([s], filename=\\\"svm_linear.html\\\")\\n print(\\\"C={}\\\".format(Cs[np.argmax(results)]))\",\n \"def find_linear_svm_hyperparams():\\n NUM_ITERS = 10\\n # coefs = np.arange(-5, 5).astype(np.float)\\n coefs = np.linspace(0.25, 1, 10)\\n Cs = np.power(2, coefs)\\n results = []\\n\\n for _ in range(NUM_ITERS):\\n data = FaceDataset(\\\"embeddings/dev\\\", n=50)\\n train_data, train_labels = data.train()\\n test_data, test_labels = data.test()\\n accs = []\\n for c in tqdm(Cs):\\n clf = svm.SVC(kernel=\\\"linear\\\", C=c)\\n clf, _ = train(clf, train_data, train_labels)\\n acc, _ = test(clf, test_data, test_labels)\\n accs.append(acc)\\n results.append(accs)\\n\\n results = np.mean(results, axis=0)\\n s = plotly.graph_objs.Scatter(x=Cs, y=results)\\n plotly.offline.plot([s], filename=\\\"svm_linear.html\\\")\\n print(\\\"C={}\\\".format(Cs[np.argmax(results)]))\",\n \"def svm():\",\n \"def svc_model(params):\\n\\n if (params['random']):\\n params['C'] = random.randrange(1, 13, step=1) * 0.1\\n params['degree'] = random.choice([2, 3, 4, 5])\\n params['kernel'] = random.choice(['linear', 'rbf', 'poly', 'sigmoid'])\\n \\n model = svm.SVC(\\n decision_function_shape='ovo',\\n C=params['C'],\\n degree=params['degree'],\\n kernel=params['kernel']\\n )\\n\\n return model\",\n \"def __init__(self, kernel='poly', degree=3, verbose=False, gamma='auto', reg=1/1000, random_state=0):\\n print(\\\"Initialize model SVM\\\")\\n # Check if gamma='auto' is useful\\n self.kernel = kernel\\n self.random_state = random_state\\n self.model = SVC(gamma=gamma, kernel=kernel, degree=degree, verbose=verbose, C=reg, random_state=random_state)\",\n \"def train_model(kernel, label):\\n clf = svm.SVC(kernel='precomputed')\\n clf.fit(kernel,label)\\n return clf\",\n \"def modelKSVM():\\n\\n list_kernel_type = ['linear', 'poly', 'rbf']\\n random_state = 20 # Do not change this random_state\\n\\n objs_KSVM = []\\n\\n # Create a list of objects for the classifier for each of the above \\\"kernel\\\" types\\n for kernel in list_kernel_type:\\n svm = SVC(kernel=kernel, random_state=random_state)\\n objs_KSVM.append(svm)\\n\\n return objs_KSVM\",\n \"def svr_kernel(name, kernel, epsilon=None, **kwargs):\\n def _name(msg):\\n return '%s.%s_%s' % (name, kernel, msg)\\n\\n hp_space = _svm_hp_space(_name, kernel=kernel, **kwargs)\\n hp_space.update(_svr_hp_space(_name, epsilon))\\n return scope.sklearn_SVR(**hp_space)\",\n \"def SVM():\\n x1, x2 = generate_training_data_2D()\\n Y = np.concatenate([np.zeros(x1.shape[0], dtype=np.int32),\\n np.ones(x2.shape[0], dtype=np.int32)])\\n X = np.concatenate([x1, x2], axis=0)\\n rng = np.random.get_state()\\n np.random.shuffle(X)\\n # Set the random state back to previous to shuffle X & Y similarly\\n np.random.set_state(rng)\\n np.random.shuffle(Y)\\n\\n models, titles = get_fitted_svm(X, Y)\\n\\n plot_decision_boundary(X, Y, models, titles)\",\n \"def SVM(x_train, x_test, y_train, kernel):\\n svc_model = SVC(kernel=kernel)\\n svc_model.fit(x_train, y_train)\\n y_pred = svc_model.predict(x_test)\\n return y_pred\",\n \"def train_svm(data, labels, kernel, C, gamma, degree, coef0):\\n if kernel == 'linear':\\n model = SVC(kernel=kernel, C=C)\\n elif kernel == 'poly':\\n model = SVC(kernel=kernel, C=C, degree=degree, coef0=coef0)\\n elif kernel == 'rbf':\\n model = SVC(kernel=kernel, C=C, gamma=gamma)\\n else:\\n raise ArgumentError(\\\"Unknown kernel function: %s\\\" % kernel)\\n model.fit(data, labels)\\n return model\",\n \"def convert(context, cm_node, inputs, outputs):\\n kernel_enum = {'linearKernel': 'LINEAR', 'polyKernel': 'POLY',\\n 'rbfKernel': 'RBF', 'sigmoidKernel': 'SIGMOID', 'precomputedKernel': 'PRECOMPUTED'}\\n kernel = cm_node.supportVectorClassifier.kernel\\n kernel_val = kernel.WhichOneof('kernel')\\n svc_kernel = kernel_enum[kernel_val]\\n\\n if kernel_val == 'rbfKernel':\\n svc_kernel_params = [kernel.rbfKernel.gamma, 0.0, 0.0]\\n elif kernel_val == 'polyKernel':\\n svc_kernel_params = [kernel.polyKernel.gamma,\\n kernel.polyKernel.coef0, kernel.polyKernel.degree]\\n elif kernel_val == 'sigmoidKernel':\\n svc_kernel_params = [kernel.sigmoidKernel.gamma,\\n kernel.sigmoidKernel.coef0, 0.0]\\n elif kernel_val == 'linearKernel':\\n svc_kernel_params = [0.0, 0.0, 0.0]\\n\\n prob_a = cm_node.supportVectorClassifier.probA\\n prob_b = cm_node.supportVectorClassifier.probB\\n svc_vectors_per_class = cm_node.supportVectorClassifier.numberOfSupportVectorsPerClass\\n n_supports, svc_support_vectors = extract_support_vectors_as_dense_tensor(cm_node.supportVectorClassifier)\\n chain_coef = list(itertools.chain.from_iterable(\\n [coef.alpha for coef in cm_node.supportVectorClassifier.coefficients]))\\n svc_coefficients = chain_coef\\n svc_rho = [-x for x in cm_node.supportVectorClassifier.rho]\\n\\n nb = NodeBuilder(context, 'SVMClassifier', op_domain='ai.onnx.ml')\\n nb.add_attribute('kernel_type', svc_kernel)\\n nb.add_attribute('kernel_params', svc_kernel_params)\\n if prob_a:\\n nb.add_attribute('prob_a', prob_a)\\n if prob_b:\\n nb.add_attribute('prob_b', prob_b)\\n nb.add_attribute('vectors_per_class', svc_vectors_per_class)\\n nb.add_attribute('support_vectors', svc_support_vectors)\\n nb.add_attribute('coefficients', svc_coefficients)\\n nb.add_attribute('rho', svc_rho)\\n svc_classes = cm_node.supportVectorClassifier.WhichOneof('ClassLabels')\\n if svc_classes == 'int64ClassLabels':\\n class_labels = list(int(i) for i in cm_node.supportVectorClassifier.int64ClassLabels.vector)\\n nb.add_attribute('classlabels_ints', class_labels)\\n elif svc_classes == 'stringClassLabels':\\n class_labels = list(str(s) for s in cm_node.supportVectorClassifier.stringClassLabels.vector)\\n nb.add_attribute('classlabels_strings', class_labels)\\n\\n nb.extend_inputs(inputs)\\n\\n # Find the ONNX name for the predicted label in CoreML\\n predicted_label_name = context.get_onnx_name(cm_node.description.predictedFeatureName)\\n nb.add_output(predicted_label_name)\\n\\n # The variable used to store the class probabilities produced by ONNX linear classifier\\n probability_tensor_name = context.get_unique_name('probability_tensor')\\n nb.add_output(probability_tensor_name)\\n\\n nodes = [nb.make_node()]\\n\\n if cm_node.description.predictedProbabilitiesName != '':\\n # Find the corresponding ONNX name for CoreML's probability output (a dictionary)\\n predicted_probability_name = context.get_onnx_name(cm_node.description.predictedProbabilitiesName)\\n # Create a ZipMap to connect probability tensor and probability dictionary\\n nodes.append(model_util.make_zipmap_node(context, probability_tensor_name,\\n predicted_probability_name, class_labels))\\n\\n return nodes\",\n \"def __init__(self):\\n self.svclassifier = SVC(kernel='linear')\",\n \"def __init__(self, train_x, train_y, test_x, test_y, Tunning_Cs=[0.001, 0.01, 0.1, 1, 10]): \\n self.Cs = Tunning_Cs\\n self.train_x = train_x\\n self.train_y = train_y\\n self.test_x = test_x \\n self.test_y = test_y\\n self.model = svm.SVR(kernel='rbf', gamma='auto')\",\n \"def svmtrain(x,y,w=None):\\n # xl = x.tolist() \\n # yl = y.tolist()\\n clf = svm.SVC(kernel='linear', C=1000) # apparently C param here really matters\\n clf.fit(x,y)\\n return({'w':clf.coef_, 'b':clf.intercept_,'clf':clf, 'n_support':clf.support_vectors_.shape[0]})\",\n \"def classical_kernel_estimation(in_train, in_test, labels):\\n X_train = []\\n Y_train = []\\n X_test = []\\n Y_test = []\\n for lab in labels:\\n for datum in in_train[lab]:\\n X_train.append(datum)\\n Y_train.append(lab)\\n for datum in in_test[lab]:\\n X_test.append(datum)\\n Y_test.append(lab)\\n clf = svm.SVC(gamma='auto')\\n clf.fit(X_train, Y_train)\\n print(clf.score(X_test, Y_test))\",\n \"def train_svm(X, y):\\n svm = SVC(C=1000000.0, gamma=0.0, kernel='rbf')\\n svm.fit(X, y)\\n return svm\",\n \"def svm_clf_training(max_features, data):\\r\\n X_train, y_train, X_test, y_test = data\\r\\n clf = Pipeline([('feature_selection', SelectKBest(score_func=chi2, k=max_features)),\\r\\n ('clf', svm.SVC(C=1., kernel='linear'))])\\r\\n\\r\\n vectorizer = CountVectorizer(ngram_range=(1, 2), lowercase=True) # unigrams and bigrams\\r\\n X_matrix_tr = vectorizer.fit_transform(X_train)\\r\\n # parameters = [{'clf__kernel': ['linear'], 'clf__C': [0.1, 1, 10, 100]},\\r\\n # {'clf__kernel': ['rbf'], 'clf__C': [0.1, 1, 10, 100], 'clf__gamma': [0.001, 0.01, 0.1]},\\r\\n # {'clf__kernel': ['poly'], 'clf__C': [0.1, 1, 10, 100], 'clf__degree': [2, 3, 4, 5]}]\\r\\n # clf = GridSearchCV(svc, parameters, scoring='accuracy')\\r\\n clf.fit(X_matrix_tr, y_train)\\r\\n # print(\\\"Best parameters set found on development set:\\\")\\r\\n # print()\\r\\n # print(clf.best_estimator_)\\r\\n # print()\\r\\n # print(\\\"Grid scores on development set:\\\")\\r\\n # print()\\r\\n # for params, mean_score, scores in clf.grid_scores_:\\r\\n # print(\\\"%0.3f (+/-%0.03f) for %r\\\"\\r\\n # % (mean_score, scores.std() / 2, params))\\r\\n # print()\\r\\n voc = vectorizer.get_feature_names()\\r\\n # vectorizer1 = CountVectorizer(ngram_range=(1, 2), lowercase=True, vocabulary=voc)\\r\\n # X_matrix_val = vectorizer1.fit_transform(X_test)\\r\\n # y_pred = clf.predict(X_matrix_val)\\r\\n\\r\\n # for i in range(len(X_test)):\\r\\n # if y_test[i] != y_pred[i]:\\r\\n # print(X_test[i], y_test[i], y_pred[i])\\r\\n # print(classification_report(y_test, y_pred))\\r\\n return clf, voc\",\n \"def __init__(self,training_data,default_kernel=\\\"rbf\\\"):\\n my_data = genfromtxt(training_data, delimiter='\\\\t',skip_header=0)\\n n_col = my_data.shape[1]\\n n_features=n_col-1 #assuming that the latest column\\n #contains the the outputs \\n #preprocessing data\\n X = preprocessing.scale(np.hsplit(my_data,[n_features,n_col])[0])\\n Y = np.squeeze(np.asarray(np.hsplit(my_data,[n_features,n_col])[1]))\\n #defining scaling\\n self.scaler = preprocessing.Scaler()\\n self.scaler.fit(np.hsplit(my_data,[n_features,n_col])[0])\\n #define classifier\\n self.classifier = svm.SVC(class_weight='auto',cache_size=DEFAULT_CACHE_SIZE, kernel=default_kernel)\\n self.classifier.fit(X, Y)\",\n \"def __init__(self, **kwargs):\\n super(SVM, self).__init__()\\n\\n # initialize some default values for the SVM backend\\n self.max_iter = kwargs.pop('max_iter', 1e6)\\n\\n # parameters for k cross validation / hyper-parameter tuning\\n self.params = [{\\n 'kernel': ['rbf', 'sigmoid', 'poly'],\\n 'C': [1e1, 1e2, 1e3, 1e4],\\n 'gamma': [1e4, 1e3, 1e2, 1, 1e-1, 1e-2],\\n 'degree': [2,3,4]}]\\n self.k_cross_val = kwargs.pop('k_cross_val', 5)\\n\\n # initialize the classifier using grid search to find optimal parameters\\n # via cross validation\\n if kwargs.pop('cross_validation', True):\\n self.clf = GridSearchCV(_SVC(max_iter=self.max_iter, **kwargs),\\n self.params,\\n cv=self.k_cross_val)\\n else:\\n probability = kwargs.pop('probability', True)\\n self.clf = _SVC(max_iter=self.max_iter, probability=probability, **kwargs)\",\n \"def build_svm_pipeline():\\n svm_pipeline = None\\n\\n svm_pipeline = Pipeline([\\n ('vect', CountVectorizer()),\\n ('clf', SGDClassifier()),\\n ])\\n\\n return svm_pipeline\",\n \"def select_hyperparams(\\n df,\\n kfold_params,\\n tfidf_path,\\n model_path,\\n code_col,\\n target_col,\\n n_trials,\\n hyperparam_space,\\n default_hyperparams,\\n):\\n\\n study = optuna.create_study(direction=\\\"maximize\\\", study_name=\\\"svm with kernels\\\")\\n objective = Objective(df, kfold_params, code_col, target_col, **hyperparam_space)\\n\\n if n_trials > 0:\\n study.optimize(objective, n_trials=n_trials)\\n params = study.best_params\\n else:\\n params = default_hyperparams\\n\\n best_tfidf_params = {\\n \\\"smooth_idf\\\": True,\\n }\\n best_svm_params = {\\n \\\"random_state\\\": RANDOM_STATE,\\n \\\"max_iter\\\": MAX_ITER,\\n }\\n for key, value in params.items():\\n model_name, param_name = key.split(\\\"__\\\")\\n if model_name == \\\"tfidf\\\":\\n best_tfidf_params[param_name] = value\\n elif model_name == \\\"svm\\\":\\n best_svm_params[param_name] = value\\n\\n code_blocks_tfidf = tfidf_fit_transform(df[code_col], best_tfidf_params, tfidf_path)\\n X, y = code_blocks_tfidf, df[target_col].values\\n clf = SVC(**best_svm_params)\\n\\n f1_mean, f1_std, accuracy_mean, accuracy_std, preds = cross_val_predict(\\n objective.kf, clf, X, y\\n )\\n if model_path is not None:\\n clf.fit(X, y)\\n pickle.dump(clf, open(model_path, \\\"wb\\\"))\\n\\n metrics = dict(\\n test_f1_score=f1_mean,\\n test_accuracy=accuracy_mean,\\n test_f1_std=f1_std,\\n test_accuracy_std=accuracy_std,\\n )\\n\\n return best_tfidf_params, best_svm_params, metrics, preds\",\n \"def spkernel(*args,\\n node_label='atom',\\n edge_weight=None,\\n node_kernels=None,\\n n_jobs=None,\\n verbose=True):\\n # pre-process\\n Gn = args[0] if len(args) == 1 else [args[0], args[1]]\\n Gn = [g.copy() for g in Gn]\\n weight = None\\n if edge_weight is None:\\n if verbose:\\n print('\\\\n None edge weight specified. Set all weight to 1.\\\\n')\\n else:\\n try:\\n some_weight = list(\\n nx.get_edge_attributes(Gn[0], edge_weight).values())[0]\\n if isinstance(some_weight, (float, int)):\\n weight = edge_weight\\n else:\\n if verbose:\\n print(\\n '\\\\n Edge weight with name %s is not float or integer. Set all weight to 1.\\\\n'\\n % edge_weight)\\n except:\\n if verbose:\\n print(\\n '\\\\n Edge weight with name \\\"%s\\\" is not found in the edge attributes. Set all weight to 1.\\\\n'\\n % edge_weight)\\n ds_attrs = get_dataset_attributes(\\n Gn,\\n attr_names=['node_labeled', 'node_attr_dim', 'is_directed'],\\n node_label=node_label)\\n\\n # remove graphs with no edges, as no sp can be found in their structures, \\n # so the kernel between such a graph and itself will be zero.\\n len_gn = len(Gn)\\n Gn = [(idx, G) for idx, G in enumerate(Gn) if nx.number_of_edges(G) != 0]\\n idx = [G[0] for G in Gn]\\n Gn = [G[1] for G in Gn]\\n if len(Gn) != len_gn:\\n if verbose:\\n print('\\\\n %d graphs are removed as they don\\\\'t contain edges.\\\\n' %\\n (len_gn - len(Gn)))\\n\\n start_time = time.time()\\n\\n pool = Pool(n_jobs)\\n # get shortest path graphs of Gn\\n getsp_partial = partial(wrapper_getSPGraph, weight)\\n itr = zip(Gn, range(0, len(Gn)))\\n if len(Gn) < 100 * n_jobs:\\n# # use default chunksize as pool.map when iterable is less than 100\\n# chunksize, extra = divmod(len(Gn), n_jobs * 4)\\n# if extra:\\n# chunksize += 1\\n chunksize = int(len(Gn) / n_jobs) + 1\\n else:\\n chunksize = 100\\n if verbose:\\n iterator = tqdm(pool.imap_unordered(getsp_partial, itr, chunksize),\\n desc='getting sp graphs', file=sys.stdout)\\n else:\\n iterator = pool.imap_unordered(getsp_partial, itr, chunksize)\\n for i, g in iterator:\\n Gn[i] = g\\n pool.close()\\n pool.join()\\n \\n# # ---- direct running, normally use single CPU core. ----\\n# for i in tqdm(range(len(Gn)), desc='getting sp graphs', file=sys.stdout):\\n# i, Gn[i] = wrapper_getSPGraph(weight, (Gn[i], i))\\n\\n # # ---- use pool.map to parallel ----\\n # result_sp = pool.map(getsp_partial, range(0, len(Gn)))\\n # for i in result_sp:\\n # Gn[i[0]] = i[1]\\n # or\\n # getsp_partial = partial(wrap_getSPGraph, Gn, weight)\\n # for i, g in tqdm(\\n # pool.map(getsp_partial, range(0, len(Gn))),\\n # desc='getting sp graphs',\\n # file=sys.stdout):\\n # Gn[i] = g\\n\\n # # ---- only for the Fast Computation of Shortest Path Kernel (FCSP)\\n # sp_ml = [0] * len(Gn) # shortest path matrices\\n # for i in result_sp:\\n # sp_ml[i[0]] = i[1]\\n # edge_x_g = [[] for i in range(len(sp_ml))]\\n # edge_y_g = [[] for i in range(len(sp_ml))]\\n # edge_w_g = [[] for i in range(len(sp_ml))]\\n # for idx, item in enumerate(sp_ml):\\n # for i1 in range(len(item)):\\n # for i2 in range(i1 + 1, len(item)):\\n # if item[i1, i2] != np.inf:\\n # edge_x_g[idx].append(i1)\\n # edge_y_g[idx].append(i2)\\n # edge_w_g[idx].append(item[i1, i2])\\n # print(len(edge_x_g[0]))\\n # print(len(edge_y_g[0]))\\n # print(len(edge_w_g[0]))\\n\\n Kmatrix = np.zeros((len(Gn), len(Gn)))\\n\\n # ---- use pool.imap_unordered to parallel and track progress. ----\\n def init_worker(gn_toshare):\\n global G_gn\\n G_gn = gn_toshare\\n do_partial = partial(wrapper_sp_do, ds_attrs, node_label, node_kernels) \\n parallel_gm(do_partial, Kmatrix, Gn, init_worker=init_worker, \\n glbv=(Gn,), n_jobs=n_jobs, verbose=verbose)\\n\\n\\n # # ---- use pool.map to parallel. ----\\n # # result_perf = pool.map(do_partial, itr)\\n # do_partial = partial(spkernel_do, Gn, ds_attrs, node_label, node_kernels)\\n # itr = combinations_with_replacement(range(0, len(Gn)), 2)\\n # for i, j, kernel in tqdm(\\n # pool.map(do_partial, itr), desc='calculating kernels',\\n # file=sys.stdout):\\n # Kmatrix[i][j] = kernel\\n # Kmatrix[j][i] = kernel\\n # pool.close()\\n # pool.join()\\n\\n # # ---- use joblib.Parallel to parallel and track progress. ----\\n # result_perf = Parallel(\\n # n_jobs=n_jobs, verbose=10)(\\n # delayed(do_partial)(ij)\\n # for ij in combinations_with_replacement(range(0, len(Gn)), 2))\\n # result_perf = [\\n # do_partial(ij)\\n # for ij in combinations_with_replacement(range(0, len(Gn)), 2)\\n # ]\\n # for i in result_perf:\\n # Kmatrix[i[0]][i[1]] = i[2]\\n # Kmatrix[i[1]][i[0]] = i[2]\\n\\n# # ---- direct running, normally use single CPU core. ----\\n# from itertools import combinations_with_replacement\\n# itr = combinations_with_replacement(range(0, len(Gn)), 2)\\n# for i, j in tqdm(itr, desc='calculating kernels', file=sys.stdout):\\n# kernel = spkernel_do(Gn[i], Gn[j], ds_attrs, node_label, node_kernels)\\n# Kmatrix[i][j] = kernel\\n# Kmatrix[j][i] = kernel\\n\\n run_time = time.time() - start_time\\n if verbose:\\n print(\\n \\\"\\\\n --- shortest path kernel matrix of size %d built in %s seconds ---\\\"\\n % (len(Gn), run_time))\\n\\n return Kmatrix, run_time, idx\",\n \"def ex_1_a(x, y):\\n ###########\\n ## Train an SVM with a linear kernel\\n ## and plot the decision boundary and support vectors using 'plot_svm_decision_boundary' function\\n ###########\\n\\n clf = svm.SVC(kernel='linear')\\n clf.fit(x, y)\\n plot_svm_decision_boundary(clf, x, y)\\n pass\",\n \"def ex_2_c(x_train, y_train, x_test, y_test):\\n ###########\\n ## TODO:\\n ## Train SVMs with RBF kernels for different values of the gamma\\n ## and plot the variation of the test and training scores with gamma using 'plot_score_vs_gamma' function.\\n ## Plot the decision boundary and support vectors for the best value of gamma\\n ## using 'plot_svm_decision_boundary' function\\n ###########\\n gammas = np.arange(0.01, 2, 0.02)\\n\\n test_scores = np.array([])\\n train_scores = np.array([])\\n best_svm = None\\n best_test_score = 0\\n\\n for gamma in gammas:\\n clf = svm.SVC(kernel='rbf', gamma=gamma)\\n clf.fit(x_train, y_train)\\n\\n test_score = clf.score(x_test, y_test)\\n\\n if test_score > best_test_score:\\n best_test_score = test_score\\n best_svm = clf\\n\\n test_scores = np.append(test_scores, test_score)\\n train_scores = np.append(train_scores, clf.score(x_train, y_train))\\n\\n plot_score_vs_gamma(train_scores, test_scores, gammas)\\n\\n plot_svm_decision_boundary(clf, x_train, y_train, x_test, y_test)\",\n \"def ex_2_b(x_train, y_train, x_test, y_test):\\n ###########\\n ## TODO:\\n ## Train SVMs with polynomial kernels for different values of the degree\\n ## (Remember to set the 'coef0' parameter to 1)\\n ## and plot the variation of the training and test scores with polynomial degree using 'plot_score_vs_degree' func.\\n ## Plot the decision boundary and support vectors for the best value of degree\\n ## using 'plot_svm_decision_boundary' function\\n ###########\\n degrees = range(1, 21)\\n\\n test_scores = np.array([])\\n train_scores = np.array([])\\n best_svm = None\\n best_test_score = 0\\n\\n for deg in degrees:\\n clf = svm.SVC(kernel='poly', degree=deg, coef0=1)\\n clf.fit(x_train, y_train)\\n\\n test_score = clf.score(x_test, y_test)\\n\\n if test_score > best_test_score:\\n best_test_score = test_score\\n best_svm = clf\\n\\n test_scores = np.append(test_scores, test_score)\\n train_scores = np.append(train_scores, clf.score(x_train, y_train))\\n\\n plot_score_vs_degree(train_scores, test_scores, degrees)\\n\\n plot_svm_decision_boundary(clf, x_train, y_train, x_test, y_test)\",\n \"def svm_model_fn(features, labels, mode, params):\\n\\n feature_columns = [layers.real_valued_column(i) for i in features.keys()]\\n example_id_column(features)\\n\\n weight_column_name = params.get(\\\"weight_column_name\\\")\\n\\n head = head_lib.binary_svm_head(\\n weight_column_name=weight_column_name,\\n enable_centered_bias=False)\\n\\n optimizer = sdca_optimizer.SDCAOptimizer(\\n example_id_column=\\\"index\\\",\\n num_loss_partitions=params[\\\"num_loss_partitions\\\"],\\n symmetric_l1_regularization=params[\\\"l1_regularization\\\"],\\n symmetric_l2_regularization=params[\\\"l2_regularization\\\"])\\n\\n chief_hook = linear._SdcaUpdateWeightsHook()\\n update_weights_hook = chief_hook\\n\\n if not isinstance(optimizer, sdca_optimizer.SDCAOptimizer):\\n raise ValueError(\\\"Optimizer must be of type SDCAOptimizer\\\")\\n\\n if isinstance(head,\\n head_lib._BinarySvmHead): # pylint: disable=protected-access\\n loss_type = \\\"hinge_loss\\\"\\n elif isinstance(head,\\n head_lib._BinaryLogisticHead): # pylint:\\n # disable=protected-access\\n loss_type = \\\"logistic_loss\\\"\\n elif isinstance(head,\\n head_lib._RegressionHead): # pylint:\\n # disable=protected-access\\n assert head.logits_dimension == 1, (\\\"SDCA only applies for \\\"\\n \\\"logits_dimension=1.\\\")\\n loss_type = \\\"squared_loss\\\"\\n else:\\n raise ValueError(\\\"Unsupported head type: {}\\\".format(head))\\n\\n parent_scope = \\\"linear\\\"\\n\\n with variable_scope.variable_op_scope(\\n features.values(), parent_scope) as scope:\\n features = features.copy()\\n features.update(layers.transform_features(features, feature_columns))\\n logits, columns_to_variables, bias = (\\n layers.weighted_sum_from_feature_columns(\\n columns_to_tensors=features,\\n feature_columns=feature_columns,\\n num_outputs=1,\\n scope=scope))\\n\\n linear._add_bias_column(feature_columns, features, bias,\\n columns_to_variables)\\n\\n def _train_op_fn(unused_loss):\\n global_step = contrib_variables.get_global_step()\\n sdca_model, train_op = optimizer.get_train_step(columns_to_variables,\\n weight_column_name,\\n loss_type, features,\\n labels, global_step)\\n if update_weights_hook is not None:\\n update_weights_hook.set_parameters(sdca_model, train_op)\\n return train_op\\n\\n model_fn_ops = head.create_model_fn_ops(\\n features=features,\\n labels=labels,\\n mode=mode,\\n train_op_fn=_train_op_fn,\\n logits=logits)\\n if update_weights_hook is not None:\\n return model_fn_ops._replace(\\n training_chief_hooks=(model_fn_ops.training_chief_hooks +\\n [update_weights_hook]))\\n return model_fn_ops\",\n \"def get_hyperparams(self):\",\n \"def custom_training(nb_tweet_sample, randomised, equal_pos_neg, language, name_kernel, Resource, keep_null_vector):\\n m_features, m_labels = get_characteristic_label_vectors(nb_tweet_sample, randomised, equal_pos_neg, Resource,\\n keep_null_vector, language)\\n\\n kernel = Kernel.get_correct_kernel(name_kernel)\\n custom_SVM = SVM(kernel)\\n custom_SVM.fit(m_features, m_labels)\\n\\n return custom_SVM\",\n \"def __init__(self, foundVariables, trainingData, trainingClasses, trainingWeights, testingData, testingClasses):\\n self.clf = svm.SVC(probability=True)\\n self.foundVariables = foundVariables\\n self.trainingData = trainingData\\n self.trainingClasses = trainingClasses\\n self.testingData = testingData\\n self.testingClasses = testingClasses\\n self.trainingWeights = trainingWeights\",\n \"def ex_1_a(x, y):\\n ###########\\n ## TODO:\\n ## Train an SVM with a linear kernel\\n ## and plot the decision boundary and support vectors using 'plot_svm_decision_boundary' function\\n ###########\\n\\n clf = svm.SVC(kernel='linear')\\n clf.fit(x, y)\\n\\n plot_svm_decision_boundary(clf, x, y)\",\n \"def _find_svm_rbf_params(df, metrics, kernel):\\n context = ramp.DataContext(data=df)\\n config = ramp.Configuration(target=\\\"target\\\",\\n features=[ramp.BaseFeature(x) for x in metrics])\\n x, y = ramp.models.get_xy(config, context)\\n\\n if kernel == \\\"linear\\\":\\n param_grid = dict(C=10.0 ** np.arange(-2, 5))\\n else:\\n param_grid = dict(gamma=10.0 ** np.arange(-5, 4),\\n C=10.0 ** np.arange(-2, 9))\\n grid = sklearn.grid_search.GridSearchCV(sklearn.svm.SVC(kernel=kernel),\\n param_grid=param_grid,\\n cv=sklearn.cross_validation.StratifiedKFold(y=y, k=3),\\n verbose=True)\\n grid.fit(x, y)\\n print grid.best_estimator_\\n out = {}\\n for attr in param_grid.keys():\\n out[attr] = getattr(grid.best_estimator_, attr)\\n return out\",\n \"def train(self, prob: SvmProblem):\\n # Define variables\\n self.prob = prob\\n c = prob.C\\n c2 = prob.gamma\\n xkern = prob.xkernel\\n xsk = prob.xskernel\\n\\n # Swap params, so SVM solves X* with correct params\\n prob.C = c2\\n prob.xkernel = xsk\\n\\n # Find SVM solution in X*\\n svm = SVM()\\n priv_clf = svm.train(prob.Xstar, prob)\\n\\n # Replace swapped out params so modified SVM solves X with correct params\\n prob.C = c\\n prob.xkernel = xkern\\n\\n # Get the 'frames of knowledge' - Get the kernel distance from each\\n # privileged training data-point to the privileged support vectors\\n frames = np.zeros((prob.num, len(priv_clf.support_vectors)))\\n for i in range(prob.num):\\n for j in range(len(priv_clf.support_vectors)):\\n frames[i][j] = prob.xkernel((priv_clf.support_vectors[j]), prob.Xstar[i])\\n\\n # Form pairs so that each training point is matched against each 'frame of knowledge'\\n training_pairs = np.zeros((prob.num, len(priv_clf.support_vectors)), dtype=object)\\n for i in range(prob.num):\\n for j in range(len(priv_clf.support_vectors)):\\n training_pairs[i][j] = [prob.X[i], frames[i][j]]\\n training_pairs = np.array(training_pairs)\\n\\n regr_pairs = np.zeros((len(priv_clf.support_vectors), prob.num), dtype=object)\\n for i in range(prob.num):\\n for j in range(len(priv_clf.support_vectors)):\\n regr_pairs[j][i] = training_pairs[i][j]\\n\\n # Learn a regression based on above pairs\\n self.models = []\\n for dataSet in regr_pairs:\\n regr = SVR(kernel='rbf')\\n xs = []\\n ys = []\\n for i in range(prob.num):\\n xs.append(dataSet[i][0].flatten())\\n ys.append(dataSet[i][1])\\n xs = np.array(xs)\\n ys = np.array(ys)\\n self.models.append(regr.fit(xs, ys))\\n\\n # Transform data from X using learned regression\\n new_xs = []\\n new_ys = []\\n for i in range(prob.num):\\n new_xs.append(self.transform(prob.X[i].reshape(1, -1)).flatten())\\n new_ys.append(priv_clf.predict(prob.Xstar[i]))\\n new_x = np.asarray(new_xs)\\n new_y = np.array(new_ys)\\n\\n # Form a new problem and learn an SVMd+ solution for it\\n new_prob = SvmProblem(new_x, prob.Xstar, new_y)\\n new_svm = SVMdp()\\n self.clf = new_svm.train(new_prob)\",\n \"def setup_svm(self, classifier_name=\\\"SVM\\\", **kwargs):\\n if not classifier_name in self.classifiers:\\n clf = svm.SVC(**kwargs)\\n clf.fit(self.X_train, self.y_train)\\n self.classifiers[classifier_name] = clf\",\n \"def svm(xtrain, ytrain, xtest, ytest,labels_mapping, scaled = False):\\n if not scaled :\\n scaler = StandardScaler()\\n xtrain = scaler.fit_transform(xtrain)\\n xtest = scaler.transform(xtest)\\n\\n svm = SVC(C=10, cache_size=1500, class_weight='balanced')\\n svm = __train_and_test(svm, xtrain, ytrain, xtest, ytest,labels_mapping)\\n return svm\",\n \"def train_svm_model(self, X_train, X_test, y_train, y_test):\\r\\n clf = Pipeline([('vect', CountVectorizer()), ('tfidf', TfidfTransformer()),\\r\\n ('clf', LinearSVC())])\\r\\n clf = clf.fit(X_train, y_train)\\r\\n pred = clf.predict(X_test)\\r\\n print('Confusion matrix\\\\n',confusion_matrix(y_test,pred))\\r\\n print('Classification_report\\\\n',classification_report(y_test,pred))\\r\\n return clf\",\n \"def train(prob: SvmProblem):\\n # Define variables\\n x = prob.X\\n y = prob.Y\\n C = prob.C\\n C2 = prob.gamma\\n\\n # Swap params, so SVM solves X* with correct params\\n xk = prob.xkernel\\n xsk = prob.xskernel\\n\\n prob.C = C2\\n prob.xkernel = xsk\\n\\n svm = SVM()\\n xstar_clf = svm.train(prob.Xstar, prob)\\n\\n # Get distance to decision boundary\\n xi_star = np.zeros(prob.num)\\n for i in range(prob.num):\\n output = (1 - prob.Y[i] * (xstar_clf.f(prob.Xstar[i])))\\n xi_star[i] = max(0, output)\\n\\n # Replace swapped out params so modified SVM solves X with correct params\\n prob.C = C\\n prob.xkernel = xk\\n\\n # Define the inputs to CVXOPT - See Appendix G.4\\n P = prob.yi_yj * prob.xi_xj\\n q = -np.ones((prob.num, 1))\\n G1 = -np.eye(prob.num)\\n G2 = np.eye(prob.num)\\n G3 = xi_star.reshape(1, -1)\\n G = np.vstack((G1, G2))\\n G = np.vstack((G, G3))\\n h1 = np.zeros(prob.num).reshape(-1, 1)\\n h2 = np.repeat((1 + prob.delta) * C, prob.num).reshape(-1, 1)\\n h3 = sum(xi_star) * C\\n h = np.vstack((h1, h2))\\n h = np.vstack((h, h3))\\n A = y.reshape(1, -1)\\n b = np.zeros(1)\\n\\n P = matrix(P, tc='d')\\n q = matrix(q, tc='d')\\n G = matrix(G, tc='d')\\n h = matrix(h, tc='d')\\n A = matrix(A, tc='d')\\n b = matrix(b, tc='d')\\n\\n # Solve optimization problem using CVXOPT\\n solvers.options['show_progress'] = False\\n sol = solvers.qp(P, q, G, h, A, b)\\n alphas = np.array(sol['x'])\\n\\n # Get the bias\\n bacond1 = (alphas > 1e-8)\\n bacond2 = (alphas <= (1 + prob.delta) * C)\\n bcond = np.array([a and b for a, b in zip(bacond1, bacond2)]).flatten()\\n\\n yS = y[bcond]\\n xS = x[bcond]\\n aS = alphas[bcond]\\n\\n sum_total = 0\\n for s in range(len(yS)):\\n inner_total = 0\\n for m in range(len(yS)):\\n am = aS[m]\\n ym = yS[m]\\n xm_xs = prob.xkernel(xS[m], xS[s])\\n inner_total += am * ym * xm_xs\\n sum_total += yS[s] - inner_total\\n\\n bias = sum_total / len(yS)\\n\\n # Populate Classifier object to be returned\\n clf = Classifier()\\n clf.b = bias\\n clf.alphas = alphas\\n clf.xs = x\\n clf.ys = y\\n clf.kern = prob.xkernel\\n return clf\",\n \"def search_ksvm_hyperparams(model, x, y, kernel, C_list, eps_list, folds=3):#C_list,\\n # divide data into training and validation sets:\\n N = x.shape[0]\\n\\n # get random indices for dataset folds\\n indices = torch.randperm(N)\\n length = N // folds\\n\\n max_acc = 0.0\\n max_C = 0.0\\n max_eps = 0.0\\n for C in C_list:\\n for eps in eps_list:\\n acc = torch.zeros(folds)\\n for k in range(folds):\\n x_train = torch.cat((x[indices[0:k*length]],x[indices[(k+1)*length:]]),dim = 0)\\n y_train = torch.cat((y[indices[0:k*length]],y[indices[(k+1)*length:]]),dim = 0)\\n x_val = x[indices[k*length:(k+1)*length]]\\n y_val = y[indices[k*length:(k+1)*length]]\\n\\n model.__init__(kernel, C, eps)\\n model.train(x_train, y_train, print_progress = False)\\n y_pred = model.predict(x_val)\\n acc[k] = ((y_val==y_pred).sum()) / float(y_val.shape[0])\\n acc_mean = acc.mean()\\n if(acc_mean > max_acc):\\n max_acc = acc_mean\\n max_C = C\\n max_eps = eps\\n\\n print(\\\"at C = {} and eps = {} we get acc = {}\\\" .format(C, eps, acc_mean))\\n\\n\\n print(\\\"Max we get at: C: {} and eps = {} we get acc = {}\\\" .format(max_C, max_eps, max_acc))\\n return max_acc, max_C, max_eps\",\n \"def SVM_train(X, y, cv):\\r\\n rev = 10000\\r\\n start_time = time.time()\\r\\n print('\\\\n'+ '# '*10+'[Training] Support Vector Machine (SVM) (max_iter='+str(rev)+'):'+ ' #'*10)\\r\\n parameters = {\\r\\n 'kernel':('linear', 'poly', 'rbf'),\\r\\n 'C':(1, 5, 10),\\r\\n 'gamma':('scale', 'auto')\\r\\n }\\r\\n print('-'*2+'Grid Search Parameters:')\\r\\n print(parameters)\\r\\n clf = svm.SVC(random_state=rstate, probability=True, max_iter=rev) # Max_iter infinite as default, stuck on large datasets > 10^4.\\r\\n clf = GridSearchCV(clf, parameters, cv=cv, scoring='f1')\\r\\n clf.fit(X, y)\\r\\n print('-'*2+'GridSearch Results:')\\r\\n with pd.option_context('display.max_rows', None, 'display.max_columns', None):\\r\\n print(pd.DataFrame(clf.cv_results_))\\r\\n print('> '*2+'Training time: %.4f seconds.'%(time.time()-start_time))\\r\\n return clf\",\n \"def train_SVM(data: np.array, labels: np.array)->None:\\n print(\\\"SVM is not implemented yet!\\\")\",\n \"def hyperparameter_cv(X_data, y_data, hyperparameters):\\n\\n # Create Grid of hyperparameters\\n grid = cartesian_product(hyperparameters)\\n\\n # Loop through hyperparameters \\n best_score = 0\\n for hyperparameter in grid:\\n # Initialize Modle\\n model = svm.SVC(kernel='linear', **hyperparameter)\\n\\n # Train and Get Accuracy\\n print(f\\\"Training using hyperparameters: {hyperparameter}\\\")\\n score = cross_validation_score(X_data, y_data, model, folds=5)\\n print(f\\\"Accuracy Score: {score}\\\")\\n\\n if score > best_score:\\n best_score = score\\n best_parameters = hyperparameter\\n \\n return best_score, best_parameters\",\n \"def train_linear_SVM(X_train_input, y_train_input, C=1):\\r\\n from sklearn.svm import SVC\\r\\n svc_clf = SVC(kernel='linear', probability=True, C=C)\\r\\n svc_clf.fit(X_train_input, y_train_input)\\r\\n return svc_clf\",\n \"def ex_1_b(x, y):\\n ###########\\n ## Add a point (4,0) with label 1 to the data set and then\\n ## train an SVM with a linear kernel\\n ## and plot the decision boundary and support vectors using 'plot_svm_decision_boundary' function\\n ###########\\n new_x = np.vstack((x, np.array([4,0])))\\n new_y = np.hstack((y, np.array((1))))\\n\\n clf = svm.SVC(kernel='linear')\\n clf.fit(new_x, new_y)\\n plot_svm_decision_boundary(clf, new_x, new_y)\\n pass\",\n \"def extract_svm_parameters(clf):\\n\\n return {\\n 'n_support': clf.__dict__['n_support_'].tolist(),\\n 'support_vectors': clf.__dict__['support_vectors_'].tolist(),\\n 'dual_coef': clf.__dict__['_dual_coef_'].tolist(),\\n 'intercept': clf.__dict__['_intercept_'].tolist(),\\n 'classes': clf.__dict__['classes_'].tolist(),\\n }\",\n \"def ex_1_c(x, y):\\n ###########\\n ## Add a point (4,0) with label 1 to the data set and then\\n ## train an SVM with a linear kernel with different values of C\\n ## and plot the decision boundary and support vectors for each using 'plot_svm_decision_boundary' function\\n ###########\\n Cs = [1e6, 1, 0.1, 0.001]\\n new_x = np.vstack((x, np.array([4,0])))\\n new_y = np.hstack((y, np.array((1))))\\n\\n for c in Cs:\\n clf = svm.SVC(kernel='linear', C=c)\\n clf.fit(new_x, new_y)\\n plot_svm_decision_boundary(clf, new_x, new_y)\\n return\",\n \"def define_kernel(self, *args, **kwargs):\\n base_kernel = self.base_kernel\\n if base_kernel is None:\\n base_kernel = 'VertexHistogram'\\n k = getattr(kernels, self.kernel_name)\\n k_base = getattr(kernels, base_kernel)\\n kernel = k(base_graph_kernel=k_base, *args, **kwargs)\\n return kernel\",\n \"def svm_train(c, g, v, dname):\\n if sys.platform != 'win32':\\n # grid_py = '../tools/grid.py'\\n # gnuplot_exe = '/usr/bin/gnuplot'\\n svmtrain_exe = './PromoterSVM/libsvm/windows/my-svm-train'\\n else:\\n # grid_py = r\\\"D:\\\\LiYuan\\\\Data_Science\\\\libsvm-3.21\\\\windows\\\\grid.py\\\"\\n # gnuplot_exe = r\\\"D:\\\\Program Files\\\\gnuplot\\\\bin\\\\gnuplot.exe\\\"\\n svmtrain_exe = r'D:\\\\LiYuan\\\\\\\"Bioinformatic Research\\\"\\\\IMU\\\\zuo\\\\Tasks\\\\\\\"20160206-Promoter SVM\\\"\\\\biopromoter_script\\\\PromoterSVM\\\\libsvm\\\\windows\\\\my-svm-train.exe'\\n\\n df_model = dname + \\\".model\\\"\\n cmd = '{0} -c {1} -g {2} -v {3} \\\"{4}\\\" \\\"{5}\\\"'.format(svmtrain_exe, c, g, v, dname, df_model)\\n Popen(cmd, shell=True, stdout=PIPE).communicate()\",\n \"def ex_2_c(x_train, y_train, x_test, y_test):\\n ###########\\n ## TODO:\\n ## Train SVMs with RBF kernels for different values of the gamma\\n ## and plot the variation of the test and training scores with gamma using 'plot_score_vs_gamma' function.\\n ## Plot the decision boundary and support vectors for the best value of gamma\\n ## using 'plot_svm_decision_boundary' function\\n ###########\\n gammas = np.arange(0.01, 2, 0.02)\\n machines = [svm.SVC(kernel='rbf', gamma=g, coef0=1.0) for g in gammas]\\n\\n for machine in machines:\\n machine.fit(x_train, y_train)\\n\\n trainScores = [machine.score(x_train, y_train) for machine in machines]\\n testScores = [machine.score(x_test, y_test) for machine in machines]\\n\\n plot_score_vs_gamma(trainScores, testScores, gammas)\\n\\n bestGamma = np.argmax(testScores)\\n print('Score of best rbf gamma ({}): {}'.format(gammas[bestGamma], testScores[bestGamma]))\\n plot_svm_decision_boundary(machines[bestGamma], x_train, y_train, x_test, y_test)\",\n \"def train(self, trainingData, trainingLabels, validationData, validationLabels):\\n from sklearn import svm\\n \\n \\\"*** YOUR CODE HERE ***\\\"\\n self.sklearn_svm = svm.SVC(C=5, kernel='rbf', gamma=0.005, decision_function_shape='ovo')\\n self.sklearn_svm.fit(trainingData, trainingLabels)\",\n \"def main():\\n\\n if len(sys.argv) < 4 or len(sys.argv) > 5:\\n print 'Usage: classifier.py data_dimension train_set_path test_set_path [option: add_bias]'; \\n return; \\n\\n # create sets of possible hyperparameter values\\n setC = {0.001, 0.01, 0.1, 1, 10, 25, 100}; # trade off regularizer and error minimization\\n setRho = {0.001, 0.01, 0.1, 1}; # learning rate for gradient descent \\n hyperparams = [setC, setRho];\\n \\n # create svm classifier for selected data\\n dataDim = int(sys.argv[1]);\\n trainPath = str(sys.argv[2]);\\n testPath = str(sys.argv[3]);\\n if len(sys.argv) == 5:\\n c = Classifier('svm', hyperparams, dataDim, testPath, trainPath, addBias=True);\\n else:\\n c = Classifier('svm', hyperparams, dataDim, testPath, trainPath);\\n \\n print 'Classifier type: ', c.type, \\\\\\n '\\\\nTraining set: ', trainPath, \\\\\\n '\\\\nTest set: ', testPath;\\n \\n print 'Determining hyperparameters to use...';\\n c.learnHyperparams(report=1);\\n \\n print 'Training classifier...';\\n c.train();\\n \\n print 'Performing inference on test set...';\\n c.test(); \\n \\n print '\\\\nREPORT:', \\\\\\n '\\\\nUsing hyperparameters: ', c.theta, \\\\\\n '\\\\nLearned weight vector: ', c.w, \\\\\\n '\\\\nPrediction accuracy on test set: ', c.accuracy * 100, ' percent';\",\n \"def ex_2_b(x_train, y_train, x_test, y_test):\\n ###########\\n ## TODO:\\n ## Train SVMs with polynomial kernels for different values of the degree\\n ## (Remember to set the 'coef0' parameter to 1)\\n ## and plot the variation of the test and training scores with polynomial degree using 'plot_score_vs_degree' func.\\n ## Plot the decision boundary and support vectors for the best value of degree\\n ## using 'plot_svm_decision_boundary' function\\n ###########\\n\\n degrees = range(1, 21)\\n machines = [svm.SVC(kernel='poly', degree=d, coef0=1.0) for d in degrees]\\n\\n for machine in machines:\\n machine.fit(x_train, y_train)\\n\\n trainScores = [machine.score(x_train, y_train) for machine in machines]\\n testScores = [machine.score(x_test, y_test) for machine in machines]\\n\\n plot_score_vs_degree(trainScores, testScores, degrees)\\n\\n bestDegree = testScores.index(max(testScores))\\n print('Score of best polynomial degree ({}): {}'.format(bestDegree + 1, testScores[bestDegree]))\\n plot_svm_decision_boundary(machines[bestDegree], x_train, y_train, x_test, y_test)\",\n \"def SVM_train(Ktrain,y,lbda_vec):\\r\\n n = Ktrain.shape[0]\\r\\n for idx, lbda in enumerate(lbda_vec): \\r\\n C = 1/(2*lbda*n)\\r\\n P = matrix(Ktrain, tc=\\\"d\\\")\\r\\n q = - matrix(y,tc=\\\"d\\\")\\r\\n G = matrix( np.concatenate( (np.diagflat(y) , -np.diagflat(y) ), axis=0 ),tc=\\\"d\\\" )\\r\\n h1 = C * np.ones((n,1))\\r\\n h2 = np.zeros((n,1)) \\r\\n h = matrix(np.concatenate((h1,h2),axis=0))\\r\\n\\r\\n solvers.options['show_progress'] = False\\r\\n \\r\\n sol = solvers.qp(P,q,G,h) \\r\\n a = np.asarray(sol['x'])\\r\\n\\r\\n #alpha is sparse\\r\\n a[np.where(np.abs(a) < 1e-4)] = 0\\r\\n y_svm = np.dot(Ktrain,a)\\r\\n\\r\\n print(\\\"Précision pour lambda = \\\" + str(lbda) + \\\" :\\\", accuracy(y_svm,y))\",\n \"def __init__(self, x, y, method='svm', n_cv=5, **kwargs):\\n self.x = x\\n self.y = y\\n self.rf_stat = None\\n self.summary = {}\\n self.n_cv = n_cv\\n self.method = method\\n if 'kernel' in kwargs.keys(): self.kernel = kwargs['kernel']\\n\\n self.print_flag = kwargs.get('print_flag', 'off')\\n self.stat = {'train': None, 'test': None}\\n # self.direct = kwargs[''] # TODO more generic here\",\n \"def __init__(self):\\n super().__init__()\\n import sklearn\\n import sklearn.svm\\n self.model = sklearn.svm.LinearSVR\",\n \"def thundersvm_load_svm_model(input_svm_model_file):\\n \\n svm_model = SVC()\\n svm_model.load_from_file(input_svm_model_file)\\n \\n return svm_model\",\n \"def get_kernel_hps(self):\\n raise NotImplementedError('Abstract Method.')\",\n \"def ex_2_a(x_train, y_train, x_test, y_test):\\n ###########\\n ## TODO:\\n ## Train an SVM with a linear kernel for the given dataset\\n ## and plot the decision boundary and support vectors for each using 'plot_svm_decision_boundary' function\\n ###########\\n\\n machine = svm.SVC(kernel='linear')\\n machine.fit(x_train, y_train)\\n plot_svm_decision_boundary(machine, x_train, y_train, x_test, y_test)\\n\\n print('Linear SVM score: {}'.format(machine.score(x_test, y_test)))\",\n \"def Train_SVC(train_X, train_Y, test_X, test_Y, Accuracy):\\r\\n clf = SVC(probability=True, C=5, gamma='auto', kernel='linear')\\r\\n clf.fit(train_X, train_Y)\\r\\n y_predict = clf.predict(test_X)\\r\\n Accuracy[\\\"SVM\\\"] = metrics.accuracy_score(test_Y, y_predict)\\r\\n print(\\\"Accuracy of SVM: %.2f%%\\\" % (Accuracy[\\\"SVM\\\"] * 100))\\r\\n # Confusion Matrix\\r\\n cm_rf = confusion_matrix(test_Y, y_predict)\\r\\n rf_cm = pd.DataFrame(cm_rf, range(3), range(3))\\r\\n sn.set(font_scale=1.7)\\r\\n sn.heatmap(rf_cm, annot=True, annot_kws={\\\"size\\\": 15}, fmt='g', cmap=\\\"Greens\\\")\",\n \"def get_model_5(parameters):\\n # Generate model\\n model = svm.LinearSVC(max_iter=100000)\\n \\n # Return the model\\n return model\",\n \"def default_feature_hp_kernel_config(defn):\\n defn = _validate_definition(defn)\\n\\n # hyperparams\\n hparams = {}\\n for i, hp in enumerate(defn.hyperpriors()):\\n if not hp:\\n continue\\n # XXX(stephentu): we are arbitrarily picking w=0.1\\n hparams[i] = {k: (fn, 0.1) for k, fn in hp.iteritems()}\\n\\n if not hparams:\\n return []\\n else:\\n return [('slice_feature_hp', {'hparams': hparams})]\",\n \"def get_model_4(parameters):\\n # Generate model\\n model = svm.SVC(C=parameters['C'], gamma='scale', probability=True,\\n class_weight='balanced',\\n decision_function_shape='ovr')\\n \\n # Return the model\\n return model\",\n \"def hyper_parameter_tuning(X, y, classifier, models, sntypes_map, feature_names, fig_dir='.', remove_models=(), name=''):\\n\\n # Hyperparameter grid\\n n_estimators = [int(x) for x in np.linspace(start=200, stop=2000, num=10)]\\n max_features = ['auto', 'sqrt']\\n max_depth = [int(x) for x in np.linspace(10, 110, num=11)]\\n max_depth.append(None)\\n min_samples_split = [2, 5, 10]\\n min_samples_leaf = [1, 2, 4]\\n bootstrap = [True, False]\\n random_grid = {'n_estimators': n_estimators,\\n 'max_features': max_features,\\n 'max_depth': max_depth,\\n 'min_samples_split': min_samples_split,\\n 'min_samples_leaf': min_samples_leaf,\\n 'bootstrap': bootstrap}\\n\\n # Get data\\n num_features = X.shape[1]\\n model_names = [sntypes_map[model] for model in models]\\n X, y, models, remove_models = remove_redundant_classes(X, y, models, remove_models)\\n\\n # Get best features\\n n = 50\\n num_features, feature_names, X = get_n_best_features(n, X, y, classifier, feature_names, num_features, fig_dir, name, models, model_names)\\n\\n # Randomised Search\\n clf_random = RandomizedSearchCV(estimator=classifier, param_distributions=random_grid, n_iter=7, cv=3, verbose=2,\\n random_state=42, n_jobs=2)\\n clf_random.fit(X, y)\\n print(clf_random.best_params_)\\n\\n def evaluate(model, test_features, test_labels):\\n predictions = model.predict(test_features)\\n errors = abs(predictions - test_labels)\\n mape = 100 * np.mean(errors / test_labels)\\n accuracy = 100 - mape\\n print('Model Performance')\\n print('Average Error: {:0.4f} degrees.'.format(np.mean(errors)))\\n print('Accuracy = {:0.2f}%.'.format(accuracy))\\n\\n return accuracy\\n\\n best_random = clf_random.best_estimator_\\n # random_accuracy = evaluate(best_random, test_features, test_labels)\",\n \"def get_vertex_vek(*args, data_dir=None, **kwargs):\\n\\n annots = _apply_vek_prob(data_dir=data_dir)\\n vertex_labels, parcel_labels = [], []\\n for hemi in ('lh', 'rh'):\\n vc = _convert_vek_to_classes(getattr(annots, hemi), data_dir=data_dir)\\n vertex_labels.append(vc)\\n parcel_labels.append(np.unique(vc))\\n return NETWORKS(np.hstack(vertex_labels), np.hstack(parcel_labels))\",\n \"def build_model():\\n # build pipeline with count vecotrizer, tfidf and support vector machine\\n pipeline_SVC = Pipeline([\\n ('vect', CountVectorizer(tokenizer = tokenize)),\\n ('tfidf', TfidfTransformer()),\\n ('multi-clf', MultiOutputClassifier(LinearSVC()))\\n ])\\n\\n # define parameters for gridsearch\\n parameters_SVC = {\\n 'vect__max_df': (.6, 1),\\n 'tfidf__norm': ('l1', 'l2'),\\n 'multi-clf__estimator__C': (.1, 1, 100)\\n }\\n\\n # build parameter grid and fit data\\n model = GridSearchCV(pipeline_SVC, parameters_SVC)\\n\\n return model\",\n \"def _get_current_hyperparameters(self):\",\n \"def __init__(self,training_data):\\n my_data = genfromtxt(training_data, delimiter='\\\\t',skip_header=0)\\n n_col = my_data.shape[1]\\n n_features=n_col-1 #assuming that the latest column\\n #contains the the outputs \\n #preprocessing data\\n X = preprocessing.scale(np.hsplit(my_data,[n_features,n_col])[0])\\n Y = np.squeeze(np.asarray(np.hsplit(my_data,[n_features,n_col])[1]))\\n #defining scaling\\n self.scaler = preprocessing.Scaler()\\n self.scaler.fit(np.hsplit(my_data,[n_features,n_col])[0])\\n #define classifier\\n self.classifier = svm.LinearSVC(class_weight='auto',C=1.0)\\n self.classifier.fit(X, Y)\",\n \"def svm_fit(self, c: float = 1.0):\\r\\n self.svmModel = SVC(C=c, gamma='auto').fit(self.x, self.y)\",\n \"def __init__(self,\\n gridsearch='half',\\n n_components=3,\\n classifier='svm',\\n cv=5,\\n min_resources='smallest',\\n factor=3,\\n score_func=metrics.f1_score,\\n average='weighted',\\n random_state=None,\\n n_jobs=-1,\\n **kwargs,\\n ):\\n\\n freq_thres = helpers.FREQ_THRES(freq_thres=0)\\n\\n log = helpers.LOG(log=False)\\n\\n if classifier == 'svm':\\n\\n classifier = SVC(random_state=random_state)\\n\\n mapper = umap.UMAP(random_state=random_state,\\n n_components=n_components)\\n\\n scorer = metrics.make_scorer(score_func=score_func,\\n average=average,\\n )\\n\\n pipeline = Pipeline([('freq', freq_thres),\\n ('log', log),\\n ('umap', mapper),\\n ('classifier', classifier),\\n ])\\n\\n params_grid_pipeline = {**kwargs}\\n\\n if gridsearch == 'full':\\n self.clf_pipeline = GridSearchCV(pipeline,\\n params_grid_pipeline,\\n cv=cv,\\n scoring=scorer,\\n n_jobs=n_jobs,\\n )\\n elif gridsearch == 'half':\\n self.clf_pipeline = \\\\\\n HalvingGridSearchCV(pipeline,\\n params_grid_pipeline,\\n cv=cv,\\n scoring=scorer,\\n n_jobs=n_jobs,\\n min_resources=min_resources,\\n factor=factor,\\n random_state=random_state\\n )\",\n \"def __init__(self):\\n super().__init__()\\n import sklearn\\n import sklearn.svm\\n self.model = sklearn.svm.NuSVR\",\n \"def create_SVM_profile(size_sample, randomness, pos_equal_neg, kernel, Resource, m_features=None,\\n m_labels=None, language='en'):\\n if m_features is None and m_labels is None:\\n m_features, m_labels = get_characteristic_label_vectors(size_sample, randomness, pos_equal_neg, Resource, False,\\n language)\\n\\n Classifier = SVM(kernel)\\n Classifier.fit(m_features, m_labels)\\n\\n name_file = construct_name_file(size_sample, randomness, pos_equal_neg, str(kernel).split('.')[1])\\n\\n Classifier.save_to_file(name_file)\",\n \"def test_SVM_test_C_parameter(params, X_train, X_test, y_train, y_test):\",\n \"def train_svm(data: np.ndarray, test_labels: list, test_samples: list, train_labels: list,\\n train_samples: list) -> np.ndarray:\\n model = svm.SVC(kernel=\\\"rbf\\\", C=1024, gamma=2)\\n model.fit(get_data_by_indexes(train_samples, data), train_labels)\\n prediction = model.predict(get_data_by_indexes(test_samples, data))\\n print(\\\"SVM fitness score {0:5.2f}%\\\".format(\\n model.score(get_data_by_indexes(test_samples, data), test_labels) * float(100)))\\n return prediction\",\n \"def ex_3_a(x_train, y_train, x_test, y_test):\\n ###########\\n ## Train multi-class SVMs with one-versus-rest strategy with\\n ## - linear kernel\\n ## - rbf kernel with gamma going from 10**-5 to 10**5\\n ## - plot the scores with varying gamma using the function plot_score_versus_gamma\\n ## - Mind that the chance level is not .5 anymore and add the score obtained with the linear kernel as optional argument of this function\\n ###########\\n dfs = 'ovr'\\n c = 10\\n\\n linear = svm.SVC(kernel='linear', C=c, decision_function_shape=dfs)\\n linear.fit(x_train, y_train)\\n lin_score_train = linear.score(x_train, y_train)\\n lin_score_test = linear.score(x_test, y_test)\\n\\n gammas = [pow(10, i) for i in range(-5, 6)]\\n rbfs = [svm.SVC(kernel='rbf', gamma=gamma, C=c, decision_function_shape=dfs) for gamma in gammas]\\n for rbf in rbfs:\\n rbf.fit(x_train, y_train)\\n\\n train_scores = [rbf.score(x_train, y_train) for rbf in rbfs]\\n test_scores = [rbf.score(x_test, y_test) for rbf in rbfs]\\n\\n plot_score_vs_gamma(train_scores, test_scores, gammas, lin_score_train, lin_score_test, .2)\",\n \"def ex_1_c(x, y):\\n ###########\\n ## TODO:\\n ## Add a point (4,0) with label 1 to the data set and then\\n ## train an SVM with a linear kernel with different values of C\\n ## and plot the decision boundary and support vectors for each using 'plot_svm_decision_boundary' function\\n ###########\\n Cs = [1e6, 1, 0.1, 0.001]\\n\\n new_x = (4, 0)\\n new_y = 1\\n\\n x = np.vstack([x, new_x])\\n y = np.hstack([y, new_y])\\n\\n for C in Cs:\\n clf = svm.SVC(kernel='linear', C=C)\\n clf.fit(x, y)\\n plot_svm_decision_boundary(clf, x, y)\",\n \"def __init__(self, estimator, target_language='java',\\n target_method='predict', **kwargs):\\n super(SVC, self).__init__(estimator, target_language=target_language,\\n target_method=target_method, **kwargs)\\n self.estimator = estimator\",\n \"def get_kernel_vector(name, kernel, x, d_1, hyps,\\n cutoffs=None, hyps_mask=None,\\n n_cpus=1, n_sample=100):\\n\\n size = len(_global_training_data[name])\\n\\n if (n_cpus is None):\\n n_cpus = mp.cpu_count()\\n if (n_cpus == 1):\\n return get_kernel_vector_unit(\\n name, 0, size, x, d_1, kernel, hyps,\\n cutoffs, hyps_mask)\\n\\n block_id, nbatch = partition_c(n_sample, size, n_cpus)\\n\\n result_queue = mp.Queue()\\n children = []\\n for wid in range(nbatch):\\n s, e = block_id[wid]\\n children.append(\\n mp.Process(\\n target=queue_wrapper,\\n args=(result_queue, wid,\\n get_kernel_vector_unit,\\n (name, s, e, x, d_1, kernel, hyps,\\n cutoffs, hyps_mask\\n )\\n )\\n )\\n )\\n\\n # Run child processes.\\n for c in children:\\n c.start()\\n\\n # Wait for all results to arrive.\\n k12_v = np.zeros(size*3)\\n for _ in range(nbatch):\\n wid, result_chunk = result_queue.get(block=True)\\n s, e = block_id[wid]\\n k12_v[s*3:e*3] = result_chunk\\n\\n # Join child processes (clean up zombies).\\n for c in children:\\n c.join()\\n\\n return k12_v\",\n \"def plot_svm(N=5, std=0.60, kernel='linear'):\\n X, y = make_blobs(n_samples=200, centers=2, random_state=0,\\n cluster_std=std)\\n\\n X_train, y_train = X[:N], y[:N]\\n X_test, y_test = X[N:], y[N:]\\n\\n clf = SVC(kernel=str(kernel))\\n clf.fit(X_train, y_train)\\n\\n plt.scatter(X_train[:, 0], X_train[:, 1], c=y_train, s=50, cmap='spring')\\n plt.scatter(X_test[:, 0], X_test[:, 1], c=y_test, s=50, cmap='spring',\\n alpha=0.2)\\n plt.xlim(-1, 4)\\n plt.ylim(-1, 6)\\n plot_svc_decision_function(clf, plt.gca())\\n plt.scatter(clf.support_vectors_[:, 0], clf.support_vectors_[:, 1],\\n s=200, facecolors='none')\\n\\n train_score = clf.score(X_train, y_train)\\n test_score = clf.score(X_test, y_test) if len(X_test) > 0 else 'NA'\\n plt.title('Train Accuracy = {0}; Test Accuracy = {1}'.format(train_score,\\n test_score))\",\n \"def train(K, labels, C):\\n K= sparse.hstack((1+np.arange(len(labels))[:,None], K)).A\\n prob = svm_problem(labels, K, isKernel=True)\\n param = svm_parameter('-t 4 -c ' + str(C))\\n return svm_train(prob, param)\",\n \"def svm_classify(train_image_feats, train_labels, test_image_feats, kernel_type):\\r\\n\\r\\n categories = np.unique(train_labels)\\r\\n # [Desc] make 15 different SVM solver (one(each category) vs. the other(14 other category))\\r\\n svc_list = []\\r\\n num_categories = len(categories)\\r\\n for cat_i in tqdm(range(num_categories)):\\r\\n category = categories[cat_i]\\r\\n if kernel_type == 'RBF':\\r\\n svc = svm.SVC(kernel='rbf', probability=True)\\r\\n elif kernel_type == 'linear':\\r\\n svc = svm.SVC(kernel='linear', probability=True)\\r\\n new_label_for_svm = np.where(train_labels == category, 1, 0)\\r\\n\\r\\n svc.fit(train_image_feats, new_label_for_svm)\\r\\n svc_list.append(svc)\\r\\n\\r\\n # [Desc] get test images' class using trained svm\\r\\n probability_list = []\\r\\n for cat_i in range(num_categories):\\r\\n svc = svc_list[cat_i]\\r\\n logit = svc.decision_function(test_image_feats)\\r\\n probability = logit\\r\\n probability_list.append(probability)\\r\\n probability_mat = np.array(probability_list)\\r\\n probability_mat = np.transpose(probability_mat)\\r\\n # [Desc] get each class to argmax each logit value.\\r\\n argmax_class = np.argmax(probability_mat, axis=1)\\r\\n\\r\\n return categories[argmax_class]\",\n \"def SVMRegression(trainingObs,trainingParam,Obs):\\n svr = SVR(C=1.0, cache_size=2000, coef0=0.0, degree=3, epsilon=0.1, gamma=0., kernel='rbf', probability=False, shrinking=True, tol=0.00001)\\n nparam=trainingParam.shape[1]\\n vparam = []\\n for i in range(0,nparam):\\n print i\\n svr.fit(trainingObs,trainingParam[:,i])\\n vparam.append(svr.predict(Obs))\\n vparam = np.array(vparam)\\n return vparam.T\",\n \"def cross_validation(feature_train, help_rank_train, model_name):\\n clf = svm.SVC(kernel='linear', C=1).fit(feature_train, help_rank_train)\\n clf_model = open(model_name,'wb')\\n dump(clf, clf_model, -1)\\n return\",\n \"def add_model_parameter_ui(clf_name):\\n params = dict()\\n if clf_name == 'KNN':\\n K = st.sidebar.slider(\\\"K\\\", 1, 5)\\n params[\\\"K\\\"] = K\\n\\n elif clf_name == 'SVM':\\n C = st.sidebar.slider(\\\"C\\\", 0.01, 10.0)\\n params[\\\"C\\\"] = C\\n\\n elif clf_name == 'Random Forest':\\n max_depth = st.sidebar.slider(\\\"max_depth\\\", 2, 15)\\n n_estimators = st.sidebar.slider(\\\"n_estimators\\\", 1, 100)\\n params[\\\"max_depth\\\"] = max_depth\\n params[\\\"n_estimators\\\"] = n_estimators\\n\\n else:\\n pass\\n\\n return params\",\n \"def hyperparams():\\n H = 6\\n return Munch(N=500, H=H, D=(H // 2) ** 2, batch_size=10, precision=to.float32)\",\n \"def find_knn_hyperparams():\\n n_neighbors = np.arange(5, 10)\\n ps = np.arange(1, 10)\\n results = []\\n\\n for p in ps:\\n result = []\\n for _ in range(10):\\n data = FaceDataset(\\\"embeddings/known\\\", n=50)\\n train_data, train_labels = data.train()\\n test_data, test_labels = data.test()\\n accs = []\\n for n in n_neighbors:\\n clf = KNeighborsClassifier(n_neighbors=n, weights=\\\"distance\\\", p=p)\\n clf, _ = train(clf, train_data, train_labels)\\n acc, _ = test(clf, test_data, test_labels)\\n accs.append(acc)\\n result.append(accs)\\n result = np.mean(result, axis=0)\\n results.append(result)\\n\\n plots = []\\n for i in range(len(ps)):\\n p = plotly.graph_objs.Scatter(x=n_neighbors, y=results[i], name=\\\"p={}\\\".format(ps[i]))\\n plots.append(p)\\n\\n plotly.offline.plot(plots, filename=\\\"knn.html\\\")\\n print(\\\"C={}\\\".format(n_neighbors[np.argmax(results)]))\",\n \"def ex_2_a(x_train, y_train, x_test, y_test):\\n ###########\\n ## Train an SVM with a linear kernel for the given dataset\\n ## and plot the decision boundary and support vectors for each using 'plot_svm_decision_boundary' function\\n ###########\\n\\n clf = svm.SVC(kernel='linear')\\n clf.fit(x_train, y_train)\\n plot_svm_decision_boundary(clf, x_train, y_train, x_test, y_test)\\n print(\\\"ex_2_a score:\\\", clf.score(x_test, y_test))\\n\\n pass\",\n \"def esvm(encs_test, encs_train, C=1000):\\n\\n\\n # set up labels\\n # TODO\\n encs_test=np.array(encs_test).squeeze(1)\\n encs_train=np.array(encs_train).squeeze(1)\\n\\n label=np.ones((encs_train.shape[0]+1,1))\\n label[-1,0]=-1\\n label *=-1\\n label=label.ravel()\\n print(label.shape)\\n print(label)\\n def loop(i):\\n # compute SVM \\n # and make feature transformation\\n # TODO\\n svc = LinearSVC(C=C,class_weight='balanced')\\n test_added=encs_test[i].reshape(1,-1)\\n encs_train_new=np.concatenate((encs_train,test_added),axis=0)\\n svc.fit(encs_train_new, label)\\n\\n return svc.coef_\\n\\n # let's do that in parallel: \\n # if that doesn't work for you, just exchange 'parmap' with 'map'\\n # Even better: use DASK arrays instead, then everything should be\\n # parallelized\\n new_encs = list(map( loop, tqdm(range(len(encs_test)))))\\n new_encs = np.concatenate(new_encs, axis=0)\\n # return new encodings\\n\\n return new_encs\",\n \"def soft_margin_hyperplane(svc, X, y):\\n assert isinstance(svc, sklearn.svm.classes.SVC)\\n assert X.shape[1] == 2, 'X must be of shape (n_samples, 2)'\\n x_min = X[:, 0].min()\\n x_max = X[:, 0].max()\\n w = svc.coef_[0]\\n a = -w[0] / w[1]\\n xx = np.linspace(x_min * 2, x_max * 2)\\n yy = a * xx - (svc.intercept_[0]) / w[1]\\n margin = 1 / np.sqrt(np.sum(svc.coef_ ** 2))\\n yy_down = yy + a * margin\\n yy_up = yy - a * margin\\n plt.plot(xx, yy, color='DimGray', linestyle='-')\\n plt.plot(xx, yy_down, color='DimGray', linestyle=':')\\n plt.plot(xx, yy_up, color='DimGray', linestyle=':')\",\n \"def train(self, trainingData, trainingLabels, validationData, validationLabels ):\\n import sklearn\\n from sklearn import svm\\n\\n \\\"*** YOUR CODE HERE ***\\\"\\n self.sklearn_classifier = svm.SVC(C=2, gamma=0.025, decision_function_shape='ovo', tol=0.015)\\n self.sklearn_classifier.fit(trainingData, trainingLabels)\",\n \"def _binary_svm_head(\\n label_name=None,\\n weight_column_name=None,\\n enable_centered_bias=False,\\n head_name=None,\\n thresholds=None,):\\n return _BinarySvmHead(\\n label_name=label_name,\\n weight_column_name=weight_column_name,\\n enable_centered_bias=enable_centered_bias,\\n head_name=head_name,\\n thresholds=thresholds)\",\n \"def __call__(self, X):\\n\\t\\t\\n\\t\\tif (self.classifier == None):\\n\\t\\t\\t# reinit\\n\\t\\t\\tclf = svm.SVC(C = self.C, cache_size = self.cache_size, gamma = self.gamma, kernel = self.kernel,\\n\\t\\t\\t\\tclass_weight = None, coef0=0.0, degree=3,\\n\\t\\t\\t\\tmax_iter = -1, probability=False, random_state=None,\\n\\t\\t\\t\\tshrinking = True, tol=0.001, verbose=False)\\n\\t\\t\\tclf.set_params(self.params)\\n\\t\\t\\tself.classifier = clf\\n\\t\\t\\t\\n\\t\\tpredictions = self.classifier.predict(X)\\n\\t\\treturn predictions\",\n \"def test_svm(x, y, tune):\\n if tune:\\n params = {'clf__C': stats.uniform(0, 100),\\n 'clf__gamma': stats.uniform(0, 1)}\\n\\n # Perform hyperparameter tuning on C and gamma using randomized searching\\n rand_search = RandomizedSearchCV(create_pipeline(SVC()),\\n n_iter=20,\\n param_distributions=params,\\n n_jobs=-1,\\n cv=5,\\n random_state=2017)\\n rand_search.fit(x, y)\\n print(\\\"best_params: {0}\\\".format(rand_search.best_params_))\\n return rand_search.best_score_ * 100\\n else:\\n # Perform classification without tuning\\n svc = SVC(\\n gamma=0.93121875826256051,\\n C=70.331975797816796\\n )\\n pipeline = create_pipeline(svc)\\n return accuracy(pipeline, x, y)\",\n \"def __init__(self,training_data):\\n my_data = genfromtxt(training_data, delimiter='\\\\t',skip_header=0)\\n n_col = my_data.shape[1]\\n self.n_features=n_col-1 #assuming that the latest column\\n #contains the the outputs \\n #pre-processing data\\n X = preprocessing.scale(np.hsplit(my_data,[self.n_features,n_col])[0])\\n Y = np.squeeze(np.asarray(np.hsplit(my_data,[self.n_features,n_col])[1]))\\n #defining scaling\\n self.scaler = preprocessing.Scaler()\\n self.scaler.fit(np.hsplit(my_data,[self.n_features,n_col])[0])\\n #define classifier\\n self.classifier = svm.SVR(kernel='linear', C=1e3, cache_size=DEFAULT_CACHE_SIZE)\\n #self.classifier = svm.SVR(kernel='rbf', C=1e3, gamma=0.1, cache_size=DEFAULT_CACHE_SIZE)\\n self.classifier.fit(X, Y)\",\n \"def set_hyperparams(self, params):\",\n \"def losd_cnn_svm_model(num_class=8, num_flow_channel=10, cnn_svm_model_id=1, feature_pool='max', device=torch.device(\\\"cuda\\\" if torch.cuda.is_available() else \\\"cpu\\\")):\\n# feature_dimension = 2048 # change this according to which layer's feature you want\\n num_gpu_device = torch.cuda.device_count()\\n\\n # load spatial cnn net\\n input_spatial_cnn_model_file = ''.join(['model/cnn_net/spatial_lucid_08_split_no_', str(cnn_svm_model_id).zfill(2), '_nfch_10_nepochs_500_lr_0.0005_ss_model_best.pth.tar'])\\n print('loading spatial cnn trained model from: {}' .format(input_spatial_cnn_model_file))\\n spatial_cnn_model = load_resnet_cnn_net_model(input_spatial_cnn_model_file, num_class=num_class, num_channel=3, device=device)\\n print('----------------------------------------------------------------------------------------')\\n\\n # load motion cnn net\\n input_motion_cnn_model_file = ''.join(['model/cnn_net/motion_lucid_08_split_no_', str(cnn_svm_model_id).zfill(2), '_nfch_10_nepochs_500_lr_0.01_ss_model_best.pth.tar'])\\n print('loading motion cnn trained model from: {}' .format(input_motion_cnn_model_file))\\n motion_cnn_model = load_resnet_cnn_net_model(input_motion_cnn_model_file, num_class=num_class, num_channel=2*num_flow_channel, device=device)\\n print('----------------------------------------------------------------------------------------')\\n\\n # for svm model\\n input_spatial_motion_svm_model_path = ''.join(['model/svm/spatial_motion_lucid_08_split_no_', str(cnn_svm_model_id).zfill(2), '_nfch_10_nepochs_500_slr_0.0005_mlr_0.01_network_resnet101_', str(feature_pool), '_pooling_thundersvm_1v1/'])\\n input_spatial_motion_svm_model_file = ''.join([input_spatial_motion_svm_model_path, 'best_model_basedon_train_val_data_nclass_12_kernel_linear_int_c_0.1_max_c_1000.0_num_div_c_46_int_g_0.1_max_g_1.0_num_div_g_10'])\\n print('loading spatial and motion net svm model from: \\\"{}\\\"' .format(input_spatial_motion_svm_model_file))\\n spatial_motion_svm_model = thundersvm_load_svm_model(input_spatial_motion_svm_model_file)\\n print('----------------------------------------------------------------------------------------')\\n \\n # model paralization (if you have multiple gpus)\\n print('model will use \\\"{}\\\" GPUs' .format(num_gpu_device))\\n if num_gpu_device > 1:\\n spatial_cnn_model = nn.DataParallel(spatial_cnn_model)\\n motion_cnn_model = nn.DataParallel(motion_cnn_model)\\n \\n return spatial_cnn_model, motion_cnn_model, spatial_motion_svm_model\",\n \"def build_model():\\n pipeline = Pipeline(\\n [\\n (\\\"vect\\\", CountVectorizer(tokenizer=tokenize)),\\n (\\\"tfidf\\\", TfidfTransformer()),\\n (\\\"clf\\\", MultiOutputClassifier(LinearSVC(dual=False))),\\n ]\\n )\\n\\n # use grid search to optimize the pipeline parameters\\n parameters = {\\\"tfidf__use_idf\\\": (True, False), \\\"clf__estimator__C\\\": [1, 100]}\\n cv = GridSearchCV(pipeline, param_grid=parameters)\\n\\n return cv\",\n \"def CalculateSVM(data=None):\\n vectorizer = TfidfVectorizer(tokenizer=pre_process)\\n classifier = LinearSVC()\\n train, test = train_test_split([(i['text'], i['stars']) for i in data],\\n test_size=.2,\\n random_state=10)\\n x_train = vectorizer.fit_transform(i[0] for i in train)\\n x_test = vectorizer.transform(i[0] for i in test)\\n classifier.fit(x_train, [i[1] for i in train])\\n score = classifier.score(x_test, [i[1] for i in test])\\n print score\",\n \"def train_all(self, dataset, mu=None):\\n\\n\\t\\tX = dataset.X #get_design_matrix()\\n\\t\\ty = dataset.y\\n\\n\\t\\tclf = svm.SVC(C = self.C, cache_size = self.cache_size, gamma = self.gamma, kernel = self.kernel,\\n\\t\\t\\t\\tclass_weight = None, coef0=0.0, degree=3,\\n\\t\\t\\t\\tmax_iter = -1, probability=False, random_state=None,\\n\\t\\t\\t\\tshrinking = True, tol=0.001, verbose=False)\\n\\t\\tclf.fit (X, y)\\n\\t\\t\\n\\t\\t# save the last classifier\\n\\t\\tself.classifier = clf\\n\\n\\t\\t# get model parameter\\n\\t\\tself.alpha = clf.dual_coef_\\n\\t\\tself.bias = clf.intercept_\\n\\t\\t# TODO\\n\\t\\tself.params = clf.get_params (deep=True)\\n\\n\\n\\t\\t#TODO:self.mu = sharedX(mu)?\\n\\t\\tself._params = [self.alpha, self.bias]\\n\\t\\tprint(self._params)\",\n \"def hyper(self, input):\\n return\",\n \"def clf_svm(vector_col:str,\\n df_train:pd.DataFrame,\\n model:LinearSVC,\\n return_ranking=False) -> list:\\n\\n if return_ranking: return list(model.decision_function(df_train[vector_col].to_list()))\\n \\n return list(model.predict(df_train[vector_col].to_list()))\",\n \"def cv_lsvm(x_data, y_data, n_class, n_feats):\\n\\n # Do standard scaling to all data (should do train and project unto test)\\n #sample_scaler = StandardScaler()\\n #x_scaled = sample_scaler.fit_transform(x_data)\\n\\n # Grid search CV to search for optimal model parameter C\\n #C_range = np.logspace(-2, 10, 13)\\n C_range = np.logspace(-2, 10, 5)\\n param_grid = dict(C = C_range)\\n cv = StratifiedShuffleSplit(y_data, n_iter = 3, test_size = 0.2, random_state = 0)\\n grid = GridSearchCV(SVC(kernel = \\\"linear\\\"), param_grid = param_grid, cv = cv)\\n grid.fit(x_data, y_data)\\n\\n return grid\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73476094","0.70958614","0.6964052","0.67831784","0.67662734","0.66739416","0.65586966","0.64921445","0.64792943","0.63226485","0.6296224","0.62792623","0.610844","0.61017793","0.61011374","0.6083185","0.6076828","0.6073266","0.6069783","0.6007494","0.598378","0.5978208","0.59208894","0.5910748","0.58755463","0.58331966","0.58162045","0.57634085","0.57414293","0.5699124","0.5678598","0.56777173","0.5666278","0.56028366","0.5584719","0.55759054","0.5563336","0.5560649","0.55426204","0.55423194","0.55386394","0.55211663","0.5516383","0.55108964","0.5468471","0.54578066","0.542058","0.53978866","0.5397872","0.5379003","0.53784233","0.5359927","0.53596365","0.5352589","0.53358537","0.5322709","0.5310472","0.5297836","0.52896833","0.52880883","0.5280535","0.5267292","0.525584","0.5253975","0.5238956","0.5237165","0.52311146","0.5225794","0.52252215","0.5220649","0.52166915","0.5212394","0.5204868","0.52017206","0.5198739","0.5197065","0.51840776","0.5167803","0.5164099","0.51524746","0.51452565","0.51406616","0.51385164","0.51258254","0.51228875","0.5118715","0.5116876","0.5116417","0.511072","0.5105052","0.50954807","0.50912935","0.5077863","0.507535","0.50712097","0.5061472","0.50546056","0.50495595","0.5045799","0.50398856"],"string":"[\n \"0.73476094\",\n \"0.70958614\",\n \"0.6964052\",\n \"0.67831784\",\n \"0.67662734\",\n \"0.66739416\",\n \"0.65586966\",\n \"0.64921445\",\n \"0.64792943\",\n \"0.63226485\",\n \"0.6296224\",\n \"0.62792623\",\n \"0.610844\",\n \"0.61017793\",\n \"0.61011374\",\n \"0.6083185\",\n \"0.6076828\",\n \"0.6073266\",\n \"0.6069783\",\n \"0.6007494\",\n \"0.598378\",\n \"0.5978208\",\n \"0.59208894\",\n \"0.5910748\",\n \"0.58755463\",\n \"0.58331966\",\n \"0.58162045\",\n \"0.57634085\",\n \"0.57414293\",\n \"0.5699124\",\n \"0.5678598\",\n \"0.56777173\",\n \"0.5666278\",\n \"0.56028366\",\n \"0.5584719\",\n \"0.55759054\",\n \"0.5563336\",\n \"0.5560649\",\n \"0.55426204\",\n \"0.55423194\",\n \"0.55386394\",\n \"0.55211663\",\n \"0.5516383\",\n \"0.55108964\",\n \"0.5468471\",\n \"0.54578066\",\n \"0.542058\",\n \"0.53978866\",\n \"0.5397872\",\n \"0.5379003\",\n \"0.53784233\",\n \"0.5359927\",\n \"0.53596365\",\n \"0.5352589\",\n \"0.53358537\",\n \"0.5322709\",\n \"0.5310472\",\n \"0.5297836\",\n \"0.52896833\",\n \"0.52880883\",\n \"0.5280535\",\n \"0.5267292\",\n \"0.525584\",\n \"0.5253975\",\n \"0.5238956\",\n \"0.5237165\",\n \"0.52311146\",\n \"0.5225794\",\n \"0.52252215\",\n \"0.5220649\",\n \"0.52166915\",\n \"0.5212394\",\n \"0.5204868\",\n \"0.52017206\",\n \"0.5198739\",\n \"0.5197065\",\n \"0.51840776\",\n \"0.5167803\",\n \"0.5164099\",\n \"0.51524746\",\n \"0.51452565\",\n \"0.51406616\",\n \"0.51385164\",\n \"0.51258254\",\n \"0.51228875\",\n \"0.5118715\",\n \"0.5116876\",\n \"0.5116417\",\n \"0.511072\",\n \"0.5105052\",\n \"0.50954807\",\n \"0.50912935\",\n \"0.5077863\",\n \"0.507535\",\n \"0.50712097\",\n \"0.5061472\",\n \"0.50546056\",\n \"0.50495595\",\n \"0.5045799\",\n \"0.50398856\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.71698"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":81985,"cells":{"query":{"kind":"string","value":"Return a pyll graph with hyperparamters that will construct a sklearn.svm.SVR model with a user specified kernel."},"document":{"kind":"string","value":"def svr_kernel(name, kernel, epsilon=None, **kwargs):\n def _name(msg):\n return '%s.%s_%s' % (name, kernel, msg)\n\n hp_space = _svm_hp_space(_name, kernel=kernel, **kwargs)\n hp_space.update(_svr_hp_space(_name, epsilon))\n return scope.sklearn_SVR(**hp_space)"},"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 svm():","def __init__(self, kernel='poly', degree=3, verbose=False, gamma='auto', reg=1/1000, random_state=0):\n print(\"Initialize model SVM\")\n # Check if gamma='auto' is useful\n self.kernel = kernel\n self.random_state = random_state\n self.model = SVC(gamma=gamma, kernel=kernel, degree=degree, verbose=verbose, C=reg, random_state=random_state)","def find_svm_hyperparams():\n NUM_ITERS = 10\n # coefs = np.arange(-5, 5).astype(np.float)\n coefs = np.linspace(0.25, 1, 10)\n Cs = np.power(2, coefs)\n results = []\n\n for _ in range(NUM_ITERS):\n data = FaceDataset(\"embeddings/dev\", n=50)\n train_data, train_labels = data.train()\n test_data, test_labels = data.test()\n accs = []\n for c in tqdm(Cs):\n clf = svm.SVC(kernel=\"linear\", C=c)\n clf, _ = train(clf, train_data, train_labels)\n acc, _ = test(clf, test_data, test_labels)\n accs.append(acc)\n results.append(accs)\n\n results = np.mean(results, axis=0)\n s = plotly.graph_objs.Scatter(x=Cs, y=results)\n plotly.offline.plot([s], filename=\"svm_linear.html\")\n print(\"C={}\".format(Cs[np.argmax(results)]))","def find_linear_svm_hyperparams():\n NUM_ITERS = 10\n # coefs = np.arange(-5, 5).astype(np.float)\n coefs = np.linspace(0.25, 1, 10)\n Cs = np.power(2, coefs)\n results = []\n\n for _ in range(NUM_ITERS):\n data = FaceDataset(\"embeddings/dev\", n=50)\n train_data, train_labels = data.train()\n test_data, test_labels = data.test()\n accs = []\n for c in tqdm(Cs):\n clf = svm.SVC(kernel=\"linear\", C=c)\n clf, _ = train(clf, train_data, train_labels)\n acc, _ = test(clf, test_data, test_labels)\n accs.append(acc)\n results.append(accs)\n\n results = np.mean(results, axis=0)\n s = plotly.graph_objs.Scatter(x=Cs, y=results)\n plotly.offline.plot([s], filename=\"svm_linear.html\")\n print(\"C={}\".format(Cs[np.argmax(results)]))","def svc_model(params):\n\n if (params['random']):\n params['C'] = random.randrange(1, 13, step=1) * 0.1\n params['degree'] = random.choice([2, 3, 4, 5])\n params['kernel'] = random.choice(['linear', 'rbf', 'poly', 'sigmoid'])\n \n model = svm.SVC(\n decision_function_shape='ovo',\n C=params['C'],\n degree=params['degree'],\n kernel=params['kernel']\n )\n\n return model","def modelKSVM():\n\n list_kernel_type = ['linear', 'poly', 'rbf']\n random_state = 20 # Do not change this random_state\n\n objs_KSVM = []\n\n # Create a list of objects for the classifier for each of the above \"kernel\" types\n for kernel in list_kernel_type:\n svm = SVC(kernel=kernel, random_state=random_state)\n objs_KSVM.append(svm)\n\n return objs_KSVM","def __init__(self):\n self.svclassifier = SVC(kernel='linear')","def __init__(self, train_x, train_y, test_x, test_y, Tunning_Cs=[0.001, 0.01, 0.1, 1, 10]): \n self.Cs = Tunning_Cs\n self.train_x = train_x\n self.train_y = train_y\n self.test_x = test_x \n self.test_y = test_y\n self.model = svm.SVR(kernel='rbf', gamma='auto')","def svc_kernel(name, kernel, random_state=None, probability=False, **kwargs):\n def _name(msg):\n return '%s.%s_%s' % (name, kernel, msg)\n\n hp_space = _svm_hp_space(_name, kernel=kernel, **kwargs)\n hp_space.update(_svc_hp_space(_name, random_state, probability))\n return scope.sklearn_SVC(**hp_space)","def train_model(kernel, label):\n clf = svm.SVC(kernel='precomputed')\n clf.fit(kernel,label)\n return clf","def SVM():\n x1, x2 = generate_training_data_2D()\n Y = np.concatenate([np.zeros(x1.shape[0], dtype=np.int32),\n np.ones(x2.shape[0], dtype=np.int32)])\n X = np.concatenate([x1, x2], axis=0)\n rng = np.random.get_state()\n np.random.shuffle(X)\n # Set the random state back to previous to shuffle X & Y similarly\n np.random.set_state(rng)\n np.random.shuffle(Y)\n\n models, titles = get_fitted_svm(X, Y)\n\n plot_decision_boundary(X, Y, models, titles)","def train_svm(data, labels, kernel, C, gamma, degree, coef0):\n if kernel == 'linear':\n model = SVC(kernel=kernel, C=C)\n elif kernel == 'poly':\n model = SVC(kernel=kernel, C=C, degree=degree, coef0=coef0)\n elif kernel == 'rbf':\n model = SVC(kernel=kernel, C=C, gamma=gamma)\n else:\n raise ArgumentError(\"Unknown kernel function: %s\" % kernel)\n model.fit(data, labels)\n return model","def __init__(self):\n super().__init__()\n import sklearn\n import sklearn.svm\n self.model = sklearn.svm.LinearSVR","def svm_model_fn(features, labels, mode, params):\n\n feature_columns = [layers.real_valued_column(i) for i in features.keys()]\n example_id_column(features)\n\n weight_column_name = params.get(\"weight_column_name\")\n\n head = head_lib.binary_svm_head(\n weight_column_name=weight_column_name,\n enable_centered_bias=False)\n\n optimizer = sdca_optimizer.SDCAOptimizer(\n example_id_column=\"index\",\n num_loss_partitions=params[\"num_loss_partitions\"],\n symmetric_l1_regularization=params[\"l1_regularization\"],\n symmetric_l2_regularization=params[\"l2_regularization\"])\n\n chief_hook = linear._SdcaUpdateWeightsHook()\n update_weights_hook = chief_hook\n\n if not isinstance(optimizer, sdca_optimizer.SDCAOptimizer):\n raise ValueError(\"Optimizer must be of type SDCAOptimizer\")\n\n if isinstance(head,\n head_lib._BinarySvmHead): # pylint: disable=protected-access\n loss_type = \"hinge_loss\"\n elif isinstance(head,\n head_lib._BinaryLogisticHead): # pylint:\n # disable=protected-access\n loss_type = \"logistic_loss\"\n elif isinstance(head,\n head_lib._RegressionHead): # pylint:\n # disable=protected-access\n assert head.logits_dimension == 1, (\"SDCA only applies for \"\n \"logits_dimension=1.\")\n loss_type = \"squared_loss\"\n else:\n raise ValueError(\"Unsupported head type: {}\".format(head))\n\n parent_scope = \"linear\"\n\n with variable_scope.variable_op_scope(\n features.values(), parent_scope) as scope:\n features = features.copy()\n features.update(layers.transform_features(features, feature_columns))\n logits, columns_to_variables, bias = (\n layers.weighted_sum_from_feature_columns(\n columns_to_tensors=features,\n feature_columns=feature_columns,\n num_outputs=1,\n scope=scope))\n\n linear._add_bias_column(feature_columns, features, bias,\n columns_to_variables)\n\n def _train_op_fn(unused_loss):\n global_step = contrib_variables.get_global_step()\n sdca_model, train_op = optimizer.get_train_step(columns_to_variables,\n weight_column_name,\n loss_type, features,\n labels, global_step)\n if update_weights_hook is not None:\n update_weights_hook.set_parameters(sdca_model, train_op)\n return train_op\n\n model_fn_ops = head.create_model_fn_ops(\n features=features,\n labels=labels,\n mode=mode,\n train_op_fn=_train_op_fn,\n logits=logits)\n if update_weights_hook is not None:\n return model_fn_ops._replace(\n training_chief_hooks=(model_fn_ops.training_chief_hooks +\n [update_weights_hook]))\n return model_fn_ops","def __init__(self):\n super().__init__()\n import sklearn\n import sklearn.svm\n self.model = sklearn.svm.NuSVR","def SVM(x_train, x_test, y_train, kernel):\n svc_model = SVC(kernel=kernel)\n svc_model.fit(x_train, y_train)\n y_pred = svc_model.predict(x_test)\n return y_pred","def spkernel(*args,\n node_label='atom',\n edge_weight=None,\n node_kernels=None,\n n_jobs=None,\n verbose=True):\n # pre-process\n Gn = args[0] if len(args) == 1 else [args[0], args[1]]\n Gn = [g.copy() for g in Gn]\n weight = None\n if edge_weight is None:\n if verbose:\n print('\\n None edge weight specified. Set all weight to 1.\\n')\n else:\n try:\n some_weight = list(\n nx.get_edge_attributes(Gn[0], edge_weight).values())[0]\n if isinstance(some_weight, (float, int)):\n weight = edge_weight\n else:\n if verbose:\n print(\n '\\n Edge weight with name %s is not float or integer. Set all weight to 1.\\n'\n % edge_weight)\n except:\n if verbose:\n print(\n '\\n Edge weight with name \"%s\" is not found in the edge attributes. Set all weight to 1.\\n'\n % edge_weight)\n ds_attrs = get_dataset_attributes(\n Gn,\n attr_names=['node_labeled', 'node_attr_dim', 'is_directed'],\n node_label=node_label)\n\n # remove graphs with no edges, as no sp can be found in their structures, \n # so the kernel between such a graph and itself will be zero.\n len_gn = len(Gn)\n Gn = [(idx, G) for idx, G in enumerate(Gn) if nx.number_of_edges(G) != 0]\n idx = [G[0] for G in Gn]\n Gn = [G[1] for G in Gn]\n if len(Gn) != len_gn:\n if verbose:\n print('\\n %d graphs are removed as they don\\'t contain edges.\\n' %\n (len_gn - len(Gn)))\n\n start_time = time.time()\n\n pool = Pool(n_jobs)\n # get shortest path graphs of Gn\n getsp_partial = partial(wrapper_getSPGraph, weight)\n itr = zip(Gn, range(0, len(Gn)))\n if len(Gn) < 100 * n_jobs:\n# # use default chunksize as pool.map when iterable is less than 100\n# chunksize, extra = divmod(len(Gn), n_jobs * 4)\n# if extra:\n# chunksize += 1\n chunksize = int(len(Gn) / n_jobs) + 1\n else:\n chunksize = 100\n if verbose:\n iterator = tqdm(pool.imap_unordered(getsp_partial, itr, chunksize),\n desc='getting sp graphs', file=sys.stdout)\n else:\n iterator = pool.imap_unordered(getsp_partial, itr, chunksize)\n for i, g in iterator:\n Gn[i] = g\n pool.close()\n pool.join()\n \n# # ---- direct running, normally use single CPU core. ----\n# for i in tqdm(range(len(Gn)), desc='getting sp graphs', file=sys.stdout):\n# i, Gn[i] = wrapper_getSPGraph(weight, (Gn[i], i))\n\n # # ---- use pool.map to parallel ----\n # result_sp = pool.map(getsp_partial, range(0, len(Gn)))\n # for i in result_sp:\n # Gn[i[0]] = i[1]\n # or\n # getsp_partial = partial(wrap_getSPGraph, Gn, weight)\n # for i, g in tqdm(\n # pool.map(getsp_partial, range(0, len(Gn))),\n # desc='getting sp graphs',\n # file=sys.stdout):\n # Gn[i] = g\n\n # # ---- only for the Fast Computation of Shortest Path Kernel (FCSP)\n # sp_ml = [0] * len(Gn) # shortest path matrices\n # for i in result_sp:\n # sp_ml[i[0]] = i[1]\n # edge_x_g = [[] for i in range(len(sp_ml))]\n # edge_y_g = [[] for i in range(len(sp_ml))]\n # edge_w_g = [[] for i in range(len(sp_ml))]\n # for idx, item in enumerate(sp_ml):\n # for i1 in range(len(item)):\n # for i2 in range(i1 + 1, len(item)):\n # if item[i1, i2] != np.inf:\n # edge_x_g[idx].append(i1)\n # edge_y_g[idx].append(i2)\n # edge_w_g[idx].append(item[i1, i2])\n # print(len(edge_x_g[0]))\n # print(len(edge_y_g[0]))\n # print(len(edge_w_g[0]))\n\n Kmatrix = np.zeros((len(Gn), len(Gn)))\n\n # ---- use pool.imap_unordered to parallel and track progress. ----\n def init_worker(gn_toshare):\n global G_gn\n G_gn = gn_toshare\n do_partial = partial(wrapper_sp_do, ds_attrs, node_label, node_kernels) \n parallel_gm(do_partial, Kmatrix, Gn, init_worker=init_worker, \n glbv=(Gn,), n_jobs=n_jobs, verbose=verbose)\n\n\n # # ---- use pool.map to parallel. ----\n # # result_perf = pool.map(do_partial, itr)\n # do_partial = partial(spkernel_do, Gn, ds_attrs, node_label, node_kernels)\n # itr = combinations_with_replacement(range(0, len(Gn)), 2)\n # for i, j, kernel in tqdm(\n # pool.map(do_partial, itr), desc='calculating kernels',\n # file=sys.stdout):\n # Kmatrix[i][j] = kernel\n # Kmatrix[j][i] = kernel\n # pool.close()\n # pool.join()\n\n # # ---- use joblib.Parallel to parallel and track progress. ----\n # result_perf = Parallel(\n # n_jobs=n_jobs, verbose=10)(\n # delayed(do_partial)(ij)\n # for ij in combinations_with_replacement(range(0, len(Gn)), 2))\n # result_perf = [\n # do_partial(ij)\n # for ij in combinations_with_replacement(range(0, len(Gn)), 2)\n # ]\n # for i in result_perf:\n # Kmatrix[i[0]][i[1]] = i[2]\n # Kmatrix[i[1]][i[0]] = i[2]\n\n# # ---- direct running, normally use single CPU core. ----\n# from itertools import combinations_with_replacement\n# itr = combinations_with_replacement(range(0, len(Gn)), 2)\n# for i, j in tqdm(itr, desc='calculating kernels', file=sys.stdout):\n# kernel = spkernel_do(Gn[i], Gn[j], ds_attrs, node_label, node_kernels)\n# Kmatrix[i][j] = kernel\n# Kmatrix[j][i] = kernel\n\n run_time = time.time() - start_time\n if verbose:\n print(\n \"\\n --- shortest path kernel matrix of size %d built in %s seconds ---\"\n % (len(Gn), run_time))\n\n return Kmatrix, run_time, idx","def svr(self):\n\n svr_parameters = [{'kernel': ['linear', 'rbf'],\n 'C': hel.powerlist(0.1, 2, 10),\n 'epsilon': hel.powerlist(0.01, 2, 10),\n 'gamma': ['scale']},\n {'kernel': ['poly'],\n 'degree': list(range(2, 5, 1)),\n 'C': hel.powerlist(0.1, 2, 10),\n 'epsilon': hel.powerlist(0.01, 2, 10),\n 'gamma': ['scale']}]\n svr_grid = GridSearchCV(estimator=SVR(),\n param_grid=svr_parameters,\n scoring=self.scorer, cv=5, n_jobs=-1,\n iid=False)\n svr_grid_result = svr_grid.fit(self.X_train_scaled, self.y_train_scaled)\n best_svr_parameters = svr_grid_result.best_params_\n svr_score = svr_grid_result.best_score_\n print('Best SVR params: ' + str(best_svr_parameters))\n print('SVR score: ' + str(svr_score))\n if best_svr_parameters['kernel'] == 'poly':\n svr_regressor = SVR(kernel=best_svr_parameters['kernel'],\n degree=best_svr_parameters['degree'],\n C=best_svr_parameters['C'],\n epsilon=best_svr_parameters['epsilon'],\n gamma='scale')\n else:\n svr_regressor = SVR(kernel=best_svr_parameters['kernel'],\n C=best_svr_parameters['C'],\n epsilon=best_svr_parameters['epsilon'],\n gamma='scale')\n return svr_regressor","def convert(context, cm_node, inputs, outputs):\n kernel_enum = {'linearKernel': 'LINEAR', 'polyKernel': 'POLY',\n 'rbfKernel': 'RBF', 'sigmoidKernel': 'SIGMOID', 'precomputedKernel': 'PRECOMPUTED'}\n kernel = cm_node.supportVectorClassifier.kernel\n kernel_val = kernel.WhichOneof('kernel')\n svc_kernel = kernel_enum[kernel_val]\n\n if kernel_val == 'rbfKernel':\n svc_kernel_params = [kernel.rbfKernel.gamma, 0.0, 0.0]\n elif kernel_val == 'polyKernel':\n svc_kernel_params = [kernel.polyKernel.gamma,\n kernel.polyKernel.coef0, kernel.polyKernel.degree]\n elif kernel_val == 'sigmoidKernel':\n svc_kernel_params = [kernel.sigmoidKernel.gamma,\n kernel.sigmoidKernel.coef0, 0.0]\n elif kernel_val == 'linearKernel':\n svc_kernel_params = [0.0, 0.0, 0.0]\n\n prob_a = cm_node.supportVectorClassifier.probA\n prob_b = cm_node.supportVectorClassifier.probB\n svc_vectors_per_class = cm_node.supportVectorClassifier.numberOfSupportVectorsPerClass\n n_supports, svc_support_vectors = extract_support_vectors_as_dense_tensor(cm_node.supportVectorClassifier)\n chain_coef = list(itertools.chain.from_iterable(\n [coef.alpha for coef in cm_node.supportVectorClassifier.coefficients]))\n svc_coefficients = chain_coef\n svc_rho = [-x for x in cm_node.supportVectorClassifier.rho]\n\n nb = NodeBuilder(context, 'SVMClassifier', op_domain='ai.onnx.ml')\n nb.add_attribute('kernel_type', svc_kernel)\n nb.add_attribute('kernel_params', svc_kernel_params)\n if prob_a:\n nb.add_attribute('prob_a', prob_a)\n if prob_b:\n nb.add_attribute('prob_b', prob_b)\n nb.add_attribute('vectors_per_class', svc_vectors_per_class)\n nb.add_attribute('support_vectors', svc_support_vectors)\n nb.add_attribute('coefficients', svc_coefficients)\n nb.add_attribute('rho', svc_rho)\n svc_classes = cm_node.supportVectorClassifier.WhichOneof('ClassLabels')\n if svc_classes == 'int64ClassLabels':\n class_labels = list(int(i) for i in cm_node.supportVectorClassifier.int64ClassLabels.vector)\n nb.add_attribute('classlabels_ints', class_labels)\n elif svc_classes == 'stringClassLabels':\n class_labels = list(str(s) for s in cm_node.supportVectorClassifier.stringClassLabels.vector)\n nb.add_attribute('classlabels_strings', class_labels)\n\n nb.extend_inputs(inputs)\n\n # Find the ONNX name for the predicted label in CoreML\n predicted_label_name = context.get_onnx_name(cm_node.description.predictedFeatureName)\n nb.add_output(predicted_label_name)\n\n # The variable used to store the class probabilities produced by ONNX linear classifier\n probability_tensor_name = context.get_unique_name('probability_tensor')\n nb.add_output(probability_tensor_name)\n\n nodes = [nb.make_node()]\n\n if cm_node.description.predictedProbabilitiesName != '':\n # Find the corresponding ONNX name for CoreML's probability output (a dictionary)\n predicted_probability_name = context.get_onnx_name(cm_node.description.predictedProbabilitiesName)\n # Create a ZipMap to connect probability tensor and probability dictionary\n nodes.append(model_util.make_zipmap_node(context, probability_tensor_name,\n predicted_probability_name, class_labels))\n\n return nodes","def SVMRegression(trainingObs,trainingParam,Obs):\n svr = SVR(C=1.0, cache_size=2000, coef0=0.0, degree=3, epsilon=0.1, gamma=0., kernel='rbf', probability=False, shrinking=True, tol=0.00001)\n nparam=trainingParam.shape[1]\n vparam = []\n for i in range(0,nparam):\n print i\n svr.fit(trainingObs,trainingParam[:,i])\n vparam.append(svr.predict(Obs))\n vparam = np.array(vparam)\n return vparam.T","def getInputSpecification(cls):\n specs = super(LinearSVR, cls).getInputSpecification()\n specs.description = r\"\"\"The \\xmlNode{LinearSVR} \\textit{Linear Support Vector Regressor} is\n similar to SVR with parameter kernel=’linear’, but implemented in terms of liblinear rather than libsvm,\n so it has more flexibility in the choice of penalties and loss functions and should scale better to large numbers of samples.\n This class supports both dense and sparse input.\n \\zNormalizationPerformed{LinearSVR}\n \"\"\"\n specs.addSub(InputData.parameterInputFactory('epsilon', contentType=InputTypes.FloatType,\n descr=r\"\"\"Epsilon parameter in the epsilon-insensitive loss function. The value of\n this parameter depends on the scale of the target variable y. If unsure, set $epsilon=0.$\"\"\", default=0.0))\n specs.addSub(InputData.parameterInputFactory(\"loss\", contentType=InputTypes.makeEnumType(\"loss\", \"lossType\",['epsilon_insensitive’','squared_epsilon_insensitive']),\n descr=r\"\"\"Specifies the loss function. The epsilon-insensitive loss (standard SVR)\n is the L1 loss, while the squared epsilon-insensitive loss (``squared_epsilon_insensitive'') is the L2 loss.\"\"\",\n default='squared_epsilon_insensitive'))\n specs.addSub(InputData.parameterInputFactory(\"tol\", contentType=InputTypes.FloatType,\n descr=r\"\"\"Tolerance for stopping criterion\"\"\", default=1e-4))\n specs.addSub(InputData.parameterInputFactory(\"fit_intercept\", contentType=InputTypes.BoolType,\n descr=r\"\"\"Whether to calculate the intercept for this model. If set to false, no\n intercept will be used in calculations (i.e. data is expected to be already centered).\"\"\", default=True))\n specs.addSub(InputData.parameterInputFactory(\"intercept_scaling\", contentType=InputTypes.FloatType,\n descr=r\"\"\"When fit_intercept is True, instance vector x becomes $[x, intercept_scaling]$,\n i.e. a “synthetic” feature with constant value equals to intercept_scaling is appended\n to the instance vector. The intercept becomes $intercept_scaling * synthetic feature weight$\n \\nb the synthetic feature weight is subject to $l1/l2$ regularization as all other features.\n To lessen the effect of regularization on synthetic feature weight (and therefore on the intercept)\n $intercept_scaling$ has to be increased.\"\"\", default=1.))\n specs.addSub(InputData.parameterInputFactory(\"dual\", contentType=InputTypes.BoolType,\n descr=r\"\"\"Select the algorithm to either solve the dual or primal optimization problem.\n Prefer dual=False when $n_samples > n_features$.\"\"\", default=True))\n specs.addSub(InputData.parameterInputFactory(\"max_iter\", contentType=InputTypes.IntegerType,\n descr=r\"\"\"Hard limit on iterations within solver.``-1'' for no limit\"\"\", default=-1))\n return specs","def train(self, prob: SvmProblem):\n # Define variables\n self.prob = prob\n c = prob.C\n c2 = prob.gamma\n xkern = prob.xkernel\n xsk = prob.xskernel\n\n # Swap params, so SVM solves X* with correct params\n prob.C = c2\n prob.xkernel = xsk\n\n # Find SVM solution in X*\n svm = SVM()\n priv_clf = svm.train(prob.Xstar, prob)\n\n # Replace swapped out params so modified SVM solves X with correct params\n prob.C = c\n prob.xkernel = xkern\n\n # Get the 'frames of knowledge' - Get the kernel distance from each\n # privileged training data-point to the privileged support vectors\n frames = np.zeros((prob.num, len(priv_clf.support_vectors)))\n for i in range(prob.num):\n for j in range(len(priv_clf.support_vectors)):\n frames[i][j] = prob.xkernel((priv_clf.support_vectors[j]), prob.Xstar[i])\n\n # Form pairs so that each training point is matched against each 'frame of knowledge'\n training_pairs = np.zeros((prob.num, len(priv_clf.support_vectors)), dtype=object)\n for i in range(prob.num):\n for j in range(len(priv_clf.support_vectors)):\n training_pairs[i][j] = [prob.X[i], frames[i][j]]\n training_pairs = np.array(training_pairs)\n\n regr_pairs = np.zeros((len(priv_clf.support_vectors), prob.num), dtype=object)\n for i in range(prob.num):\n for j in range(len(priv_clf.support_vectors)):\n regr_pairs[j][i] = training_pairs[i][j]\n\n # Learn a regression based on above pairs\n self.models = []\n for dataSet in regr_pairs:\n regr = SVR(kernel='rbf')\n xs = []\n ys = []\n for i in range(prob.num):\n xs.append(dataSet[i][0].flatten())\n ys.append(dataSet[i][1])\n xs = np.array(xs)\n ys = np.array(ys)\n self.models.append(regr.fit(xs, ys))\n\n # Transform data from X using learned regression\n new_xs = []\n new_ys = []\n for i in range(prob.num):\n new_xs.append(self.transform(prob.X[i].reshape(1, -1)).flatten())\n new_ys.append(priv_clf.predict(prob.Xstar[i]))\n new_x = np.asarray(new_xs)\n new_y = np.array(new_ys)\n\n # Form a new problem and learn an SVMd+ solution for it\n new_prob = SvmProblem(new_x, prob.Xstar, new_y)\n new_svm = SVMdp()\n self.clf = new_svm.train(new_prob)","def _find_svm_rbf_params(df, metrics, kernel):\n context = ramp.DataContext(data=df)\n config = ramp.Configuration(target=\"target\",\n features=[ramp.BaseFeature(x) for x in metrics])\n x, y = ramp.models.get_xy(config, context)\n\n if kernel == \"linear\":\n param_grid = dict(C=10.0 ** np.arange(-2, 5))\n else:\n param_grid = dict(gamma=10.0 ** np.arange(-5, 4),\n C=10.0 ** np.arange(-2, 9))\n grid = sklearn.grid_search.GridSearchCV(sklearn.svm.SVC(kernel=kernel),\n param_grid=param_grid,\n cv=sklearn.cross_validation.StratifiedKFold(y=y, k=3),\n verbose=True)\n grid.fit(x, y)\n print grid.best_estimator_\n out = {}\n for attr in param_grid.keys():\n out[attr] = getattr(grid.best_estimator_, attr)\n return out","def train_svm(X, y):\n svm = SVC(C=1000000.0, gamma=0.0, kernel='rbf')\n svm.fit(X, y)\n return svm","def select_hyperparams(\n df,\n kfold_params,\n tfidf_path,\n model_path,\n code_col,\n target_col,\n n_trials,\n hyperparam_space,\n default_hyperparams,\n):\n\n study = optuna.create_study(direction=\"maximize\", study_name=\"svm with kernels\")\n objective = Objective(df, kfold_params, code_col, target_col, **hyperparam_space)\n\n if n_trials > 0:\n study.optimize(objective, n_trials=n_trials)\n params = study.best_params\n else:\n params = default_hyperparams\n\n best_tfidf_params = {\n \"smooth_idf\": True,\n }\n best_svm_params = {\n \"random_state\": RANDOM_STATE,\n \"max_iter\": MAX_ITER,\n }\n for key, value in params.items():\n model_name, param_name = key.split(\"__\")\n if model_name == \"tfidf\":\n best_tfidf_params[param_name] = value\n elif model_name == \"svm\":\n best_svm_params[param_name] = value\n\n code_blocks_tfidf = tfidf_fit_transform(df[code_col], best_tfidf_params, tfidf_path)\n X, y = code_blocks_tfidf, df[target_col].values\n clf = SVC(**best_svm_params)\n\n f1_mean, f1_std, accuracy_mean, accuracy_std, preds = cross_val_predict(\n objective.kf, clf, X, y\n )\n if model_path is not None:\n clf.fit(X, y)\n pickle.dump(clf, open(model_path, \"wb\"))\n\n metrics = dict(\n test_f1_score=f1_mean,\n test_accuracy=accuracy_mean,\n test_f1_std=f1_std,\n test_accuracy_std=accuracy_std,\n )\n\n return best_tfidf_params, best_svm_params, metrics, preds","def get_hyperparams(self):","def ex_2_b(x_train, y_train, x_test, y_test):\n ###########\n ## TODO:\n ## Train SVMs with polynomial kernels for different values of the degree\n ## (Remember to set the 'coef0' parameter to 1)\n ## and plot the variation of the training and test scores with polynomial degree using 'plot_score_vs_degree' func.\n ## Plot the decision boundary and support vectors for the best value of degree\n ## using 'plot_svm_decision_boundary' function\n ###########\n degrees = range(1, 21)\n\n test_scores = np.array([])\n train_scores = np.array([])\n best_svm = None\n best_test_score = 0\n\n for deg in degrees:\n clf = svm.SVC(kernel='poly', degree=deg, coef0=1)\n clf.fit(x_train, y_train)\n\n test_score = clf.score(x_test, y_test)\n\n if test_score > best_test_score:\n best_test_score = test_score\n best_svm = clf\n\n test_scores = np.append(test_scores, test_score)\n train_scores = np.append(train_scores, clf.score(x_train, y_train))\n\n plot_score_vs_degree(train_scores, test_scores, degrees)\n\n plot_svm_decision_boundary(clf, x_train, y_train, x_test, y_test)","def get_model_5(parameters):\n # Generate model\n model = svm.LinearSVC(max_iter=100000)\n \n # Return the model\n return model","def __init__(self, **kwargs):\n super(SVM, self).__init__()\n\n # initialize some default values for the SVM backend\n self.max_iter = kwargs.pop('max_iter', 1e6)\n\n # parameters for k cross validation / hyper-parameter tuning\n self.params = [{\n 'kernel': ['rbf', 'sigmoid', 'poly'],\n 'C': [1e1, 1e2, 1e3, 1e4],\n 'gamma': [1e4, 1e3, 1e2, 1, 1e-1, 1e-2],\n 'degree': [2,3,4]}]\n self.k_cross_val = kwargs.pop('k_cross_val', 5)\n\n # initialize the classifier using grid search to find optimal parameters\n # via cross validation\n if kwargs.pop('cross_validation', True):\n self.clf = GridSearchCV(_SVC(max_iter=self.max_iter, **kwargs),\n self.params,\n cv=self.k_cross_val)\n else:\n probability = kwargs.pop('probability', True)\n self.clf = _SVC(max_iter=self.max_iter, probability=probability, **kwargs)","def svm_regression(y, x=None, ker='rbf', opt=0.1, show=False):\n from sklearn.svm import SVR\n if x is None: # Assume linearly spaced points\n x = np.arange(0,len(y))\n # Fit the regression model\n if ker == 'linear':\n svr = SVR(kernel=ker, C=1e3)\n elif ker == 'poly':\n if type(opt) is not int:\n print('Need a degree for a polynomial fit, not' + str(opt))\n return None\n svr = SVR(kernel=ker, C=1e3, degree=opt)\n else:\n svr = SVR(kernel='rbf', C=1e3, gamma=opt) # default is radial basis func\n y_svr = svr.fit(x, y).predict(x) # Fit\n \n # And plot if requested\n if show:\n plt.scatter(x, y, c='k', label='data')\n plt.plot(x, y_svr, c='b', label='SVR model')\n plt.xlabel('data')\n plt.ylabel('target')\n plt.title('Support Vector Regression')\n plt.legend()\n plt.show()\n return y_svr","def __init__(self, x, y, method='svm', n_cv=5, **kwargs):\n self.x = x\n self.y = y\n self.rf_stat = None\n self.summary = {}\n self.n_cv = n_cv\n self.method = method\n if 'kernel' in kwargs.keys(): self.kernel = kwargs['kernel']\n\n self.print_flag = kwargs.get('print_flag', 'off')\n self.stat = {'train': None, 'test': None}\n # self.direct = kwargs[''] # TODO more generic here","def __init__(self,training_data,default_kernel=\"rbf\"):\n my_data = genfromtxt(training_data, delimiter='\\t',skip_header=0)\n n_col = my_data.shape[1]\n n_features=n_col-1 #assuming that the latest column\n #contains the the outputs \n #preprocessing data\n X = preprocessing.scale(np.hsplit(my_data,[n_features,n_col])[0])\n Y = np.squeeze(np.asarray(np.hsplit(my_data,[n_features,n_col])[1]))\n #defining scaling\n self.scaler = preprocessing.Scaler()\n self.scaler.fit(np.hsplit(my_data,[n_features,n_col])[0])\n #define classifier\n self.classifier = svm.SVC(class_weight='auto',cache_size=DEFAULT_CACHE_SIZE, kernel=default_kernel)\n self.classifier.fit(X, Y)","def build_svm_pipeline():\n svm_pipeline = None\n\n svm_pipeline = Pipeline([\n ('vect', CountVectorizer()),\n ('clf', SGDClassifier()),\n ])\n\n return svm_pipeline","def get_model_4(parameters):\n # Generate model\n model = svm.SVC(C=parameters['C'], gamma='scale', probability=True,\n class_weight='balanced',\n decision_function_shape='ovr')\n \n # Return the model\n return model","def svm_train(c, g, v, dname):\n if sys.platform != 'win32':\n # grid_py = '../tools/grid.py'\n # gnuplot_exe = '/usr/bin/gnuplot'\n svmtrain_exe = './PromoterSVM/libsvm/windows/my-svm-train'\n else:\n # grid_py = r\"D:\\LiYuan\\Data_Science\\libsvm-3.21\\windows\\grid.py\"\n # gnuplot_exe = r\"D:\\Program Files\\gnuplot\\bin\\gnuplot.exe\"\n svmtrain_exe = r'D:\\LiYuan\\\"Bioinformatic Research\"\\IMU\\zuo\\Tasks\\\"20160206-Promoter SVM\"\\biopromoter_script\\PromoterSVM\\libsvm\\windows\\my-svm-train.exe'\n\n df_model = dname + \".model\"\n cmd = '{0} -c {1} -g {2} -v {3} \"{4}\" \"{5}\"'.format(svmtrain_exe, c, g, v, dname, df_model)\n Popen(cmd, shell=True, stdout=PIPE).communicate()","def train(self, params):\n for param in params:\n if param not in self.__info__['space']:\n print(\"Error: not supported parameters {}\".format(param))\n\n if self.dataset_type == PROBLEM.CLASSIFICATION:\n model = SVC(C=float(params[\"C\"]),\n kernel=params[\"Kernel\"],\n gamma=params[\"Gamma\"],\n coef0=float(params[\"Coef0\"]))\n else:\n model = SVR(C=float(params[\"C\"]),\n kernel=params['Kernel'],\n gamma=params[\"Gamma\"],\n coef0=float(params[\"Coef0\"]))\n\n # train\n model.fit(self.X_train, self.Y_train)\n return model","def custom_training(nb_tweet_sample, randomised, equal_pos_neg, language, name_kernel, Resource, keep_null_vector):\n m_features, m_labels = get_characteristic_label_vectors(nb_tweet_sample, randomised, equal_pos_neg, Resource,\n keep_null_vector, language)\n\n kernel = Kernel.get_correct_kernel(name_kernel)\n custom_SVM = SVM(kernel)\n custom_SVM.fit(m_features, m_labels)\n\n return custom_SVM","def svmtrain(x,y,w=None):\n # xl = x.tolist() \n # yl = y.tolist()\n clf = svm.SVC(kernel='linear', C=1000) # apparently C param here really matters\n clf.fit(x,y)\n return({'w':clf.coef_, 'b':clf.intercept_,'clf':clf, 'n_support':clf.support_vectors_.shape[0]})","def classical_kernel_estimation(in_train, in_test, labels):\n X_train = []\n Y_train = []\n X_test = []\n Y_test = []\n for lab in labels:\n for datum in in_train[lab]:\n X_train.append(datum)\n Y_train.append(lab)\n for datum in in_test[lab]:\n X_test.append(datum)\n Y_test.append(lab)\n clf = svm.SVC(gamma='auto')\n clf.fit(X_train, Y_train)\n print(clf.score(X_test, Y_test))","def ex_2_c(x_train, y_train, x_test, y_test):\n ###########\n ## TODO:\n ## Train SVMs with RBF kernels for different values of the gamma\n ## and plot the variation of the test and training scores with gamma using 'plot_score_vs_gamma' function.\n ## Plot the decision boundary and support vectors for the best value of gamma\n ## using 'plot_svm_decision_boundary' function\n ###########\n gammas = np.arange(0.01, 2, 0.02)\n\n test_scores = np.array([])\n train_scores = np.array([])\n best_svm = None\n best_test_score = 0\n\n for gamma in gammas:\n clf = svm.SVC(kernel='rbf', gamma=gamma)\n clf.fit(x_train, y_train)\n\n test_score = clf.score(x_test, y_test)\n\n if test_score > best_test_score:\n best_test_score = test_score\n best_svm = clf\n\n test_scores = np.append(test_scores, test_score)\n train_scores = np.append(train_scores, clf.score(x_train, y_train))\n\n plot_score_vs_gamma(train_scores, test_scores, gammas)\n\n plot_svm_decision_boundary(clf, x_train, y_train, x_test, y_test)","def define_kernel(self, *args, **kwargs):\n base_kernel = self.base_kernel\n if base_kernel is None:\n base_kernel = 'VertexHistogram'\n k = getattr(kernels, self.kernel_name)\n k_base = getattr(kernels, base_kernel)\n kernel = k(base_graph_kernel=k_base, *args, **kwargs)\n return kernel","def svm_clf_training(max_features, data):\r\n X_train, y_train, X_test, y_test = data\r\n clf = Pipeline([('feature_selection', SelectKBest(score_func=chi2, k=max_features)),\r\n ('clf', svm.SVC(C=1., kernel='linear'))])\r\n\r\n vectorizer = CountVectorizer(ngram_range=(1, 2), lowercase=True) # unigrams and bigrams\r\n X_matrix_tr = vectorizer.fit_transform(X_train)\r\n # parameters = [{'clf__kernel': ['linear'], 'clf__C': [0.1, 1, 10, 100]},\r\n # {'clf__kernel': ['rbf'], 'clf__C': [0.1, 1, 10, 100], 'clf__gamma': [0.001, 0.01, 0.1]},\r\n # {'clf__kernel': ['poly'], 'clf__C': [0.1, 1, 10, 100], 'clf__degree': [2, 3, 4, 5]}]\r\n # clf = GridSearchCV(svc, parameters, scoring='accuracy')\r\n clf.fit(X_matrix_tr, y_train)\r\n # print(\"Best parameters set found on development set:\")\r\n # print()\r\n # print(clf.best_estimator_)\r\n # print()\r\n # print(\"Grid scores on development set:\")\r\n # print()\r\n # for params, mean_score, scores in clf.grid_scores_:\r\n # print(\"%0.3f (+/-%0.03f) for %r\"\r\n # % (mean_score, scores.std() / 2, params))\r\n # print()\r\n voc = vectorizer.get_feature_names()\r\n # vectorizer1 = CountVectorizer(ngram_range=(1, 2), lowercase=True, vocabulary=voc)\r\n # X_matrix_val = vectorizer1.fit_transform(X_test)\r\n # y_pred = clf.predict(X_matrix_val)\r\n\r\n # for i in range(len(X_test)):\r\n # if y_test[i] != y_pred[i]:\r\n # print(X_test[i], y_test[i], y_pred[i])\r\n # print(classification_report(y_test, y_pred))\r\n return clf, voc","def ex_1_a(x, y):\n ###########\n ## Train an SVM with a linear kernel\n ## and plot the decision boundary and support vectors using 'plot_svm_decision_boundary' function\n ###########\n\n clf = svm.SVC(kernel='linear')\n clf.fit(x, y)\n plot_svm_decision_boundary(clf, x, y)\n pass","def SVR_predict(data, X_train, X_test, y_train, y_test, param):\n if param == 'NUETP' or param == 'SOEGP':\n kernel_name = 'sigmoid'\n c_value = 90.0\n elif param == 'HYTCP' or param == 'WYTCP':\n kernel_name = 'linear'\n c_value = 1000\n else:\n raise ValueError('Incorrect parameter name')\n clf = SVR(kernel=kernel_name, C=c_value, epsilon=0.3).fit(X_train, y_train)\n future_x = data[['GDP_scaled','CLPRB_scaled','EMFDB_scaled','ENPRP_scaled','NGMPB_scaled','PAPRB_scaled','PCP_scaled','ZNDX_scaled','OP_scaled','OP2_scaled']][-6:]\n pred = pd.DataFrame(clf.predict(future_x))\n #Replacing negative values with 0\n for i in range(6):\n if pred[0][i] < 0:\n pred[0][i] = 0\n data[param][-6:] = pred[0]\n return data","def __init__(self, foundVariables, trainingData, trainingClasses, trainingWeights, testingData, testingClasses):\n self.clf = svm.SVC(probability=True)\n self.foundVariables = foundVariables\n self.trainingData = trainingData\n self.trainingClasses = trainingClasses\n self.testingData = testingData\n self.testingClasses = testingClasses\n self.trainingWeights = trainingWeights","def sgd_model(params):\n\n \n if (params['random']):\n params['loss'] = random.choice(['hinge', 'log', 'modified_huber', 'squared_hinge', 'perceptron', 'squared_loss', 'huber', 'epsilon_insensitive', 'squared_epsilon_insensitive'])\n params['penalty'] = random.choice(['none', 'l2', 'l1', 'elasticnet'])\n params['alpha'] = random.choice([0.001, 0.0001, 0.00001])\n model = SGDClassifier(\n loss=params['loss'],\n penalty=params['penalty'],\n alpha=params['alpha']\n )\n\n return model","def plot_svm(N=5, std=0.60, kernel='linear'):\n X, y = make_blobs(n_samples=200, centers=2, random_state=0,\n cluster_std=std)\n\n X_train, y_train = X[:N], y[:N]\n X_test, y_test = X[N:], y[N:]\n\n clf = SVC(kernel=str(kernel))\n clf.fit(X_train, y_train)\n\n plt.scatter(X_train[:, 0], X_train[:, 1], c=y_train, s=50, cmap='spring')\n plt.scatter(X_test[:, 0], X_test[:, 1], c=y_test, s=50, cmap='spring',\n alpha=0.2)\n plt.xlim(-1, 4)\n plt.ylim(-1, 6)\n plot_svc_decision_function(clf, plt.gca())\n plt.scatter(clf.support_vectors_[:, 0], clf.support_vectors_[:, 1],\n s=200, facecolors='none')\n\n train_score = clf.score(X_train, y_train)\n test_score = clf.score(X_test, y_test) if len(X_test) > 0 else 'NA'\n plt.title('Train Accuracy = {0}; Test Accuracy = {1}'.format(train_score,\n test_score))","def get_nonlinear_model():\n ss = StandardScaler()\n svm = SVC(kernel='rbf', probability=True, random_state=42) # kernel SVM\n\n svm_model = Pipeline(steps=(['scale', ss], ['clf', svm]))\n\n svm_model_params = {\n 'clf__C':loguniform(1e-3,1e3),\n 'clf__gamma':loguniform(1e-4,1e1)\n }\n\n # model: classifier with randomised parameter search over nested 3-fold CV\n nonlinear_model = RandomizedSearchCV(svm_model, svm_model_params, n_iter=100, cv=3)\n\n return clone(nonlinear_model)","def get_vertex_vek(*args, data_dir=None, **kwargs):\n\n annots = _apply_vek_prob(data_dir=data_dir)\n vertex_labels, parcel_labels = [], []\n for hemi in ('lh', 'rh'):\n vc = _convert_vek_to_classes(getattr(annots, hemi), data_dir=data_dir)\n vertex_labels.append(vc)\n parcel_labels.append(np.unique(vc))\n return NETWORKS(np.hstack(vertex_labels), np.hstack(parcel_labels))","def GenerateS(s): \n for i in range(len(x_train)):\n for j in range(len(SVs)):\n index = int(SVs[j])\n s[i] = s[i] + alpha[index]*y_train[index] * Kernel(i, index) # (DotProduct(i, index)+1)**5\n return s","def kernel_to_skl(kernel):\n try:\n kernel = eval('kernels.' + kernel, {'__builtins__': None},\n {'kernels': __import__('sklearn.gaussian_process.kernels',\n fromlist=['kernels'])})\n except (TypeError, AttributeError):\n raise AttributeError('scikit-learn kernel unknown.')\n\n return kernel","def getInputSpecification(cls):\n specs = super(NuSVR, cls).getInputSpecification()\n specs.description = r\"\"\"The \\xmlNode{NuSVR} \\textit{Nu-Support Vector Regression} is an Nu-Support Vector Regressor.\n It is very similar to SVC but with the addition of the hyper-parameter Nu for controlling the\n number of support vectors. However, unlike NuSVC, where nu replaces C,\n here nu replaces the parameter epsilon of epsilon-SVR.\n \\zNormalizationPerformed{NuSVR}\n \"\"\"\n specs.addSub(InputData.parameterInputFactory('nu', contentType=InputTypes.FloatType,\n descr=r\"\"\"An upper bound on the fraction of margin errors and\n a lower bound of the fraction of support vectors. Should be in the interval $(0, 1]$.\"\"\", default=0.5))\n specs.addSub(InputData.parameterInputFactory('C', contentType=InputTypes.FloatType,\n descr=r\"\"\"Regularization parameter. The strength of the regularization is inversely\n proportional to C.\n Must be strictly positive. The penalty is a squared l2 penalty.\"\"\", default=1.0))\n specs.addSub(InputData.parameterInputFactory(\"kernel\", contentType=InputTypes.makeEnumType(\"kernel\", \"kernelType\",['linear','poly',\n 'rbf','sigmoid']),\n descr=r\"\"\"Specifies the kernel type to be used in the algorithm. It must be one of\n ``linear'', ``poly'', ``rbf'' or ``sigmoid''.\"\"\", default='rbf'))\n specs.addSub(InputData.parameterInputFactory(\"degree\", contentType=InputTypes.IntegerType,\n descr=r\"\"\"Degree of the polynomial kernel function ('poly').Ignored by all other kernels.\"\"\",\n default=3))\n specs.addSub(InputData.parameterInputFactory(\"gamma\", contentType=InputTypes.FloatType,\n descr=r\"\"\"Kernel coefficient for ``poly'', ``rbf'' or ``sigmoid''. If not input, then it uses\n $1 / (n_features * X.var())$ as value of gamma\"\"\", default=\"scale\"))\n specs.addSub(InputData.parameterInputFactory(\"coef0\", contentType=InputTypes.FloatType,\n descr=r\"\"\"Independent term in kernel function\"\"\", default=0.0))\n specs.addSub(InputData.parameterInputFactory(\"tol\", contentType=InputTypes.FloatType,\n descr=r\"\"\"Tolerance for stopping criterion\"\"\", default=1e-3))\n specs.addSub(InputData.parameterInputFactory(\"cache_size\", contentType=InputTypes.FloatType,\n descr=r\"\"\"Size of the kernel cache (in MB)\"\"\", default=200.))\n specs.addSub(InputData.parameterInputFactory(\"shrinking\", contentType=InputTypes.BoolType,\n descr=r\"\"\"Whether to use the shrinking heuristic.\"\"\", default=True))\n specs.addSub(InputData.parameterInputFactory(\"max_iter\", contentType=InputTypes.IntegerType,\n descr=r\"\"\"Hard limit on iterations within solver.``-1'' for no limit\"\"\", default=-1))\n return specs","def build_model():\n # build pipeline with count vecotrizer, tfidf and support vector machine\n pipeline_SVC = Pipeline([\n ('vect', CountVectorizer(tokenizer = tokenize)),\n ('tfidf', TfidfTransformer()),\n ('multi-clf', MultiOutputClassifier(LinearSVC()))\n ])\n\n # define parameters for gridsearch\n parameters_SVC = {\n 'vect__max_df': (.6, 1),\n 'tfidf__norm': ('l1', 'l2'),\n 'multi-clf__estimator__C': (.1, 1, 100)\n }\n\n # build parameter grid and fit data\n model = GridSearchCV(pipeline_SVC, parameters_SVC)\n\n return model","def __init__(self, estimator, target_language='java',\n target_method='predict', **kwargs):\n super(SVC, self).__init__(estimator, target_language=target_language,\n target_method=target_method, **kwargs)\n self.estimator = estimator","def add_model_parameter_ui(clf_name):\n params = dict()\n if clf_name == 'KNN':\n K = st.sidebar.slider(\"K\", 1, 5)\n params[\"K\"] = K\n\n elif clf_name == 'SVM':\n C = st.sidebar.slider(\"C\", 0.01, 10.0)\n params[\"C\"] = C\n\n elif clf_name == 'Random Forest':\n max_depth = st.sidebar.slider(\"max_depth\", 2, 15)\n n_estimators = st.sidebar.slider(\"n_estimators\", 1, 100)\n params[\"max_depth\"] = max_depth\n params[\"n_estimators\"] = n_estimators\n\n else:\n pass\n\n return params","def test_lrp_svm(self, syn_genomic_data, syn_fm, syn_idx, rep, tmp_path, syn_true_pvalues): \n rep_to_plot = 0\n ttbrs = [0.5, 1,1.5]\n idx = syn_idx[str(rep_to_plot)]\n fig, axes = plt.subplots(len(ttbrs), 5, figsize=[30,15])\n x_3d = syn_fm(\"3d\")[str(rep_to_plot)][:]\n x_2d = syn_fm(\"2d\")[str(rep_to_plot)][:]\n indices_true= [inds_true for inds_true, x in enumerate(syn_true_pvalues[0].flatten()) if x]\n\n for i, ttbr in enumerate(ttbrs):\n print('Using tbrr={}'.format(ttbr))\n labels = generate_syn_phenotypes(tower_to_base_ratio=ttbr, quantity=rep)\n labels_cat = {}\n for key, l in labels.items():\n labels_cat[key] = tensorflow.keras.utils.to_categorical((l+1)/2)\n \n best_params_montaez['n_snps']= x_3d.shape[1]\n \n l_0b=labels_cat[str(rep_to_plot)]\n\n model = create_montaez_dense_model(best_params_montaez)\n y_integers = np.argmax(l_0b[idx.train], axis=1)\n class_weights = class_weight.compute_class_weight('balanced', np.unique(y_integers), y_integers)\n d_class_weights = dict(enumerate(class_weights))\n\n model.fit(x=x_3d[idx.train], y=l_0b[idx.train], validation_data=(x_3d[idx.test], l_0b[idx.test]), epochs=best_params_montaez['epochs'], class_weight=d_class_weights, callbacks=[ ReduceLROnPlateau(monitor='val_loss', factor=best_params_montaez['factor'], patience=best_params_montaez['patience'], mode='min'),],)\n\n model = iutils.keras.graph.model_wo_softmax(model)\n analyzer = innvestigate.analyzer.LRPAlpha1Beta0(model)\n weights = analyzer.analyze(x_3d).sum(0)\n\n top_indices_sorted, filtered_weights = postprocess_weights(weights, top_k, filter_window_size, p_svm, p_pnorm_filter)\n\n complete_pvalues = chi_square(syn_genomic_data[str(rep_to_plot)][:], labels[str(rep_to_plot)])\n \n pvalues_filled_deep = np.ones(n_total_snps)\n pvalues_filled_deep[top_indices_sorted] = complete_pvalues[top_indices_sorted]\n\n # Plot RPVT\n plot_pvalues(complete_pvalues, indices_true, axes[i][0])\n if i==0:\n axes[i][0].set_title('RPVT $-log_{10}$(p-values)', fontsize=22)\n axes[i][0].set_ylabel('$-log_{10}$(p-value)', fontsize=18)\n plt.setp(axes[i][0].get_yticklabels(), fontsize=16)\n plt.setp(axes[i][0].get_xticklabels(), fontsize=16)\n\n # Plot svm weights \n clf = LinearSVC(penalty='l2', loss='hinge', C=0.0022, dual=True, tol=1e-3, verbose=0, class_weight='balanced')\n idx_now, pvalues, raw_weights = combi_method(clf, syn_genomic_data[str(rep_to_plot)][:],x_2d, labels[str(rep_to_plot)], 35, 2, 2, 30)\n #filtered_svm_weights = postprocess_weights_without_avg(raw_weights, p_svm)\n pvalues_filled_combi = np.ones(len(complete_pvalues))\n pvalues_filled_combi[idx_now] = pvalues\n #svm_weights = toy_classifier.fit(x_2d, labels[str(rep_to_plot)]).coef_\n axes[i][1].scatter(range(len(np.absolute(raw_weights).sum(1))), 1000*np.absolute(raw_weights).sum(1), marker='.', color='darkblue')\n axes[i][1].scatter(indices_true,1000*np.absolute(raw_weights).sum(1)[indices_true], color='fuchsia')\n axes[i][1].set_ylim(0,1000*(np.max(np.absolute(raw_weights).sum(1))+0.001))\n if i==0:\n axes[i][1].set_title('Absolute SVM weights * 1000', fontsize=22)\n plt.setp(axes[i][1].get_yticklabels(), fontsize=16)\n plt.setp(axes[i][1].get_xticklabels(), fontsize=16)\n\t\t\t\n # Plot COMBI\n plot_pvalues(pvalues_filled_combi, indices_true, axes[i][2])\n if i==0:\n axes[i][2].set_title('COMBI $-log_{10}$(p-values)', fontsize=22)\n if i==2:\n axes[i][2].set_xlabel('SNP position', fontsize=18)\n plt.setp(axes[i][2].get_yticklabels(), fontsize=16)\n plt.setp(axes[i][2].get_xticklabels(), fontsize=16)\n\t\t\t\n # Plot LRP relevance scores\n axes[i][3].scatter(range(len(np.absolute(weights).reshape(-1, 3).sum(1))), np.absolute(weights).reshape(-1, 3).sum(1), marker='.', color='darkblue')\n axes[i][3].scatter(indices_true,np.absolute(weights).reshape(-1, 3).sum(1)[indices_true], color='fuchsia')\n #axes[i][1].legend()\n axes[i][3].set_ylim(0,np.max(np.absolute(weights).reshape(-1, 3).sum(1))+1)\n if i==0:\n axes[i][3].set_title('LRP relevance scores', fontsize=22)\n plt.setp(axes[i][3].get_yticklabels(), fontsize=16)\n plt.setp(axes[i][3].get_xticklabels(), fontsize=16)\n\t\t\t\n # Plot DeepCOMBI\n plot_pvalues(pvalues_filled_deep, indices_true, axes[i][4])\n if i==0:\n axes[i][4].set_title('DeepCOMBI $-log_{10}$(p-value)', fontsize=22)\n plt.setp(axes[i][4].get_yticklabels(), fontsize=16)\n plt.setp(axes[i][4].get_xticklabels(), fontsize=16)\n\t\t\t\n ## Plot distribution of postprocessed vectors\n #axes[i][2].plot(postprocessed_weights)\n #axes[i][2].set_title('Postprocessed relevance')\n\n fig.savefig(os.path.join(IMG_DIR, 'manhattan-example-toy-NAR.png'), bbox_inches='tight')","def train_model(self, text, labels):\n clf = svm.SVR()\n count_vect = CountVectorizer()\n tfidf_transformer = TfidfTransformer()\n counts = count_vect.fit_transform(text)\n tfidf = tfidf_transformer.fit_transform(counts)\n clf.fit(tfidf, labels)\n\n return clf, count_vect, tfidf_transformer","def SVM_train(X, y, cv):\r\n rev = 10000\r\n start_time = time.time()\r\n print('\\n'+ '# '*10+'[Training] Support Vector Machine (SVM) (max_iter='+str(rev)+'):'+ ' #'*10)\r\n parameters = {\r\n 'kernel':('linear', 'poly', 'rbf'),\r\n 'C':(1, 5, 10),\r\n 'gamma':('scale', 'auto')\r\n }\r\n print('-'*2+'Grid Search Parameters:')\r\n print(parameters)\r\n clf = svm.SVC(random_state=rstate, probability=True, max_iter=rev) # Max_iter infinite as default, stuck on large datasets > 10^4.\r\n clf = GridSearchCV(clf, parameters, cv=cv, scoring='f1')\r\n clf.fit(X, y)\r\n print('-'*2+'GridSearch Results:')\r\n with pd.option_context('display.max_rows', None, 'display.max_columns', None):\r\n print(pd.DataFrame(clf.cv_results_))\r\n print('> '*2+'Training time: %.4f seconds.'%(time.time()-start_time))\r\n return clf","def train(self, trainingData, trainingLabels, validationData, validationLabels):\n from sklearn import svm\n \n \"*** YOUR CODE HERE ***\"\n self.sklearn_svm = svm.SVC(C=5, kernel='rbf', gamma=0.005, decision_function_shape='ovo')\n self.sklearn_svm.fit(trainingData, trainingLabels)","def train_SVM(data: np.array, labels: np.array)->None:\n print(\"SVM is not implemented yet!\")","def thundersvm_load_svm_model(input_svm_model_file):\n \n svm_model = SVC()\n svm_model.load_from_file(input_svm_model_file)\n \n return svm_model","def hyper_parameter_tuning(X, y, classifier, models, sntypes_map, feature_names, fig_dir='.', remove_models=(), name=''):\n\n # Hyperparameter grid\n n_estimators = [int(x) for x in np.linspace(start=200, stop=2000, num=10)]\n max_features = ['auto', 'sqrt']\n max_depth = [int(x) for x in np.linspace(10, 110, num=11)]\n max_depth.append(None)\n min_samples_split = [2, 5, 10]\n min_samples_leaf = [1, 2, 4]\n bootstrap = [True, False]\n random_grid = {'n_estimators': n_estimators,\n 'max_features': max_features,\n 'max_depth': max_depth,\n 'min_samples_split': min_samples_split,\n 'min_samples_leaf': min_samples_leaf,\n 'bootstrap': bootstrap}\n\n # Get data\n num_features = X.shape[1]\n model_names = [sntypes_map[model] for model in models]\n X, y, models, remove_models = remove_redundant_classes(X, y, models, remove_models)\n\n # Get best features\n n = 50\n num_features, feature_names, X = get_n_best_features(n, X, y, classifier, feature_names, num_features, fig_dir, name, models, model_names)\n\n # Randomised Search\n clf_random = RandomizedSearchCV(estimator=classifier, param_distributions=random_grid, n_iter=7, cv=3, verbose=2,\n random_state=42, n_jobs=2)\n clf_random.fit(X, y)\n print(clf_random.best_params_)\n\n def evaluate(model, test_features, test_labels):\n predictions = model.predict(test_features)\n errors = abs(predictions - test_labels)\n mape = 100 * np.mean(errors / test_labels)\n accuracy = 100 - mape\n print('Model Performance')\n print('Average Error: {:0.4f} degrees.'.format(np.mean(errors)))\n print('Accuracy = {:0.2f}%.'.format(accuracy))\n\n return accuracy\n\n best_random = clf_random.best_estimator_\n # random_accuracy = evaluate(best_random, test_features, test_labels)","def bgplvm_test_model(seed=default_seed, optimize=False, verbose=1, plot=False):\r\n from GPy.likelihoods.gaussian import Gaussian\r\n import GPy\r\n\r\n num_inputs = 13\r\n num_inducing = 5\r\n if plot:\r\n output_dim = 1\r\n input_dim = 2\r\n else:\r\n input_dim = 2\r\n output_dim = 25\r\n\r\n # generate GPLVM-like data\r\n X = _np.random.rand(num_inputs, input_dim)\r\n lengthscales = _np.random.rand(input_dim)\r\n k = (GPy.kern.rbf(input_dim, .5, lengthscales, ARD=True)\r\n + GPy.kern.white(input_dim, 0.01))\r\n K = k.K(X)\r\n Y = _np.random.multivariate_normal(_np.zeros(num_inputs), K, output_dim).T\r\n lik = Gaussian(Y, normalize=True)\r\n\r\n k = GPy.kern.rbf_inv(input_dim, .5, _np.ones(input_dim) * 2., ARD=True) + GPy.kern.bias(input_dim) + GPy.kern.white(input_dim)\r\n # k = GPy.kern.linear(input_dim) + GPy.kern.bias(input_dim) + GPy.kern.white(input_dim, 0.00001)\r\n # k = GPy.kern.rbf(input_dim, ARD = False) + GPy.kern.white(input_dim, 0.00001)\r\n # k = GPy.kern.rbf(input_dim, .5, _np.ones(input_dim) * 2., ARD=True) + GPy.kern.rbf(input_dim, .3, _np.ones(input_dim) * .2, ARD=True)\r\n # k = GPy.kern.rbf(input_dim, .5, 2., ARD=0) + GPy.kern.rbf(input_dim, .3, .2, ARD=0)\r\n # k = GPy.kern.rbf(input_dim, .5, _np.ones(input_dim) * 2., ARD=True) + GPy.kern.linear(input_dim, _np.ones(input_dim) * .2, ARD=True)\r\n\r\n m = GPy.models.BayesianGPLVM(lik, input_dim, kernel=k, num_inducing=num_inducing)\r\n #===========================================================================\r\n # randomly obstruct data with percentage p\r\n p = .8\r\n Y_obstruct = Y.copy()\r\n Y_obstruct[_np.random.uniform(size=(Y.shape)) < p] = _np.nan\r\n #===========================================================================\r\n m2 = GPy.models.BayesianGPLVMWithMissingData(Y_obstruct, input_dim, kernel=k, num_inducing=num_inducing)\r\n m.lengthscales = lengthscales\r\n\r\n if plot:\r\n import matplotlib.pyplot as pb\r\n m.plot()\r\n pb.title('PCA initialisation')\r\n m2.plot()\r\n pb.title('PCA initialisation')\r\n\r\n if optimize:\r\n m.optimize('scg', messages=verbose)\r\n m2.optimize('scg', messages=verbose)\r\n if plot:\r\n m.plot()\r\n pb.title('After optimisation')\r\n m2.plot()\r\n pb.title('After optimisation')\r\n\r\n return m, m2","def set_hyperparams(self, params):","def svm(xtrain, ytrain, xtest, ytest,labels_mapping, scaled = False):\n if not scaled :\n scaler = StandardScaler()\n xtrain = scaler.fit_transform(xtrain)\n xtest = scaler.transform(xtest)\n\n svm = SVC(C=10, cache_size=1500, class_weight='balanced')\n svm = __train_and_test(svm, xtrain, ytrain, xtest, ytest,labels_mapping)\n return svm","def ex_2_b(x_train, y_train, x_test, y_test):\n ###########\n ## TODO:\n ## Train SVMs with polynomial kernels for different values of the degree\n ## (Remember to set the 'coef0' parameter to 1)\n ## and plot the variation of the test and training scores with polynomial degree using 'plot_score_vs_degree' func.\n ## Plot the decision boundary and support vectors for the best value of degree\n ## using 'plot_svm_decision_boundary' function\n ###########\n\n degrees = range(1, 21)\n machines = [svm.SVC(kernel='poly', degree=d, coef0=1.0) for d in degrees]\n\n for machine in machines:\n machine.fit(x_train, y_train)\n\n trainScores = [machine.score(x_train, y_train) for machine in machines]\n testScores = [machine.score(x_test, y_test) for machine in machines]\n\n plot_score_vs_degree(trainScores, testScores, degrees)\n\n bestDegree = testScores.index(max(testScores))\n print('Score of best polynomial degree ({}): {}'.format(bestDegree + 1, testScores[bestDegree]))\n plot_svm_decision_boundary(machines[bestDegree], x_train, y_train, x_test, y_test)","def SVM_train(Ktrain,y,lbda_vec):\r\n n = Ktrain.shape[0]\r\n for idx, lbda in enumerate(lbda_vec): \r\n C = 1/(2*lbda*n)\r\n P = matrix(Ktrain, tc=\"d\")\r\n q = - matrix(y,tc=\"d\")\r\n G = matrix( np.concatenate( (np.diagflat(y) , -np.diagflat(y) ), axis=0 ),tc=\"d\" )\r\n h1 = C * np.ones((n,1))\r\n h2 = np.zeros((n,1)) \r\n h = matrix(np.concatenate((h1,h2),axis=0))\r\n\r\n solvers.options['show_progress'] = False\r\n \r\n sol = solvers.qp(P,q,G,h) \r\n a = np.asarray(sol['x'])\r\n\r\n #alpha is sparse\r\n a[np.where(np.abs(a) < 1e-4)] = 0\r\n y_svm = np.dot(Ktrain,a)\r\n\r\n print(\"Précision pour lambda = \" + str(lbda) + \" :\", accuracy(y_svm,y))","def hyperparameter_cv(X_data, y_data, hyperparameters):\n\n # Create Grid of hyperparameters\n grid = cartesian_product(hyperparameters)\n\n # Loop through hyperparameters \n best_score = 0\n for hyperparameter in grid:\n # Initialize Modle\n model = svm.SVC(kernel='linear', **hyperparameter)\n\n # Train and Get Accuracy\n print(f\"Training using hyperparameters: {hyperparameter}\")\n score = cross_validation_score(X_data, y_data, model, folds=5)\n print(f\"Accuracy Score: {score}\")\n\n if score > best_score:\n best_score = score\n best_parameters = hyperparameter\n \n return best_score, best_parameters","def test_SVM_rbf_test_C_parameter(params, X_train, X_test, y_train, y_test):","def search_ksvm_hyperparams(model, x, y, kernel, C_list, eps_list, folds=3):#C_list,\n # divide data into training and validation sets:\n N = x.shape[0]\n\n # get random indices for dataset folds\n indices = torch.randperm(N)\n length = N // folds\n\n max_acc = 0.0\n max_C = 0.0\n max_eps = 0.0\n for C in C_list:\n for eps in eps_list:\n acc = torch.zeros(folds)\n for k in range(folds):\n x_train = torch.cat((x[indices[0:k*length]],x[indices[(k+1)*length:]]),dim = 0)\n y_train = torch.cat((y[indices[0:k*length]],y[indices[(k+1)*length:]]),dim = 0)\n x_val = x[indices[k*length:(k+1)*length]]\n y_val = y[indices[k*length:(k+1)*length]]\n\n model.__init__(kernel, C, eps)\n model.train(x_train, y_train, print_progress = False)\n y_pred = model.predict(x_val)\n acc[k] = ((y_val==y_pred).sum()) / float(y_val.shape[0])\n acc_mean = acc.mean()\n if(acc_mean > max_acc):\n max_acc = acc_mean\n max_C = C\n max_eps = eps\n\n print(\"at C = {} and eps = {} we get acc = {}\" .format(C, eps, acc_mean))\n\n\n print(\"Max we get at: C: {} and eps = {} we get acc = {}\" .format(max_C, max_eps, max_acc))\n return max_acc, max_C, max_eps","def sklearn2graph(model, output_names=None, **kwargs):\n conv = identify_interpreter(model)\n return conv(model, output_names=output_names, **kwargs)","def train_linear_SVM(X_train_input, y_train_input, C=1):\r\n from sklearn.svm import SVC\r\n svc_clf = SVC(kernel='linear', probability=True, C=C)\r\n svc_clf.fit(X_train_input, y_train_input)\r\n return svc_clf","def svr_grid_search(self, param_grid, make_plots=False, winner_plot=False):\n # TODO: Generalize to pass in any arbitrary learning object, e.g. my Neuron-By-Neuron object to search.\n # Update variable that determines whether we generate a plot for the lowest mse values.\n if winner_plot:\n self.winner_plot = winner_plot\n\n # Iterate over each parameter and generate a surface.\n cnt = 1\n\n for params in ParameterGrid(param_grid):\n my_gamma = params['gamma']\n my_c = params['C']\n\n # Set shrinking heuristics to false as per the example Matlab code.\n clf = SVR(shrinking=False, kernel='rbf', C=my_c, gamma=my_gamma, cache_size=500)\n # Train against training set.\n tic = time.time()\n clf.fit(self.x_train, self.y_train)\n toc = time.time() - tic\n\n # Generate predicted set using SVR network using the test set.\n train_prediction = clf.predict(self.x_train)\n\n # Create output based on SVR prediction.\n self.prediction = clf.predict(self.x_test)\n\n # Calculate the Mean Squared Error based on the ideal test output and that predicted by the SVR.\n train_mse = mean_squared_error(self.y_train, train_prediction)\n test_mse = mean_squared_error(self.y_test, self.prediction)\n\n # Record Best mse and update with a better\n if test_mse < self.best_mse:\n self.best_mse = test_mse\n self.best_prediction = self.prediction\n self.winner = {\n 'SVR': clf,\n 'train_mse': train_mse,\n 'test_mse': test_mse,\n 'train_time': toc\n }\n if make_plots:\n # Generate graph and save as file for upload to LaTeX document.\n # Have to do this because I wanted to add another parameter with gamma = 'auto'\n # When gamma = 'auto', it sets it to the reciprocal of the number of RBFs, if I'm not mistaken.\n\n if my_gamma != 'auto':\n gamma_str = '%0.3f' % my_gamma\n else:\n gamma_str = my_gamma\n\n my_title = 'Surface with gamma=%s C=%0.3f and mse=%0.5f (train mse=%0.5f)' % (\n gamma_str, my_c, test_mse, train_mse)\n my_filename = '%s_%d' % (self.plot_filename_prefix, cnt)\n Plot(self.x_test[:, 0], self.x_test[:, 1], self.prediction).surf_rand(title=my_title,\n save_fig_path=my_filename)\n cnt += 1\n\n if self.winner_plot:\n my_gamma = self.winner['SVR'].gamma\n my_c = self.winner['SVR'].C\n if my_gamma != 'auto':\n gamma_str = '%0.3f' % my_gamma\n else:\n gamma_str = my_gamma\n\n my_title = 'Surface with gamma=%s C=%0.3f and Test mse=%0.5f (Train mse=%0.5f)' % (\n gamma_str, my_c, self.winner['test_mse'], self.winner['train_mse'])\n my_filename = '%s_winner.png' % self.plot_filename_prefix\n Plot(self.x_test[:, 0], self.x_test[:, 1], self.best_prediction).surf_rand(title=my_title,\n save_fig_path=my_filename)\n return self.winner","def main():\n\n if len(sys.argv) < 4 or len(sys.argv) > 5:\n print 'Usage: classifier.py data_dimension train_set_path test_set_path [option: add_bias]'; \n return; \n\n # create sets of possible hyperparameter values\n setC = {0.001, 0.01, 0.1, 1, 10, 25, 100}; # trade off regularizer and error minimization\n setRho = {0.001, 0.01, 0.1, 1}; # learning rate for gradient descent \n hyperparams = [setC, setRho];\n \n # create svm classifier for selected data\n dataDim = int(sys.argv[1]);\n trainPath = str(sys.argv[2]);\n testPath = str(sys.argv[3]);\n if len(sys.argv) == 5:\n c = Classifier('svm', hyperparams, dataDim, testPath, trainPath, addBias=True);\n else:\n c = Classifier('svm', hyperparams, dataDim, testPath, trainPath);\n \n print 'Classifier type: ', c.type, \\\n '\\nTraining set: ', trainPath, \\\n '\\nTest set: ', testPath;\n \n print 'Determining hyperparameters to use...';\n c.learnHyperparams(report=1);\n \n print 'Training classifier...';\n c.train();\n \n print 'Performing inference on test set...';\n c.test(); \n \n print '\\nREPORT:', \\\n '\\nUsing hyperparameters: ', c.theta, \\\n '\\nLearned weight vector: ', c.w, \\\n '\\nPrediction accuracy on test set: ', c.accuracy * 100, ' percent';","def train(prob: SvmProblem):\n # Define variables\n x = prob.X\n y = prob.Y\n C = prob.C\n C2 = prob.gamma\n\n # Swap params, so SVM solves X* with correct params\n xk = prob.xkernel\n xsk = prob.xskernel\n\n prob.C = C2\n prob.xkernel = xsk\n\n svm = SVM()\n xstar_clf = svm.train(prob.Xstar, prob)\n\n # Get distance to decision boundary\n xi_star = np.zeros(prob.num)\n for i in range(prob.num):\n output = (1 - prob.Y[i] * (xstar_clf.f(prob.Xstar[i])))\n xi_star[i] = max(0, output)\n\n # Replace swapped out params so modified SVM solves X with correct params\n prob.C = C\n prob.xkernel = xk\n\n # Define the inputs to CVXOPT - See Appendix G.4\n P = prob.yi_yj * prob.xi_xj\n q = -np.ones((prob.num, 1))\n G1 = -np.eye(prob.num)\n G2 = np.eye(prob.num)\n G3 = xi_star.reshape(1, -1)\n G = np.vstack((G1, G2))\n G = np.vstack((G, G3))\n h1 = np.zeros(prob.num).reshape(-1, 1)\n h2 = np.repeat((1 + prob.delta) * C, prob.num).reshape(-1, 1)\n h3 = sum(xi_star) * C\n h = np.vstack((h1, h2))\n h = np.vstack((h, h3))\n A = y.reshape(1, -1)\n b = np.zeros(1)\n\n P = matrix(P, tc='d')\n q = matrix(q, tc='d')\n G = matrix(G, tc='d')\n h = matrix(h, tc='d')\n A = matrix(A, tc='d')\n b = matrix(b, tc='d')\n\n # Solve optimization problem using CVXOPT\n solvers.options['show_progress'] = False\n sol = solvers.qp(P, q, G, h, A, b)\n alphas = np.array(sol['x'])\n\n # Get the bias\n bacond1 = (alphas > 1e-8)\n bacond2 = (alphas <= (1 + prob.delta) * C)\n bcond = np.array([a and b for a, b in zip(bacond1, bacond2)]).flatten()\n\n yS = y[bcond]\n xS = x[bcond]\n aS = alphas[bcond]\n\n sum_total = 0\n for s in range(len(yS)):\n inner_total = 0\n for m in range(len(yS)):\n am = aS[m]\n ym = yS[m]\n xm_xs = prob.xkernel(xS[m], xS[s])\n inner_total += am * ym * xm_xs\n sum_total += yS[s] - inner_total\n\n bias = sum_total / len(yS)\n\n # Populate Classifier object to be returned\n clf = Classifier()\n clf.b = bias\n clf.alphas = alphas\n clf.xs = x\n clf.ys = y\n clf.kern = prob.xkernel\n return clf","def run_model(LinearSVM_params, category):\n \n # Unload common parameters\n config = LinearSVM_params['configs'][category] if LinearSVM_params['configs'] else None\n verbose = LinearSVM_params['verbose']\n warning = LinearSVM_params['warning']\n stats_path = LinearSVM_params['stats_path']\n\n model_name = LinearSVM_params['model_name']\n print(f'Running model {model_name}')\n\n # Unload the training data specific parameters\n train_size = LinearSVM_params['train_size']\n active_learning_iter = LinearSVM_params['active_learning_iter']\n cross_validation = LinearSVM_params['cross_validate']\n full = LinearSVM_params['full_dataset']\n active_learning = LinearSVM_params['active_learning']\n w_hx = LinearSVM_params['with_historical_data']\n w_k = LinearSVM_params['with_k']\n\n # Specify the desired operation\n fine_tuning = LinearSVM_params['fine_tuning']\n save_model = LinearSVM_params['save_model']\n to_params = True\n\n if fine_tuning:\n class_weights = [{0: i, 1: 1.0-i} for i in np.linspace(.1, .9, num=9)]\n class_weights.append('balanced')\n class_weights.append(None)\n\n ft_params = {\n # 'penalty': ['l1', 'l2'],\n 'penalty': ['l1'],\n # 'loss': ['hinge', 'squared_hinge'],\n 'loss': ['squared_hinge'],\n 'dual': [False],\n # 'C': [.001, .01, .1, 1, 10],\n 'C': [i for i in np.linspace(0.001, 0.01, num=10)],\n # 'tol': [.0001, .001, .01, .1, 1],\n 'tol': [i for i in np.linspace(0.01, 0.1, num=10)],\n 'fit_intercept': [True],\n 'class_weight': class_weights,\n }\n\n _ = grid_search(\n ActiveLinearSVM,\n ft_params,\n train_size,\n active_learning_iter,\n active_learning=active_learning,\n w_hx=w_hx,\n w_k=w_k,\n info=True\n )\n else:\n # Load the desired sized dataset under desired option\n amine_list, x_t, y_t, x_v, y_v, all_data, all_labels = process_dataset(\n train_size=train_size,\n active_learning_iter=active_learning_iter,\n verbose=verbose,\n cross_validation=cross_validation,\n full=full,\n active_learning=active_learning,\n w_hx=w_hx,\n w_k=w_k\n )\n\n # print(amine_list)\n for amine in amine_list:\n if cross_validation:\n # print(\"Training and cross validation on {} amine.\".format(amine))\n\n # Create the LinearSVM model instance for the specific amine\n ALSVM = ActiveLinearSVM(\n amine=amine,\n config=config,\n verbose=verbose,\n stats_path=stats_path,\n model_name=model_name)\n\n # Load the training and validation set into the model\n ALSVM.load_dataset(x_t[amine], y_t[amine], x_v[amine], y_v[amine], all_data[amine], all_labels[amine])\n\n # Train the data on the training set\n ALSVM.train(warning=warning)\n\n # Conduct active learning with all the observations available in the pool\n if active_learning:\n ALSVM.active_learning(num_iter=active_learning_iter, warning=warning, to_params=to_params)\n else:\n ALSVM.store_metrics_to_params()\n\n # Save the model for future reproducibility\n if save_model:\n ALSVM.save_model(model_name)\n\n # TODO: testing part not implemented: might need to change the logic loading things in","def mylinearsvm(lambdat, eta_init, maxiter, X, y):\n d = np.size(X, 1)\n beta_init = np.zeros(d)\n theta_init = np.zeros(d)\n betas, objs = fast_grad(beta_init, theta_init, lambdat, eta_init, maxiter,X=X,y=y)\n return betas, objs","def office_smooth_kernels(parser, args, params):\n parser.add_argument('-h_length', type=str,\n help='Variance of Gaussian [horizontal] (default=25)',\n metavar='', default='25')\n parser.add_argument('-v_length', type=str,\n help='Variance of Gaussian [vertical] (default=5)',\n metavar='', default='5')\n local_args = parser.parse_known_args(args)\n h_length = local_args[0].h_length\n v_length = local_args[0].v_length\n\n control.smooth_kernels(params, h_length, v_length)","def do_lsvm(x_data, y_data, bst_model):\n bst_lsvm = SVC(C = bst_model.best_estimator_.C, kernel = \"linear\")\n bst_lsvm_fit = bst_lsvm.fit(x_data, y_data)\n return True","def test_SVM_test_C_parameter(params, X_train, X_test, y_train, y_test):","def ex_1_a(x, y):\n ###########\n ## TODO:\n ## Train an SVM with a linear kernel\n ## and plot the decision boundary and support vectors using 'plot_svm_decision_boundary' function\n ###########\n\n clf = svm.SVC(kernel='linear')\n clf.fit(x, y)\n\n plot_svm_decision_boundary(clf, x, y)","def select_model():\r\n from sklearn import tree\r\n import graphviz\r\n\r\n ValidationSetAndLabels = AllSets[1]\r\n ValLabels = ValidationSetAndLabels[:, [-1]] # extract labels (last column)\r\n ValSet = np.delete(ValidationSetAndLabels, -1, axis=1) # delete labels\r\n\r\n TrainingSetAndLabels = AllSets[2]\r\n TrainLabels = TrainingSetAndLabels[:, [-1]] # extract labels (last column)\r\n TrainSet = np.delete(TrainingSetAndLabels, -1, axis=1) # delete labels\r\n\r\n \"\"\"\r\n This is the code to select the best hyperparameter (part b)\r\n\r\n for SplitCriterion in ['entropy', 'gini']:\r\n print \"Criterion: \" + SplitCriterion + '\\n'\r\n\r\n for MaxDepth in [int(depth) for depth in np.linspace(1, np.log2(TrainSet.shape[1]), 5)]:\r\n print \"max_depth: \" + str(MaxDepth) + '\\n'\r\n\r\n MyTree = tree.DecisionTreeClassifier(criterion=SplitCriterion, max_depth=MaxDepth)\r\n MyTree = MyTree.fit(TrainSet, TrainLabels)\r\n\r\n Predictions = MyTree.predict(ValSet)\r\n Result = np.abs(Predictions - ValLabels.flatten())\r\n\r\n Accuracy = 100 * float(np.count_nonzero(Result == 0)) / Predictions.shape[0]\r\n\r\n print \"Accuracy for this test is: %f %%\" %Accuracy\r\n print '\\n'\r\n\r\n print '\\n'\r\n \"\"\"\r\n\r\n MyTree = tree.DecisionTreeClassifier(criterion='entropy', max_depth=12)\r\n\r\n MyTree = MyTree.fit(TrainSet, TrainLabels)\r\n\r\n Predictions = MyTree.predict(ValSet)\r\n Result = np.abs(Predictions - ValLabels.flatten())\r\n\r\n Accuracy = 100 * float(np.count_nonzero(Result == 0)) / Predictions.shape[0]\r\n\r\n dot_data = tree.export_graphviz(MyTree, out_file=None, max_depth=2,\r\n feature_names=AllSets[3], filled=True, rounded=True, special_characters=True,\r\n class_names=TrainLabels.flatten().astype(str))\r\n graph = graphviz.Source(dot_data)\r\n graph.render(\"output\")","def __init__(self, training_data, kernel, par_sigma, par_lambda):\n self.kernel = kernel\n self.par_sigma = par_sigma\n self.par_lambda = par_lambda\n self.training_data = training_data\n\n self.assert_data_shape(training_data)\n\n # train model\n k = self.kernel.get_kernel_matrix(training_data[0], training_data[0])\n u = scipy.linalg.cholesky(k + self.par_lambda * numpy.identity(k.shape[0]))\n beta = scipy.linalg.solve_triangular(u, training_data[1], trans='T')\n alpha = scipy.linalg.solve_triangular(u, beta)\n\n self.alpha = alpha.reshape(alpha.size, 1)\n self.u = u","def _get_current_hyperparameters(self):","def make_graph_from_vectors(X, *, knn_edges, random_edges=0, virtual_vertices=0, deduplicate=True,\n directed=True, verbose=False, squared=False, GraphEmbeddingClass=GraphEmbedding,\n **kwargs):\n num_vectors, vector_dim = X.shape\n X = np.require(check_numpy(X), dtype=np.float32, requirements=['C_CONTIGUOUS'])\n if virtual_vertices != 0:\n if verbose: print(\"Creating virtual vertices by k-means\")\n X_clusters = KMeans(virtual_vertices).fit(X).cluster_centers_\n X = np.concatenate([X, X_clusters])\n\n if verbose:\n print(\"Searching for nearest neighbors\")\n try:\n from faiss import IndexFlatL2\n index = IndexFlatL2(vector_dim)\n index.add(X)\n neighbor_distances, neighbor_indices = index.search(X, knn_edges + 1)\n except ImportError:\n warn(\"faiss not found, using slow knn instead\")\n neighbor_distances, neighbor_indices = NearestNeighbors(n_neighbors=knn_edges + 1).fit(X).kneighbors(X)\n\n if not squared:\n neighbor_distances **= 0.5\n if verbose:\n print(\"Adding knn edges\")\n edges_from, edges_to, distances = [], [], []\n for vertex_i in np.arange(num_vectors):\n for neighbor_i, distance in zip(neighbor_indices[vertex_i], neighbor_distances[vertex_i]):\n if vertex_i == neighbor_i: continue # forbid loops\n if neighbor_i == -1: continue # ANN engine uses -1 for padding\n edges_from.append(vertex_i)\n edges_to.append(neighbor_i)\n distances.append(distance)\n\n if random_edges != 0:\n if verbose: print(\"Adding random edges\")\n random_from = np.random.randint(0, num_vectors, num_vectors * random_edges)\n random_to = np.random.randint(0, num_vectors, num_vectors * random_edges)\n for vertex_i, neighbor_i in zip(random_from, random_to):\n if vertex_i != neighbor_i:\n distance = np.sum((X[vertex_i] - X[neighbor_i]) ** 2)\n if not squared: distance **= 0.5\n edges_from.append(vertex_i)\n edges_to.append(neighbor_i)\n distances.append(distance)\n\n if deduplicate:\n if verbose: print(\"Deduplicating edges\")\n unique_edges_dict = {} # {(from_i, to_i) : distance(i, j)}\n for from_i, to_i, distance in zip(edges_from, edges_to, distances):\n edge_iijj = int(from_i), int(to_i)\n if not directed:\n edge_iijj = tuple(sorted(edge_iijj))\n unique_edges_dict[edge_iijj] = distance\n\n edges_iijj, distances = zip(*unique_edges_dict.items())\n edges_from, edges_to = zip(*edges_iijj)\n\n edges_from, edges_to, distances = map(np.asanyarray, [edges_from, edges_to, distances])\n if verbose:\n print(\"Total edges: {}, mean edges per vertex: {}, mean distance: {}\".format(\n len(edges_from), len(edges_from) / float(num_vectors), np.mean(distances)\n ))\n return GraphEmbeddingClass(edges_from, edges_to, initial_weights=distances, directed=directed, **kwargs)","def do_rbfsvm(x_data, y_data, bst_model):\n\n bst_rbfsvm = SVC(C = bst_model.best_estimator_.C, gamma = bst_model.best_estimator_.gamma)\n bst_rbfsvm_fit = bst_lsvm.fit(x_data, y_data)\n return True","def train_svm_model(self, X_train, X_test, y_train, y_test):\r\n clf = Pipeline([('vect', CountVectorizer()), ('tfidf', TfidfTransformer()),\r\n ('clf', LinearSVC())])\r\n clf = clf.fit(X_train, y_train)\r\n pred = clf.predict(X_test)\r\n print('Confusion matrix\\n',confusion_matrix(y_test,pred))\r\n print('Classification_report\\n',classification_report(y_test,pred))\r\n return clf","def main(argv):\n\n # Parse arguments and store in model_dict\n model_dict = svm_model_dict_create()\n DR = model_dict['dim_red']\n rev_flag = model_dict['rev']\n strat_flag = 1\n\n # Load dataset and create data_dict to store metadata\n print('Loading data...')\n dataset = model_dict['dataset']\n if (dataset == 'MNIST') or (dataset == 'GTSRB'):\n X_train, y_train, X_val, y_val, X_test, y_test = load_dataset(\n model_dict)\n img_flag = None\n elif dataset == 'HAR':\n X_train, y_train, X_test, y_test = load_dataset(model_dict)\n img_flag = None\n # TODO: 2 classes case\n # if model_dict['classes'] == 2:\n # X_train = X_train\n\n data_dict = get_data_shape(X_train, X_test)\n n_features = data_dict['no_of_features']\n\n # Reshape dataset to have dimensions suitable for SVM\n X_train_flat = X_train.reshape(-1, n_features)\n X_test_flat = X_test.reshape(-1, n_features)\n # Center dataset with mean of training set\n mean = np.mean(X_train_flat, axis=0)\n X_train_flat -= mean\n X_test_flat -= mean\n\n # Create a new model or load an existing one\n clf = model_creator(model_dict, X_train_flat, y_train)\n model_tester(model_dict, clf, X_test_flat, y_test)\n\n # Assign parameters\n n_mag = 25 # No. of deviations to consider\n dev_list = np.linspace(0.1, 2.5, n_mag) # A list of deviations mag.\n if dataset == 'MNIST':\n rd_list = [784, 331, 200, 100, 90, 80, 70, 60, 50, 40, 30, 20, 10] # Reduced dimensions to use\n # rd_list = [784]\n elif dataset == 'HAR':\n rd_list = [561, 200, 100, 90, 80, 70, 60, 50, 40, 30, 20, 10]\n # rd_list = [561]\n n_rd = len(rd_list)\n output_list = []\n clear_flag = None\n # Clear old output files\n if clear_flag ==1:\n abs_path_o = resolve_path_o(model_dict)\n _, fname = file_create(model_dict)\n os.remove(abs_path_o + fname + '.txt')\n _, fname = file_create(model_dict, rd=1, strat=strat_flag, rev=rev_flag)\n os.remove(abs_path_o + fname + '.txt')\n\n # Test clf against adv. samples\n print('Performing attack...')\n if model_dict['classes'] != 2:\n for i in range(n_mag):\n X_adv, y_ini = mult_cls_atk(clf, X_test_flat, mean, dev_list[i])\n output_list.append(acc_calc_all(clf, X_adv, y_test, y_ini))\n if img_flag != None:\n save_svm_images(model_dict, data_dict, X_test, X_adv,\n dev_list[i])\n fname = print_svm_output(model_dict, output_list, dev_list)\n # subprocess.call([\"gnuplot -e \\\"filename='{}.png'; in_name='{}.txt'\\\" gnu_in_loop.plg\".format(fname,fname)], shell=True)\n # else:\n # # TODO: 2 classes\n # print('TODO')\n\n # Retrain defense and strategic attack\n print('--------------Retrain Defense & Strategic Attack--------------')\n for rd in rd_list:\n output_list = []\n print('Reduced dimensions: {}'.format(rd))\n\n # Dimension reduce dataset and reshape\n X_train_dr, _, dr_alg = dr_wrapper(\n X_train_flat, X_test_flat, DR, rd, y_train, rev=rev_flag)\n\n # With dimension reduced dataset, create new model or load existing one\n clf = model_creator(model_dict, X_train_dr, y_train, rd, rev_flag)\n # Modify classifier to include transformation matrix\n clf = model_transform(model_dict, clf, dr_alg)\n\n model_tester(model_dict, clf, X_test_flat, y_test, rd, rev_flag)\n\n # rev_flag = 1\n # model_dict['rev'] = rev_flag\n # # Dimension reduce dataset and reshape\n # X_train_dr, _, dr_alg = dr_wrapper(\n # X_train_flat, X_test_flat, DR, rd, y_train, rev=rev_flag)\n #\n # # With dimension reduced dataset, create new model or load existing one\n # clf_1 = model_creator(model_dict, X_train_dr, y_train, rd, rev_flag)\n # # Modify classifier to include transformation matrix\n # clf_1 = model_transform(model_dict, clf_1, dr_alg)\n # # Test model on original data\n # model_tester(model_dict, clf_1, X_test_flat, y_test, rd, rev_flag)\n #\n # print clf_1.coef_[0]-clf.coef_[0]\n # print np.linalg.norm(clf_1.coef_[0]), np.linalg.norm(clf.coef_[0])\n # print np.dot(clf_1.coef_[0],clf.coef_[0])/(np.linalg.norm(clf_1.coef_[0])*np.linalg.norm(clf.coef_[0]))\n\n # Strategic attack: create new adv samples based on retrained clf\n print('Performing strategic attack...')\n for i in range(n_mag):\n X_adv, y_ini = mult_cls_atk(clf, X_test_flat, mean, dev_list[i])\n output_list.append(acc_calc_all(clf, X_adv, y_test, y_ini))\n if img_flag != None:\n save_svm_images(model_dict, data_dict, X_test_flat, X_adv,\n dev_list[i], rd, dr_alg, rev_flag)\n\n fname = print_svm_output(model_dict, output_list, dev_list, rd,\n strat_flag, rev_flag)\n\n # fname = dataset +'_' + fname\n subprocess.call(\n [\"gnuplot -e \\\"mname='{}'\\\" gnu_in_loop.plg\".format(fname)], shell=True)","def computesvd(train, K):\n mean = global_mean(train)\n train = standardize(train, mean)\n std = compute_std(train)\n train = div_std(train)\n\n U, s, Vt = sp.linalg.svds(train, k=K)\n\n dim = (len(s), len(s))\n S = np.zeros(dim)\n for i in range(len(s)):\n S[i, i] = mt.sqrt(s[i])\n\n U = sp.lil_matrix(U, dtype=np.float32) # dim(M,k)\n S = sp.lil_matrix(S, dtype=np.float32) # dim(k,k)\n Vt = sp.lil_matrix(Vt, dtype=np.float32) # dim(k,N)\n\n user_features = S.dot(Vt)\n item_features = np.transpose(U.dot(S))\n\n return user_features, item_features, mean, std","def kernel_test(l, v):\n\t\"Testing RBF and Matern kernels with: \"\n\tx = np.array([1,2,3,4])\n\ty = np.array([2,4,6])\n\tprint(x)\n\tprint(y)\n\tprint(\"RBF Kernel with l= \" + str(l) + \": \")\n\tprint(rbf_kernel(x,y,l))\n\tprint(\"Matern Kernel with l= \" + str(l) + \" and v= \" + str(v) + \": \")\n\tprint(matern_kernel(x,y,l, v))","def setup_svm(self, classifier_name=\"SVM\", **kwargs):\n if not classifier_name in self.classifiers:\n clf = svm.SVC(**kwargs)\n clf.fit(self.X_train, self.y_train)\n self.classifiers[classifier_name] = clf","def _create_selu(cls, onnx_node, inputs, opset_version):\n alpha = onnx_node.getattr(\"alpha\", 1.67326)\n gamma = onnx_node.getattr(\"gamma\", 1.0507)\n _, forward = cls._common_onnx_node_to_singa_op(onnx_node, inputs,\n opset_version)\n return _, forward(alpha, gamma)","def losd_cnn_svm_model(num_class=8, num_flow_channel=10, cnn_svm_model_id=1, feature_pool='max', device=torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")):\n# feature_dimension = 2048 # change this according to which layer's feature you want\n num_gpu_device = torch.cuda.device_count()\n\n # load spatial cnn net\n input_spatial_cnn_model_file = ''.join(['model/cnn_net/spatial_lucid_08_split_no_', str(cnn_svm_model_id).zfill(2), '_nfch_10_nepochs_500_lr_0.0005_ss_model_best.pth.tar'])\n print('loading spatial cnn trained model from: {}' .format(input_spatial_cnn_model_file))\n spatial_cnn_model = load_resnet_cnn_net_model(input_spatial_cnn_model_file, num_class=num_class, num_channel=3, device=device)\n print('----------------------------------------------------------------------------------------')\n\n # load motion cnn net\n input_motion_cnn_model_file = ''.join(['model/cnn_net/motion_lucid_08_split_no_', str(cnn_svm_model_id).zfill(2), '_nfch_10_nepochs_500_lr_0.01_ss_model_best.pth.tar'])\n print('loading motion cnn trained model from: {}' .format(input_motion_cnn_model_file))\n motion_cnn_model = load_resnet_cnn_net_model(input_motion_cnn_model_file, num_class=num_class, num_channel=2*num_flow_channel, device=device)\n print('----------------------------------------------------------------------------------------')\n\n # for svm model\n input_spatial_motion_svm_model_path = ''.join(['model/svm/spatial_motion_lucid_08_split_no_', str(cnn_svm_model_id).zfill(2), '_nfch_10_nepochs_500_slr_0.0005_mlr_0.01_network_resnet101_', str(feature_pool), '_pooling_thundersvm_1v1/'])\n input_spatial_motion_svm_model_file = ''.join([input_spatial_motion_svm_model_path, 'best_model_basedon_train_val_data_nclass_12_kernel_linear_int_c_0.1_max_c_1000.0_num_div_c_46_int_g_0.1_max_g_1.0_num_div_g_10'])\n print('loading spatial and motion net svm model from: \"{}\"' .format(input_spatial_motion_svm_model_file))\n spatial_motion_svm_model = thundersvm_load_svm_model(input_spatial_motion_svm_model_file)\n print('----------------------------------------------------------------------------------------')\n \n # model paralization (if you have multiple gpus)\n print('model will use \"{}\" GPUs' .format(num_gpu_device))\n if num_gpu_device > 1:\n spatial_cnn_model = nn.DataParallel(spatial_cnn_model)\n motion_cnn_model = nn.DataParallel(motion_cnn_model)\n \n return spatial_cnn_model, motion_cnn_model, spatial_motion_svm_model","def optimize_gp_hyperparams(x, y, optimization_steps, learning_rate,\r\n kernel=rational_quadratic_kernel_torch, params=None):\r\n x = np.array(x).reshape(-1, 1)\r\n y = np.array(y).reshape(-1, 1)\r\n N = len(x)\r\n\r\n # tranform our training set in Tensor\r\n x_tensor = torch.from_numpy(x).float()\r\n y_tensor = torch.from_numpy(y).float()\r\n\r\n # we should define our hyperparameters as torch parameters where we keep track of\r\n # the operations to get hte gradients from them\r\n m = np.abs(y[-1][0])\r\n mu = torch.tensor(m).float()\r\n s = np.var(y)\r\n sig = torch.tensor(s).float()\r\n if params:\r\n lambda_param = nn.Parameter(torch.tensor(params['ls']), requires_grad=True)\r\n alpha_param = nn.Parameter(torch.tensor(params['a']), requires_grad=True)\r\n output_variance = nn.Parameter(torch.tensor(params['ov']), requires_grad=True)\r\n noise_variance = nn.Parameter(torch.tensor(params['nv']), requires_grad=True)\r\n mu_param = nn.Parameter(torch.tensor(params['mu']), requires_grad=True)\r\n sig_param = nn.Parameter(torch.tensor(params['sig']), requires_grad=True)\r\n\r\n else:\r\n lambda_param = nn.Parameter(torch.tensor(1.), requires_grad=True)\r\n alpha_param = nn.Parameter(torch.tensor(1.), requires_grad=True)\r\n output_variance = nn.Parameter(torch.tensor(1.), requires_grad=True)\r\n noise_variance = nn.Parameter(torch.tensor(2.5), requires_grad=True)\r\n mu_param = nn.Parameter(mu, requires_grad=True)\r\n sig_param = nn.Parameter(sig, requires_grad=True)\r\n\r\n # we use Adam as optimizer\r\n optim = torch.optim.Adam([lambda_param, alpha_param, output_variance,\r\n noise_variance, mu_param, sig_param], lr=learning_rate)\r\n\r\n # optimization loop using the log-likelihood that involves the cholesky decomposition\r\n nlls = []\r\n lambdas = []\r\n output_variances = []\r\n noise_variances = []\r\n iterations = optimization_steps\r\n for i in range(iterations):\r\n if lambda_param.item() == lambda_param.item():\r\n return_dict = {'ls': lambda_param.item(),\r\n 'a': alpha_param.item(),\r\n 'ov': output_variance.item(),\r\n 'nv': noise_variance.item(),\r\n 'mu': mu_param.item(),\r\n 'sig': sig_param.item()}\r\n assert noise_variance >= 0, f\"ouch! {i, noise_variance}\"\r\n optim.zero_grad()\r\n K = kernel(x_tensor, x_tensor, lambda_param, alpha_param,\r\n output_variance) + noise_variance * torch.eye(N)\r\n try:\r\n cholesky = torch.cholesky(K)\r\n _alpha_temp, _ = torch.solve(y_tensor, cholesky)\r\n _alpha, _ = torch.solve(_alpha_temp, cholesky.t())\r\n except:\r\n return return_dict\r\n nll = N / 2 * torch.log(torch.tensor(2 * np.pi)) + 0.5 * torch.matmul(y_tensor.transpose(0, 1), _alpha) + \\\r\n torch.sum(torch.log(torch.diag(cholesky)))\r\n\r\n # we have to add the log-likelihood of the prior\r\n norm = distributions.Normal(loc=m, scale=s)\r\n prior_negloglike = torch.log(lambda_param) - torch.log(torch.exp(norm.log_prob(lambda_param)))\r\n\r\n nll += 0.9 * prior_negloglike\r\n nll.backward()\r\n\r\n nlls.append(nll.item())\r\n lambdas.append(lambda_param.item())\r\n output_variances.append(output_variance.item())\r\n noise_variances.append(noise_variance.item())\r\n optim.step()\r\n\r\n # projected in the constraints (lengthscale and output variance should be positive)\r\n for p in [lambda_param, output_variance]:\r\n p.data.clamp_(min=0.0000001)\r\n noise_variance.data.clamp_(min=0.001, max=0.05)\r\n alpha_param.data.clamp_(min=0.001, max=0.1)\r\n # mu_param.data.clamp_(min=0.01, max=40)\r\n # sig_param.data.clamp_(min=0.01, max=40)\r\n\r\n return_dict = {'ls': lambda_param.item(),\r\n 'a': alpha_param.item(),\r\n 'ov': output_variance.item(),\r\n 'nv': noise_variance.item(),\r\n 'mu': mu_param.item(),\r\n 'sig': sig_param.item()}\r\n\r\n return return_dict","def __init__(self,\n gridsearch='half',\n n_components=3,\n classifier='svm',\n cv=5,\n min_resources='smallest',\n factor=3,\n score_func=metrics.f1_score,\n average='weighted',\n random_state=None,\n n_jobs=-1,\n **kwargs,\n ):\n\n freq_thres = helpers.FREQ_THRES(freq_thres=0)\n\n log = helpers.LOG(log=False)\n\n if classifier == 'svm':\n\n classifier = SVC(random_state=random_state)\n\n mapper = umap.UMAP(random_state=random_state,\n n_components=n_components)\n\n scorer = metrics.make_scorer(score_func=score_func,\n average=average,\n )\n\n pipeline = Pipeline([('freq', freq_thres),\n ('log', log),\n ('umap', mapper),\n ('classifier', classifier),\n ])\n\n params_grid_pipeline = {**kwargs}\n\n if gridsearch == 'full':\n self.clf_pipeline = GridSearchCV(pipeline,\n params_grid_pipeline,\n cv=cv,\n scoring=scorer,\n n_jobs=n_jobs,\n )\n elif gridsearch == 'half':\n self.clf_pipeline = \\\n HalvingGridSearchCV(pipeline,\n params_grid_pipeline,\n cv=cv,\n scoring=scorer,\n n_jobs=n_jobs,\n min_resources=min_resources,\n factor=factor,\n random_state=random_state\n )","def ex_3_a(x_train, y_train, x_test, y_test):\n ###########\n ## Train multi-class SVMs with one-versus-rest strategy with\n ## - linear kernel\n ## - rbf kernel with gamma going from 10**-5 to 10**5\n ## - plot the scores with varying gamma using the function plot_score_versus_gamma\n ## - Mind that the chance level is not .5 anymore and add the score obtained with the linear kernel as optional argument of this function\n ###########\n dfs = 'ovr'\n c = 10\n\n linear = svm.SVC(kernel='linear', C=c, decision_function_shape=dfs)\n linear.fit(x_train, y_train)\n lin_score_train = linear.score(x_train, y_train)\n lin_score_test = linear.score(x_test, y_test)\n\n gammas = [pow(10, i) for i in range(-5, 6)]\n rbfs = [svm.SVC(kernel='rbf', gamma=gamma, C=c, decision_function_shape=dfs) for gamma in gammas]\n for rbf in rbfs:\n rbf.fit(x_train, y_train)\n\n train_scores = [rbf.score(x_train, y_train) for rbf in rbfs]\n test_scores = [rbf.score(x_test, y_test) for rbf in rbfs]\n\n plot_score_vs_gamma(train_scores, test_scores, gammas, lin_score_train, lin_score_test, .2)","def extract_svm_parameters(clf):\n\n return {\n 'n_support': clf.__dict__['n_support_'].tolist(),\n 'support_vectors': clf.__dict__['support_vectors_'].tolist(),\n 'dual_coef': clf.__dict__['_dual_coef_'].tolist(),\n 'intercept': clf.__dict__['_intercept_'].tolist(),\n 'classes': clf.__dict__['classes_'].tolist(),\n }","def ex_2_c(x_train, y_train, x_test, y_test):\n ###########\n ## TODO:\n ## Train SVMs with RBF kernels for different values of the gamma\n ## and plot the variation of the test and training scores with gamma using 'plot_score_vs_gamma' function.\n ## Plot the decision boundary and support vectors for the best value of gamma\n ## using 'plot_svm_decision_boundary' function\n ###########\n gammas = np.arange(0.01, 2, 0.02)\n machines = [svm.SVC(kernel='rbf', gamma=g, coef0=1.0) for g in gammas]\n\n for machine in machines:\n machine.fit(x_train, y_train)\n\n trainScores = [machine.score(x_train, y_train) for machine in machines]\n testScores = [machine.score(x_test, y_test) for machine in machines]\n\n plot_score_vs_gamma(trainScores, testScores, gammas)\n\n bestGamma = np.argmax(testScores)\n print('Score of best rbf gamma ({}): {}'.format(gammas[bestGamma], testScores[bestGamma]))\n plot_svm_decision_boundary(machines[bestGamma], x_train, y_train, x_test, y_test)","def learn_model(reviews, reviews_vectors):\n\n from sklearn.svm import LinearSVC\n\n labels = get_labels_vector(reviews)\n clf = LinearSVC()\n clf.fit(reviews_vectors, labels)\n\n return clf","def generate_model(is_self_training=False):\n if not is_self_training:\n vectors = ds.VECTORS\n labels = ds.LABELS\n else:\n vectors = ds.VECTORS_SELF\n labels = ds.LABELS_SELF\n classifier_type = globals.DEFAULT_CLASSIFIER\n vectors_scaled = pr.scale(np.array(vectors))\n scaler = pr.StandardScaler().fit(vectors)\n vectors_normalized = pr.normalize(vectors_scaled, norm='l2')\n normalizer = pr.Normalizer().fit(vectors_scaled)\n vectors = vectors_normalized\n vectors = vectors.tolist()\n if classifier_type == cons.CLASSIFIER_SVM:\n kernel_function = globals.DEFAULT_KERNEL\n c_parameter = globals.DEFAULT_C_PARAMETER\n gamma = globals.DEFAULT_GAMMA_SVM\n if is_self_training:\n class_weights = get_modified_class_weight(get_size(True))\n else:\n class_weights = globals.DEFAULT_CLASS_WEIGHTS\n model = svm.SVC(kernel=kernel_function, C=c_parameter,\n class_weight=class_weights, gamma=gamma, probability=True)\n model.fit(vectors, labels)\n else:\n model = None\n ds.SCALAR = scaler\n ds.NORMALIZER = normalizer\n ds.MODEL = model\n return"],"string":"[\n \"def svm():\",\n \"def __init__(self, kernel='poly', degree=3, verbose=False, gamma='auto', reg=1/1000, random_state=0):\\n print(\\\"Initialize model SVM\\\")\\n # Check if gamma='auto' is useful\\n self.kernel = kernel\\n self.random_state = random_state\\n self.model = SVC(gamma=gamma, kernel=kernel, degree=degree, verbose=verbose, C=reg, random_state=random_state)\",\n \"def find_svm_hyperparams():\\n NUM_ITERS = 10\\n # coefs = np.arange(-5, 5).astype(np.float)\\n coefs = np.linspace(0.25, 1, 10)\\n Cs = np.power(2, coefs)\\n results = []\\n\\n for _ in range(NUM_ITERS):\\n data = FaceDataset(\\\"embeddings/dev\\\", n=50)\\n train_data, train_labels = data.train()\\n test_data, test_labels = data.test()\\n accs = []\\n for c in tqdm(Cs):\\n clf = svm.SVC(kernel=\\\"linear\\\", C=c)\\n clf, _ = train(clf, train_data, train_labels)\\n acc, _ = test(clf, test_data, test_labels)\\n accs.append(acc)\\n results.append(accs)\\n\\n results = np.mean(results, axis=0)\\n s = plotly.graph_objs.Scatter(x=Cs, y=results)\\n plotly.offline.plot([s], filename=\\\"svm_linear.html\\\")\\n print(\\\"C={}\\\".format(Cs[np.argmax(results)]))\",\n \"def find_linear_svm_hyperparams():\\n NUM_ITERS = 10\\n # coefs = np.arange(-5, 5).astype(np.float)\\n coefs = np.linspace(0.25, 1, 10)\\n Cs = np.power(2, coefs)\\n results = []\\n\\n for _ in range(NUM_ITERS):\\n data = FaceDataset(\\\"embeddings/dev\\\", n=50)\\n train_data, train_labels = data.train()\\n test_data, test_labels = data.test()\\n accs = []\\n for c in tqdm(Cs):\\n clf = svm.SVC(kernel=\\\"linear\\\", C=c)\\n clf, _ = train(clf, train_data, train_labels)\\n acc, _ = test(clf, test_data, test_labels)\\n accs.append(acc)\\n results.append(accs)\\n\\n results = np.mean(results, axis=0)\\n s = plotly.graph_objs.Scatter(x=Cs, y=results)\\n plotly.offline.plot([s], filename=\\\"svm_linear.html\\\")\\n print(\\\"C={}\\\".format(Cs[np.argmax(results)]))\",\n \"def svc_model(params):\\n\\n if (params['random']):\\n params['C'] = random.randrange(1, 13, step=1) * 0.1\\n params['degree'] = random.choice([2, 3, 4, 5])\\n params['kernel'] = random.choice(['linear', 'rbf', 'poly', 'sigmoid'])\\n \\n model = svm.SVC(\\n decision_function_shape='ovo',\\n C=params['C'],\\n degree=params['degree'],\\n kernel=params['kernel']\\n )\\n\\n return model\",\n \"def modelKSVM():\\n\\n list_kernel_type = ['linear', 'poly', 'rbf']\\n random_state = 20 # Do not change this random_state\\n\\n objs_KSVM = []\\n\\n # Create a list of objects for the classifier for each of the above \\\"kernel\\\" types\\n for kernel in list_kernel_type:\\n svm = SVC(kernel=kernel, random_state=random_state)\\n objs_KSVM.append(svm)\\n\\n return objs_KSVM\",\n \"def __init__(self):\\n self.svclassifier = SVC(kernel='linear')\",\n \"def __init__(self, train_x, train_y, test_x, test_y, Tunning_Cs=[0.001, 0.01, 0.1, 1, 10]): \\n self.Cs = Tunning_Cs\\n self.train_x = train_x\\n self.train_y = train_y\\n self.test_x = test_x \\n self.test_y = test_y\\n self.model = svm.SVR(kernel='rbf', gamma='auto')\",\n \"def svc_kernel(name, kernel, random_state=None, probability=False, **kwargs):\\n def _name(msg):\\n return '%s.%s_%s' % (name, kernel, msg)\\n\\n hp_space = _svm_hp_space(_name, kernel=kernel, **kwargs)\\n hp_space.update(_svc_hp_space(_name, random_state, probability))\\n return scope.sklearn_SVC(**hp_space)\",\n \"def train_model(kernel, label):\\n clf = svm.SVC(kernel='precomputed')\\n clf.fit(kernel,label)\\n return clf\",\n \"def SVM():\\n x1, x2 = generate_training_data_2D()\\n Y = np.concatenate([np.zeros(x1.shape[0], dtype=np.int32),\\n np.ones(x2.shape[0], dtype=np.int32)])\\n X = np.concatenate([x1, x2], axis=0)\\n rng = np.random.get_state()\\n np.random.shuffle(X)\\n # Set the random state back to previous to shuffle X & Y similarly\\n np.random.set_state(rng)\\n np.random.shuffle(Y)\\n\\n models, titles = get_fitted_svm(X, Y)\\n\\n plot_decision_boundary(X, Y, models, titles)\",\n \"def train_svm(data, labels, kernel, C, gamma, degree, coef0):\\n if kernel == 'linear':\\n model = SVC(kernel=kernel, C=C)\\n elif kernel == 'poly':\\n model = SVC(kernel=kernel, C=C, degree=degree, coef0=coef0)\\n elif kernel == 'rbf':\\n model = SVC(kernel=kernel, C=C, gamma=gamma)\\n else:\\n raise ArgumentError(\\\"Unknown kernel function: %s\\\" % kernel)\\n model.fit(data, labels)\\n return model\",\n \"def __init__(self):\\n super().__init__()\\n import sklearn\\n import sklearn.svm\\n self.model = sklearn.svm.LinearSVR\",\n \"def svm_model_fn(features, labels, mode, params):\\n\\n feature_columns = [layers.real_valued_column(i) for i in features.keys()]\\n example_id_column(features)\\n\\n weight_column_name = params.get(\\\"weight_column_name\\\")\\n\\n head = head_lib.binary_svm_head(\\n weight_column_name=weight_column_name,\\n enable_centered_bias=False)\\n\\n optimizer = sdca_optimizer.SDCAOptimizer(\\n example_id_column=\\\"index\\\",\\n num_loss_partitions=params[\\\"num_loss_partitions\\\"],\\n symmetric_l1_regularization=params[\\\"l1_regularization\\\"],\\n symmetric_l2_regularization=params[\\\"l2_regularization\\\"])\\n\\n chief_hook = linear._SdcaUpdateWeightsHook()\\n update_weights_hook = chief_hook\\n\\n if not isinstance(optimizer, sdca_optimizer.SDCAOptimizer):\\n raise ValueError(\\\"Optimizer must be of type SDCAOptimizer\\\")\\n\\n if isinstance(head,\\n head_lib._BinarySvmHead): # pylint: disable=protected-access\\n loss_type = \\\"hinge_loss\\\"\\n elif isinstance(head,\\n head_lib._BinaryLogisticHead): # pylint:\\n # disable=protected-access\\n loss_type = \\\"logistic_loss\\\"\\n elif isinstance(head,\\n head_lib._RegressionHead): # pylint:\\n # disable=protected-access\\n assert head.logits_dimension == 1, (\\\"SDCA only applies for \\\"\\n \\\"logits_dimension=1.\\\")\\n loss_type = \\\"squared_loss\\\"\\n else:\\n raise ValueError(\\\"Unsupported head type: {}\\\".format(head))\\n\\n parent_scope = \\\"linear\\\"\\n\\n with variable_scope.variable_op_scope(\\n features.values(), parent_scope) as scope:\\n features = features.copy()\\n features.update(layers.transform_features(features, feature_columns))\\n logits, columns_to_variables, bias = (\\n layers.weighted_sum_from_feature_columns(\\n columns_to_tensors=features,\\n feature_columns=feature_columns,\\n num_outputs=1,\\n scope=scope))\\n\\n linear._add_bias_column(feature_columns, features, bias,\\n columns_to_variables)\\n\\n def _train_op_fn(unused_loss):\\n global_step = contrib_variables.get_global_step()\\n sdca_model, train_op = optimizer.get_train_step(columns_to_variables,\\n weight_column_name,\\n loss_type, features,\\n labels, global_step)\\n if update_weights_hook is not None:\\n update_weights_hook.set_parameters(sdca_model, train_op)\\n return train_op\\n\\n model_fn_ops = head.create_model_fn_ops(\\n features=features,\\n labels=labels,\\n mode=mode,\\n train_op_fn=_train_op_fn,\\n logits=logits)\\n if update_weights_hook is not None:\\n return model_fn_ops._replace(\\n training_chief_hooks=(model_fn_ops.training_chief_hooks +\\n [update_weights_hook]))\\n return model_fn_ops\",\n \"def __init__(self):\\n super().__init__()\\n import sklearn\\n import sklearn.svm\\n self.model = sklearn.svm.NuSVR\",\n \"def SVM(x_train, x_test, y_train, kernel):\\n svc_model = SVC(kernel=kernel)\\n svc_model.fit(x_train, y_train)\\n y_pred = svc_model.predict(x_test)\\n return y_pred\",\n \"def spkernel(*args,\\n node_label='atom',\\n edge_weight=None,\\n node_kernels=None,\\n n_jobs=None,\\n verbose=True):\\n # pre-process\\n Gn = args[0] if len(args) == 1 else [args[0], args[1]]\\n Gn = [g.copy() for g in Gn]\\n weight = None\\n if edge_weight is None:\\n if verbose:\\n print('\\\\n None edge weight specified. Set all weight to 1.\\\\n')\\n else:\\n try:\\n some_weight = list(\\n nx.get_edge_attributes(Gn[0], edge_weight).values())[0]\\n if isinstance(some_weight, (float, int)):\\n weight = edge_weight\\n else:\\n if verbose:\\n print(\\n '\\\\n Edge weight with name %s is not float or integer. Set all weight to 1.\\\\n'\\n % edge_weight)\\n except:\\n if verbose:\\n print(\\n '\\\\n Edge weight with name \\\"%s\\\" is not found in the edge attributes. Set all weight to 1.\\\\n'\\n % edge_weight)\\n ds_attrs = get_dataset_attributes(\\n Gn,\\n attr_names=['node_labeled', 'node_attr_dim', 'is_directed'],\\n node_label=node_label)\\n\\n # remove graphs with no edges, as no sp can be found in their structures, \\n # so the kernel between such a graph and itself will be zero.\\n len_gn = len(Gn)\\n Gn = [(idx, G) for idx, G in enumerate(Gn) if nx.number_of_edges(G) != 0]\\n idx = [G[0] for G in Gn]\\n Gn = [G[1] for G in Gn]\\n if len(Gn) != len_gn:\\n if verbose:\\n print('\\\\n %d graphs are removed as they don\\\\'t contain edges.\\\\n' %\\n (len_gn - len(Gn)))\\n\\n start_time = time.time()\\n\\n pool = Pool(n_jobs)\\n # get shortest path graphs of Gn\\n getsp_partial = partial(wrapper_getSPGraph, weight)\\n itr = zip(Gn, range(0, len(Gn)))\\n if len(Gn) < 100 * n_jobs:\\n# # use default chunksize as pool.map when iterable is less than 100\\n# chunksize, extra = divmod(len(Gn), n_jobs * 4)\\n# if extra:\\n# chunksize += 1\\n chunksize = int(len(Gn) / n_jobs) + 1\\n else:\\n chunksize = 100\\n if verbose:\\n iterator = tqdm(pool.imap_unordered(getsp_partial, itr, chunksize),\\n desc='getting sp graphs', file=sys.stdout)\\n else:\\n iterator = pool.imap_unordered(getsp_partial, itr, chunksize)\\n for i, g in iterator:\\n Gn[i] = g\\n pool.close()\\n pool.join()\\n \\n# # ---- direct running, normally use single CPU core. ----\\n# for i in tqdm(range(len(Gn)), desc='getting sp graphs', file=sys.stdout):\\n# i, Gn[i] = wrapper_getSPGraph(weight, (Gn[i], i))\\n\\n # # ---- use pool.map to parallel ----\\n # result_sp = pool.map(getsp_partial, range(0, len(Gn)))\\n # for i in result_sp:\\n # Gn[i[0]] = i[1]\\n # or\\n # getsp_partial = partial(wrap_getSPGraph, Gn, weight)\\n # for i, g in tqdm(\\n # pool.map(getsp_partial, range(0, len(Gn))),\\n # desc='getting sp graphs',\\n # file=sys.stdout):\\n # Gn[i] = g\\n\\n # # ---- only for the Fast Computation of Shortest Path Kernel (FCSP)\\n # sp_ml = [0] * len(Gn) # shortest path matrices\\n # for i in result_sp:\\n # sp_ml[i[0]] = i[1]\\n # edge_x_g = [[] for i in range(len(sp_ml))]\\n # edge_y_g = [[] for i in range(len(sp_ml))]\\n # edge_w_g = [[] for i in range(len(sp_ml))]\\n # for idx, item in enumerate(sp_ml):\\n # for i1 in range(len(item)):\\n # for i2 in range(i1 + 1, len(item)):\\n # if item[i1, i2] != np.inf:\\n # edge_x_g[idx].append(i1)\\n # edge_y_g[idx].append(i2)\\n # edge_w_g[idx].append(item[i1, i2])\\n # print(len(edge_x_g[0]))\\n # print(len(edge_y_g[0]))\\n # print(len(edge_w_g[0]))\\n\\n Kmatrix = np.zeros((len(Gn), len(Gn)))\\n\\n # ---- use pool.imap_unordered to parallel and track progress. ----\\n def init_worker(gn_toshare):\\n global G_gn\\n G_gn = gn_toshare\\n do_partial = partial(wrapper_sp_do, ds_attrs, node_label, node_kernels) \\n parallel_gm(do_partial, Kmatrix, Gn, init_worker=init_worker, \\n glbv=(Gn,), n_jobs=n_jobs, verbose=verbose)\\n\\n\\n # # ---- use pool.map to parallel. ----\\n # # result_perf = pool.map(do_partial, itr)\\n # do_partial = partial(spkernel_do, Gn, ds_attrs, node_label, node_kernels)\\n # itr = combinations_with_replacement(range(0, len(Gn)), 2)\\n # for i, j, kernel in tqdm(\\n # pool.map(do_partial, itr), desc='calculating kernels',\\n # file=sys.stdout):\\n # Kmatrix[i][j] = kernel\\n # Kmatrix[j][i] = kernel\\n # pool.close()\\n # pool.join()\\n\\n # # ---- use joblib.Parallel to parallel and track progress. ----\\n # result_perf = Parallel(\\n # n_jobs=n_jobs, verbose=10)(\\n # delayed(do_partial)(ij)\\n # for ij in combinations_with_replacement(range(0, len(Gn)), 2))\\n # result_perf = [\\n # do_partial(ij)\\n # for ij in combinations_with_replacement(range(0, len(Gn)), 2)\\n # ]\\n # for i in result_perf:\\n # Kmatrix[i[0]][i[1]] = i[2]\\n # Kmatrix[i[1]][i[0]] = i[2]\\n\\n# # ---- direct running, normally use single CPU core. ----\\n# from itertools import combinations_with_replacement\\n# itr = combinations_with_replacement(range(0, len(Gn)), 2)\\n# for i, j in tqdm(itr, desc='calculating kernels', file=sys.stdout):\\n# kernel = spkernel_do(Gn[i], Gn[j], ds_attrs, node_label, node_kernels)\\n# Kmatrix[i][j] = kernel\\n# Kmatrix[j][i] = kernel\\n\\n run_time = time.time() - start_time\\n if verbose:\\n print(\\n \\\"\\\\n --- shortest path kernel matrix of size %d built in %s seconds ---\\\"\\n % (len(Gn), run_time))\\n\\n return Kmatrix, run_time, idx\",\n \"def svr(self):\\n\\n svr_parameters = [{'kernel': ['linear', 'rbf'],\\n 'C': hel.powerlist(0.1, 2, 10),\\n 'epsilon': hel.powerlist(0.01, 2, 10),\\n 'gamma': ['scale']},\\n {'kernel': ['poly'],\\n 'degree': list(range(2, 5, 1)),\\n 'C': hel.powerlist(0.1, 2, 10),\\n 'epsilon': hel.powerlist(0.01, 2, 10),\\n 'gamma': ['scale']}]\\n svr_grid = GridSearchCV(estimator=SVR(),\\n param_grid=svr_parameters,\\n scoring=self.scorer, cv=5, n_jobs=-1,\\n iid=False)\\n svr_grid_result = svr_grid.fit(self.X_train_scaled, self.y_train_scaled)\\n best_svr_parameters = svr_grid_result.best_params_\\n svr_score = svr_grid_result.best_score_\\n print('Best SVR params: ' + str(best_svr_parameters))\\n print('SVR score: ' + str(svr_score))\\n if best_svr_parameters['kernel'] == 'poly':\\n svr_regressor = SVR(kernel=best_svr_parameters['kernel'],\\n degree=best_svr_parameters['degree'],\\n C=best_svr_parameters['C'],\\n epsilon=best_svr_parameters['epsilon'],\\n gamma='scale')\\n else:\\n svr_regressor = SVR(kernel=best_svr_parameters['kernel'],\\n C=best_svr_parameters['C'],\\n epsilon=best_svr_parameters['epsilon'],\\n gamma='scale')\\n return svr_regressor\",\n \"def convert(context, cm_node, inputs, outputs):\\n kernel_enum = {'linearKernel': 'LINEAR', 'polyKernel': 'POLY',\\n 'rbfKernel': 'RBF', 'sigmoidKernel': 'SIGMOID', 'precomputedKernel': 'PRECOMPUTED'}\\n kernel = cm_node.supportVectorClassifier.kernel\\n kernel_val = kernel.WhichOneof('kernel')\\n svc_kernel = kernel_enum[kernel_val]\\n\\n if kernel_val == 'rbfKernel':\\n svc_kernel_params = [kernel.rbfKernel.gamma, 0.0, 0.0]\\n elif kernel_val == 'polyKernel':\\n svc_kernel_params = [kernel.polyKernel.gamma,\\n kernel.polyKernel.coef0, kernel.polyKernel.degree]\\n elif kernel_val == 'sigmoidKernel':\\n svc_kernel_params = [kernel.sigmoidKernel.gamma,\\n kernel.sigmoidKernel.coef0, 0.0]\\n elif kernel_val == 'linearKernel':\\n svc_kernel_params = [0.0, 0.0, 0.0]\\n\\n prob_a = cm_node.supportVectorClassifier.probA\\n prob_b = cm_node.supportVectorClassifier.probB\\n svc_vectors_per_class = cm_node.supportVectorClassifier.numberOfSupportVectorsPerClass\\n n_supports, svc_support_vectors = extract_support_vectors_as_dense_tensor(cm_node.supportVectorClassifier)\\n chain_coef = list(itertools.chain.from_iterable(\\n [coef.alpha for coef in cm_node.supportVectorClassifier.coefficients]))\\n svc_coefficients = chain_coef\\n svc_rho = [-x for x in cm_node.supportVectorClassifier.rho]\\n\\n nb = NodeBuilder(context, 'SVMClassifier', op_domain='ai.onnx.ml')\\n nb.add_attribute('kernel_type', svc_kernel)\\n nb.add_attribute('kernel_params', svc_kernel_params)\\n if prob_a:\\n nb.add_attribute('prob_a', prob_a)\\n if prob_b:\\n nb.add_attribute('prob_b', prob_b)\\n nb.add_attribute('vectors_per_class', svc_vectors_per_class)\\n nb.add_attribute('support_vectors', svc_support_vectors)\\n nb.add_attribute('coefficients', svc_coefficients)\\n nb.add_attribute('rho', svc_rho)\\n svc_classes = cm_node.supportVectorClassifier.WhichOneof('ClassLabels')\\n if svc_classes == 'int64ClassLabels':\\n class_labels = list(int(i) for i in cm_node.supportVectorClassifier.int64ClassLabels.vector)\\n nb.add_attribute('classlabels_ints', class_labels)\\n elif svc_classes == 'stringClassLabels':\\n class_labels = list(str(s) for s in cm_node.supportVectorClassifier.stringClassLabels.vector)\\n nb.add_attribute('classlabels_strings', class_labels)\\n\\n nb.extend_inputs(inputs)\\n\\n # Find the ONNX name for the predicted label in CoreML\\n predicted_label_name = context.get_onnx_name(cm_node.description.predictedFeatureName)\\n nb.add_output(predicted_label_name)\\n\\n # The variable used to store the class probabilities produced by ONNX linear classifier\\n probability_tensor_name = context.get_unique_name('probability_tensor')\\n nb.add_output(probability_tensor_name)\\n\\n nodes = [nb.make_node()]\\n\\n if cm_node.description.predictedProbabilitiesName != '':\\n # Find the corresponding ONNX name for CoreML's probability output (a dictionary)\\n predicted_probability_name = context.get_onnx_name(cm_node.description.predictedProbabilitiesName)\\n # Create a ZipMap to connect probability tensor and probability dictionary\\n nodes.append(model_util.make_zipmap_node(context, probability_tensor_name,\\n predicted_probability_name, class_labels))\\n\\n return nodes\",\n \"def SVMRegression(trainingObs,trainingParam,Obs):\\n svr = SVR(C=1.0, cache_size=2000, coef0=0.0, degree=3, epsilon=0.1, gamma=0., kernel='rbf', probability=False, shrinking=True, tol=0.00001)\\n nparam=trainingParam.shape[1]\\n vparam = []\\n for i in range(0,nparam):\\n print i\\n svr.fit(trainingObs,trainingParam[:,i])\\n vparam.append(svr.predict(Obs))\\n vparam = np.array(vparam)\\n return vparam.T\",\n \"def getInputSpecification(cls):\\n specs = super(LinearSVR, cls).getInputSpecification()\\n specs.description = r\\\"\\\"\\\"The \\\\xmlNode{LinearSVR} \\\\textit{Linear Support Vector Regressor} is\\n similar to SVR with parameter kernel=’linear’, but implemented in terms of liblinear rather than libsvm,\\n so it has more flexibility in the choice of penalties and loss functions and should scale better to large numbers of samples.\\n This class supports both dense and sparse input.\\n \\\\zNormalizationPerformed{LinearSVR}\\n \\\"\\\"\\\"\\n specs.addSub(InputData.parameterInputFactory('epsilon', contentType=InputTypes.FloatType,\\n descr=r\\\"\\\"\\\"Epsilon parameter in the epsilon-insensitive loss function. The value of\\n this parameter depends on the scale of the target variable y. If unsure, set $epsilon=0.$\\\"\\\"\\\", default=0.0))\\n specs.addSub(InputData.parameterInputFactory(\\\"loss\\\", contentType=InputTypes.makeEnumType(\\\"loss\\\", \\\"lossType\\\",['epsilon_insensitive’','squared_epsilon_insensitive']),\\n descr=r\\\"\\\"\\\"Specifies the loss function. The epsilon-insensitive loss (standard SVR)\\n is the L1 loss, while the squared epsilon-insensitive loss (``squared_epsilon_insensitive'') is the L2 loss.\\\"\\\"\\\",\\n default='squared_epsilon_insensitive'))\\n specs.addSub(InputData.parameterInputFactory(\\\"tol\\\", contentType=InputTypes.FloatType,\\n descr=r\\\"\\\"\\\"Tolerance for stopping criterion\\\"\\\"\\\", default=1e-4))\\n specs.addSub(InputData.parameterInputFactory(\\\"fit_intercept\\\", contentType=InputTypes.BoolType,\\n descr=r\\\"\\\"\\\"Whether to calculate the intercept for this model. If set to false, no\\n intercept will be used in calculations (i.e. data is expected to be already centered).\\\"\\\"\\\", default=True))\\n specs.addSub(InputData.parameterInputFactory(\\\"intercept_scaling\\\", contentType=InputTypes.FloatType,\\n descr=r\\\"\\\"\\\"When fit_intercept is True, instance vector x becomes $[x, intercept_scaling]$,\\n i.e. a “synthetic” feature with constant value equals to intercept_scaling is appended\\n to the instance vector. The intercept becomes $intercept_scaling * synthetic feature weight$\\n \\\\nb the synthetic feature weight is subject to $l1/l2$ regularization as all other features.\\n To lessen the effect of regularization on synthetic feature weight (and therefore on the intercept)\\n $intercept_scaling$ has to be increased.\\\"\\\"\\\", default=1.))\\n specs.addSub(InputData.parameterInputFactory(\\\"dual\\\", contentType=InputTypes.BoolType,\\n descr=r\\\"\\\"\\\"Select the algorithm to either solve the dual or primal optimization problem.\\n Prefer dual=False when $n_samples > n_features$.\\\"\\\"\\\", default=True))\\n specs.addSub(InputData.parameterInputFactory(\\\"max_iter\\\", contentType=InputTypes.IntegerType,\\n descr=r\\\"\\\"\\\"Hard limit on iterations within solver.``-1'' for no limit\\\"\\\"\\\", default=-1))\\n return specs\",\n \"def train(self, prob: SvmProblem):\\n # Define variables\\n self.prob = prob\\n c = prob.C\\n c2 = prob.gamma\\n xkern = prob.xkernel\\n xsk = prob.xskernel\\n\\n # Swap params, so SVM solves X* with correct params\\n prob.C = c2\\n prob.xkernel = xsk\\n\\n # Find SVM solution in X*\\n svm = SVM()\\n priv_clf = svm.train(prob.Xstar, prob)\\n\\n # Replace swapped out params so modified SVM solves X with correct params\\n prob.C = c\\n prob.xkernel = xkern\\n\\n # Get the 'frames of knowledge' - Get the kernel distance from each\\n # privileged training data-point to the privileged support vectors\\n frames = np.zeros((prob.num, len(priv_clf.support_vectors)))\\n for i in range(prob.num):\\n for j in range(len(priv_clf.support_vectors)):\\n frames[i][j] = prob.xkernel((priv_clf.support_vectors[j]), prob.Xstar[i])\\n\\n # Form pairs so that each training point is matched against each 'frame of knowledge'\\n training_pairs = np.zeros((prob.num, len(priv_clf.support_vectors)), dtype=object)\\n for i in range(prob.num):\\n for j in range(len(priv_clf.support_vectors)):\\n training_pairs[i][j] = [prob.X[i], frames[i][j]]\\n training_pairs = np.array(training_pairs)\\n\\n regr_pairs = np.zeros((len(priv_clf.support_vectors), prob.num), dtype=object)\\n for i in range(prob.num):\\n for j in range(len(priv_clf.support_vectors)):\\n regr_pairs[j][i] = training_pairs[i][j]\\n\\n # Learn a regression based on above pairs\\n self.models = []\\n for dataSet in regr_pairs:\\n regr = SVR(kernel='rbf')\\n xs = []\\n ys = []\\n for i in range(prob.num):\\n xs.append(dataSet[i][0].flatten())\\n ys.append(dataSet[i][1])\\n xs = np.array(xs)\\n ys = np.array(ys)\\n self.models.append(regr.fit(xs, ys))\\n\\n # Transform data from X using learned regression\\n new_xs = []\\n new_ys = []\\n for i in range(prob.num):\\n new_xs.append(self.transform(prob.X[i].reshape(1, -1)).flatten())\\n new_ys.append(priv_clf.predict(prob.Xstar[i]))\\n new_x = np.asarray(new_xs)\\n new_y = np.array(new_ys)\\n\\n # Form a new problem and learn an SVMd+ solution for it\\n new_prob = SvmProblem(new_x, prob.Xstar, new_y)\\n new_svm = SVMdp()\\n self.clf = new_svm.train(new_prob)\",\n \"def _find_svm_rbf_params(df, metrics, kernel):\\n context = ramp.DataContext(data=df)\\n config = ramp.Configuration(target=\\\"target\\\",\\n features=[ramp.BaseFeature(x) for x in metrics])\\n x, y = ramp.models.get_xy(config, context)\\n\\n if kernel == \\\"linear\\\":\\n param_grid = dict(C=10.0 ** np.arange(-2, 5))\\n else:\\n param_grid = dict(gamma=10.0 ** np.arange(-5, 4),\\n C=10.0 ** np.arange(-2, 9))\\n grid = sklearn.grid_search.GridSearchCV(sklearn.svm.SVC(kernel=kernel),\\n param_grid=param_grid,\\n cv=sklearn.cross_validation.StratifiedKFold(y=y, k=3),\\n verbose=True)\\n grid.fit(x, y)\\n print grid.best_estimator_\\n out = {}\\n for attr in param_grid.keys():\\n out[attr] = getattr(grid.best_estimator_, attr)\\n return out\",\n \"def train_svm(X, y):\\n svm = SVC(C=1000000.0, gamma=0.0, kernel='rbf')\\n svm.fit(X, y)\\n return svm\",\n \"def select_hyperparams(\\n df,\\n kfold_params,\\n tfidf_path,\\n model_path,\\n code_col,\\n target_col,\\n n_trials,\\n hyperparam_space,\\n default_hyperparams,\\n):\\n\\n study = optuna.create_study(direction=\\\"maximize\\\", study_name=\\\"svm with kernels\\\")\\n objective = Objective(df, kfold_params, code_col, target_col, **hyperparam_space)\\n\\n if n_trials > 0:\\n study.optimize(objective, n_trials=n_trials)\\n params = study.best_params\\n else:\\n params = default_hyperparams\\n\\n best_tfidf_params = {\\n \\\"smooth_idf\\\": True,\\n }\\n best_svm_params = {\\n \\\"random_state\\\": RANDOM_STATE,\\n \\\"max_iter\\\": MAX_ITER,\\n }\\n for key, value in params.items():\\n model_name, param_name = key.split(\\\"__\\\")\\n if model_name == \\\"tfidf\\\":\\n best_tfidf_params[param_name] = value\\n elif model_name == \\\"svm\\\":\\n best_svm_params[param_name] = value\\n\\n code_blocks_tfidf = tfidf_fit_transform(df[code_col], best_tfidf_params, tfidf_path)\\n X, y = code_blocks_tfidf, df[target_col].values\\n clf = SVC(**best_svm_params)\\n\\n f1_mean, f1_std, accuracy_mean, accuracy_std, preds = cross_val_predict(\\n objective.kf, clf, X, y\\n )\\n if model_path is not None:\\n clf.fit(X, y)\\n pickle.dump(clf, open(model_path, \\\"wb\\\"))\\n\\n metrics = dict(\\n test_f1_score=f1_mean,\\n test_accuracy=accuracy_mean,\\n test_f1_std=f1_std,\\n test_accuracy_std=accuracy_std,\\n )\\n\\n return best_tfidf_params, best_svm_params, metrics, preds\",\n \"def get_hyperparams(self):\",\n \"def ex_2_b(x_train, y_train, x_test, y_test):\\n ###########\\n ## TODO:\\n ## Train SVMs with polynomial kernels for different values of the degree\\n ## (Remember to set the 'coef0' parameter to 1)\\n ## and plot the variation of the training and test scores with polynomial degree using 'plot_score_vs_degree' func.\\n ## Plot the decision boundary and support vectors for the best value of degree\\n ## using 'plot_svm_decision_boundary' function\\n ###########\\n degrees = range(1, 21)\\n\\n test_scores = np.array([])\\n train_scores = np.array([])\\n best_svm = None\\n best_test_score = 0\\n\\n for deg in degrees:\\n clf = svm.SVC(kernel='poly', degree=deg, coef0=1)\\n clf.fit(x_train, y_train)\\n\\n test_score = clf.score(x_test, y_test)\\n\\n if test_score > best_test_score:\\n best_test_score = test_score\\n best_svm = clf\\n\\n test_scores = np.append(test_scores, test_score)\\n train_scores = np.append(train_scores, clf.score(x_train, y_train))\\n\\n plot_score_vs_degree(train_scores, test_scores, degrees)\\n\\n plot_svm_decision_boundary(clf, x_train, y_train, x_test, y_test)\",\n \"def get_model_5(parameters):\\n # Generate model\\n model = svm.LinearSVC(max_iter=100000)\\n \\n # Return the model\\n return model\",\n \"def __init__(self, **kwargs):\\n super(SVM, self).__init__()\\n\\n # initialize some default values for the SVM backend\\n self.max_iter = kwargs.pop('max_iter', 1e6)\\n\\n # parameters for k cross validation / hyper-parameter tuning\\n self.params = [{\\n 'kernel': ['rbf', 'sigmoid', 'poly'],\\n 'C': [1e1, 1e2, 1e3, 1e4],\\n 'gamma': [1e4, 1e3, 1e2, 1, 1e-1, 1e-2],\\n 'degree': [2,3,4]}]\\n self.k_cross_val = kwargs.pop('k_cross_val', 5)\\n\\n # initialize the classifier using grid search to find optimal parameters\\n # via cross validation\\n if kwargs.pop('cross_validation', True):\\n self.clf = GridSearchCV(_SVC(max_iter=self.max_iter, **kwargs),\\n self.params,\\n cv=self.k_cross_val)\\n else:\\n probability = kwargs.pop('probability', True)\\n self.clf = _SVC(max_iter=self.max_iter, probability=probability, **kwargs)\",\n \"def svm_regression(y, x=None, ker='rbf', opt=0.1, show=False):\\n from sklearn.svm import SVR\\n if x is None: # Assume linearly spaced points\\n x = np.arange(0,len(y))\\n # Fit the regression model\\n if ker == 'linear':\\n svr = SVR(kernel=ker, C=1e3)\\n elif ker == 'poly':\\n if type(opt) is not int:\\n print('Need a degree for a polynomial fit, not' + str(opt))\\n return None\\n svr = SVR(kernel=ker, C=1e3, degree=opt)\\n else:\\n svr = SVR(kernel='rbf', C=1e3, gamma=opt) # default is radial basis func\\n y_svr = svr.fit(x, y).predict(x) # Fit\\n \\n # And plot if requested\\n if show:\\n plt.scatter(x, y, c='k', label='data')\\n plt.plot(x, y_svr, c='b', label='SVR model')\\n plt.xlabel('data')\\n plt.ylabel('target')\\n plt.title('Support Vector Regression')\\n plt.legend()\\n plt.show()\\n return y_svr\",\n \"def __init__(self, x, y, method='svm', n_cv=5, **kwargs):\\n self.x = x\\n self.y = y\\n self.rf_stat = None\\n self.summary = {}\\n self.n_cv = n_cv\\n self.method = method\\n if 'kernel' in kwargs.keys(): self.kernel = kwargs['kernel']\\n\\n self.print_flag = kwargs.get('print_flag', 'off')\\n self.stat = {'train': None, 'test': None}\\n # self.direct = kwargs[''] # TODO more generic here\",\n \"def __init__(self,training_data,default_kernel=\\\"rbf\\\"):\\n my_data = genfromtxt(training_data, delimiter='\\\\t',skip_header=0)\\n n_col = my_data.shape[1]\\n n_features=n_col-1 #assuming that the latest column\\n #contains the the outputs \\n #preprocessing data\\n X = preprocessing.scale(np.hsplit(my_data,[n_features,n_col])[0])\\n Y = np.squeeze(np.asarray(np.hsplit(my_data,[n_features,n_col])[1]))\\n #defining scaling\\n self.scaler = preprocessing.Scaler()\\n self.scaler.fit(np.hsplit(my_data,[n_features,n_col])[0])\\n #define classifier\\n self.classifier = svm.SVC(class_weight='auto',cache_size=DEFAULT_CACHE_SIZE, kernel=default_kernel)\\n self.classifier.fit(X, Y)\",\n \"def build_svm_pipeline():\\n svm_pipeline = None\\n\\n svm_pipeline = Pipeline([\\n ('vect', CountVectorizer()),\\n ('clf', SGDClassifier()),\\n ])\\n\\n return svm_pipeline\",\n \"def get_model_4(parameters):\\n # Generate model\\n model = svm.SVC(C=parameters['C'], gamma='scale', probability=True,\\n class_weight='balanced',\\n decision_function_shape='ovr')\\n \\n # Return the model\\n return model\",\n \"def svm_train(c, g, v, dname):\\n if sys.platform != 'win32':\\n # grid_py = '../tools/grid.py'\\n # gnuplot_exe = '/usr/bin/gnuplot'\\n svmtrain_exe = './PromoterSVM/libsvm/windows/my-svm-train'\\n else:\\n # grid_py = r\\\"D:\\\\LiYuan\\\\Data_Science\\\\libsvm-3.21\\\\windows\\\\grid.py\\\"\\n # gnuplot_exe = r\\\"D:\\\\Program Files\\\\gnuplot\\\\bin\\\\gnuplot.exe\\\"\\n svmtrain_exe = r'D:\\\\LiYuan\\\\\\\"Bioinformatic Research\\\"\\\\IMU\\\\zuo\\\\Tasks\\\\\\\"20160206-Promoter SVM\\\"\\\\biopromoter_script\\\\PromoterSVM\\\\libsvm\\\\windows\\\\my-svm-train.exe'\\n\\n df_model = dname + \\\".model\\\"\\n cmd = '{0} -c {1} -g {2} -v {3} \\\"{4}\\\" \\\"{5}\\\"'.format(svmtrain_exe, c, g, v, dname, df_model)\\n Popen(cmd, shell=True, stdout=PIPE).communicate()\",\n \"def train(self, params):\\n for param in params:\\n if param not in self.__info__['space']:\\n print(\\\"Error: not supported parameters {}\\\".format(param))\\n\\n if self.dataset_type == PROBLEM.CLASSIFICATION:\\n model = SVC(C=float(params[\\\"C\\\"]),\\n kernel=params[\\\"Kernel\\\"],\\n gamma=params[\\\"Gamma\\\"],\\n coef0=float(params[\\\"Coef0\\\"]))\\n else:\\n model = SVR(C=float(params[\\\"C\\\"]),\\n kernel=params['Kernel'],\\n gamma=params[\\\"Gamma\\\"],\\n coef0=float(params[\\\"Coef0\\\"]))\\n\\n # train\\n model.fit(self.X_train, self.Y_train)\\n return model\",\n \"def custom_training(nb_tweet_sample, randomised, equal_pos_neg, language, name_kernel, Resource, keep_null_vector):\\n m_features, m_labels = get_characteristic_label_vectors(nb_tweet_sample, randomised, equal_pos_neg, Resource,\\n keep_null_vector, language)\\n\\n kernel = Kernel.get_correct_kernel(name_kernel)\\n custom_SVM = SVM(kernel)\\n custom_SVM.fit(m_features, m_labels)\\n\\n return custom_SVM\",\n \"def svmtrain(x,y,w=None):\\n # xl = x.tolist() \\n # yl = y.tolist()\\n clf = svm.SVC(kernel='linear', C=1000) # apparently C param here really matters\\n clf.fit(x,y)\\n return({'w':clf.coef_, 'b':clf.intercept_,'clf':clf, 'n_support':clf.support_vectors_.shape[0]})\",\n \"def classical_kernel_estimation(in_train, in_test, labels):\\n X_train = []\\n Y_train = []\\n X_test = []\\n Y_test = []\\n for lab in labels:\\n for datum in in_train[lab]:\\n X_train.append(datum)\\n Y_train.append(lab)\\n for datum in in_test[lab]:\\n X_test.append(datum)\\n Y_test.append(lab)\\n clf = svm.SVC(gamma='auto')\\n clf.fit(X_train, Y_train)\\n print(clf.score(X_test, Y_test))\",\n \"def ex_2_c(x_train, y_train, x_test, y_test):\\n ###########\\n ## TODO:\\n ## Train SVMs with RBF kernels for different values of the gamma\\n ## and plot the variation of the test and training scores with gamma using 'plot_score_vs_gamma' function.\\n ## Plot the decision boundary and support vectors for the best value of gamma\\n ## using 'plot_svm_decision_boundary' function\\n ###########\\n gammas = np.arange(0.01, 2, 0.02)\\n\\n test_scores = np.array([])\\n train_scores = np.array([])\\n best_svm = None\\n best_test_score = 0\\n\\n for gamma in gammas:\\n clf = svm.SVC(kernel='rbf', gamma=gamma)\\n clf.fit(x_train, y_train)\\n\\n test_score = clf.score(x_test, y_test)\\n\\n if test_score > best_test_score:\\n best_test_score = test_score\\n best_svm = clf\\n\\n test_scores = np.append(test_scores, test_score)\\n train_scores = np.append(train_scores, clf.score(x_train, y_train))\\n\\n plot_score_vs_gamma(train_scores, test_scores, gammas)\\n\\n plot_svm_decision_boundary(clf, x_train, y_train, x_test, y_test)\",\n \"def define_kernel(self, *args, **kwargs):\\n base_kernel = self.base_kernel\\n if base_kernel is None:\\n base_kernel = 'VertexHistogram'\\n k = getattr(kernels, self.kernel_name)\\n k_base = getattr(kernels, base_kernel)\\n kernel = k(base_graph_kernel=k_base, *args, **kwargs)\\n return kernel\",\n \"def svm_clf_training(max_features, data):\\r\\n X_train, y_train, X_test, y_test = data\\r\\n clf = Pipeline([('feature_selection', SelectKBest(score_func=chi2, k=max_features)),\\r\\n ('clf', svm.SVC(C=1., kernel='linear'))])\\r\\n\\r\\n vectorizer = CountVectorizer(ngram_range=(1, 2), lowercase=True) # unigrams and bigrams\\r\\n X_matrix_tr = vectorizer.fit_transform(X_train)\\r\\n # parameters = [{'clf__kernel': ['linear'], 'clf__C': [0.1, 1, 10, 100]},\\r\\n # {'clf__kernel': ['rbf'], 'clf__C': [0.1, 1, 10, 100], 'clf__gamma': [0.001, 0.01, 0.1]},\\r\\n # {'clf__kernel': ['poly'], 'clf__C': [0.1, 1, 10, 100], 'clf__degree': [2, 3, 4, 5]}]\\r\\n # clf = GridSearchCV(svc, parameters, scoring='accuracy')\\r\\n clf.fit(X_matrix_tr, y_train)\\r\\n # print(\\\"Best parameters set found on development set:\\\")\\r\\n # print()\\r\\n # print(clf.best_estimator_)\\r\\n # print()\\r\\n # print(\\\"Grid scores on development set:\\\")\\r\\n # print()\\r\\n # for params, mean_score, scores in clf.grid_scores_:\\r\\n # print(\\\"%0.3f (+/-%0.03f) for %r\\\"\\r\\n # % (mean_score, scores.std() / 2, params))\\r\\n # print()\\r\\n voc = vectorizer.get_feature_names()\\r\\n # vectorizer1 = CountVectorizer(ngram_range=(1, 2), lowercase=True, vocabulary=voc)\\r\\n # X_matrix_val = vectorizer1.fit_transform(X_test)\\r\\n # y_pred = clf.predict(X_matrix_val)\\r\\n\\r\\n # for i in range(len(X_test)):\\r\\n # if y_test[i] != y_pred[i]:\\r\\n # print(X_test[i], y_test[i], y_pred[i])\\r\\n # print(classification_report(y_test, y_pred))\\r\\n return clf, voc\",\n \"def ex_1_a(x, y):\\n ###########\\n ## Train an SVM with a linear kernel\\n ## and plot the decision boundary and support vectors using 'plot_svm_decision_boundary' function\\n ###########\\n\\n clf = svm.SVC(kernel='linear')\\n clf.fit(x, y)\\n plot_svm_decision_boundary(clf, x, y)\\n pass\",\n \"def SVR_predict(data, X_train, X_test, y_train, y_test, param):\\n if param == 'NUETP' or param == 'SOEGP':\\n kernel_name = 'sigmoid'\\n c_value = 90.0\\n elif param == 'HYTCP' or param == 'WYTCP':\\n kernel_name = 'linear'\\n c_value = 1000\\n else:\\n raise ValueError('Incorrect parameter name')\\n clf = SVR(kernel=kernel_name, C=c_value, epsilon=0.3).fit(X_train, y_train)\\n future_x = data[['GDP_scaled','CLPRB_scaled','EMFDB_scaled','ENPRP_scaled','NGMPB_scaled','PAPRB_scaled','PCP_scaled','ZNDX_scaled','OP_scaled','OP2_scaled']][-6:]\\n pred = pd.DataFrame(clf.predict(future_x))\\n #Replacing negative values with 0\\n for i in range(6):\\n if pred[0][i] < 0:\\n pred[0][i] = 0\\n data[param][-6:] = pred[0]\\n return data\",\n \"def __init__(self, foundVariables, trainingData, trainingClasses, trainingWeights, testingData, testingClasses):\\n self.clf = svm.SVC(probability=True)\\n self.foundVariables = foundVariables\\n self.trainingData = trainingData\\n self.trainingClasses = trainingClasses\\n self.testingData = testingData\\n self.testingClasses = testingClasses\\n self.trainingWeights = trainingWeights\",\n \"def sgd_model(params):\\n\\n \\n if (params['random']):\\n params['loss'] = random.choice(['hinge', 'log', 'modified_huber', 'squared_hinge', 'perceptron', 'squared_loss', 'huber', 'epsilon_insensitive', 'squared_epsilon_insensitive'])\\n params['penalty'] = random.choice(['none', 'l2', 'l1', 'elasticnet'])\\n params['alpha'] = random.choice([0.001, 0.0001, 0.00001])\\n model = SGDClassifier(\\n loss=params['loss'],\\n penalty=params['penalty'],\\n alpha=params['alpha']\\n )\\n\\n return model\",\n \"def plot_svm(N=5, std=0.60, kernel='linear'):\\n X, y = make_blobs(n_samples=200, centers=2, random_state=0,\\n cluster_std=std)\\n\\n X_train, y_train = X[:N], y[:N]\\n X_test, y_test = X[N:], y[N:]\\n\\n clf = SVC(kernel=str(kernel))\\n clf.fit(X_train, y_train)\\n\\n plt.scatter(X_train[:, 0], X_train[:, 1], c=y_train, s=50, cmap='spring')\\n plt.scatter(X_test[:, 0], X_test[:, 1], c=y_test, s=50, cmap='spring',\\n alpha=0.2)\\n plt.xlim(-1, 4)\\n plt.ylim(-1, 6)\\n plot_svc_decision_function(clf, plt.gca())\\n plt.scatter(clf.support_vectors_[:, 0], clf.support_vectors_[:, 1],\\n s=200, facecolors='none')\\n\\n train_score = clf.score(X_train, y_train)\\n test_score = clf.score(X_test, y_test) if len(X_test) > 0 else 'NA'\\n plt.title('Train Accuracy = {0}; Test Accuracy = {1}'.format(train_score,\\n test_score))\",\n \"def get_nonlinear_model():\\n ss = StandardScaler()\\n svm = SVC(kernel='rbf', probability=True, random_state=42) # kernel SVM\\n\\n svm_model = Pipeline(steps=(['scale', ss], ['clf', svm]))\\n\\n svm_model_params = {\\n 'clf__C':loguniform(1e-3,1e3),\\n 'clf__gamma':loguniform(1e-4,1e1)\\n }\\n\\n # model: classifier with randomised parameter search over nested 3-fold CV\\n nonlinear_model = RandomizedSearchCV(svm_model, svm_model_params, n_iter=100, cv=3)\\n\\n return clone(nonlinear_model)\",\n \"def get_vertex_vek(*args, data_dir=None, **kwargs):\\n\\n annots = _apply_vek_prob(data_dir=data_dir)\\n vertex_labels, parcel_labels = [], []\\n for hemi in ('lh', 'rh'):\\n vc = _convert_vek_to_classes(getattr(annots, hemi), data_dir=data_dir)\\n vertex_labels.append(vc)\\n parcel_labels.append(np.unique(vc))\\n return NETWORKS(np.hstack(vertex_labels), np.hstack(parcel_labels))\",\n \"def GenerateS(s): \\n for i in range(len(x_train)):\\n for j in range(len(SVs)):\\n index = int(SVs[j])\\n s[i] = s[i] + alpha[index]*y_train[index] * Kernel(i, index) # (DotProduct(i, index)+1)**5\\n return s\",\n \"def kernel_to_skl(kernel):\\n try:\\n kernel = eval('kernels.' + kernel, {'__builtins__': None},\\n {'kernels': __import__('sklearn.gaussian_process.kernels',\\n fromlist=['kernels'])})\\n except (TypeError, AttributeError):\\n raise AttributeError('scikit-learn kernel unknown.')\\n\\n return kernel\",\n \"def getInputSpecification(cls):\\n specs = super(NuSVR, cls).getInputSpecification()\\n specs.description = r\\\"\\\"\\\"The \\\\xmlNode{NuSVR} \\\\textit{Nu-Support Vector Regression} is an Nu-Support Vector Regressor.\\n It is very similar to SVC but with the addition of the hyper-parameter Nu for controlling the\\n number of support vectors. However, unlike NuSVC, where nu replaces C,\\n here nu replaces the parameter epsilon of epsilon-SVR.\\n \\\\zNormalizationPerformed{NuSVR}\\n \\\"\\\"\\\"\\n specs.addSub(InputData.parameterInputFactory('nu', contentType=InputTypes.FloatType,\\n descr=r\\\"\\\"\\\"An upper bound on the fraction of margin errors and\\n a lower bound of the fraction of support vectors. Should be in the interval $(0, 1]$.\\\"\\\"\\\", default=0.5))\\n specs.addSub(InputData.parameterInputFactory('C', contentType=InputTypes.FloatType,\\n descr=r\\\"\\\"\\\"Regularization parameter. The strength of the regularization is inversely\\n proportional to C.\\n Must be strictly positive. The penalty is a squared l2 penalty.\\\"\\\"\\\", default=1.0))\\n specs.addSub(InputData.parameterInputFactory(\\\"kernel\\\", contentType=InputTypes.makeEnumType(\\\"kernel\\\", \\\"kernelType\\\",['linear','poly',\\n 'rbf','sigmoid']),\\n descr=r\\\"\\\"\\\"Specifies the kernel type to be used in the algorithm. It must be one of\\n ``linear'', ``poly'', ``rbf'' or ``sigmoid''.\\\"\\\"\\\", default='rbf'))\\n specs.addSub(InputData.parameterInputFactory(\\\"degree\\\", contentType=InputTypes.IntegerType,\\n descr=r\\\"\\\"\\\"Degree of the polynomial kernel function ('poly').Ignored by all other kernels.\\\"\\\"\\\",\\n default=3))\\n specs.addSub(InputData.parameterInputFactory(\\\"gamma\\\", contentType=InputTypes.FloatType,\\n descr=r\\\"\\\"\\\"Kernel coefficient for ``poly'', ``rbf'' or ``sigmoid''. If not input, then it uses\\n $1 / (n_features * X.var())$ as value of gamma\\\"\\\"\\\", default=\\\"scale\\\"))\\n specs.addSub(InputData.parameterInputFactory(\\\"coef0\\\", contentType=InputTypes.FloatType,\\n descr=r\\\"\\\"\\\"Independent term in kernel function\\\"\\\"\\\", default=0.0))\\n specs.addSub(InputData.parameterInputFactory(\\\"tol\\\", contentType=InputTypes.FloatType,\\n descr=r\\\"\\\"\\\"Tolerance for stopping criterion\\\"\\\"\\\", default=1e-3))\\n specs.addSub(InputData.parameterInputFactory(\\\"cache_size\\\", contentType=InputTypes.FloatType,\\n descr=r\\\"\\\"\\\"Size of the kernel cache (in MB)\\\"\\\"\\\", default=200.))\\n specs.addSub(InputData.parameterInputFactory(\\\"shrinking\\\", contentType=InputTypes.BoolType,\\n descr=r\\\"\\\"\\\"Whether to use the shrinking heuristic.\\\"\\\"\\\", default=True))\\n specs.addSub(InputData.parameterInputFactory(\\\"max_iter\\\", contentType=InputTypes.IntegerType,\\n descr=r\\\"\\\"\\\"Hard limit on iterations within solver.``-1'' for no limit\\\"\\\"\\\", default=-1))\\n return specs\",\n \"def build_model():\\n # build pipeline with count vecotrizer, tfidf and support vector machine\\n pipeline_SVC = Pipeline([\\n ('vect', CountVectorizer(tokenizer = tokenize)),\\n ('tfidf', TfidfTransformer()),\\n ('multi-clf', MultiOutputClassifier(LinearSVC()))\\n ])\\n\\n # define parameters for gridsearch\\n parameters_SVC = {\\n 'vect__max_df': (.6, 1),\\n 'tfidf__norm': ('l1', 'l2'),\\n 'multi-clf__estimator__C': (.1, 1, 100)\\n }\\n\\n # build parameter grid and fit data\\n model = GridSearchCV(pipeline_SVC, parameters_SVC)\\n\\n return model\",\n \"def __init__(self, estimator, target_language='java',\\n target_method='predict', **kwargs):\\n super(SVC, self).__init__(estimator, target_language=target_language,\\n target_method=target_method, **kwargs)\\n self.estimator = estimator\",\n \"def add_model_parameter_ui(clf_name):\\n params = dict()\\n if clf_name == 'KNN':\\n K = st.sidebar.slider(\\\"K\\\", 1, 5)\\n params[\\\"K\\\"] = K\\n\\n elif clf_name == 'SVM':\\n C = st.sidebar.slider(\\\"C\\\", 0.01, 10.0)\\n params[\\\"C\\\"] = C\\n\\n elif clf_name == 'Random Forest':\\n max_depth = st.sidebar.slider(\\\"max_depth\\\", 2, 15)\\n n_estimators = st.sidebar.slider(\\\"n_estimators\\\", 1, 100)\\n params[\\\"max_depth\\\"] = max_depth\\n params[\\\"n_estimators\\\"] = n_estimators\\n\\n else:\\n pass\\n\\n return params\",\n \"def test_lrp_svm(self, syn_genomic_data, syn_fm, syn_idx, rep, tmp_path, syn_true_pvalues): \\n rep_to_plot = 0\\n ttbrs = [0.5, 1,1.5]\\n idx = syn_idx[str(rep_to_plot)]\\n fig, axes = plt.subplots(len(ttbrs), 5, figsize=[30,15])\\n x_3d = syn_fm(\\\"3d\\\")[str(rep_to_plot)][:]\\n x_2d = syn_fm(\\\"2d\\\")[str(rep_to_plot)][:]\\n indices_true= [inds_true for inds_true, x in enumerate(syn_true_pvalues[0].flatten()) if x]\\n\\n for i, ttbr in enumerate(ttbrs):\\n print('Using tbrr={}'.format(ttbr))\\n labels = generate_syn_phenotypes(tower_to_base_ratio=ttbr, quantity=rep)\\n labels_cat = {}\\n for key, l in labels.items():\\n labels_cat[key] = tensorflow.keras.utils.to_categorical((l+1)/2)\\n \\n best_params_montaez['n_snps']= x_3d.shape[1]\\n \\n l_0b=labels_cat[str(rep_to_plot)]\\n\\n model = create_montaez_dense_model(best_params_montaez)\\n y_integers = np.argmax(l_0b[idx.train], axis=1)\\n class_weights = class_weight.compute_class_weight('balanced', np.unique(y_integers), y_integers)\\n d_class_weights = dict(enumerate(class_weights))\\n\\n model.fit(x=x_3d[idx.train], y=l_0b[idx.train], validation_data=(x_3d[idx.test], l_0b[idx.test]), epochs=best_params_montaez['epochs'], class_weight=d_class_weights, callbacks=[ ReduceLROnPlateau(monitor='val_loss', factor=best_params_montaez['factor'], patience=best_params_montaez['patience'], mode='min'),],)\\n\\n model = iutils.keras.graph.model_wo_softmax(model)\\n analyzer = innvestigate.analyzer.LRPAlpha1Beta0(model)\\n weights = analyzer.analyze(x_3d).sum(0)\\n\\n top_indices_sorted, filtered_weights = postprocess_weights(weights, top_k, filter_window_size, p_svm, p_pnorm_filter)\\n\\n complete_pvalues = chi_square(syn_genomic_data[str(rep_to_plot)][:], labels[str(rep_to_plot)])\\n \\n pvalues_filled_deep = np.ones(n_total_snps)\\n pvalues_filled_deep[top_indices_sorted] = complete_pvalues[top_indices_sorted]\\n\\n # Plot RPVT\\n plot_pvalues(complete_pvalues, indices_true, axes[i][0])\\n if i==0:\\n axes[i][0].set_title('RPVT $-log_{10}$(p-values)', fontsize=22)\\n axes[i][0].set_ylabel('$-log_{10}$(p-value)', fontsize=18)\\n plt.setp(axes[i][0].get_yticklabels(), fontsize=16)\\n plt.setp(axes[i][0].get_xticklabels(), fontsize=16)\\n\\n # Plot svm weights \\n clf = LinearSVC(penalty='l2', loss='hinge', C=0.0022, dual=True, tol=1e-3, verbose=0, class_weight='balanced')\\n idx_now, pvalues, raw_weights = combi_method(clf, syn_genomic_data[str(rep_to_plot)][:],x_2d, labels[str(rep_to_plot)], 35, 2, 2, 30)\\n #filtered_svm_weights = postprocess_weights_without_avg(raw_weights, p_svm)\\n pvalues_filled_combi = np.ones(len(complete_pvalues))\\n pvalues_filled_combi[idx_now] = pvalues\\n #svm_weights = toy_classifier.fit(x_2d, labels[str(rep_to_plot)]).coef_\\n axes[i][1].scatter(range(len(np.absolute(raw_weights).sum(1))), 1000*np.absolute(raw_weights).sum(1), marker='.', color='darkblue')\\n axes[i][1].scatter(indices_true,1000*np.absolute(raw_weights).sum(1)[indices_true], color='fuchsia')\\n axes[i][1].set_ylim(0,1000*(np.max(np.absolute(raw_weights).sum(1))+0.001))\\n if i==0:\\n axes[i][1].set_title('Absolute SVM weights * 1000', fontsize=22)\\n plt.setp(axes[i][1].get_yticklabels(), fontsize=16)\\n plt.setp(axes[i][1].get_xticklabels(), fontsize=16)\\n\\t\\t\\t\\n # Plot COMBI\\n plot_pvalues(pvalues_filled_combi, indices_true, axes[i][2])\\n if i==0:\\n axes[i][2].set_title('COMBI $-log_{10}$(p-values)', fontsize=22)\\n if i==2:\\n axes[i][2].set_xlabel('SNP position', fontsize=18)\\n plt.setp(axes[i][2].get_yticklabels(), fontsize=16)\\n plt.setp(axes[i][2].get_xticklabels(), fontsize=16)\\n\\t\\t\\t\\n # Plot LRP relevance scores\\n axes[i][3].scatter(range(len(np.absolute(weights).reshape(-1, 3).sum(1))), np.absolute(weights).reshape(-1, 3).sum(1), marker='.', color='darkblue')\\n axes[i][3].scatter(indices_true,np.absolute(weights).reshape(-1, 3).sum(1)[indices_true], color='fuchsia')\\n #axes[i][1].legend()\\n axes[i][3].set_ylim(0,np.max(np.absolute(weights).reshape(-1, 3).sum(1))+1)\\n if i==0:\\n axes[i][3].set_title('LRP relevance scores', fontsize=22)\\n plt.setp(axes[i][3].get_yticklabels(), fontsize=16)\\n plt.setp(axes[i][3].get_xticklabels(), fontsize=16)\\n\\t\\t\\t\\n # Plot DeepCOMBI\\n plot_pvalues(pvalues_filled_deep, indices_true, axes[i][4])\\n if i==0:\\n axes[i][4].set_title('DeepCOMBI $-log_{10}$(p-value)', fontsize=22)\\n plt.setp(axes[i][4].get_yticklabels(), fontsize=16)\\n plt.setp(axes[i][4].get_xticklabels(), fontsize=16)\\n\\t\\t\\t\\n ## Plot distribution of postprocessed vectors\\n #axes[i][2].plot(postprocessed_weights)\\n #axes[i][2].set_title('Postprocessed relevance')\\n\\n fig.savefig(os.path.join(IMG_DIR, 'manhattan-example-toy-NAR.png'), bbox_inches='tight')\",\n \"def train_model(self, text, labels):\\n clf = svm.SVR()\\n count_vect = CountVectorizer()\\n tfidf_transformer = TfidfTransformer()\\n counts = count_vect.fit_transform(text)\\n tfidf = tfidf_transformer.fit_transform(counts)\\n clf.fit(tfidf, labels)\\n\\n return clf, count_vect, tfidf_transformer\",\n \"def SVM_train(X, y, cv):\\r\\n rev = 10000\\r\\n start_time = time.time()\\r\\n print('\\\\n'+ '# '*10+'[Training] Support Vector Machine (SVM) (max_iter='+str(rev)+'):'+ ' #'*10)\\r\\n parameters = {\\r\\n 'kernel':('linear', 'poly', 'rbf'),\\r\\n 'C':(1, 5, 10),\\r\\n 'gamma':('scale', 'auto')\\r\\n }\\r\\n print('-'*2+'Grid Search Parameters:')\\r\\n print(parameters)\\r\\n clf = svm.SVC(random_state=rstate, probability=True, max_iter=rev) # Max_iter infinite as default, stuck on large datasets > 10^4.\\r\\n clf = GridSearchCV(clf, parameters, cv=cv, scoring='f1')\\r\\n clf.fit(X, y)\\r\\n print('-'*2+'GridSearch Results:')\\r\\n with pd.option_context('display.max_rows', None, 'display.max_columns', None):\\r\\n print(pd.DataFrame(clf.cv_results_))\\r\\n print('> '*2+'Training time: %.4f seconds.'%(time.time()-start_time))\\r\\n return clf\",\n \"def train(self, trainingData, trainingLabels, validationData, validationLabels):\\n from sklearn import svm\\n \\n \\\"*** YOUR CODE HERE ***\\\"\\n self.sklearn_svm = svm.SVC(C=5, kernel='rbf', gamma=0.005, decision_function_shape='ovo')\\n self.sklearn_svm.fit(trainingData, trainingLabels)\",\n \"def train_SVM(data: np.array, labels: np.array)->None:\\n print(\\\"SVM is not implemented yet!\\\")\",\n \"def thundersvm_load_svm_model(input_svm_model_file):\\n \\n svm_model = SVC()\\n svm_model.load_from_file(input_svm_model_file)\\n \\n return svm_model\",\n \"def hyper_parameter_tuning(X, y, classifier, models, sntypes_map, feature_names, fig_dir='.', remove_models=(), name=''):\\n\\n # Hyperparameter grid\\n n_estimators = [int(x) for x in np.linspace(start=200, stop=2000, num=10)]\\n max_features = ['auto', 'sqrt']\\n max_depth = [int(x) for x in np.linspace(10, 110, num=11)]\\n max_depth.append(None)\\n min_samples_split = [2, 5, 10]\\n min_samples_leaf = [1, 2, 4]\\n bootstrap = [True, False]\\n random_grid = {'n_estimators': n_estimators,\\n 'max_features': max_features,\\n 'max_depth': max_depth,\\n 'min_samples_split': min_samples_split,\\n 'min_samples_leaf': min_samples_leaf,\\n 'bootstrap': bootstrap}\\n\\n # Get data\\n num_features = X.shape[1]\\n model_names = [sntypes_map[model] for model in models]\\n X, y, models, remove_models = remove_redundant_classes(X, y, models, remove_models)\\n\\n # Get best features\\n n = 50\\n num_features, feature_names, X = get_n_best_features(n, X, y, classifier, feature_names, num_features, fig_dir, name, models, model_names)\\n\\n # Randomised Search\\n clf_random = RandomizedSearchCV(estimator=classifier, param_distributions=random_grid, n_iter=7, cv=3, verbose=2,\\n random_state=42, n_jobs=2)\\n clf_random.fit(X, y)\\n print(clf_random.best_params_)\\n\\n def evaluate(model, test_features, test_labels):\\n predictions = model.predict(test_features)\\n errors = abs(predictions - test_labels)\\n mape = 100 * np.mean(errors / test_labels)\\n accuracy = 100 - mape\\n print('Model Performance')\\n print('Average Error: {:0.4f} degrees.'.format(np.mean(errors)))\\n print('Accuracy = {:0.2f}%.'.format(accuracy))\\n\\n return accuracy\\n\\n best_random = clf_random.best_estimator_\\n # random_accuracy = evaluate(best_random, test_features, test_labels)\",\n \"def bgplvm_test_model(seed=default_seed, optimize=False, verbose=1, plot=False):\\r\\n from GPy.likelihoods.gaussian import Gaussian\\r\\n import GPy\\r\\n\\r\\n num_inputs = 13\\r\\n num_inducing = 5\\r\\n if plot:\\r\\n output_dim = 1\\r\\n input_dim = 2\\r\\n else:\\r\\n input_dim = 2\\r\\n output_dim = 25\\r\\n\\r\\n # generate GPLVM-like data\\r\\n X = _np.random.rand(num_inputs, input_dim)\\r\\n lengthscales = _np.random.rand(input_dim)\\r\\n k = (GPy.kern.rbf(input_dim, .5, lengthscales, ARD=True)\\r\\n + GPy.kern.white(input_dim, 0.01))\\r\\n K = k.K(X)\\r\\n Y = _np.random.multivariate_normal(_np.zeros(num_inputs), K, output_dim).T\\r\\n lik = Gaussian(Y, normalize=True)\\r\\n\\r\\n k = GPy.kern.rbf_inv(input_dim, .5, _np.ones(input_dim) * 2., ARD=True) + GPy.kern.bias(input_dim) + GPy.kern.white(input_dim)\\r\\n # k = GPy.kern.linear(input_dim) + GPy.kern.bias(input_dim) + GPy.kern.white(input_dim, 0.00001)\\r\\n # k = GPy.kern.rbf(input_dim, ARD = False) + GPy.kern.white(input_dim, 0.00001)\\r\\n # k = GPy.kern.rbf(input_dim, .5, _np.ones(input_dim) * 2., ARD=True) + GPy.kern.rbf(input_dim, .3, _np.ones(input_dim) * .2, ARD=True)\\r\\n # k = GPy.kern.rbf(input_dim, .5, 2., ARD=0) + GPy.kern.rbf(input_dim, .3, .2, ARD=0)\\r\\n # k = GPy.kern.rbf(input_dim, .5, _np.ones(input_dim) * 2., ARD=True) + GPy.kern.linear(input_dim, _np.ones(input_dim) * .2, ARD=True)\\r\\n\\r\\n m = GPy.models.BayesianGPLVM(lik, input_dim, kernel=k, num_inducing=num_inducing)\\r\\n #===========================================================================\\r\\n # randomly obstruct data with percentage p\\r\\n p = .8\\r\\n Y_obstruct = Y.copy()\\r\\n Y_obstruct[_np.random.uniform(size=(Y.shape)) < p] = _np.nan\\r\\n #===========================================================================\\r\\n m2 = GPy.models.BayesianGPLVMWithMissingData(Y_obstruct, input_dim, kernel=k, num_inducing=num_inducing)\\r\\n m.lengthscales = lengthscales\\r\\n\\r\\n if plot:\\r\\n import matplotlib.pyplot as pb\\r\\n m.plot()\\r\\n pb.title('PCA initialisation')\\r\\n m2.plot()\\r\\n pb.title('PCA initialisation')\\r\\n\\r\\n if optimize:\\r\\n m.optimize('scg', messages=verbose)\\r\\n m2.optimize('scg', messages=verbose)\\r\\n if plot:\\r\\n m.plot()\\r\\n pb.title('After optimisation')\\r\\n m2.plot()\\r\\n pb.title('After optimisation')\\r\\n\\r\\n return m, m2\",\n \"def set_hyperparams(self, params):\",\n \"def svm(xtrain, ytrain, xtest, ytest,labels_mapping, scaled = False):\\n if not scaled :\\n scaler = StandardScaler()\\n xtrain = scaler.fit_transform(xtrain)\\n xtest = scaler.transform(xtest)\\n\\n svm = SVC(C=10, cache_size=1500, class_weight='balanced')\\n svm = __train_and_test(svm, xtrain, ytrain, xtest, ytest,labels_mapping)\\n return svm\",\n \"def ex_2_b(x_train, y_train, x_test, y_test):\\n ###########\\n ## TODO:\\n ## Train SVMs with polynomial kernels for different values of the degree\\n ## (Remember to set the 'coef0' parameter to 1)\\n ## and plot the variation of the test and training scores with polynomial degree using 'plot_score_vs_degree' func.\\n ## Plot the decision boundary and support vectors for the best value of degree\\n ## using 'plot_svm_decision_boundary' function\\n ###########\\n\\n degrees = range(1, 21)\\n machines = [svm.SVC(kernel='poly', degree=d, coef0=1.0) for d in degrees]\\n\\n for machine in machines:\\n machine.fit(x_train, y_train)\\n\\n trainScores = [machine.score(x_train, y_train) for machine in machines]\\n testScores = [machine.score(x_test, y_test) for machine in machines]\\n\\n plot_score_vs_degree(trainScores, testScores, degrees)\\n\\n bestDegree = testScores.index(max(testScores))\\n print('Score of best polynomial degree ({}): {}'.format(bestDegree + 1, testScores[bestDegree]))\\n plot_svm_decision_boundary(machines[bestDegree], x_train, y_train, x_test, y_test)\",\n \"def SVM_train(Ktrain,y,lbda_vec):\\r\\n n = Ktrain.shape[0]\\r\\n for idx, lbda in enumerate(lbda_vec): \\r\\n C = 1/(2*lbda*n)\\r\\n P = matrix(Ktrain, tc=\\\"d\\\")\\r\\n q = - matrix(y,tc=\\\"d\\\")\\r\\n G = matrix( np.concatenate( (np.diagflat(y) , -np.diagflat(y) ), axis=0 ),tc=\\\"d\\\" )\\r\\n h1 = C * np.ones((n,1))\\r\\n h2 = np.zeros((n,1)) \\r\\n h = matrix(np.concatenate((h1,h2),axis=0))\\r\\n\\r\\n solvers.options['show_progress'] = False\\r\\n \\r\\n sol = solvers.qp(P,q,G,h) \\r\\n a = np.asarray(sol['x'])\\r\\n\\r\\n #alpha is sparse\\r\\n a[np.where(np.abs(a) < 1e-4)] = 0\\r\\n y_svm = np.dot(Ktrain,a)\\r\\n\\r\\n print(\\\"Précision pour lambda = \\\" + str(lbda) + \\\" :\\\", accuracy(y_svm,y))\",\n \"def hyperparameter_cv(X_data, y_data, hyperparameters):\\n\\n # Create Grid of hyperparameters\\n grid = cartesian_product(hyperparameters)\\n\\n # Loop through hyperparameters \\n best_score = 0\\n for hyperparameter in grid:\\n # Initialize Modle\\n model = svm.SVC(kernel='linear', **hyperparameter)\\n\\n # Train and Get Accuracy\\n print(f\\\"Training using hyperparameters: {hyperparameter}\\\")\\n score = cross_validation_score(X_data, y_data, model, folds=5)\\n print(f\\\"Accuracy Score: {score}\\\")\\n\\n if score > best_score:\\n best_score = score\\n best_parameters = hyperparameter\\n \\n return best_score, best_parameters\",\n \"def test_SVM_rbf_test_C_parameter(params, X_train, X_test, y_train, y_test):\",\n \"def search_ksvm_hyperparams(model, x, y, kernel, C_list, eps_list, folds=3):#C_list,\\n # divide data into training and validation sets:\\n N = x.shape[0]\\n\\n # get random indices for dataset folds\\n indices = torch.randperm(N)\\n length = N // folds\\n\\n max_acc = 0.0\\n max_C = 0.0\\n max_eps = 0.0\\n for C in C_list:\\n for eps in eps_list:\\n acc = torch.zeros(folds)\\n for k in range(folds):\\n x_train = torch.cat((x[indices[0:k*length]],x[indices[(k+1)*length:]]),dim = 0)\\n y_train = torch.cat((y[indices[0:k*length]],y[indices[(k+1)*length:]]),dim = 0)\\n x_val = x[indices[k*length:(k+1)*length]]\\n y_val = y[indices[k*length:(k+1)*length]]\\n\\n model.__init__(kernel, C, eps)\\n model.train(x_train, y_train, print_progress = False)\\n y_pred = model.predict(x_val)\\n acc[k] = ((y_val==y_pred).sum()) / float(y_val.shape[0])\\n acc_mean = acc.mean()\\n if(acc_mean > max_acc):\\n max_acc = acc_mean\\n max_C = C\\n max_eps = eps\\n\\n print(\\\"at C = {} and eps = {} we get acc = {}\\\" .format(C, eps, acc_mean))\\n\\n\\n print(\\\"Max we get at: C: {} and eps = {} we get acc = {}\\\" .format(max_C, max_eps, max_acc))\\n return max_acc, max_C, max_eps\",\n \"def sklearn2graph(model, output_names=None, **kwargs):\\n conv = identify_interpreter(model)\\n return conv(model, output_names=output_names, **kwargs)\",\n \"def train_linear_SVM(X_train_input, y_train_input, C=1):\\r\\n from sklearn.svm import SVC\\r\\n svc_clf = SVC(kernel='linear', probability=True, C=C)\\r\\n svc_clf.fit(X_train_input, y_train_input)\\r\\n return svc_clf\",\n \"def svr_grid_search(self, param_grid, make_plots=False, winner_plot=False):\\n # TODO: Generalize to pass in any arbitrary learning object, e.g. my Neuron-By-Neuron object to search.\\n # Update variable that determines whether we generate a plot for the lowest mse values.\\n if winner_plot:\\n self.winner_plot = winner_plot\\n\\n # Iterate over each parameter and generate a surface.\\n cnt = 1\\n\\n for params in ParameterGrid(param_grid):\\n my_gamma = params['gamma']\\n my_c = params['C']\\n\\n # Set shrinking heuristics to false as per the example Matlab code.\\n clf = SVR(shrinking=False, kernel='rbf', C=my_c, gamma=my_gamma, cache_size=500)\\n # Train against training set.\\n tic = time.time()\\n clf.fit(self.x_train, self.y_train)\\n toc = time.time() - tic\\n\\n # Generate predicted set using SVR network using the test set.\\n train_prediction = clf.predict(self.x_train)\\n\\n # Create output based on SVR prediction.\\n self.prediction = clf.predict(self.x_test)\\n\\n # Calculate the Mean Squared Error based on the ideal test output and that predicted by the SVR.\\n train_mse = mean_squared_error(self.y_train, train_prediction)\\n test_mse = mean_squared_error(self.y_test, self.prediction)\\n\\n # Record Best mse and update with a better\\n if test_mse < self.best_mse:\\n self.best_mse = test_mse\\n self.best_prediction = self.prediction\\n self.winner = {\\n 'SVR': clf,\\n 'train_mse': train_mse,\\n 'test_mse': test_mse,\\n 'train_time': toc\\n }\\n if make_plots:\\n # Generate graph and save as file for upload to LaTeX document.\\n # Have to do this because I wanted to add another parameter with gamma = 'auto'\\n # When gamma = 'auto', it sets it to the reciprocal of the number of RBFs, if I'm not mistaken.\\n\\n if my_gamma != 'auto':\\n gamma_str = '%0.3f' % my_gamma\\n else:\\n gamma_str = my_gamma\\n\\n my_title = 'Surface with gamma=%s C=%0.3f and mse=%0.5f (train mse=%0.5f)' % (\\n gamma_str, my_c, test_mse, train_mse)\\n my_filename = '%s_%d' % (self.plot_filename_prefix, cnt)\\n Plot(self.x_test[:, 0], self.x_test[:, 1], self.prediction).surf_rand(title=my_title,\\n save_fig_path=my_filename)\\n cnt += 1\\n\\n if self.winner_plot:\\n my_gamma = self.winner['SVR'].gamma\\n my_c = self.winner['SVR'].C\\n if my_gamma != 'auto':\\n gamma_str = '%0.3f' % my_gamma\\n else:\\n gamma_str = my_gamma\\n\\n my_title = 'Surface with gamma=%s C=%0.3f and Test mse=%0.5f (Train mse=%0.5f)' % (\\n gamma_str, my_c, self.winner['test_mse'], self.winner['train_mse'])\\n my_filename = '%s_winner.png' % self.plot_filename_prefix\\n Plot(self.x_test[:, 0], self.x_test[:, 1], self.best_prediction).surf_rand(title=my_title,\\n save_fig_path=my_filename)\\n return self.winner\",\n \"def main():\\n\\n if len(sys.argv) < 4 or len(sys.argv) > 5:\\n print 'Usage: classifier.py data_dimension train_set_path test_set_path [option: add_bias]'; \\n return; \\n\\n # create sets of possible hyperparameter values\\n setC = {0.001, 0.01, 0.1, 1, 10, 25, 100}; # trade off regularizer and error minimization\\n setRho = {0.001, 0.01, 0.1, 1}; # learning rate for gradient descent \\n hyperparams = [setC, setRho];\\n \\n # create svm classifier for selected data\\n dataDim = int(sys.argv[1]);\\n trainPath = str(sys.argv[2]);\\n testPath = str(sys.argv[3]);\\n if len(sys.argv) == 5:\\n c = Classifier('svm', hyperparams, dataDim, testPath, trainPath, addBias=True);\\n else:\\n c = Classifier('svm', hyperparams, dataDim, testPath, trainPath);\\n \\n print 'Classifier type: ', c.type, \\\\\\n '\\\\nTraining set: ', trainPath, \\\\\\n '\\\\nTest set: ', testPath;\\n \\n print 'Determining hyperparameters to use...';\\n c.learnHyperparams(report=1);\\n \\n print 'Training classifier...';\\n c.train();\\n \\n print 'Performing inference on test set...';\\n c.test(); \\n \\n print '\\\\nREPORT:', \\\\\\n '\\\\nUsing hyperparameters: ', c.theta, \\\\\\n '\\\\nLearned weight vector: ', c.w, \\\\\\n '\\\\nPrediction accuracy on test set: ', c.accuracy * 100, ' percent';\",\n \"def train(prob: SvmProblem):\\n # Define variables\\n x = prob.X\\n y = prob.Y\\n C = prob.C\\n C2 = prob.gamma\\n\\n # Swap params, so SVM solves X* with correct params\\n xk = prob.xkernel\\n xsk = prob.xskernel\\n\\n prob.C = C2\\n prob.xkernel = xsk\\n\\n svm = SVM()\\n xstar_clf = svm.train(prob.Xstar, prob)\\n\\n # Get distance to decision boundary\\n xi_star = np.zeros(prob.num)\\n for i in range(prob.num):\\n output = (1 - prob.Y[i] * (xstar_clf.f(prob.Xstar[i])))\\n xi_star[i] = max(0, output)\\n\\n # Replace swapped out params so modified SVM solves X with correct params\\n prob.C = C\\n prob.xkernel = xk\\n\\n # Define the inputs to CVXOPT - See Appendix G.4\\n P = prob.yi_yj * prob.xi_xj\\n q = -np.ones((prob.num, 1))\\n G1 = -np.eye(prob.num)\\n G2 = np.eye(prob.num)\\n G3 = xi_star.reshape(1, -1)\\n G = np.vstack((G1, G2))\\n G = np.vstack((G, G3))\\n h1 = np.zeros(prob.num).reshape(-1, 1)\\n h2 = np.repeat((1 + prob.delta) * C, prob.num).reshape(-1, 1)\\n h3 = sum(xi_star) * C\\n h = np.vstack((h1, h2))\\n h = np.vstack((h, h3))\\n A = y.reshape(1, -1)\\n b = np.zeros(1)\\n\\n P = matrix(P, tc='d')\\n q = matrix(q, tc='d')\\n G = matrix(G, tc='d')\\n h = matrix(h, tc='d')\\n A = matrix(A, tc='d')\\n b = matrix(b, tc='d')\\n\\n # Solve optimization problem using CVXOPT\\n solvers.options['show_progress'] = False\\n sol = solvers.qp(P, q, G, h, A, b)\\n alphas = np.array(sol['x'])\\n\\n # Get the bias\\n bacond1 = (alphas > 1e-8)\\n bacond2 = (alphas <= (1 + prob.delta) * C)\\n bcond = np.array([a and b for a, b in zip(bacond1, bacond2)]).flatten()\\n\\n yS = y[bcond]\\n xS = x[bcond]\\n aS = alphas[bcond]\\n\\n sum_total = 0\\n for s in range(len(yS)):\\n inner_total = 0\\n for m in range(len(yS)):\\n am = aS[m]\\n ym = yS[m]\\n xm_xs = prob.xkernel(xS[m], xS[s])\\n inner_total += am * ym * xm_xs\\n sum_total += yS[s] - inner_total\\n\\n bias = sum_total / len(yS)\\n\\n # Populate Classifier object to be returned\\n clf = Classifier()\\n clf.b = bias\\n clf.alphas = alphas\\n clf.xs = x\\n clf.ys = y\\n clf.kern = prob.xkernel\\n return clf\",\n \"def run_model(LinearSVM_params, category):\\n \\n # Unload common parameters\\n config = LinearSVM_params['configs'][category] if LinearSVM_params['configs'] else None\\n verbose = LinearSVM_params['verbose']\\n warning = LinearSVM_params['warning']\\n stats_path = LinearSVM_params['stats_path']\\n\\n model_name = LinearSVM_params['model_name']\\n print(f'Running model {model_name}')\\n\\n # Unload the training data specific parameters\\n train_size = LinearSVM_params['train_size']\\n active_learning_iter = LinearSVM_params['active_learning_iter']\\n cross_validation = LinearSVM_params['cross_validate']\\n full = LinearSVM_params['full_dataset']\\n active_learning = LinearSVM_params['active_learning']\\n w_hx = LinearSVM_params['with_historical_data']\\n w_k = LinearSVM_params['with_k']\\n\\n # Specify the desired operation\\n fine_tuning = LinearSVM_params['fine_tuning']\\n save_model = LinearSVM_params['save_model']\\n to_params = True\\n\\n if fine_tuning:\\n class_weights = [{0: i, 1: 1.0-i} for i in np.linspace(.1, .9, num=9)]\\n class_weights.append('balanced')\\n class_weights.append(None)\\n\\n ft_params = {\\n # 'penalty': ['l1', 'l2'],\\n 'penalty': ['l1'],\\n # 'loss': ['hinge', 'squared_hinge'],\\n 'loss': ['squared_hinge'],\\n 'dual': [False],\\n # 'C': [.001, .01, .1, 1, 10],\\n 'C': [i for i in np.linspace(0.001, 0.01, num=10)],\\n # 'tol': [.0001, .001, .01, .1, 1],\\n 'tol': [i for i in np.linspace(0.01, 0.1, num=10)],\\n 'fit_intercept': [True],\\n 'class_weight': class_weights,\\n }\\n\\n _ = grid_search(\\n ActiveLinearSVM,\\n ft_params,\\n train_size,\\n active_learning_iter,\\n active_learning=active_learning,\\n w_hx=w_hx,\\n w_k=w_k,\\n info=True\\n )\\n else:\\n # Load the desired sized dataset under desired option\\n amine_list, x_t, y_t, x_v, y_v, all_data, all_labels = process_dataset(\\n train_size=train_size,\\n active_learning_iter=active_learning_iter,\\n verbose=verbose,\\n cross_validation=cross_validation,\\n full=full,\\n active_learning=active_learning,\\n w_hx=w_hx,\\n w_k=w_k\\n )\\n\\n # print(amine_list)\\n for amine in amine_list:\\n if cross_validation:\\n # print(\\\"Training and cross validation on {} amine.\\\".format(amine))\\n\\n # Create the LinearSVM model instance for the specific amine\\n ALSVM = ActiveLinearSVM(\\n amine=amine,\\n config=config,\\n verbose=verbose,\\n stats_path=stats_path,\\n model_name=model_name)\\n\\n # Load the training and validation set into the model\\n ALSVM.load_dataset(x_t[amine], y_t[amine], x_v[amine], y_v[amine], all_data[amine], all_labels[amine])\\n\\n # Train the data on the training set\\n ALSVM.train(warning=warning)\\n\\n # Conduct active learning with all the observations available in the pool\\n if active_learning:\\n ALSVM.active_learning(num_iter=active_learning_iter, warning=warning, to_params=to_params)\\n else:\\n ALSVM.store_metrics_to_params()\\n\\n # Save the model for future reproducibility\\n if save_model:\\n ALSVM.save_model(model_name)\\n\\n # TODO: testing part not implemented: might need to change the logic loading things in\",\n \"def mylinearsvm(lambdat, eta_init, maxiter, X, y):\\n d = np.size(X, 1)\\n beta_init = np.zeros(d)\\n theta_init = np.zeros(d)\\n betas, objs = fast_grad(beta_init, theta_init, lambdat, eta_init, maxiter,X=X,y=y)\\n return betas, objs\",\n \"def office_smooth_kernels(parser, args, params):\\n parser.add_argument('-h_length', type=str,\\n help='Variance of Gaussian [horizontal] (default=25)',\\n metavar='', default='25')\\n parser.add_argument('-v_length', type=str,\\n help='Variance of Gaussian [vertical] (default=5)',\\n metavar='', default='5')\\n local_args = parser.parse_known_args(args)\\n h_length = local_args[0].h_length\\n v_length = local_args[0].v_length\\n\\n control.smooth_kernels(params, h_length, v_length)\",\n \"def do_lsvm(x_data, y_data, bst_model):\\n bst_lsvm = SVC(C = bst_model.best_estimator_.C, kernel = \\\"linear\\\")\\n bst_lsvm_fit = bst_lsvm.fit(x_data, y_data)\\n return True\",\n \"def test_SVM_test_C_parameter(params, X_train, X_test, y_train, y_test):\",\n \"def ex_1_a(x, y):\\n ###########\\n ## TODO:\\n ## Train an SVM with a linear kernel\\n ## and plot the decision boundary and support vectors using 'plot_svm_decision_boundary' function\\n ###########\\n\\n clf = svm.SVC(kernel='linear')\\n clf.fit(x, y)\\n\\n plot_svm_decision_boundary(clf, x, y)\",\n \"def select_model():\\r\\n from sklearn import tree\\r\\n import graphviz\\r\\n\\r\\n ValidationSetAndLabels = AllSets[1]\\r\\n ValLabels = ValidationSetAndLabels[:, [-1]] # extract labels (last column)\\r\\n ValSet = np.delete(ValidationSetAndLabels, -1, axis=1) # delete labels\\r\\n\\r\\n TrainingSetAndLabels = AllSets[2]\\r\\n TrainLabels = TrainingSetAndLabels[:, [-1]] # extract labels (last column)\\r\\n TrainSet = np.delete(TrainingSetAndLabels, -1, axis=1) # delete labels\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n This is the code to select the best hyperparameter (part b)\\r\\n\\r\\n for SplitCriterion in ['entropy', 'gini']:\\r\\n print \\\"Criterion: \\\" + SplitCriterion + '\\\\n'\\r\\n\\r\\n for MaxDepth in [int(depth) for depth in np.linspace(1, np.log2(TrainSet.shape[1]), 5)]:\\r\\n print \\\"max_depth: \\\" + str(MaxDepth) + '\\\\n'\\r\\n\\r\\n MyTree = tree.DecisionTreeClassifier(criterion=SplitCriterion, max_depth=MaxDepth)\\r\\n MyTree = MyTree.fit(TrainSet, TrainLabels)\\r\\n\\r\\n Predictions = MyTree.predict(ValSet)\\r\\n Result = np.abs(Predictions - ValLabels.flatten())\\r\\n\\r\\n Accuracy = 100 * float(np.count_nonzero(Result == 0)) / Predictions.shape[0]\\r\\n\\r\\n print \\\"Accuracy for this test is: %f %%\\\" %Accuracy\\r\\n print '\\\\n'\\r\\n\\r\\n print '\\\\n'\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n MyTree = tree.DecisionTreeClassifier(criterion='entropy', max_depth=12)\\r\\n\\r\\n MyTree = MyTree.fit(TrainSet, TrainLabels)\\r\\n\\r\\n Predictions = MyTree.predict(ValSet)\\r\\n Result = np.abs(Predictions - ValLabels.flatten())\\r\\n\\r\\n Accuracy = 100 * float(np.count_nonzero(Result == 0)) / Predictions.shape[0]\\r\\n\\r\\n dot_data = tree.export_graphviz(MyTree, out_file=None, max_depth=2,\\r\\n feature_names=AllSets[3], filled=True, rounded=True, special_characters=True,\\r\\n class_names=TrainLabels.flatten().astype(str))\\r\\n graph = graphviz.Source(dot_data)\\r\\n graph.render(\\\"output\\\")\",\n \"def __init__(self, training_data, kernel, par_sigma, par_lambda):\\n self.kernel = kernel\\n self.par_sigma = par_sigma\\n self.par_lambda = par_lambda\\n self.training_data = training_data\\n\\n self.assert_data_shape(training_data)\\n\\n # train model\\n k = self.kernel.get_kernel_matrix(training_data[0], training_data[0])\\n u = scipy.linalg.cholesky(k + self.par_lambda * numpy.identity(k.shape[0]))\\n beta = scipy.linalg.solve_triangular(u, training_data[1], trans='T')\\n alpha = scipy.linalg.solve_triangular(u, beta)\\n\\n self.alpha = alpha.reshape(alpha.size, 1)\\n self.u = u\",\n \"def _get_current_hyperparameters(self):\",\n \"def make_graph_from_vectors(X, *, knn_edges, random_edges=0, virtual_vertices=0, deduplicate=True,\\n directed=True, verbose=False, squared=False, GraphEmbeddingClass=GraphEmbedding,\\n **kwargs):\\n num_vectors, vector_dim = X.shape\\n X = np.require(check_numpy(X), dtype=np.float32, requirements=['C_CONTIGUOUS'])\\n if virtual_vertices != 0:\\n if verbose: print(\\\"Creating virtual vertices by k-means\\\")\\n X_clusters = KMeans(virtual_vertices).fit(X).cluster_centers_\\n X = np.concatenate([X, X_clusters])\\n\\n if verbose:\\n print(\\\"Searching for nearest neighbors\\\")\\n try:\\n from faiss import IndexFlatL2\\n index = IndexFlatL2(vector_dim)\\n index.add(X)\\n neighbor_distances, neighbor_indices = index.search(X, knn_edges + 1)\\n except ImportError:\\n warn(\\\"faiss not found, using slow knn instead\\\")\\n neighbor_distances, neighbor_indices = NearestNeighbors(n_neighbors=knn_edges + 1).fit(X).kneighbors(X)\\n\\n if not squared:\\n neighbor_distances **= 0.5\\n if verbose:\\n print(\\\"Adding knn edges\\\")\\n edges_from, edges_to, distances = [], [], []\\n for vertex_i in np.arange(num_vectors):\\n for neighbor_i, distance in zip(neighbor_indices[vertex_i], neighbor_distances[vertex_i]):\\n if vertex_i == neighbor_i: continue # forbid loops\\n if neighbor_i == -1: continue # ANN engine uses -1 for padding\\n edges_from.append(vertex_i)\\n edges_to.append(neighbor_i)\\n distances.append(distance)\\n\\n if random_edges != 0:\\n if verbose: print(\\\"Adding random edges\\\")\\n random_from = np.random.randint(0, num_vectors, num_vectors * random_edges)\\n random_to = np.random.randint(0, num_vectors, num_vectors * random_edges)\\n for vertex_i, neighbor_i in zip(random_from, random_to):\\n if vertex_i != neighbor_i:\\n distance = np.sum((X[vertex_i] - X[neighbor_i]) ** 2)\\n if not squared: distance **= 0.5\\n edges_from.append(vertex_i)\\n edges_to.append(neighbor_i)\\n distances.append(distance)\\n\\n if deduplicate:\\n if verbose: print(\\\"Deduplicating edges\\\")\\n unique_edges_dict = {} # {(from_i, to_i) : distance(i, j)}\\n for from_i, to_i, distance in zip(edges_from, edges_to, distances):\\n edge_iijj = int(from_i), int(to_i)\\n if not directed:\\n edge_iijj = tuple(sorted(edge_iijj))\\n unique_edges_dict[edge_iijj] = distance\\n\\n edges_iijj, distances = zip(*unique_edges_dict.items())\\n edges_from, edges_to = zip(*edges_iijj)\\n\\n edges_from, edges_to, distances = map(np.asanyarray, [edges_from, edges_to, distances])\\n if verbose:\\n print(\\\"Total edges: {}, mean edges per vertex: {}, mean distance: {}\\\".format(\\n len(edges_from), len(edges_from) / float(num_vectors), np.mean(distances)\\n ))\\n return GraphEmbeddingClass(edges_from, edges_to, initial_weights=distances, directed=directed, **kwargs)\",\n \"def do_rbfsvm(x_data, y_data, bst_model):\\n\\n bst_rbfsvm = SVC(C = bst_model.best_estimator_.C, gamma = bst_model.best_estimator_.gamma)\\n bst_rbfsvm_fit = bst_lsvm.fit(x_data, y_data)\\n return True\",\n \"def train_svm_model(self, X_train, X_test, y_train, y_test):\\r\\n clf = Pipeline([('vect', CountVectorizer()), ('tfidf', TfidfTransformer()),\\r\\n ('clf', LinearSVC())])\\r\\n clf = clf.fit(X_train, y_train)\\r\\n pred = clf.predict(X_test)\\r\\n print('Confusion matrix\\\\n',confusion_matrix(y_test,pred))\\r\\n print('Classification_report\\\\n',classification_report(y_test,pred))\\r\\n return clf\",\n \"def main(argv):\\n\\n # Parse arguments and store in model_dict\\n model_dict = svm_model_dict_create()\\n DR = model_dict['dim_red']\\n rev_flag = model_dict['rev']\\n strat_flag = 1\\n\\n # Load dataset and create data_dict to store metadata\\n print('Loading data...')\\n dataset = model_dict['dataset']\\n if (dataset == 'MNIST') or (dataset == 'GTSRB'):\\n X_train, y_train, X_val, y_val, X_test, y_test = load_dataset(\\n model_dict)\\n img_flag = None\\n elif dataset == 'HAR':\\n X_train, y_train, X_test, y_test = load_dataset(model_dict)\\n img_flag = None\\n # TODO: 2 classes case\\n # if model_dict['classes'] == 2:\\n # X_train = X_train\\n\\n data_dict = get_data_shape(X_train, X_test)\\n n_features = data_dict['no_of_features']\\n\\n # Reshape dataset to have dimensions suitable for SVM\\n X_train_flat = X_train.reshape(-1, n_features)\\n X_test_flat = X_test.reshape(-1, n_features)\\n # Center dataset with mean of training set\\n mean = np.mean(X_train_flat, axis=0)\\n X_train_flat -= mean\\n X_test_flat -= mean\\n\\n # Create a new model or load an existing one\\n clf = model_creator(model_dict, X_train_flat, y_train)\\n model_tester(model_dict, clf, X_test_flat, y_test)\\n\\n # Assign parameters\\n n_mag = 25 # No. of deviations to consider\\n dev_list = np.linspace(0.1, 2.5, n_mag) # A list of deviations mag.\\n if dataset == 'MNIST':\\n rd_list = [784, 331, 200, 100, 90, 80, 70, 60, 50, 40, 30, 20, 10] # Reduced dimensions to use\\n # rd_list = [784]\\n elif dataset == 'HAR':\\n rd_list = [561, 200, 100, 90, 80, 70, 60, 50, 40, 30, 20, 10]\\n # rd_list = [561]\\n n_rd = len(rd_list)\\n output_list = []\\n clear_flag = None\\n # Clear old output files\\n if clear_flag ==1:\\n abs_path_o = resolve_path_o(model_dict)\\n _, fname = file_create(model_dict)\\n os.remove(abs_path_o + fname + '.txt')\\n _, fname = file_create(model_dict, rd=1, strat=strat_flag, rev=rev_flag)\\n os.remove(abs_path_o + fname + '.txt')\\n\\n # Test clf against adv. samples\\n print('Performing attack...')\\n if model_dict['classes'] != 2:\\n for i in range(n_mag):\\n X_adv, y_ini = mult_cls_atk(clf, X_test_flat, mean, dev_list[i])\\n output_list.append(acc_calc_all(clf, X_adv, y_test, y_ini))\\n if img_flag != None:\\n save_svm_images(model_dict, data_dict, X_test, X_adv,\\n dev_list[i])\\n fname = print_svm_output(model_dict, output_list, dev_list)\\n # subprocess.call([\\\"gnuplot -e \\\\\\\"filename='{}.png'; in_name='{}.txt'\\\\\\\" gnu_in_loop.plg\\\".format(fname,fname)], shell=True)\\n # else:\\n # # TODO: 2 classes\\n # print('TODO')\\n\\n # Retrain defense and strategic attack\\n print('--------------Retrain Defense & Strategic Attack--------------')\\n for rd in rd_list:\\n output_list = []\\n print('Reduced dimensions: {}'.format(rd))\\n\\n # Dimension reduce dataset and reshape\\n X_train_dr, _, dr_alg = dr_wrapper(\\n X_train_flat, X_test_flat, DR, rd, y_train, rev=rev_flag)\\n\\n # With dimension reduced dataset, create new model or load existing one\\n clf = model_creator(model_dict, X_train_dr, y_train, rd, rev_flag)\\n # Modify classifier to include transformation matrix\\n clf = model_transform(model_dict, clf, dr_alg)\\n\\n model_tester(model_dict, clf, X_test_flat, y_test, rd, rev_flag)\\n\\n # rev_flag = 1\\n # model_dict['rev'] = rev_flag\\n # # Dimension reduce dataset and reshape\\n # X_train_dr, _, dr_alg = dr_wrapper(\\n # X_train_flat, X_test_flat, DR, rd, y_train, rev=rev_flag)\\n #\\n # # With dimension reduced dataset, create new model or load existing one\\n # clf_1 = model_creator(model_dict, X_train_dr, y_train, rd, rev_flag)\\n # # Modify classifier to include transformation matrix\\n # clf_1 = model_transform(model_dict, clf_1, dr_alg)\\n # # Test model on original data\\n # model_tester(model_dict, clf_1, X_test_flat, y_test, rd, rev_flag)\\n #\\n # print clf_1.coef_[0]-clf.coef_[0]\\n # print np.linalg.norm(clf_1.coef_[0]), np.linalg.norm(clf.coef_[0])\\n # print np.dot(clf_1.coef_[0],clf.coef_[0])/(np.linalg.norm(clf_1.coef_[0])*np.linalg.norm(clf.coef_[0]))\\n\\n # Strategic attack: create new adv samples based on retrained clf\\n print('Performing strategic attack...')\\n for i in range(n_mag):\\n X_adv, y_ini = mult_cls_atk(clf, X_test_flat, mean, dev_list[i])\\n output_list.append(acc_calc_all(clf, X_adv, y_test, y_ini))\\n if img_flag != None:\\n save_svm_images(model_dict, data_dict, X_test_flat, X_adv,\\n dev_list[i], rd, dr_alg, rev_flag)\\n\\n fname = print_svm_output(model_dict, output_list, dev_list, rd,\\n strat_flag, rev_flag)\\n\\n # fname = dataset +'_' + fname\\n subprocess.call(\\n [\\\"gnuplot -e \\\\\\\"mname='{}'\\\\\\\" gnu_in_loop.plg\\\".format(fname)], shell=True)\",\n \"def computesvd(train, K):\\n mean = global_mean(train)\\n train = standardize(train, mean)\\n std = compute_std(train)\\n train = div_std(train)\\n\\n U, s, Vt = sp.linalg.svds(train, k=K)\\n\\n dim = (len(s), len(s))\\n S = np.zeros(dim)\\n for i in range(len(s)):\\n S[i, i] = mt.sqrt(s[i])\\n\\n U = sp.lil_matrix(U, dtype=np.float32) # dim(M,k)\\n S = sp.lil_matrix(S, dtype=np.float32) # dim(k,k)\\n Vt = sp.lil_matrix(Vt, dtype=np.float32) # dim(k,N)\\n\\n user_features = S.dot(Vt)\\n item_features = np.transpose(U.dot(S))\\n\\n return user_features, item_features, mean, std\",\n \"def kernel_test(l, v):\\n\\t\\\"Testing RBF and Matern kernels with: \\\"\\n\\tx = np.array([1,2,3,4])\\n\\ty = np.array([2,4,6])\\n\\tprint(x)\\n\\tprint(y)\\n\\tprint(\\\"RBF Kernel with l= \\\" + str(l) + \\\": \\\")\\n\\tprint(rbf_kernel(x,y,l))\\n\\tprint(\\\"Matern Kernel with l= \\\" + str(l) + \\\" and v= \\\" + str(v) + \\\": \\\")\\n\\tprint(matern_kernel(x,y,l, v))\",\n \"def setup_svm(self, classifier_name=\\\"SVM\\\", **kwargs):\\n if not classifier_name in self.classifiers:\\n clf = svm.SVC(**kwargs)\\n clf.fit(self.X_train, self.y_train)\\n self.classifiers[classifier_name] = clf\",\n \"def _create_selu(cls, onnx_node, inputs, opset_version):\\n alpha = onnx_node.getattr(\\\"alpha\\\", 1.67326)\\n gamma = onnx_node.getattr(\\\"gamma\\\", 1.0507)\\n _, forward = cls._common_onnx_node_to_singa_op(onnx_node, inputs,\\n opset_version)\\n return _, forward(alpha, gamma)\",\n \"def losd_cnn_svm_model(num_class=8, num_flow_channel=10, cnn_svm_model_id=1, feature_pool='max', device=torch.device(\\\"cuda\\\" if torch.cuda.is_available() else \\\"cpu\\\")):\\n# feature_dimension = 2048 # change this according to which layer's feature you want\\n num_gpu_device = torch.cuda.device_count()\\n\\n # load spatial cnn net\\n input_spatial_cnn_model_file = ''.join(['model/cnn_net/spatial_lucid_08_split_no_', str(cnn_svm_model_id).zfill(2), '_nfch_10_nepochs_500_lr_0.0005_ss_model_best.pth.tar'])\\n print('loading spatial cnn trained model from: {}' .format(input_spatial_cnn_model_file))\\n spatial_cnn_model = load_resnet_cnn_net_model(input_spatial_cnn_model_file, num_class=num_class, num_channel=3, device=device)\\n print('----------------------------------------------------------------------------------------')\\n\\n # load motion cnn net\\n input_motion_cnn_model_file = ''.join(['model/cnn_net/motion_lucid_08_split_no_', str(cnn_svm_model_id).zfill(2), '_nfch_10_nepochs_500_lr_0.01_ss_model_best.pth.tar'])\\n print('loading motion cnn trained model from: {}' .format(input_motion_cnn_model_file))\\n motion_cnn_model = load_resnet_cnn_net_model(input_motion_cnn_model_file, num_class=num_class, num_channel=2*num_flow_channel, device=device)\\n print('----------------------------------------------------------------------------------------')\\n\\n # for svm model\\n input_spatial_motion_svm_model_path = ''.join(['model/svm/spatial_motion_lucid_08_split_no_', str(cnn_svm_model_id).zfill(2), '_nfch_10_nepochs_500_slr_0.0005_mlr_0.01_network_resnet101_', str(feature_pool), '_pooling_thundersvm_1v1/'])\\n input_spatial_motion_svm_model_file = ''.join([input_spatial_motion_svm_model_path, 'best_model_basedon_train_val_data_nclass_12_kernel_linear_int_c_0.1_max_c_1000.0_num_div_c_46_int_g_0.1_max_g_1.0_num_div_g_10'])\\n print('loading spatial and motion net svm model from: \\\"{}\\\"' .format(input_spatial_motion_svm_model_file))\\n spatial_motion_svm_model = thundersvm_load_svm_model(input_spatial_motion_svm_model_file)\\n print('----------------------------------------------------------------------------------------')\\n \\n # model paralization (if you have multiple gpus)\\n print('model will use \\\"{}\\\" GPUs' .format(num_gpu_device))\\n if num_gpu_device > 1:\\n spatial_cnn_model = nn.DataParallel(spatial_cnn_model)\\n motion_cnn_model = nn.DataParallel(motion_cnn_model)\\n \\n return spatial_cnn_model, motion_cnn_model, spatial_motion_svm_model\",\n \"def optimize_gp_hyperparams(x, y, optimization_steps, learning_rate,\\r\\n kernel=rational_quadratic_kernel_torch, params=None):\\r\\n x = np.array(x).reshape(-1, 1)\\r\\n y = np.array(y).reshape(-1, 1)\\r\\n N = len(x)\\r\\n\\r\\n # tranform our training set in Tensor\\r\\n x_tensor = torch.from_numpy(x).float()\\r\\n y_tensor = torch.from_numpy(y).float()\\r\\n\\r\\n # we should define our hyperparameters as torch parameters where we keep track of\\r\\n # the operations to get hte gradients from them\\r\\n m = np.abs(y[-1][0])\\r\\n mu = torch.tensor(m).float()\\r\\n s = np.var(y)\\r\\n sig = torch.tensor(s).float()\\r\\n if params:\\r\\n lambda_param = nn.Parameter(torch.tensor(params['ls']), requires_grad=True)\\r\\n alpha_param = nn.Parameter(torch.tensor(params['a']), requires_grad=True)\\r\\n output_variance = nn.Parameter(torch.tensor(params['ov']), requires_grad=True)\\r\\n noise_variance = nn.Parameter(torch.tensor(params['nv']), requires_grad=True)\\r\\n mu_param = nn.Parameter(torch.tensor(params['mu']), requires_grad=True)\\r\\n sig_param = nn.Parameter(torch.tensor(params['sig']), requires_grad=True)\\r\\n\\r\\n else:\\r\\n lambda_param = nn.Parameter(torch.tensor(1.), requires_grad=True)\\r\\n alpha_param = nn.Parameter(torch.tensor(1.), requires_grad=True)\\r\\n output_variance = nn.Parameter(torch.tensor(1.), requires_grad=True)\\r\\n noise_variance = nn.Parameter(torch.tensor(2.5), requires_grad=True)\\r\\n mu_param = nn.Parameter(mu, requires_grad=True)\\r\\n sig_param = nn.Parameter(sig, requires_grad=True)\\r\\n\\r\\n # we use Adam as optimizer\\r\\n optim = torch.optim.Adam([lambda_param, alpha_param, output_variance,\\r\\n noise_variance, mu_param, sig_param], lr=learning_rate)\\r\\n\\r\\n # optimization loop using the log-likelihood that involves the cholesky decomposition\\r\\n nlls = []\\r\\n lambdas = []\\r\\n output_variances = []\\r\\n noise_variances = []\\r\\n iterations = optimization_steps\\r\\n for i in range(iterations):\\r\\n if lambda_param.item() == lambda_param.item():\\r\\n return_dict = {'ls': lambda_param.item(),\\r\\n 'a': alpha_param.item(),\\r\\n 'ov': output_variance.item(),\\r\\n 'nv': noise_variance.item(),\\r\\n 'mu': mu_param.item(),\\r\\n 'sig': sig_param.item()}\\r\\n assert noise_variance >= 0, f\\\"ouch! {i, noise_variance}\\\"\\r\\n optim.zero_grad()\\r\\n K = kernel(x_tensor, x_tensor, lambda_param, alpha_param,\\r\\n output_variance) + noise_variance * torch.eye(N)\\r\\n try:\\r\\n cholesky = torch.cholesky(K)\\r\\n _alpha_temp, _ = torch.solve(y_tensor, cholesky)\\r\\n _alpha, _ = torch.solve(_alpha_temp, cholesky.t())\\r\\n except:\\r\\n return return_dict\\r\\n nll = N / 2 * torch.log(torch.tensor(2 * np.pi)) + 0.5 * torch.matmul(y_tensor.transpose(0, 1), _alpha) + \\\\\\r\\n torch.sum(torch.log(torch.diag(cholesky)))\\r\\n\\r\\n # we have to add the log-likelihood of the prior\\r\\n norm = distributions.Normal(loc=m, scale=s)\\r\\n prior_negloglike = torch.log(lambda_param) - torch.log(torch.exp(norm.log_prob(lambda_param)))\\r\\n\\r\\n nll += 0.9 * prior_negloglike\\r\\n nll.backward()\\r\\n\\r\\n nlls.append(nll.item())\\r\\n lambdas.append(lambda_param.item())\\r\\n output_variances.append(output_variance.item())\\r\\n noise_variances.append(noise_variance.item())\\r\\n optim.step()\\r\\n\\r\\n # projected in the constraints (lengthscale and output variance should be positive)\\r\\n for p in [lambda_param, output_variance]:\\r\\n p.data.clamp_(min=0.0000001)\\r\\n noise_variance.data.clamp_(min=0.001, max=0.05)\\r\\n alpha_param.data.clamp_(min=0.001, max=0.1)\\r\\n # mu_param.data.clamp_(min=0.01, max=40)\\r\\n # sig_param.data.clamp_(min=0.01, max=40)\\r\\n\\r\\n return_dict = {'ls': lambda_param.item(),\\r\\n 'a': alpha_param.item(),\\r\\n 'ov': output_variance.item(),\\r\\n 'nv': noise_variance.item(),\\r\\n 'mu': mu_param.item(),\\r\\n 'sig': sig_param.item()}\\r\\n\\r\\n return return_dict\",\n \"def __init__(self,\\n gridsearch='half',\\n n_components=3,\\n classifier='svm',\\n cv=5,\\n min_resources='smallest',\\n factor=3,\\n score_func=metrics.f1_score,\\n average='weighted',\\n random_state=None,\\n n_jobs=-1,\\n **kwargs,\\n ):\\n\\n freq_thres = helpers.FREQ_THRES(freq_thres=0)\\n\\n log = helpers.LOG(log=False)\\n\\n if classifier == 'svm':\\n\\n classifier = SVC(random_state=random_state)\\n\\n mapper = umap.UMAP(random_state=random_state,\\n n_components=n_components)\\n\\n scorer = metrics.make_scorer(score_func=score_func,\\n average=average,\\n )\\n\\n pipeline = Pipeline([('freq', freq_thres),\\n ('log', log),\\n ('umap', mapper),\\n ('classifier', classifier),\\n ])\\n\\n params_grid_pipeline = {**kwargs}\\n\\n if gridsearch == 'full':\\n self.clf_pipeline = GridSearchCV(pipeline,\\n params_grid_pipeline,\\n cv=cv,\\n scoring=scorer,\\n n_jobs=n_jobs,\\n )\\n elif gridsearch == 'half':\\n self.clf_pipeline = \\\\\\n HalvingGridSearchCV(pipeline,\\n params_grid_pipeline,\\n cv=cv,\\n scoring=scorer,\\n n_jobs=n_jobs,\\n min_resources=min_resources,\\n factor=factor,\\n random_state=random_state\\n )\",\n \"def ex_3_a(x_train, y_train, x_test, y_test):\\n ###########\\n ## Train multi-class SVMs with one-versus-rest strategy with\\n ## - linear kernel\\n ## - rbf kernel with gamma going from 10**-5 to 10**5\\n ## - plot the scores with varying gamma using the function plot_score_versus_gamma\\n ## - Mind that the chance level is not .5 anymore and add the score obtained with the linear kernel as optional argument of this function\\n ###########\\n dfs = 'ovr'\\n c = 10\\n\\n linear = svm.SVC(kernel='linear', C=c, decision_function_shape=dfs)\\n linear.fit(x_train, y_train)\\n lin_score_train = linear.score(x_train, y_train)\\n lin_score_test = linear.score(x_test, y_test)\\n\\n gammas = [pow(10, i) for i in range(-5, 6)]\\n rbfs = [svm.SVC(kernel='rbf', gamma=gamma, C=c, decision_function_shape=dfs) for gamma in gammas]\\n for rbf in rbfs:\\n rbf.fit(x_train, y_train)\\n\\n train_scores = [rbf.score(x_train, y_train) for rbf in rbfs]\\n test_scores = [rbf.score(x_test, y_test) for rbf in rbfs]\\n\\n plot_score_vs_gamma(train_scores, test_scores, gammas, lin_score_train, lin_score_test, .2)\",\n \"def extract_svm_parameters(clf):\\n\\n return {\\n 'n_support': clf.__dict__['n_support_'].tolist(),\\n 'support_vectors': clf.__dict__['support_vectors_'].tolist(),\\n 'dual_coef': clf.__dict__['_dual_coef_'].tolist(),\\n 'intercept': clf.__dict__['_intercept_'].tolist(),\\n 'classes': clf.__dict__['classes_'].tolist(),\\n }\",\n \"def ex_2_c(x_train, y_train, x_test, y_test):\\n ###########\\n ## TODO:\\n ## Train SVMs with RBF kernels for different values of the gamma\\n ## and plot the variation of the test and training scores with gamma using 'plot_score_vs_gamma' function.\\n ## Plot the decision boundary and support vectors for the best value of gamma\\n ## using 'plot_svm_decision_boundary' function\\n ###########\\n gammas = np.arange(0.01, 2, 0.02)\\n machines = [svm.SVC(kernel='rbf', gamma=g, coef0=1.0) for g in gammas]\\n\\n for machine in machines:\\n machine.fit(x_train, y_train)\\n\\n trainScores = [machine.score(x_train, y_train) for machine in machines]\\n testScores = [machine.score(x_test, y_test) for machine in machines]\\n\\n plot_score_vs_gamma(trainScores, testScores, gammas)\\n\\n bestGamma = np.argmax(testScores)\\n print('Score of best rbf gamma ({}): {}'.format(gammas[bestGamma], testScores[bestGamma]))\\n plot_svm_decision_boundary(machines[bestGamma], x_train, y_train, x_test, y_test)\",\n \"def learn_model(reviews, reviews_vectors):\\n\\n from sklearn.svm import LinearSVC\\n\\n labels = get_labels_vector(reviews)\\n clf = LinearSVC()\\n clf.fit(reviews_vectors, labels)\\n\\n return clf\",\n \"def generate_model(is_self_training=False):\\n if not is_self_training:\\n vectors = ds.VECTORS\\n labels = ds.LABELS\\n else:\\n vectors = ds.VECTORS_SELF\\n labels = ds.LABELS_SELF\\n classifier_type = globals.DEFAULT_CLASSIFIER\\n vectors_scaled = pr.scale(np.array(vectors))\\n scaler = pr.StandardScaler().fit(vectors)\\n vectors_normalized = pr.normalize(vectors_scaled, norm='l2')\\n normalizer = pr.Normalizer().fit(vectors_scaled)\\n vectors = vectors_normalized\\n vectors = vectors.tolist()\\n if classifier_type == cons.CLASSIFIER_SVM:\\n kernel_function = globals.DEFAULT_KERNEL\\n c_parameter = globals.DEFAULT_C_PARAMETER\\n gamma = globals.DEFAULT_GAMMA_SVM\\n if is_self_training:\\n class_weights = get_modified_class_weight(get_size(True))\\n else:\\n class_weights = globals.DEFAULT_CLASS_WEIGHTS\\n model = svm.SVC(kernel=kernel_function, C=c_parameter,\\n class_weight=class_weights, gamma=gamma, probability=True)\\n model.fit(vectors, labels)\\n else:\\n model = None\\n ds.SCALAR = scaler\\n ds.NORMALIZER = normalizer\\n ds.MODEL = model\\n return\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69277614","0.6893122","0.68732125","0.6781692","0.6691403","0.6546042","0.64860064","0.6480777","0.6352892","0.632312","0.6207076","0.61844045","0.6074828","0.60648793","0.60161895","0.5979811","0.5845912","0.580389","0.57575077","0.5752655","0.5745429","0.5734548","0.5673906","0.56684715","0.5644076","0.56378037","0.5626803","0.5590054","0.55892015","0.5572327","0.5565854","0.55199456","0.55023277","0.54858494","0.54795504","0.5472693","0.54433334","0.54283196","0.541712","0.54117095","0.537817","0.535074","0.53430575","0.5320121","0.530365","0.52794987","0.52685905","0.5250119","0.5245866","0.5243585","0.5233251","0.522897","0.52255684","0.5222284","0.5206316","0.5200788","0.5193874","0.5193475","0.51924646","0.5191264","0.5190322","0.51872146","0.51831424","0.5171995","0.51688814","0.51634234","0.5158548","0.51523906","0.5147485","0.5141135","0.5135743","0.5131231","0.5129196","0.51107216","0.5099643","0.5097225","0.508318","0.50768","0.5075416","0.50688213","0.506111","0.5058793","0.50566053","0.50518936","0.50405097","0.50369567","0.5036308","0.5028806","0.50250477","0.5008597","0.50074095","0.5004156","0.4998567","0.49983943","0.4998035","0.49974754","0.49902755","0.4987422","0.49784002","0.49719754"],"string":"[\n \"0.69277614\",\n \"0.6893122\",\n \"0.68732125\",\n \"0.6781692\",\n \"0.6691403\",\n \"0.6546042\",\n \"0.64860064\",\n \"0.6480777\",\n \"0.6352892\",\n \"0.632312\",\n \"0.6207076\",\n \"0.61844045\",\n \"0.6074828\",\n \"0.60648793\",\n \"0.60161895\",\n \"0.5979811\",\n \"0.5845912\",\n \"0.580389\",\n \"0.57575077\",\n \"0.5752655\",\n \"0.5745429\",\n \"0.5734548\",\n \"0.5673906\",\n \"0.56684715\",\n \"0.5644076\",\n \"0.56378037\",\n \"0.5626803\",\n \"0.5590054\",\n \"0.55892015\",\n \"0.5572327\",\n \"0.5565854\",\n \"0.55199456\",\n \"0.55023277\",\n \"0.54858494\",\n \"0.54795504\",\n \"0.5472693\",\n \"0.54433334\",\n \"0.54283196\",\n \"0.541712\",\n \"0.54117095\",\n \"0.537817\",\n \"0.535074\",\n \"0.53430575\",\n \"0.5320121\",\n \"0.530365\",\n \"0.52794987\",\n \"0.52685905\",\n \"0.5250119\",\n \"0.5245866\",\n \"0.5243585\",\n \"0.5233251\",\n \"0.522897\",\n \"0.52255684\",\n \"0.5222284\",\n \"0.5206316\",\n \"0.5200788\",\n \"0.5193874\",\n \"0.5193475\",\n \"0.51924646\",\n \"0.5191264\",\n \"0.5190322\",\n \"0.51872146\",\n \"0.51831424\",\n \"0.5171995\",\n \"0.51688814\",\n \"0.51634234\",\n \"0.5158548\",\n \"0.51523906\",\n \"0.5147485\",\n \"0.5141135\",\n \"0.5135743\",\n \"0.5131231\",\n \"0.5129196\",\n \"0.51107216\",\n \"0.5099643\",\n \"0.5097225\",\n \"0.508318\",\n \"0.50768\",\n \"0.5075416\",\n \"0.50688213\",\n \"0.506111\",\n \"0.5058793\",\n \"0.50566053\",\n \"0.50518936\",\n \"0.50405097\",\n \"0.50369567\",\n \"0.5036308\",\n \"0.5028806\",\n \"0.50250477\",\n \"0.5008597\",\n \"0.50074095\",\n \"0.5004156\",\n \"0.4998567\",\n \"0.49983943\",\n \"0.4998035\",\n \"0.49974754\",\n \"0.49902755\",\n \"0.4987422\",\n \"0.49784002\",\n \"0.49719754\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.71148735"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81986,"cells":{"query":{"kind":"string","value":"Generic preprocessing appropriate for a wide variety of data"},"document":{"kind":"string","value":"def any_preprocessing(name):\n return hp.choice('%s' % name, [\n [pca(name + '.pca')],\n [standard_scaler(name + '.standard_scaler')],\n [min_max_scaler(name + '.min_max_scaler')],\n [normalizer(name + '.normalizer')],\n # -- not putting in one-hot because it can make vectors huge\n #[one_hot_encoder(name + '.one_hot_encoder')],\n []\n ])"},"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 preprocess(data):\n raise NotImplementedError","def preprocess(self, data, label):\n\t\traise NotImplementedError","def preprocess(self):","def preprocess(self,data):\n preprocessObj = PreprocessData()\n preprocess_data = preprocessObj.preprocess(data)\n return preprocess_data","def preprocess(data):\n # Data Preprocessing\n data['GDP_scaled']=preprocessing.scale(data['GDP'])\n data['CLPRB_scaled']=preprocessing.scale(data['CLPRB'])\n data['EMFDB_scaled']=preprocessing.scale(data['EMFDB'])\n data['ENPRP_scaled']=preprocessing.scale(data['ENPRP'])\n data['NGMPB_scaled']=preprocessing.scale(data['NGMPB'])\n data['PAPRB_scaled']=preprocessing.scale(data['PAPRB'])\n data['PCP_scaled']=preprocessing.scale(data['PCP'])\n data['ZNDX_scaled']=preprocessing.scale(data['ZNDX'])\n data['OP_scaled']=preprocessing.scale(data['Nominal Price'])\n data['OP2_scaled']=preprocessing.scale(data['Inflation Adjusted Price'])\n\n return data","def _preprocess_fn(data):\n\n # Validate input\n if not isinstance(data, dict) or 'image' not in data:\n raise ValueError('Argument `data` must be a dictionary, '\n 'not %s' % str(type(data)))\n\n # Apply all the individual steps in sequence.\n image = data['image']\n image = decode_image(image)\n image = normalize_value_range(image)\n image = get_multiscale_patches(image, **preprocessing_kwargs)\n\n data['image'] = image\n return data","def _build_preprocessing(self):\n\n # For now, do nothing\n pass","def preprocessing(ct):\n return value_preprocessing(ct, False)","def preprocess(dataset):\n preped_dataset = {}\n preped_dataset['c'] = preprocess_set(dataset['c'])\n preped_dataset['r'] = preprocess_set(dataset['r'])\n preped_dataset['y'] = dataset['y']\n return preped_dataset","def get_preprocess_fn(**preprocessing_kwargs):\n\n def _preprocess_fn(data):\n \"\"\"The preprocessing function that is returned.\"\"\"\n\n # Validate input\n if not isinstance(data, dict) or 'image' not in data:\n raise ValueError('Argument `data` must be a dictionary, '\n 'not %s' % str(type(data)))\n\n # Apply all the individual steps in sequence.\n image = data['image']\n image = decode_image(image)\n image = normalize_value_range(image)\n image = get_multiscale_patches(image, **preprocessing_kwargs)\n\n data['image'] = image\n return data\n\n return _preprocess_fn","def preprocess(self):\n pass","def preprocess(self):\n pass","def preprocess(self):\n pass","def parse_preproc(key, content):\n if inspect.isclass(key):\n pp = key(**content)\n key = pp.__class__.__name__.lower()\n elif key.lower() == 'none':\n pp = DummyNone()\n elif key.lower() == 'recenter':\n pp = StandardScaler(with_mean=True, with_std=False)\n elif key.lower() == 'standardize':\n pp = StandardScaler(with_mean=True, with_std=True)\n elif key.lower() == 'normalize':\n content.setdefault('norm', 'l2')\n # pp = Normalizer(norm=content[1][0])\n pp = Normalizer(**content)\n elif key.lower() == 'minmax':\n content.setdefault('feature_range', (0, 1))\n pp = MinMaxScaler(**content)\n else:\n pp = DummyNone()\n return (key, pp, 'preproc')","def _preprocess(self, data):\n\n # pipeline: first call the previous statistics:\n if self.previous_statistics is not None:\n data = self.previous_statistics.statistics(data)\n # the first of the statistics need to take list as input, in order to match the API. Then actually the\n # transformations work on np.arrays. In fact the first statistic transforms the list to array. Therefore, the\n # following code needs to be called only if the self statistic is the first, i.e. it does not have a\n # previous_statistic element.\n else:\n data = self._check_and_transform_input(data)\n\n return data","def _preprocess(self, args):\n def preprocess_dates(args):\n \"\"\"Combine date and end_date into a range.\"\"\"\n if 'date' in args:\n if args.get('period') == 'range' and 'end_date' in args:\n args['date'] = '{},{}'.format(args['date'],\n args['end_date'])\n return args\n\n def preprocess_bools(args):\n \"\"\"Convert all booleans to integers.\"\"\"\n for arg in args:\n if type(args[arg]) == bool:\n args[arg] = int(args[arg])\n return args\n for name, value in locals().items():\n if name.startswith('preprocess_') and callable(value):\n args = value(args)\n return args","def _preprocess(self, data, normalize=False) -> np.ndarray:\n \n preprocessor = StandardScaler() if not normalize else Normalizer()\n\n data = preprocessor.fit_transform(data)\n \n return data","def preprocess_data(self, data, scale_data=True):\n print(\"preprocess_data not implemented\")\n return data","def preprocess_data(self):\n\n self._preprocess_train_data()\n self._preprocess_test_data()","def preprocess_input(x, data_format=None): # pylint: disable=unused-argument\n return x","def preprocess(data, to_drop=[]):\n \n columns = data.columns.to_list()\n \n # split data to numeric vs categorical\n numeric_features = data.select_dtypes(include=[\n 'int64', 'float64']).columns\n \n if len(to_drop) > 0:\n categorical_features = data.select_dtypes(include=[\n 'object']).drop(to_drop, axis=1).columns\n print(categorical_features)\n else: \n categorical_features = data.select_dtypes(include=[\n 'object']).columns\n \n categorical_transformer = Pipeline(steps=[\n ('imputer', SimpleImputer(strategy='most_frequent', fill_value='missing'))])\n \n numerical_transformer = Pipeline(steps=[\n ('imputer', SimpleImputer(strategy='median')),\n ('scaler', RobustScaler())\n ])\n # missing_values = np.nan\n \n# Bundle preprocessing for numerical and categorical data\n preprocessor = ColumnTransformer(\n transformers=[\n ('num', numerical_transformer, numeric_features),\n ('cat', categorical_transformer, categorical_features)\n ])\n\n my_pipeline = Pipeline(steps=[('preprocessor', preprocessor) ])\n \n for col in to_drop:\n columns.remove(col)\n print('Hello')\n \n trans_data = my_pipeline.fit_transform(data)\n return trans_data#pd.DataFrame(#, columns=columns) ","def preprocess_feature(df):","def stage_two_preprocessing(data: pd.Series) -> pd.Series:\n # designed to be run after remove_contractions\n data_ = data.dropna()\n data_ = remove_punctuation(data_)\n data_ = numbers_to_words(data_)\n data_ = remove_stopwords(data_)\n return data_","def preprocess(\n self, data: List[Dict[str, Any]]\n ) -> Generator[Dict[str, Any], None, None]:\n raise NotImplementedError","def stage_one_preprocessing(data: pd.Series) -> pd.Series:\n data_ = data.dropna()\n print('ascii')\n data_ = remove_non_ascii(data)\n print('lower')\n data_ = to_lowercase(data_)\n print('slash')\n data_ = underscore_and_slash_to_space(data_)\n print('ellipse')\n data_ = remove_ellipses(data_)\n print('white')\n data_ = shrink_whitespace(data_)\n #print('contracts')\n #data_ = remove_contractions(data_)\n return data_","def preprocess(self, data):\n if self.mode == 'image':\n data = self.transpose(data)\n data = self.dilate(data)\n data = self.mask(data)\n\n if self.mode == 'histogram':\n data = self.flatten(data)\n data = self.mask(data)\n\n if self.mode == 'curve':\n if isinstance(data, np.ndarray) or (isinstance(data, list) and contains_numbers(data)):\n if hasattr(self, 'objects'):\n xdata = self.main_object.get_xdata()\n else:\n xdata = range(len(data))\n\n data = [xdata, data]\n\n smoothed = self.smooth(data[1].squeeze() if data[1].ndim > 1 else data[1])\n data = [*data, smoothed]\n\n if self.mode == 'loss':\n if isinstance(data, tuple):\n loss, lr = data\n else:\n loss, lr = data, None\n\n if loss is None:\n smoothed = None\n else:\n smoothed = self.smooth(loss)\n\n data = [loss, smoothed, lr]\n\n return data","def preprocessing(train_raw_, test_raw_):\n \n undef = np.float64(-999.0)\n pred_dict = {'s':'1','b':'0', '?':'-1'}\n # drop 1st column (Id) and also 1st row with column names (\"[1:,\") \n train_raw = train_raw_[1:, :]\n test_raw = test_raw_[1:, :] \n \n # Change s(signal) and b(background) for s:1 and b:0, and change '?' for -1\n train_raw[:,1] = np.vectorize(pred_dict.get)(train_raw[:,1].astype(str))\n test_raw[:,1] = np.vectorize(pred_dict.get)(test_raw[:,1].astype(str))\n \n # Divide the dataset in four according to PRI_jet_num feature and cast to float\n train_data_jets = divide_dataset_by_jet(train_raw)\n test_data_jets = divide_dataset_by_jet(test_raw)\n \n # Remove columns with nan values or with standard deviation of 0\n test_data_jets, train_data_jets = clean_features(test_data_jets, train_data_jets, undef)\n \n # Standardize train and test sets to have mean=0 and std=1\n train_data_jets, test_data_jets = standardize(train_data_jets, test_data_jets)\n \n # Replace remaining undefined values by mean, median or zero\n train_data_mean, train_data_median, train_data_null = replace_nan(train_data_jets)\n test_data_mean, test_data_median, test_data_null = replace_nan(test_data_jets)\n \n return train_data_mean, train_data_median, train_data_null, test_data_mean, test_data_median, test_data_null","def _preprocess_data_point(self, x: DataPoint) -> DataPoint:\n for preprocessor in self._pre:\n x = preprocessor(x)\n if x is None:\n raise ValueError(\"Preprocessor should not return None\")\n return x","def _preprocess(self):\n self.data['sentences'] = self.data['text'].apply(self._tokenize_sent)\n self.data['nouns'] = self.data['sentences'].apply(self._get_nouns)\n # self._get_frequent_features()\n # self._compactness_pruning()\n # self._redundancy_pruning()\n # self._get_features()\n self._extract_opinions()","def preprocessing_fn(inputs):\n outputs = {}\n\n for key in ONE_HOT_FEATURES.keys():\n dim = ONE_HOT_FEATURES[key]\n int_value = tft.compute_and_apply_vocabulary(\n fill_in_missing(inputs[key]), top_k=dim + 1\n )\n outputs[transformed_name(key)] = convert_num_to_one_hot(\n int_value, num_labels=dim + 1\n )\n\n for key, bucket_count in BUCKET_FEATURES.items():\n temp_feature = tft.bucketize(\n convert_zip_code(fill_in_missing(inputs[key])),\n bucket_count,\n )\n outputs[transformed_name(key)] = convert_num_to_one_hot(\n temp_feature, num_labels=bucket_count + 1\n )\n\n for key in TEXT_FEATURES.keys():\n outputs[transformed_name(key)] = fill_in_missing(inputs[key])\n\n outputs[transformed_name(LABEL_KEY)] = fill_in_missing(inputs[LABEL_KEY])\n\n return outputs","def test_data_preprocessing(raw_data): \r\n\r\n # get data output\r\n data_output = raw_data[['Submitby Date Time', 'Challenge Manager', 'Challenge Copilot', 'Posting Date Date', 'Track',\r\n 'Technology List', 'First Place Prize', 'Num Registrations', 'Total Prize']]\r\n with open('cache/extended_columns.pkl', 'rb') as f:\r\n extended_columns = pickle.load(f)\r\n with open('cache/num_date_columns.pkl', 'rb') as f:\r\n max_date_columns = pickle.load(f)\r\n \r\n data_output = class_binaryzation_for_test(data_output, extended_columns)\r\n try:\r\n data_output = date_separation1(data_output, max_num_columns=NUM_DATE_COLUMNS)\r\n except:\r\n data_output = date_separation2(data_output)\r\n data_output = money_digitalization(data_output)\r\n data_output = get_date_in_days(data_output)\r\n data_output['Days from Posting to Submit'] = data_output['Submitby Date Time Days from 2016'] \\\r\n - data_output['Posting Date Date Days from 2016'] \r\n\r\n return data_output","def preprocess(self, first_inputs,second_inputs,third_inputs):\r\n pass","def preprocess_dataset(self, dataset, params=None):\n if params is None:\n assert self.params_loaded, (\n \"You must either provide parameters or load the model params before preprocessing.\")\n params = self.params\n for key in dataset.keys():\n if dataset[key] is None:\n continue\n if hasattr(params, \"whiten_data\") and params.whiten_data:\n if hasattr(params, \"whiten_method\"):\n if params.whiten_method == \"FT\": # other methods require patching first\n if hasattr(params, \"whiten_batch_size\"):\n batch_size = params.whiten_batch_size\n else:\n batch_size = None\n dataset[key].images, dataset[key].data_mean, dataset[key].w_filter = \\\n dp.whiten_data_batch(dataset[key].images, method=params.whiten_method,\n batch_size=batch_size)\n print(\"INFO:preprocessing:FT Whitened \"+key+\" data\")\n if hasattr(params, \"lpf_data\") and params.lpf_data:\n dataset[key].images, dataset[key].data_mean, dataset[key].lpf_filter = \\\n dp.lpf_data(dataset[key].images, cutoff=params.lpf_cutoff)\n print(\"INFO:preprocessing:Low pass filtered \"+key+\" data\")\n if hasattr(params, \"contrast_normalize\") and params.contrast_normalize:\n if hasattr(params, \"gauss_patch_size\"):\n dataset[key].images = dp.contrast_normalize(dataset[key].images,\n params.gauss_patch_size)\n else:\n dataset[key].images = dp.contrast_normalize(dataset[key].images)\n print(\"INFO:preprocessing:Contrast normalized \"+key+\" data\")\n if hasattr(params, \"standardize_data\") and params.standardize_data:\n if params.data_type == \"mnist\":\n eps = 1e-5\n else:\n eps = None\n dataset[key].images, dataset[key].data_mean, dataset[key].data_std = \\\n dp.standardize_data(dataset[key].images, eps)\n self.data_mean = dataset[key].data_mean\n self.data_std = dataset[key].data_std\n print(\"INFO:preprocessing:Standardized \"+key+\" data\")\n if hasattr(params, \"extract_patches\") and params.extract_patches:\n assert all(key in params.__dict__.keys()\n for key in [\"num_patches\", \"patch_edge_size\", \"overlapping_patches\",\n \"randomize_patches\"]), (\"Insufficient params for patches.\")\n out_shape = (int(params.num_patches), int(params.patch_edge_size),\n int(params.patch_edge_size), dataset[key].num_channels)\n dataset[key].num_examples = out_shape[0]\n dataset[key].reset_counters()\n if hasattr(params, \"patch_variance_threshold\"):\n dataset[key].images = dp.extract_patches(dataset[key].images, out_shape,\n params.overlapping_patches, params.randomize_patches,\n params.patch_variance_threshold, dataset[key].rand_state)\n else:\n dataset[key].images = dp.extract_patches(dataset[key].images, out_shape,\n params.overlapping_patches, params.randomize_patches,\n var_thresh=0, rand_state=dataset[key].rand_state)\n dataset[key].shape = dataset[key].images.shape\n dataset[key].num_rows = dataset[key].shape[1]\n dataset[key].num_cols = dataset[key].shape[2]\n dataset[key].num_channels = dataset[key].shape[3]\n dataset[key].num_pixels = np.prod(dataset[key].shape[1:])\n print(\"INFO:preprocessing:Extracted patches from \"+key+\" data\")\n if hasattr(params, \"whiten_data\") and params.whiten_data:\n if hasattr(params, \"whiten_method\") and params.whiten_method != \"FT\":\n dataset[key].images, dataset[key].data_mean, dataset[key].w_filter = \\\n dp.whiten_data(dataset[key].images, method=params.whiten_method)\n print(\"INFO:preprocessing:Whitened \"+key+\" data\")\n if hasattr(params, \"norm_data\") and params.norm_data:\n dataset[key].images, dataset[key].data_max = dp.normalize_data_with_max(dataset[key].images)\n self.data_max = dataset[key].data_max\n print(\"INFO:preprocessing:Normalized \"+key+\" data with maximum\")\n if hasattr(params, \"rescale_data\") and params.rescale_data:\n dataset[key].images, dataset[key].data_min, dataset[key].data_max = dp.rescale_data_to_one(dataset[key].images)\n self.data_max = dataset[key].data_max\n self.data_min = dataset[key].data_min\n print(\"INFO:preprocessing:Rescaled each \"+key+\" datapoint to one\")\n if hasattr(params, \"center_data\") and params.center_data:\n dataset[key].images, dataset[key].data_mean = dp.center_data(dataset[key].images,\n use_dataset_mean=True)\n self.data_mean = dataset[key].data_mean\n print(\"INFO:preprocessing:Centered \"+key+\" data\")\n return dataset","def _preprocess_training_model(self, data):\n def _pre_process(raw_data):\n \"\"\" Pre-process raw data. \"\"\"\n pattern = re.compile(\n r\"((?<=')\\w\\d.*?(?=')|(?<=\\\")\\w\\d.*?(?=\\\")|[\\w\\d]+)\")\n words = re.findall(pattern, raw_data)\n return ' '.join(list(map(string_utils.snake_case_to_camel, words)))\n\n data_list = []\n # Preprocess the dataset with naming convention, etc.\n with Progress() as progress:\n preprocess_task = progress.add_task('Pre-processing dataset...',\n total=data.shape[0])\n for idx, row in data.iterrows():\n row_data = {}\n for column in ['text', 'key', 'value']:\n row_data[column] = _pre_process(row[column])\n data_list.append(row_data)\n progress.update(preprocess_task, advance=1)\n return pd.DataFrame(data=data_list)","def pre_processor(self):","def preprocess_func(cls, func):\n pass","def run_preprocessing(self, serie):\n pass","def preprocess(data,scale):\n ##log_transformation\n #data['log_sale_price'] = np.log(data['sale_price'])\n #data['log_lot_area'] = np.log(data['lot_area'])\n #data['house_age'] = data['year_sold']- data['year_built']\n \n y = data['stay']\n \n #sales['log_sale_price'] = np.log(sales['sale_price'])\n #sales['log_lot_area'] = np.log(sales['lot_area'])\n #sales['house_age'] = sales['year_sold']- sales['year_built']\n data_dummy = data.copy()\n \n #dummy coding\n data_scale = pd.get_dummies(data_dummy).drop(columns = ['stay'])\n\n \n #scale the value\n if scale == True:\n S = StandardScaler().fit(data_scale)\n data_scale = S.transform(data_scale)\n \n return y, data_scale","def process(self, preprocess_args: Dict) -> None:\n dataset2preprocessor = {\n 'vhi': VHIPreprocessor,\n }\n\n for dataset, variables in preprocess_args.items():\n\n # check the format is as we expected\n assert dataset in dataset2preprocessor, \\\n f'{dataset} is not supported! Supported datasets are {dataset2preprocessor.keys()}'\n\n assert type(variables) is list, \\\n f'Expected {dataset} values to be a list. Got {type(variables)} instead'\n\n preprocessor = dataset2preprocessor[dataset](self.data)\n\n for variable in variables:\n preprocessor.preprocess(**variable)","def preprocess_data(self, lidar_data):\n raise NotImplementedError(\"Lidar preprocessing object must implement a way \"\n \"to preprocess data\")","def preprocess_main():","def preproc_pipeline(data):\n # Preprocess\n data = preprocess(data)\n\n # Optional --> run a technical analysis on it and add more features\n data = generate_ta(data)\n \n # Split\n train_set, validation_set, test_set = train_val_test_split(data)\n \n # Set up for Keras\n train_set = shape_for_keras(train_set)\n validation_set = shape_for_keras(validation_set)\n test_set = shape_for_keras(test_set)\n\n # We could save this to csv.\n return train_set, validation_set, test_set","def preprocessing_fn(inputs):\n outputs = {}\n for key in _DENSE_FLOAT_FEATURE_KEYS:\n # Preserve this feature as a dense float, setting nan's to the mean.\n outputs[_transformed_name(key)] = tft.scale_to_z_score(\n _fill_in_missing(inputs[key]))\n\n for key in _VOCAB_FEATURE_KEYS:\n # Build a vocabulary for this feature.\n outputs[_transformed_name(key)] = tft.compute_and_apply_vocabulary(\n _fill_in_missing(inputs[key]),\n top_k=_VOCAB_SIZE,\n num_oov_buckets=_OOV_SIZE)\n\n for key in _BUCKET_FEATURE_KEYS:\n outputs[_transformed_name(key)] = tft.bucketize(\n _fill_in_missing(inputs[key]), _FEATURE_BUCKET_COUNT,\n always_return_num_quantiles=False)\n\n for key in _CATEGORICAL_FEATURE_KEYS:\n outputs[_transformed_name(key)] = _fill_in_missing(inputs[key])\n\n # Was this passenger a big tipper?\n taxi_fare = _fill_in_missing(inputs[_FARE_KEY])\n tips = _fill_in_missing(inputs[_LABEL_KEY])\n outputs[_transformed_name(_LABEL_KEY)] = tf.where(\n tf.is_nan(taxi_fare),\n tf.cast(tf.zeros_like(taxi_fare), tf.int64),\n # Test if the tip was > 20% of the fare.\n tf.cast(\n tf.greater(tips, tf.multiply(taxi_fare, tf.constant(0.2))), tf.int64))\n\n return outputs","def preprocess_(data, categories=None):\n res = []\n for x in data:\n if len(x['points']) < 3:\n continue\n if x['geomType'] == 3:\n x['base_curve'] = x['points'][:6]\n x['points'] = x['points'][6:]\n\n elif x['geomType'] == 9:\n x['base_curve'] = x['points'][:3]\n x['points'] = x['points'][3:]\n else:\n continue\n dst = {**x['attrs'], **x['attrd'], **x['attri']}\n x['attrs'] = dst\n x.pop('attrd')\n x.pop('attri')\n x['ogeomType'] = x['geomType']\n x['geomType'] = 8\n x['uid'] = int(x['attrs']['ElementID'])\n x['category'] = x['attrs']['Category']\n if categories is None or x['category'] in categories:\n rs = list(filter(None, geom.RevitInterface.factory(**x)))\n res.extend(rs)\n return res","def preprocess(config: Config) -> None:\n print(colored(\"preprocessing:\", attrs=[\"bold\"]))\n factory = PreprocessingFactory()\n factory.process(config)","def preprocess(function, **kwargs):\n\n print kwargs, \"preprocess\"\n return function(**kwargs)","def preprocess_data(X):\n # NOTE: # If you have conducted any pre-processing on the image,\n # please implement this function to apply onto test images.\n return X","def preprocess(item):\n item = feature_engineering(item)\n item = encode_features(item)\n return item","def preprocess(self, data_f):\n \n return self.vec.transform(data_f.review)","def preprocess(self, latent_codes, **kwargs):\n raise NotImplementedError(f'Should be implemented in derived class!')","def _build_tracking_preprocessing(input_shape):\n\n def preprocessing(input_img, **kwargs):\n\n to_normalize = False if np.percentile(input_img, 98) > 1.0 else True\n\n if len(input_img.shape) == 4:\n print(\n \"Only preprocessing single image, we will consider the first one of the batch\"\n )\n image = input_img[0] * 255.0 if to_normalize else input_img[0] * 1.0\n else:\n image = input_img * 255.0 if to_normalize else input_img * 1.0\n\n image = cv2.resize(image, input_shape)\n x, _ = transform_test(mx.nd.array(image), min(input_shape))\n return x\n\n return preprocessing","def preprocess(self, real, **kwargs):\n self._preprocessed = True","def preprocess_raw(self):\n pass","def pre_process(cls, *args, **kwargs):\n pass","def pre_process(cls, *args, **kwargs):\n pass","def pre_process(cls, *args, **kwargs):\n pass","def pre_process(cls, *args, **kwargs):\n pass","def _get_data_preprocessing_fns(self):\n # Create new functions with partial positional arguments assigned\n process_path_fn = \\\n partial(data_preprocessing.process_path,\n one_hot=self.ONE_HOT,\n num_classes=self._NUM_CLASSES,\n class_names=self._CLASS_NAMES)\n process_img_path_fn = data_preprocessing.process_img_path\n convert_format_fn = \\\n partial(data_preprocessing.convert_format,\n grayscale_in=self._GRAYSCALE_IN,\n grayscale_out=self._GRAYSCALE_OUT)\n random_rotate_fn = \\\n partial(data_preprocessing.random_rotate,\n stddev=self._ROTATE_STDDEV)\n random_zoom_fn = \\\n partial(data_preprocessing.random_zoom,\n max_percent=self._ZOOM_MAX_PERCENT,\n stddev=self._ZOOM_STDDEV,\n img_height=self._HEIGHT,\n img_width=self._WIDTH)\n resize_fn = \\\n partial(data_preprocessing.resize,\n height=self._HEIGHT,\n width=self._WIDTH)\n\n funcs = edict({'process_path': process_path_fn,\n 'process_img_path': process_img_path_fn,\n 'convert_format': convert_format_fn,\n 'random_rotate': random_rotate_fn,\n 'random_zoom': random_zoom_fn,\n 'resize': resize_fn})\n\n return funcs","def preprocessing_transform(self, x):\n if isinstance(self.column_text, int) and self.column_text not in x.columns:\n col = self.column_text\n else:\n col = list(x.columns).index(self.column_text)\n\n ct = x.shape[0]\n # INPUTS\n if self.method_embedding.lower() in ['roberta', \"camembert\", \"xlm-roberta\"]:\n ids = np.ones((ct, self.maxlen), dtype='int32')\n else:\n ids = np.zeros((ct, self.maxlen), dtype='int32')\n att = np.zeros((ct, self.maxlen), dtype='int32')\n tok = np.zeros((ct, self.maxlen), dtype='int32')\n\n for k in range(ct):\n text = \" \" + \" \".join(x.iloc[k, col].split())\n\n if self.method_embedding == 'RoBERTa':\n enc = self.tokenizer.encode(text)\n else:\n enc = self.tokenizer.encode(text, max_length=self.maxlen, truncation=True)\n\n # CREATE BERT INPUTS\n if self.method_embedding == 'RoBERTa':\n ids[k, :len(enc.ids)] = enc.ids[:self.maxlen]\n att[k, :len(enc.ids)] = 1\n else:\n ids[k, :len(enc)] = enc\n att[k, :len(enc)] = 1\n\n x_preprocessed = [ids, att, tok]\n if self.dimension_embedding == 'word_embedding':\n return x_preprocessed\n else:\n model_extractor = self.model_extract_document_embedding()\n document_embedding = model_extractor.predict(x_preprocessed)\n return document_embedding","def transform(self, data):","def _process(proc_data):\n int_list = {\n 'sent_bytes', 'packets_transmitted', 'packets_received', 'response_bytes', 'icmp_seq',\n 'ttl', 'duplicates', 'vr', 'hl', 'tos', 'len', 'id', 'flg', 'off', 'pro', 'cks'\n }\n\n float_list = {\n 'packet_loss_percent', 'round_trip_ms_min', 'round_trip_ms_avg', 'round_trip_ms_max',\n 'round_trip_ms_stddev', 'timestamp', 'time_ms'\n }\n\n for key in proc_data:\n if key in int_list:\n proc_data[key] = jc.utils.convert_to_int(proc_data[key])\n\n if key in float_list:\n proc_data[key] = jc.utils.convert_to_float(proc_data[key])\n\n return proc_data","def data_preprocessing_TA(X):\n \n #Removing the mean and scaling the data\n X_prep=StandardScaler().fit_transform(X)\n #do here your preprocessing\n return X_prep","def preprocessing_fn(inputs):\n outputs = {}\n\n # This function is the entry point for your feature engineering with\n # TensorFlow Transform, using the TFX Transform component. In this example\n # the feature engineering is very simple, only applying z-score scaling.\n for key in Features.FEATURE_KEYS:\n outputs[transformed_name(key)] = tft.scale_to_z_score(inputs[key])\n\n # inputs[key]\n\n # tft.scale_to_z_score(inputs[key])\n\n # Do not apply label transformation as it will result in wrong evaluation.\n outputs[transformed_name(\n Features.LABEL_KEY)] = inputs[Features.LABEL_KEY]\n\n return outputs","def preprocess():\n # Load the data\n random.seed(77)\n X,y = make_classification(n_samples=500, n_features=30, n_informative=8, n_redundant=2, \n n_repeated=0, n_classes=3, n_clusters_per_class=2, weights=None, \n flip_y=0.01, class_sep=1.0, hypercube=True, shift=0.0, scale=1.0, \n shuffle=True, random_state=None)\n\n x_train, x_val, y_train, y_val = train_test_split(X, y, random_state=0, test_size=0.25)\n\n # Standardize the data\n scaler = StandardScaler()\n X_train = scaler.fit_transform(x_train)\n X_val = scaler.transform(x_val)\n\n \n return X_train,y_train,X_val,y_val","def small_preprocess(data):\r\n \r\n # Remove new line characters\r\n data = [re.sub('\\s+', ' ', sent) for sent in data]\r\n # Remove distracting single quotes\r\n data = [re.sub(\"\\'\", \"\", sent) for sent in data]\r\n\r\n return data","def transform():","def preprocess(df, model_config, y=None, type='train', count_enc=True,\n likelihood_enc=False, scaling=False,\n use_groups=['number', 'count', 'likelihood']):\n\n print('preprocess data..')\n\n # extract datetime features\n df = transform_datetime_features(df)\n print('datetime features extracted')\n\n # categorical count encoding\n if count_enc:\n if type == 'train':\n df, categorical_values = count_encoding(df)\n model_config['categorical_values'] = categorical_values\n elif type == 'test':\n df = count_encoding(df, model_config['categorical_values'])\n print('count encoding of categorical features added')\n\n # mean target encoding\n if likelihood_enc:\n if type == 'train':\n cat_cols = df.columns[df.columns.str.startswith('string')].tolist()\n df, categorical_values, global_avg = likelihood_encoding(df.join(y), cat_cols)\n model_config['mean_target'] = categorical_values\n model_config['global_avg'] = global_avg\n model_config['cat_cols'] = cat_cols\n elif type == 'test':\n df = likelihood_encoding(df, model_config['cat_cols'],\n categorical_values=model_config['mean_target'],\n global_avg=model_config['global_avg'])\n print('mean target encoding of categorical features added')\n\n # drop constant features\n if type == 'train':\n df = drop_const_cols(df)\n\n # filter columns\n if type == 'train':\n df, used_columns = filter_columns(df, groups=use_groups)\n model_config['used_columns'] = used_columns\n elif type=='test':\n df_pred = df[['line_id']]\n df = df[model_config['used_columns']]\n\n # scaling\n if scaling:\n if type == 'train':\n df, scaler_mean, scaler_std = std_scaler(df)\n model_config['scaler_mean'] = scaler_mean\n model_config['scaler_std'] = scaler_std\n elif type=='test':\n df = std_scaler(df, model_config['scaler_mean'], model_config['scaler_std'])\n\n\n if type == 'train':\n return df, model_config\n else:\n return df, df_pred","def _preprocess_values(self,Y):\r\n return Y","def _preprocess_values(self,Y):\r\n return Y","def preprocess(self, data, scope):\n if scope != 'train':\n # reshape\n data = self._data_reshape(data)\n\n # normalize\n if data.dtype == np.int16:\n start_unit = -1000\n end_unit = 300\n data = 2 * (data.astype(np.float32) - start_unit) / (end_unit - start_unit) - 1\n\n # subtract train mean and divide by train std\n if scope == 'train':\n self.mean = np.mean(data)\n data -= self.mean\n self.std = np.std(data)\n data /= self.std\n else:\n data -= self.mean\n data /= self.std\n\n # reshape for channel\n s = data.shape\n if len(data.shape) == 4:\n data = data.reshape((s[0], s[1], s[2], s[3], 1))\n else:\n data = data.reshape((s[0], s[1], s[2], 1))\n return data","def preprocess(self, instances, stats=None, **kwargs):\n pass","def preprocess(self):\n raise RuntimeError(\"please implement this function!\")","def preprocess_data(self):\n\n selected_data = []\n selected_name = []\n quant_norm_applied = []\n\n rgb_color_to_keys = self.get_rgb_items_for_plot()\n for data_key in rgb_color_to_keys.values():\n if data_key in self.dict_to_plot:\n selected_name.append(data_key)\n\n if self.scaler_data is not None:\n if np.count_nonzero(self.scaler_data) == 0:\n logger.warning(\"scaler is zero - scaling was not applied\")\n elif len(self.scaler_data[self.scaler_data == 0]) > 0:\n logger.warning(\"scaler data has zero values\")\n\n for i, k in enumerate(selected_name):\n q_norm_applied = False\n if self.quantitative_normalization:\n # Quantitative normalization\n (\n data_arr,\n q_norm_applied,\n ) = self.img_model_adv.param_quant_analysis.apply_quantitative_normalization(\n data_in=self.dict_to_plot[k],\n scaler_dict=self.scaler_norm_dict,\n scaler_name_default=self.get_selected_scaler_name(),\n data_name=k,\n ref_name=self.quantitative_ref_eline,\n name_not_scalable=self.name_not_scalable,\n )\n else:\n # Normalize by the selected scaler in a regular way\n data_arr = normalize_data_by_scaler(\n data_in=self.dict_to_plot[k],\n scaler=self.scaler_data,\n data_name=k,\n name_not_scalable=self.name_not_scalable,\n )\n\n selected_data.append(data_arr)\n quant_norm_applied.append(q_norm_applied)\n\n return selected_data, selected_name, rgb_color_to_keys, quant_norm_applied","def allreduce( # pylint:disable=invalid-name\n data: np.ndarray, op: Op, prepare_fun: Optional[Callable[[np.ndarray], None]] = None\n) -> np.ndarray:\n if prepare_fun is None:\n return collective.allreduce(data, collective.Op(op))\n raise Exception(\"preprocessing function is no longer supported\")","def classical_preprocessing(*args, **kwargs):\r\n qnode.construct(args, kwargs)\r\n return qml.math.stack(qnode.qtape.get_parameters())","def preprocessing_input(self, df, prepro_kwargs=None):\n if prepro_kwargs is None:\n assert hasattr(self,\n 'experiment'), 'Set up the prepro_kwargs argument'\n if 'feature_config' in self.experiment.keys():\n prepro_kwargs = self.experiment.feature_config.validation_augmentation\n elif self.experiment['data_config'] is not None:\n prepro_kwargs = self.experiment.data_config.validation_augmentation\n\n prepro = MetaDataGenerator(**prepro_kwargs)\n return prepro.standardize(df)","def preprocess_data(data):\n def deal_line(line):\n pos, rating = line.split(',')\n row, col = pos.split(\"_\")\n row = row.replace(\"r\", \"\")\n col = col.replace(\"c\", \"\")\n return int(row), int(col), float(rating)\n\n def statistics(data):\n row = set([line[0] for line in data])\n col = set([line[1] for line in data])\n return min(row), max(row), min(col), max(col)\n\n # parse each line\n data = [deal_line(line) for line in data]\n\n # do statistics on the dataset.\n min_row, max_row, min_col, max_col = statistics(data)\n print(\"number of items: {}, number of users: {}\".format(max_row, max_col))\n\n # build rating matrix.\n ratings = sp.lil_matrix((max_row, max_col))\n for row, col, rating in data:\n ratings[row - 1, col - 1] = rating\n return ratings","def preprocess(args):\n prism.preprocess.run(\n input_fp=args.input,\n output_fp=args.output,\n no_prefilter=args.no_prefilter,\n full_pattern_proportion=args.full_pattern_proportion,\n error=args.error,\n bisulfite_conversion_rate=args.bisulfite_conversion_rate,\n processivity=args.processivity,\n recruitment_efficiency=args.recruitment_efficiency,\n threads=args.threads,\n seed=args.seed,\n verbose=args.verbose,\n )","def _preprocess(self, feature_dict):\n return feature_dict","def preprocess(N, sigma2, R, f_def, params):\n\n #\n if 'scale' in params:\n if params['scale']:\n\n #\n N0 = np.sum(R * f_def, axis=1)\n\n #\n f_def *= np.average(N / N0)\n\n return N, sigma2, R, f_def, params","def preprocess(data):\n\n #remove urls and convert to lowercase\n #used this thread for help on urls: https://stackoverflow.com/questions/11331982/how-to-remove-any-url-within-a-string-in-python\n remove_url = [re.sub(r'^https?:\\/\\/.*[\\r\\n]*', '', x) for x in data]\n lower=[x.lower() for x in remove_url]\n\n #remove all non alphanumeric chars and empty strings\n return filter(None, [re.sub(r'\\W','',x) for x in lower])","def _preprocess_values(self,Y):\n return Y","def preprocess_sample(qid_raw, condition_raw, output_raw):\n qid, condition, output = split_to_words(qid_raw, condition_raw, output_raw)\n \n qid, condition, output, dictionary_standardization = standardize_words(qid, condition, output)\n\n return qid, condition, output, dictionary_standardization","def apply_preprocessing(\n data: List[np.ndarray],\n sample_rate: Union[int, List[int]],\n funcs: List[str],\n *,\n kwargs: dict = {},\n) -> np.ndarray:\n if isinstance(sample_rate, int):\n sample_rate = [sample_rate] * len(data)\n try:\n assert len(data) == len(sample_rate)\n except AssertionError:\n raise ValueError(\n \"The number of sample rates must be the same as the number of data\"\n )\n for func in funcs:\n if hasattr(preprocessing, func):\n preproc: Callable = getattr(preprocessing, func, **kwargs)\n data = p_map(preproc, data, sample_rate,\n desc=f\"Applying {func}...\")\n else:\n raise ValueError(f\"{func} is not a valid preprocessing function\")\n return data","def pre_processing_(data_df , serialized_objects):\n max_recency_acc_dig = serialized_objects['max_recency_acc_dig'] # These values are taken from trained model values\n max_recency_dig_2yr = serialized_objects['max_recency_dig_2yr'] # These values are taken from trained model values\n max_acc_recency_mf = serialized_objects['max_acc_recency_mf'] #These are values imported in training dataset. Same values needs to be used to impute missing values in unseen data\n\n data_df = data_df.na.fill({\n 'recency_acc_dig' : max_recency_acc_dig, # Filling missing values\n 'recency_dig_2yr' : max_recency_dig_2yr,\n 'acc_recency_mf' : max_acc_recency_mf\n })\n\n freq_acc_upg_2yrs_split = [-float('inf'), 0, 1, 2, float('inf')]\n bucketizer_freq_acc_upg_2yrs = Bucketizer(splits=freq_acc_upg_2yrs_split, inputCol='freq_acc_upg_acc_2yrs', outputCol='freq_acc_upg_acc_2yrs_bkt')\n data_df = bucketizer_freq_acc_upg_2yrs.setHandleInvalid('keep').transform(data_df) # Binning the freq_acc_upg_acc_2yrs column\n\n tot_purchase_split = [-float('inf'), 0, 1, 2, 3, float('inf')]\n bucketizer_tot_purchase = Bucketizer(splits=tot_purchase_split, inputCol='tot_accsry_purchse', outputCol='tot_accsry_purchse_bkt')\n data_df = bucketizer_tot_purchase.setHandleInvalid('keep').transform(data_df) # Binning the tot_accsry_purchse column\n\n del_cols_new = ['freq_acc_upg_acc_2yrs', 'tot_accsry_purchse']\n data_df = data_df.drop(*del_cols_new) # Dropping the older continuous columns\n return data_df","def prepareData(self, *data):\n arguments = 8\n (self.X, self.X_name, self.Y, self.Y_name, self.alignment,\n self.model, self.annotations, self.args) = tuple(data[:arguments])\n \n self.width = self.args.beam_width\n self.mathType = self.args.mathType\n self.io_files = {\n 'input': self.args.intermediate_input_files,\n 'output': self.args.intermediate_output_files\n }\n self.repeat_width = self.args.repeat_width\n self.cons_count = self.args.cons_count\n self.posterior_processors = self.args.posterior_processors \n\n self.positionGenerator = \\\n list(AlignmentBeamGenerator(self.alignment, self.width))\n \n for i in range(len(self.model.states)):\n self.model.states[i].computeHints(self)\n\n return data[arguments:]","def stage_three_preprocessing(data: pd.Series) -> pd.Series:\n data_ = data.dropna()\n data_ = shrink_whitespace(data_)\n #data_ = lemmatize(data_)\n return data_","def _common_preprocess(self, data):\n\n data = data.drop('id', axis=1) \n data = data.drop(['17', '488', 'B01AF', 'H01AB'], axis=1, errors='ignore')\n\n # drop age outliers\n idx = data[(data['age'] > 99)].index\n data = data.drop(idx)\n\n # drop rows with CKD\n idx = data[((data['585'] != 0) | (data['586'] != 0)) &\n (data['ckd'] == 0)].index\n data = data.drop(idx)\n data = data.drop(['585', '586'], axis=1)\n\n return data","def preprocess_func(cls, func):\n return func","def preprocess_fn(self, X_data, Y_data):\n # Normalize image data to [0,1]\n X_data = tf.math.divide(tf.math.subtract(X_data, tf.math.reduce_min(\n X_data)), tf.math.subtract(tf.math.reduce_max(X_data), tf.math.reduce_min(X_data)))\n Y_data = tf.math.divide(tf.math.subtract(Y_data, tf.math.reduce_min(\n Y_data)), tf.math.subtract(tf.math.reduce_max(Y_data), tf.math.reduce_min(Y_data)))\n\n return X_data, Y_data","def preprocess_inference(df, path_pipeline=\"data/pipeline/pipe_01/\", preprocess_pars={}, cols_group=None):\n from util_feature import load, load_function_uri, load_dataset\n\n #### Pipeline Execution ####################################################\n pipe_default = [\n {'uri' : 'source/prepro.py::pd_colnum_bin', 'pars': {}, 'cols_family': 'colnum', 'type': '' },\n {'uri' : 'source/prepro.py::pd_colnum_binto_onehot', 'pars': {}, 'cols_family': 'colnum_bin', 'type': '' },\n {'uri': 'source/prepro.py::pd_colcat_bin', 'pars': {}, 'cols_family': 'colcat', 'type': '' },\n {'uri': 'source/prepro.py::pd_colcat_to_onehot', 'pars': {}, 'cols_family': 'colcat_bin', 'type': '' },\n {'uri' : 'source/prepro.py::pd_colcross', 'pars': {}, 'cols_family': 'colcross', 'type': 'cross' }\n ]\n pipe_list = preprocess_pars.get('pipe_list', pipe_default)\n pipe_list_X = [ task for task in pipe_list if task.get('type', '') not in ['coly', 'filter'] ]\n pipe_filter = [ task for task in pipe_list if task.get('type', '') in ['filter'] ]\n\n\n log(\"########### Load column by column type ##################################\")\n cols_group = preprocess_pars['cols_group']\n log(cols_group) ### list of model columns familty\n colid = cols_group['colid'] # \"jobId\"\n coly = cols_group['coly']\n colcat = cols_group['colcat'] # [ 'companyId', 'jobType', 'degree', 'major', 'industry' ]\n colnum = cols_group['colnum'] # ['yearsExperience', 'milesFromMetropolis']\n\n\n ##### Generate features ########################################################################\n dfi_all = {} ### Dict of all features\n cols_family_full = {'coly':coly}\n\n if len(pipe_filter) > 0 :\n log(\"##### Filter #######################################################################\")\n pipe_i = pipe_filter[ 0 ]\n pipe_fun = load_function_uri(pipe_i['uri'])\n df, col_pars = pipe_fun(df, list(df.columns), pars=pipe_i.get('pars', {}))\n\n\n ##### Processors #############################################################################\n #for colg, colg_list in cols_group.items() :\n # if colg not in ['colid', 'coly' ]:\n # dfi_all[colg] = df[colg_list] ## colnum colcat, coly\n\n\n for pipe_i in pipe_list_X :\n log(\"###################\", pipe_i, \"#######################################################\")\n pipe_fun = load_function_uri(pipe_i['uri']) ### Load the code definition into pipe_fun\n cols_name = pipe_i['cols_family']\n col_type = pipe_i['type']\n pars = pipe_i.get('pars', {})\n\n ### Load data from disk : inference time\n pars['path_pipeline'] = path_pipeline\n\n cols_list = cols_group[cols_name] if cols_name in cols_group else cols_family_full[cols_name]\n df_ = df[ cols_group[cols_name]] if cols_name in cols_group else dfi_all[cols_name]\n # cols_list = list(dfi_all[cols_name].columns)\n # df_ = dfi_all[cols_name]\n logs(df_, cols_list)\n\n if col_type == 'cross':\n pars['dfnum_hot'] = dfi_all['colnum_onehot'] ### dfnum_hot --> dfcross\n pars['dfcat_hot'] = dfi_all['colcat_onehot']\n pars['colid'] = colid\n pars['colcross_single'] = cols_group.get('colcross', [])\n elif col_type == 'add_coly':\n pass\n\n dfi, col_pars = pipe_fun(df_, cols_list, pars= pars)\n\n ### Concatenate colnum, colnum_bin into cols_family_all\n for colj, colist in col_pars['cols_new'].items() :\n ### Merge sub-family\n cols_family_full[colj] = cols_family_full.get(colj, []) + colist\n dfi_all[colj] = pd.concat((dfi_all[colj], dfi), axis=1) if colj in dfi_all else dfi\n\n\n log(\"###### Merge AlL int dfXy #############################################################\")\n dfXy = df[ colnum + colcat ]\n for t in dfi_all.keys():\n if t not in [ 'colnum', 'colcat'] :\n dfXy = pd.concat((dfXy, dfi_all[t] ), axis=1)\n\n\n colXy = list(dfXy.columns)\n if len(colid)>0:\n cols_family_full['colid']=colid\n cols_family_full['colX'] = colXy\n\n return dfXy, cols_family_full","def preprocess(self, X):\n X = X.copy()\n predictor_subset = self.predictor_subset.copy()\n if 'all' in predictor_subset:\n predictor_subset = add_all_predictors(predictor_subset, X.columns)\n \n use_temporal = 'temporal' in predictor_subset\n if use_temporal:\n X_temporal = get_temporal_predictors(\n X['TIMESTAMP_END']\n )\n predictor_subset.remove('temporal')\n\n X = X[predictor_subset]\n\n if use_temporal:\n X = pd.concat([X, X_temporal], axis=1)\n\n if 'WD' in predictor_subset:\n X = process_wind_direction_predictor(X)\n\n return X","def data_preprocessing():\n lineid_content = get_lineid_content()\n print('Read movie_lines.txt file complete...')\n convos = get_convos()\n print('Read movie_conversations.txt file complete...')\n print('Building dataset')\n get_data(lineid_content, convos)","def preprocess(self):\n\n mm_magcoord.add_aacgm_coordinates(self)\n mm_magcoord.add_quasi_dipole_coordinates(self)\n mm_sc.calculate_ecef_velocity(self)\n mm_sc.add_ram_pointing_sc_attitude_vectors(self)\n\n return","def preprocess(self, data, era):\n return data / np.max(data)","def preProcess(self, datum):\n pass","def data_preprocessing(dat: pd.DataFrame, art='C', y=None, logger=None, remove=True):\n if logger == None:\n logging.basicConfig(\n level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')\n logger = logging.getLogger(__name__)\n \n logger.info('Start data preprocessing')\n # replace original indeices with default ones\n dat = dat.reset_index(drop=True)\n\n if art == 'C':\n logger.info('Start to label target feature y for classification task')\n dat.iloc[:, -1] = LabelEncoder().fit_transform(dat.iloc[:, -1])\n logger.info('End with label encoding the target feature')\n if remove:\n # remove columns with more than 1/2 na\n dat = dat.loc[:, dat.isna().sum()/len(dat) < .5]\n logger.info('Following features are removed from the dataframe because half of their value are NA: %s' %\n (dat.columns[dat.isna().sum()/len(dat) > .5].to_list()))\n # Encoding\n oe = OneHotEncoder(drop='first')\n # get categorical columns\n if y:\n dat_y = dat[[y]]\n cols = dat.columns.to_list()\n cols.remove(y)\n dat_x = dat[cols]\n else:\n dat_y = dat[[dat.columns[-1]]]\n dat_x = dat[dat.columns[:-1]]\n dat_categ = dat_x.select_dtypes(include=['object'])\n # get kterm of categ features\n for i in dat_categ.columns:\n # save output to dat\n tmp = dat_x[i].value_counts()\n dat_x[i + '_kterm'] = dat_x[i].map(lambda x: tmp[x] if x in tmp.index else 0)\n # float columns including the k term cols\n dat_numeric = dat_x.select_dtypes(include=['float32', 'float64', 'int32', 'int64'])\n # onehot encoding and label encoding\n dat_categ_onehot = dat_categ.iloc[:, dat_categ.apply(lambda x: len(x.unique())).values < 8]\n dat_categ_label = dat_categ.iloc[:, dat_categ.apply(lambda x: len(x.unique())).values >= 8]\n flag_onehot = False\n flag_label = False\n # oe\n if dat_categ_onehot.shape[1] > 0:\n logger.info('Start to do onehot to the following categoric features: %s' %\n (str(dat_categ_onehot.columns.to_list())))\n dat_onehot = pd.DataFrame(oe.fit_transform(dat_categ_onehot.astype(str)).toarray(),\n columns=oe.get_feature_names(dat_categ_onehot.columns))\n logger.info('End with onehot')\n flag_onehot = True\n else:\n dat_onehot = None\n # le\n if dat_categ_label.shape[1] > 0:\n logger.info('Start to do label encoding to the following categoric features: %s' %\n (str(dat_categ_label.columns.to_list())))\n dat_categ_label = dat_categ_label.fillna('NULL')\n dat_label = pd.DataFrame(columns=dat_categ_label.columns)\n for i in dat_categ_label.columns:\n dat_label[i] = LabelEncoder().fit_transform(dat_categ_label[i].astype(str))\n flag_label = True\n logger.info('End with label encoding')\n else:\n dat_label = None\n # scaling\n # combine\n dat_new = pd.DataFrame()\n if flag_onehot and flag_label:\n dat_new = pd.concat([dat_numeric, dat_onehot, dat_label], axis=1)\n elif flag_onehot:\n dat_new = pd.concat([dat_numeric, dat_onehot], axis=1)\n elif flag_label:\n dat_new = pd.concat([dat_numeric, dat_label], axis=1)\n else:\n dat_new = dat_numeric\n dat_new = pd.concat([dat_new, dat_y], axis=1)\n # imputation\n dat_new = dat_new.dropna(axis=1, how='all')\n if dat_new.isna().sum().sum() > 0:\n logger.info('Nan value exist, start to fill na with iterative imputer: ' +\n str(dat_new.isna().sum().sum()))\n # include na value, impute with iterative Imputer or simple imputer\n columns = dat_new.columns\n imp = IterativeImputer(max_iter=10, random_state=0)\n # imp = SimpleImputer(missing_values=np.nan, strategy='mean')\n dat_new = imp.fit_transform(dat_new)\n dat_new = pd.DataFrame(dat_new, columns=columns)\n dat_numeric = dat_new.iloc[:, :-1].select_dtypes(include=['float32', 'float64', 'int32', 'int64'])\n logger.info('End with fill nan')\n return dat_new, dat_numeric.columns","def pre_processing_single(dataset_file_list, pre_process_paras, type='csv'):\r\n # parameters\r\n take_log = pre_process_paras['take_log']\r\n scaling = pre_process_paras['scaling']\r\n dataset_list = []\r\n data_file = dataset_file_list\r\n\r\n if type == 'csv':\r\n dataset = read_csv(data_file, take_log)\r\n elif type == 'txt':\r\n dataset = read_txt(data_file, take_log)\r\n\r\n dataset['gene_exp'] = dataset['gene_exp'].astype(np.float)\r\n\r\n if scaling: # scale to [0,1]\r\n minmax_scale(dataset['gene_exp'], feature_range=(0, 1), axis=1, copy=False)\r\n\r\n\r\n dataset_list.append(dataset)\r\n return dataset_list","def preprocessing(self, preprocessing):\n\n self._preprocessing = preprocessing","def preprocess_valid_data(self):\r\n print(\"* Preprocessing validation data.\", flush=True)\r\n prep.create_HDF_file(self.C.validation_set)\r\n\r\n self.print_time_elapsed()"],"string":"[\n \"def preprocess(data):\\n raise NotImplementedError\",\n \"def preprocess(self, data, label):\\n\\t\\traise NotImplementedError\",\n \"def preprocess(self):\",\n \"def preprocess(self,data):\\n preprocessObj = PreprocessData()\\n preprocess_data = preprocessObj.preprocess(data)\\n return preprocess_data\",\n \"def preprocess(data):\\n # Data Preprocessing\\n data['GDP_scaled']=preprocessing.scale(data['GDP'])\\n data['CLPRB_scaled']=preprocessing.scale(data['CLPRB'])\\n data['EMFDB_scaled']=preprocessing.scale(data['EMFDB'])\\n data['ENPRP_scaled']=preprocessing.scale(data['ENPRP'])\\n data['NGMPB_scaled']=preprocessing.scale(data['NGMPB'])\\n data['PAPRB_scaled']=preprocessing.scale(data['PAPRB'])\\n data['PCP_scaled']=preprocessing.scale(data['PCP'])\\n data['ZNDX_scaled']=preprocessing.scale(data['ZNDX'])\\n data['OP_scaled']=preprocessing.scale(data['Nominal Price'])\\n data['OP2_scaled']=preprocessing.scale(data['Inflation Adjusted Price'])\\n\\n return data\",\n \"def _preprocess_fn(data):\\n\\n # Validate input\\n if not isinstance(data, dict) or 'image' not in data:\\n raise ValueError('Argument `data` must be a dictionary, '\\n 'not %s' % str(type(data)))\\n\\n # Apply all the individual steps in sequence.\\n image = data['image']\\n image = decode_image(image)\\n image = normalize_value_range(image)\\n image = get_multiscale_patches(image, **preprocessing_kwargs)\\n\\n data['image'] = image\\n return data\",\n \"def _build_preprocessing(self):\\n\\n # For now, do nothing\\n pass\",\n \"def preprocessing(ct):\\n return value_preprocessing(ct, False)\",\n \"def preprocess(dataset):\\n preped_dataset = {}\\n preped_dataset['c'] = preprocess_set(dataset['c'])\\n preped_dataset['r'] = preprocess_set(dataset['r'])\\n preped_dataset['y'] = dataset['y']\\n return preped_dataset\",\n \"def get_preprocess_fn(**preprocessing_kwargs):\\n\\n def _preprocess_fn(data):\\n \\\"\\\"\\\"The preprocessing function that is returned.\\\"\\\"\\\"\\n\\n # Validate input\\n if not isinstance(data, dict) or 'image' not in data:\\n raise ValueError('Argument `data` must be a dictionary, '\\n 'not %s' % str(type(data)))\\n\\n # Apply all the individual steps in sequence.\\n image = data['image']\\n image = decode_image(image)\\n image = normalize_value_range(image)\\n image = get_multiscale_patches(image, **preprocessing_kwargs)\\n\\n data['image'] = image\\n return data\\n\\n return _preprocess_fn\",\n \"def preprocess(self):\\n pass\",\n \"def preprocess(self):\\n pass\",\n \"def preprocess(self):\\n pass\",\n \"def parse_preproc(key, content):\\n if inspect.isclass(key):\\n pp = key(**content)\\n key = pp.__class__.__name__.lower()\\n elif key.lower() == 'none':\\n pp = DummyNone()\\n elif key.lower() == 'recenter':\\n pp = StandardScaler(with_mean=True, with_std=False)\\n elif key.lower() == 'standardize':\\n pp = StandardScaler(with_mean=True, with_std=True)\\n elif key.lower() == 'normalize':\\n content.setdefault('norm', 'l2')\\n # pp = Normalizer(norm=content[1][0])\\n pp = Normalizer(**content)\\n elif key.lower() == 'minmax':\\n content.setdefault('feature_range', (0, 1))\\n pp = MinMaxScaler(**content)\\n else:\\n pp = DummyNone()\\n return (key, pp, 'preproc')\",\n \"def _preprocess(self, data):\\n\\n # pipeline: first call the previous statistics:\\n if self.previous_statistics is not None:\\n data = self.previous_statistics.statistics(data)\\n # the first of the statistics need to take list as input, in order to match the API. Then actually the\\n # transformations work on np.arrays. In fact the first statistic transforms the list to array. Therefore, the\\n # following code needs to be called only if the self statistic is the first, i.e. it does not have a\\n # previous_statistic element.\\n else:\\n data = self._check_and_transform_input(data)\\n\\n return data\",\n \"def _preprocess(self, args):\\n def preprocess_dates(args):\\n \\\"\\\"\\\"Combine date and end_date into a range.\\\"\\\"\\\"\\n if 'date' in args:\\n if args.get('period') == 'range' and 'end_date' in args:\\n args['date'] = '{},{}'.format(args['date'],\\n args['end_date'])\\n return args\\n\\n def preprocess_bools(args):\\n \\\"\\\"\\\"Convert all booleans to integers.\\\"\\\"\\\"\\n for arg in args:\\n if type(args[arg]) == bool:\\n args[arg] = int(args[arg])\\n return args\\n for name, value in locals().items():\\n if name.startswith('preprocess_') and callable(value):\\n args = value(args)\\n return args\",\n \"def _preprocess(self, data, normalize=False) -> np.ndarray:\\n \\n preprocessor = StandardScaler() if not normalize else Normalizer()\\n\\n data = preprocessor.fit_transform(data)\\n \\n return data\",\n \"def preprocess_data(self, data, scale_data=True):\\n print(\\\"preprocess_data not implemented\\\")\\n return data\",\n \"def preprocess_data(self):\\n\\n self._preprocess_train_data()\\n self._preprocess_test_data()\",\n \"def preprocess_input(x, data_format=None): # pylint: disable=unused-argument\\n return x\",\n \"def preprocess(data, to_drop=[]):\\n \\n columns = data.columns.to_list()\\n \\n # split data to numeric vs categorical\\n numeric_features = data.select_dtypes(include=[\\n 'int64', 'float64']).columns\\n \\n if len(to_drop) > 0:\\n categorical_features = data.select_dtypes(include=[\\n 'object']).drop(to_drop, axis=1).columns\\n print(categorical_features)\\n else: \\n categorical_features = data.select_dtypes(include=[\\n 'object']).columns\\n \\n categorical_transformer = Pipeline(steps=[\\n ('imputer', SimpleImputer(strategy='most_frequent', fill_value='missing'))])\\n \\n numerical_transformer = Pipeline(steps=[\\n ('imputer', SimpleImputer(strategy='median')),\\n ('scaler', RobustScaler())\\n ])\\n # missing_values = np.nan\\n \\n# Bundle preprocessing for numerical and categorical data\\n preprocessor = ColumnTransformer(\\n transformers=[\\n ('num', numerical_transformer, numeric_features),\\n ('cat', categorical_transformer, categorical_features)\\n ])\\n\\n my_pipeline = Pipeline(steps=[('preprocessor', preprocessor) ])\\n \\n for col in to_drop:\\n columns.remove(col)\\n print('Hello')\\n \\n trans_data = my_pipeline.fit_transform(data)\\n return trans_data#pd.DataFrame(#, columns=columns) \",\n \"def preprocess_feature(df):\",\n \"def stage_two_preprocessing(data: pd.Series) -> pd.Series:\\n # designed to be run after remove_contractions\\n data_ = data.dropna()\\n data_ = remove_punctuation(data_)\\n data_ = numbers_to_words(data_)\\n data_ = remove_stopwords(data_)\\n return data_\",\n \"def preprocess(\\n self, data: List[Dict[str, Any]]\\n ) -> Generator[Dict[str, Any], None, None]:\\n raise NotImplementedError\",\n \"def stage_one_preprocessing(data: pd.Series) -> pd.Series:\\n data_ = data.dropna()\\n print('ascii')\\n data_ = remove_non_ascii(data)\\n print('lower')\\n data_ = to_lowercase(data_)\\n print('slash')\\n data_ = underscore_and_slash_to_space(data_)\\n print('ellipse')\\n data_ = remove_ellipses(data_)\\n print('white')\\n data_ = shrink_whitespace(data_)\\n #print('contracts')\\n #data_ = remove_contractions(data_)\\n return data_\",\n \"def preprocess(self, data):\\n if self.mode == 'image':\\n data = self.transpose(data)\\n data = self.dilate(data)\\n data = self.mask(data)\\n\\n if self.mode == 'histogram':\\n data = self.flatten(data)\\n data = self.mask(data)\\n\\n if self.mode == 'curve':\\n if isinstance(data, np.ndarray) or (isinstance(data, list) and contains_numbers(data)):\\n if hasattr(self, 'objects'):\\n xdata = self.main_object.get_xdata()\\n else:\\n xdata = range(len(data))\\n\\n data = [xdata, data]\\n\\n smoothed = self.smooth(data[1].squeeze() if data[1].ndim > 1 else data[1])\\n data = [*data, smoothed]\\n\\n if self.mode == 'loss':\\n if isinstance(data, tuple):\\n loss, lr = data\\n else:\\n loss, lr = data, None\\n\\n if loss is None:\\n smoothed = None\\n else:\\n smoothed = self.smooth(loss)\\n\\n data = [loss, smoothed, lr]\\n\\n return data\",\n \"def preprocessing(train_raw_, test_raw_):\\n \\n undef = np.float64(-999.0)\\n pred_dict = {'s':'1','b':'0', '?':'-1'}\\n # drop 1st column (Id) and also 1st row with column names (\\\"[1:,\\\") \\n train_raw = train_raw_[1:, :]\\n test_raw = test_raw_[1:, :] \\n \\n # Change s(signal) and b(background) for s:1 and b:0, and change '?' for -1\\n train_raw[:,1] = np.vectorize(pred_dict.get)(train_raw[:,1].astype(str))\\n test_raw[:,1] = np.vectorize(pred_dict.get)(test_raw[:,1].astype(str))\\n \\n # Divide the dataset in four according to PRI_jet_num feature and cast to float\\n train_data_jets = divide_dataset_by_jet(train_raw)\\n test_data_jets = divide_dataset_by_jet(test_raw)\\n \\n # Remove columns with nan values or with standard deviation of 0\\n test_data_jets, train_data_jets = clean_features(test_data_jets, train_data_jets, undef)\\n \\n # Standardize train and test sets to have mean=0 and std=1\\n train_data_jets, test_data_jets = standardize(train_data_jets, test_data_jets)\\n \\n # Replace remaining undefined values by mean, median or zero\\n train_data_mean, train_data_median, train_data_null = replace_nan(train_data_jets)\\n test_data_mean, test_data_median, test_data_null = replace_nan(test_data_jets)\\n \\n return train_data_mean, train_data_median, train_data_null, test_data_mean, test_data_median, test_data_null\",\n \"def _preprocess_data_point(self, x: DataPoint) -> DataPoint:\\n for preprocessor in self._pre:\\n x = preprocessor(x)\\n if x is None:\\n raise ValueError(\\\"Preprocessor should not return None\\\")\\n return x\",\n \"def _preprocess(self):\\n self.data['sentences'] = self.data['text'].apply(self._tokenize_sent)\\n self.data['nouns'] = self.data['sentences'].apply(self._get_nouns)\\n # self._get_frequent_features()\\n # self._compactness_pruning()\\n # self._redundancy_pruning()\\n # self._get_features()\\n self._extract_opinions()\",\n \"def preprocessing_fn(inputs):\\n outputs = {}\\n\\n for key in ONE_HOT_FEATURES.keys():\\n dim = ONE_HOT_FEATURES[key]\\n int_value = tft.compute_and_apply_vocabulary(\\n fill_in_missing(inputs[key]), top_k=dim + 1\\n )\\n outputs[transformed_name(key)] = convert_num_to_one_hot(\\n int_value, num_labels=dim + 1\\n )\\n\\n for key, bucket_count in BUCKET_FEATURES.items():\\n temp_feature = tft.bucketize(\\n convert_zip_code(fill_in_missing(inputs[key])),\\n bucket_count,\\n )\\n outputs[transformed_name(key)] = convert_num_to_one_hot(\\n temp_feature, num_labels=bucket_count + 1\\n )\\n\\n for key in TEXT_FEATURES.keys():\\n outputs[transformed_name(key)] = fill_in_missing(inputs[key])\\n\\n outputs[transformed_name(LABEL_KEY)] = fill_in_missing(inputs[LABEL_KEY])\\n\\n return outputs\",\n \"def test_data_preprocessing(raw_data): \\r\\n\\r\\n # get data output\\r\\n data_output = raw_data[['Submitby Date Time', 'Challenge Manager', 'Challenge Copilot', 'Posting Date Date', 'Track',\\r\\n 'Technology List', 'First Place Prize', 'Num Registrations', 'Total Prize']]\\r\\n with open('cache/extended_columns.pkl', 'rb') as f:\\r\\n extended_columns = pickle.load(f)\\r\\n with open('cache/num_date_columns.pkl', 'rb') as f:\\r\\n max_date_columns = pickle.load(f)\\r\\n \\r\\n data_output = class_binaryzation_for_test(data_output, extended_columns)\\r\\n try:\\r\\n data_output = date_separation1(data_output, max_num_columns=NUM_DATE_COLUMNS)\\r\\n except:\\r\\n data_output = date_separation2(data_output)\\r\\n data_output = money_digitalization(data_output)\\r\\n data_output = get_date_in_days(data_output)\\r\\n data_output['Days from Posting to Submit'] = data_output['Submitby Date Time Days from 2016'] \\\\\\r\\n - data_output['Posting Date Date Days from 2016'] \\r\\n\\r\\n return data_output\",\n \"def preprocess(self, first_inputs,second_inputs,third_inputs):\\r\\n pass\",\n \"def preprocess_dataset(self, dataset, params=None):\\n if params is None:\\n assert self.params_loaded, (\\n \\\"You must either provide parameters or load the model params before preprocessing.\\\")\\n params = self.params\\n for key in dataset.keys():\\n if dataset[key] is None:\\n continue\\n if hasattr(params, \\\"whiten_data\\\") and params.whiten_data:\\n if hasattr(params, \\\"whiten_method\\\"):\\n if params.whiten_method == \\\"FT\\\": # other methods require patching first\\n if hasattr(params, \\\"whiten_batch_size\\\"):\\n batch_size = params.whiten_batch_size\\n else:\\n batch_size = None\\n dataset[key].images, dataset[key].data_mean, dataset[key].w_filter = \\\\\\n dp.whiten_data_batch(dataset[key].images, method=params.whiten_method,\\n batch_size=batch_size)\\n print(\\\"INFO:preprocessing:FT Whitened \\\"+key+\\\" data\\\")\\n if hasattr(params, \\\"lpf_data\\\") and params.lpf_data:\\n dataset[key].images, dataset[key].data_mean, dataset[key].lpf_filter = \\\\\\n dp.lpf_data(dataset[key].images, cutoff=params.lpf_cutoff)\\n print(\\\"INFO:preprocessing:Low pass filtered \\\"+key+\\\" data\\\")\\n if hasattr(params, \\\"contrast_normalize\\\") and params.contrast_normalize:\\n if hasattr(params, \\\"gauss_patch_size\\\"):\\n dataset[key].images = dp.contrast_normalize(dataset[key].images,\\n params.gauss_patch_size)\\n else:\\n dataset[key].images = dp.contrast_normalize(dataset[key].images)\\n print(\\\"INFO:preprocessing:Contrast normalized \\\"+key+\\\" data\\\")\\n if hasattr(params, \\\"standardize_data\\\") and params.standardize_data:\\n if params.data_type == \\\"mnist\\\":\\n eps = 1e-5\\n else:\\n eps = None\\n dataset[key].images, dataset[key].data_mean, dataset[key].data_std = \\\\\\n dp.standardize_data(dataset[key].images, eps)\\n self.data_mean = dataset[key].data_mean\\n self.data_std = dataset[key].data_std\\n print(\\\"INFO:preprocessing:Standardized \\\"+key+\\\" data\\\")\\n if hasattr(params, \\\"extract_patches\\\") and params.extract_patches:\\n assert all(key in params.__dict__.keys()\\n for key in [\\\"num_patches\\\", \\\"patch_edge_size\\\", \\\"overlapping_patches\\\",\\n \\\"randomize_patches\\\"]), (\\\"Insufficient params for patches.\\\")\\n out_shape = (int(params.num_patches), int(params.patch_edge_size),\\n int(params.patch_edge_size), dataset[key].num_channels)\\n dataset[key].num_examples = out_shape[0]\\n dataset[key].reset_counters()\\n if hasattr(params, \\\"patch_variance_threshold\\\"):\\n dataset[key].images = dp.extract_patches(dataset[key].images, out_shape,\\n params.overlapping_patches, params.randomize_patches,\\n params.patch_variance_threshold, dataset[key].rand_state)\\n else:\\n dataset[key].images = dp.extract_patches(dataset[key].images, out_shape,\\n params.overlapping_patches, params.randomize_patches,\\n var_thresh=0, rand_state=dataset[key].rand_state)\\n dataset[key].shape = dataset[key].images.shape\\n dataset[key].num_rows = dataset[key].shape[1]\\n dataset[key].num_cols = dataset[key].shape[2]\\n dataset[key].num_channels = dataset[key].shape[3]\\n dataset[key].num_pixels = np.prod(dataset[key].shape[1:])\\n print(\\\"INFO:preprocessing:Extracted patches from \\\"+key+\\\" data\\\")\\n if hasattr(params, \\\"whiten_data\\\") and params.whiten_data:\\n if hasattr(params, \\\"whiten_method\\\") and params.whiten_method != \\\"FT\\\":\\n dataset[key].images, dataset[key].data_mean, dataset[key].w_filter = \\\\\\n dp.whiten_data(dataset[key].images, method=params.whiten_method)\\n print(\\\"INFO:preprocessing:Whitened \\\"+key+\\\" data\\\")\\n if hasattr(params, \\\"norm_data\\\") and params.norm_data:\\n dataset[key].images, dataset[key].data_max = dp.normalize_data_with_max(dataset[key].images)\\n self.data_max = dataset[key].data_max\\n print(\\\"INFO:preprocessing:Normalized \\\"+key+\\\" data with maximum\\\")\\n if hasattr(params, \\\"rescale_data\\\") and params.rescale_data:\\n dataset[key].images, dataset[key].data_min, dataset[key].data_max = dp.rescale_data_to_one(dataset[key].images)\\n self.data_max = dataset[key].data_max\\n self.data_min = dataset[key].data_min\\n print(\\\"INFO:preprocessing:Rescaled each \\\"+key+\\\" datapoint to one\\\")\\n if hasattr(params, \\\"center_data\\\") and params.center_data:\\n dataset[key].images, dataset[key].data_mean = dp.center_data(dataset[key].images,\\n use_dataset_mean=True)\\n self.data_mean = dataset[key].data_mean\\n print(\\\"INFO:preprocessing:Centered \\\"+key+\\\" data\\\")\\n return dataset\",\n \"def _preprocess_training_model(self, data):\\n def _pre_process(raw_data):\\n \\\"\\\"\\\" Pre-process raw data. \\\"\\\"\\\"\\n pattern = re.compile(\\n r\\\"((?<=')\\\\w\\\\d.*?(?=')|(?<=\\\\\\\")\\\\w\\\\d.*?(?=\\\\\\\")|[\\\\w\\\\d]+)\\\")\\n words = re.findall(pattern, raw_data)\\n return ' '.join(list(map(string_utils.snake_case_to_camel, words)))\\n\\n data_list = []\\n # Preprocess the dataset with naming convention, etc.\\n with Progress() as progress:\\n preprocess_task = progress.add_task('Pre-processing dataset...',\\n total=data.shape[0])\\n for idx, row in data.iterrows():\\n row_data = {}\\n for column in ['text', 'key', 'value']:\\n row_data[column] = _pre_process(row[column])\\n data_list.append(row_data)\\n progress.update(preprocess_task, advance=1)\\n return pd.DataFrame(data=data_list)\",\n \"def pre_processor(self):\",\n \"def preprocess_func(cls, func):\\n pass\",\n \"def run_preprocessing(self, serie):\\n pass\",\n \"def preprocess(data,scale):\\n ##log_transformation\\n #data['log_sale_price'] = np.log(data['sale_price'])\\n #data['log_lot_area'] = np.log(data['lot_area'])\\n #data['house_age'] = data['year_sold']- data['year_built']\\n \\n y = data['stay']\\n \\n #sales['log_sale_price'] = np.log(sales['sale_price'])\\n #sales['log_lot_area'] = np.log(sales['lot_area'])\\n #sales['house_age'] = sales['year_sold']- sales['year_built']\\n data_dummy = data.copy()\\n \\n #dummy coding\\n data_scale = pd.get_dummies(data_dummy).drop(columns = ['stay'])\\n\\n \\n #scale the value\\n if scale == True:\\n S = StandardScaler().fit(data_scale)\\n data_scale = S.transform(data_scale)\\n \\n return y, data_scale\",\n \"def process(self, preprocess_args: Dict) -> None:\\n dataset2preprocessor = {\\n 'vhi': VHIPreprocessor,\\n }\\n\\n for dataset, variables in preprocess_args.items():\\n\\n # check the format is as we expected\\n assert dataset in dataset2preprocessor, \\\\\\n f'{dataset} is not supported! Supported datasets are {dataset2preprocessor.keys()}'\\n\\n assert type(variables) is list, \\\\\\n f'Expected {dataset} values to be a list. Got {type(variables)} instead'\\n\\n preprocessor = dataset2preprocessor[dataset](self.data)\\n\\n for variable in variables:\\n preprocessor.preprocess(**variable)\",\n \"def preprocess_data(self, lidar_data):\\n raise NotImplementedError(\\\"Lidar preprocessing object must implement a way \\\"\\n \\\"to preprocess data\\\")\",\n \"def preprocess_main():\",\n \"def preproc_pipeline(data):\\n # Preprocess\\n data = preprocess(data)\\n\\n # Optional --> run a technical analysis on it and add more features\\n data = generate_ta(data)\\n \\n # Split\\n train_set, validation_set, test_set = train_val_test_split(data)\\n \\n # Set up for Keras\\n train_set = shape_for_keras(train_set)\\n validation_set = shape_for_keras(validation_set)\\n test_set = shape_for_keras(test_set)\\n\\n # We could save this to csv.\\n return train_set, validation_set, test_set\",\n \"def preprocessing_fn(inputs):\\n outputs = {}\\n for key in _DENSE_FLOAT_FEATURE_KEYS:\\n # Preserve this feature as a dense float, setting nan's to the mean.\\n outputs[_transformed_name(key)] = tft.scale_to_z_score(\\n _fill_in_missing(inputs[key]))\\n\\n for key in _VOCAB_FEATURE_KEYS:\\n # Build a vocabulary for this feature.\\n outputs[_transformed_name(key)] = tft.compute_and_apply_vocabulary(\\n _fill_in_missing(inputs[key]),\\n top_k=_VOCAB_SIZE,\\n num_oov_buckets=_OOV_SIZE)\\n\\n for key in _BUCKET_FEATURE_KEYS:\\n outputs[_transformed_name(key)] = tft.bucketize(\\n _fill_in_missing(inputs[key]), _FEATURE_BUCKET_COUNT,\\n always_return_num_quantiles=False)\\n\\n for key in _CATEGORICAL_FEATURE_KEYS:\\n outputs[_transformed_name(key)] = _fill_in_missing(inputs[key])\\n\\n # Was this passenger a big tipper?\\n taxi_fare = _fill_in_missing(inputs[_FARE_KEY])\\n tips = _fill_in_missing(inputs[_LABEL_KEY])\\n outputs[_transformed_name(_LABEL_KEY)] = tf.where(\\n tf.is_nan(taxi_fare),\\n tf.cast(tf.zeros_like(taxi_fare), tf.int64),\\n # Test if the tip was > 20% of the fare.\\n tf.cast(\\n tf.greater(tips, tf.multiply(taxi_fare, tf.constant(0.2))), tf.int64))\\n\\n return outputs\",\n \"def preprocess_(data, categories=None):\\n res = []\\n for x in data:\\n if len(x['points']) < 3:\\n continue\\n if x['geomType'] == 3:\\n x['base_curve'] = x['points'][:6]\\n x['points'] = x['points'][6:]\\n\\n elif x['geomType'] == 9:\\n x['base_curve'] = x['points'][:3]\\n x['points'] = x['points'][3:]\\n else:\\n continue\\n dst = {**x['attrs'], **x['attrd'], **x['attri']}\\n x['attrs'] = dst\\n x.pop('attrd')\\n x.pop('attri')\\n x['ogeomType'] = x['geomType']\\n x['geomType'] = 8\\n x['uid'] = int(x['attrs']['ElementID'])\\n x['category'] = x['attrs']['Category']\\n if categories is None or x['category'] in categories:\\n rs = list(filter(None, geom.RevitInterface.factory(**x)))\\n res.extend(rs)\\n return res\",\n \"def preprocess(config: Config) -> None:\\n print(colored(\\\"preprocessing:\\\", attrs=[\\\"bold\\\"]))\\n factory = PreprocessingFactory()\\n factory.process(config)\",\n \"def preprocess(function, **kwargs):\\n\\n print kwargs, \\\"preprocess\\\"\\n return function(**kwargs)\",\n \"def preprocess_data(X):\\n # NOTE: # If you have conducted any pre-processing on the image,\\n # please implement this function to apply onto test images.\\n return X\",\n \"def preprocess(item):\\n item = feature_engineering(item)\\n item = encode_features(item)\\n return item\",\n \"def preprocess(self, data_f):\\n \\n return self.vec.transform(data_f.review)\",\n \"def preprocess(self, latent_codes, **kwargs):\\n raise NotImplementedError(f'Should be implemented in derived class!')\",\n \"def _build_tracking_preprocessing(input_shape):\\n\\n def preprocessing(input_img, **kwargs):\\n\\n to_normalize = False if np.percentile(input_img, 98) > 1.0 else True\\n\\n if len(input_img.shape) == 4:\\n print(\\n \\\"Only preprocessing single image, we will consider the first one of the batch\\\"\\n )\\n image = input_img[0] * 255.0 if to_normalize else input_img[0] * 1.0\\n else:\\n image = input_img * 255.0 if to_normalize else input_img * 1.0\\n\\n image = cv2.resize(image, input_shape)\\n x, _ = transform_test(mx.nd.array(image), min(input_shape))\\n return x\\n\\n return preprocessing\",\n \"def preprocess(self, real, **kwargs):\\n self._preprocessed = True\",\n \"def preprocess_raw(self):\\n pass\",\n \"def pre_process(cls, *args, **kwargs):\\n pass\",\n \"def pre_process(cls, *args, **kwargs):\\n pass\",\n \"def pre_process(cls, *args, **kwargs):\\n pass\",\n \"def pre_process(cls, *args, **kwargs):\\n pass\",\n \"def _get_data_preprocessing_fns(self):\\n # Create new functions with partial positional arguments assigned\\n process_path_fn = \\\\\\n partial(data_preprocessing.process_path,\\n one_hot=self.ONE_HOT,\\n num_classes=self._NUM_CLASSES,\\n class_names=self._CLASS_NAMES)\\n process_img_path_fn = data_preprocessing.process_img_path\\n convert_format_fn = \\\\\\n partial(data_preprocessing.convert_format,\\n grayscale_in=self._GRAYSCALE_IN,\\n grayscale_out=self._GRAYSCALE_OUT)\\n random_rotate_fn = \\\\\\n partial(data_preprocessing.random_rotate,\\n stddev=self._ROTATE_STDDEV)\\n random_zoom_fn = \\\\\\n partial(data_preprocessing.random_zoom,\\n max_percent=self._ZOOM_MAX_PERCENT,\\n stddev=self._ZOOM_STDDEV,\\n img_height=self._HEIGHT,\\n img_width=self._WIDTH)\\n resize_fn = \\\\\\n partial(data_preprocessing.resize,\\n height=self._HEIGHT,\\n width=self._WIDTH)\\n\\n funcs = edict({'process_path': process_path_fn,\\n 'process_img_path': process_img_path_fn,\\n 'convert_format': convert_format_fn,\\n 'random_rotate': random_rotate_fn,\\n 'random_zoom': random_zoom_fn,\\n 'resize': resize_fn})\\n\\n return funcs\",\n \"def preprocessing_transform(self, x):\\n if isinstance(self.column_text, int) and self.column_text not in x.columns:\\n col = self.column_text\\n else:\\n col = list(x.columns).index(self.column_text)\\n\\n ct = x.shape[0]\\n # INPUTS\\n if self.method_embedding.lower() in ['roberta', \\\"camembert\\\", \\\"xlm-roberta\\\"]:\\n ids = np.ones((ct, self.maxlen), dtype='int32')\\n else:\\n ids = np.zeros((ct, self.maxlen), dtype='int32')\\n att = np.zeros((ct, self.maxlen), dtype='int32')\\n tok = np.zeros((ct, self.maxlen), dtype='int32')\\n\\n for k in range(ct):\\n text = \\\" \\\" + \\\" \\\".join(x.iloc[k, col].split())\\n\\n if self.method_embedding == 'RoBERTa':\\n enc = self.tokenizer.encode(text)\\n else:\\n enc = self.tokenizer.encode(text, max_length=self.maxlen, truncation=True)\\n\\n # CREATE BERT INPUTS\\n if self.method_embedding == 'RoBERTa':\\n ids[k, :len(enc.ids)] = enc.ids[:self.maxlen]\\n att[k, :len(enc.ids)] = 1\\n else:\\n ids[k, :len(enc)] = enc\\n att[k, :len(enc)] = 1\\n\\n x_preprocessed = [ids, att, tok]\\n if self.dimension_embedding == 'word_embedding':\\n return x_preprocessed\\n else:\\n model_extractor = self.model_extract_document_embedding()\\n document_embedding = model_extractor.predict(x_preprocessed)\\n return document_embedding\",\n \"def transform(self, data):\",\n \"def _process(proc_data):\\n int_list = {\\n 'sent_bytes', 'packets_transmitted', 'packets_received', 'response_bytes', 'icmp_seq',\\n 'ttl', 'duplicates', 'vr', 'hl', 'tos', 'len', 'id', 'flg', 'off', 'pro', 'cks'\\n }\\n\\n float_list = {\\n 'packet_loss_percent', 'round_trip_ms_min', 'round_trip_ms_avg', 'round_trip_ms_max',\\n 'round_trip_ms_stddev', 'timestamp', 'time_ms'\\n }\\n\\n for key in proc_data:\\n if key in int_list:\\n proc_data[key] = jc.utils.convert_to_int(proc_data[key])\\n\\n if key in float_list:\\n proc_data[key] = jc.utils.convert_to_float(proc_data[key])\\n\\n return proc_data\",\n \"def data_preprocessing_TA(X):\\n \\n #Removing the mean and scaling the data\\n X_prep=StandardScaler().fit_transform(X)\\n #do here your preprocessing\\n return X_prep\",\n \"def preprocessing_fn(inputs):\\n outputs = {}\\n\\n # This function is the entry point for your feature engineering with\\n # TensorFlow Transform, using the TFX Transform component. In this example\\n # the feature engineering is very simple, only applying z-score scaling.\\n for key in Features.FEATURE_KEYS:\\n outputs[transformed_name(key)] = tft.scale_to_z_score(inputs[key])\\n\\n # inputs[key]\\n\\n # tft.scale_to_z_score(inputs[key])\\n\\n # Do not apply label transformation as it will result in wrong evaluation.\\n outputs[transformed_name(\\n Features.LABEL_KEY)] = inputs[Features.LABEL_KEY]\\n\\n return outputs\",\n \"def preprocess():\\n # Load the data\\n random.seed(77)\\n X,y = make_classification(n_samples=500, n_features=30, n_informative=8, n_redundant=2, \\n n_repeated=0, n_classes=3, n_clusters_per_class=2, weights=None, \\n flip_y=0.01, class_sep=1.0, hypercube=True, shift=0.0, scale=1.0, \\n shuffle=True, random_state=None)\\n\\n x_train, x_val, y_train, y_val = train_test_split(X, y, random_state=0, test_size=0.25)\\n\\n # Standardize the data\\n scaler = StandardScaler()\\n X_train = scaler.fit_transform(x_train)\\n X_val = scaler.transform(x_val)\\n\\n \\n return X_train,y_train,X_val,y_val\",\n \"def small_preprocess(data):\\r\\n \\r\\n # Remove new line characters\\r\\n data = [re.sub('\\\\s+', ' ', sent) for sent in data]\\r\\n # Remove distracting single quotes\\r\\n data = [re.sub(\\\"\\\\'\\\", \\\"\\\", sent) for sent in data]\\r\\n\\r\\n return data\",\n \"def transform():\",\n \"def preprocess(df, model_config, y=None, type='train', count_enc=True,\\n likelihood_enc=False, scaling=False,\\n use_groups=['number', 'count', 'likelihood']):\\n\\n print('preprocess data..')\\n\\n # extract datetime features\\n df = transform_datetime_features(df)\\n print('datetime features extracted')\\n\\n # categorical count encoding\\n if count_enc:\\n if type == 'train':\\n df, categorical_values = count_encoding(df)\\n model_config['categorical_values'] = categorical_values\\n elif type == 'test':\\n df = count_encoding(df, model_config['categorical_values'])\\n print('count encoding of categorical features added')\\n\\n # mean target encoding\\n if likelihood_enc:\\n if type == 'train':\\n cat_cols = df.columns[df.columns.str.startswith('string')].tolist()\\n df, categorical_values, global_avg = likelihood_encoding(df.join(y), cat_cols)\\n model_config['mean_target'] = categorical_values\\n model_config['global_avg'] = global_avg\\n model_config['cat_cols'] = cat_cols\\n elif type == 'test':\\n df = likelihood_encoding(df, model_config['cat_cols'],\\n categorical_values=model_config['mean_target'],\\n global_avg=model_config['global_avg'])\\n print('mean target encoding of categorical features added')\\n\\n # drop constant features\\n if type == 'train':\\n df = drop_const_cols(df)\\n\\n # filter columns\\n if type == 'train':\\n df, used_columns = filter_columns(df, groups=use_groups)\\n model_config['used_columns'] = used_columns\\n elif type=='test':\\n df_pred = df[['line_id']]\\n df = df[model_config['used_columns']]\\n\\n # scaling\\n if scaling:\\n if type == 'train':\\n df, scaler_mean, scaler_std = std_scaler(df)\\n model_config['scaler_mean'] = scaler_mean\\n model_config['scaler_std'] = scaler_std\\n elif type=='test':\\n df = std_scaler(df, model_config['scaler_mean'], model_config['scaler_std'])\\n\\n\\n if type == 'train':\\n return df, model_config\\n else:\\n return df, df_pred\",\n \"def _preprocess_values(self,Y):\\r\\n return Y\",\n \"def _preprocess_values(self,Y):\\r\\n return Y\",\n \"def preprocess(self, data, scope):\\n if scope != 'train':\\n # reshape\\n data = self._data_reshape(data)\\n\\n # normalize\\n if data.dtype == np.int16:\\n start_unit = -1000\\n end_unit = 300\\n data = 2 * (data.astype(np.float32) - start_unit) / (end_unit - start_unit) - 1\\n\\n # subtract train mean and divide by train std\\n if scope == 'train':\\n self.mean = np.mean(data)\\n data -= self.mean\\n self.std = np.std(data)\\n data /= self.std\\n else:\\n data -= self.mean\\n data /= self.std\\n\\n # reshape for channel\\n s = data.shape\\n if len(data.shape) == 4:\\n data = data.reshape((s[0], s[1], s[2], s[3], 1))\\n else:\\n data = data.reshape((s[0], s[1], s[2], 1))\\n return data\",\n \"def preprocess(self, instances, stats=None, **kwargs):\\n pass\",\n \"def preprocess(self):\\n raise RuntimeError(\\\"please implement this function!\\\")\",\n \"def preprocess_data(self):\\n\\n selected_data = []\\n selected_name = []\\n quant_norm_applied = []\\n\\n rgb_color_to_keys = self.get_rgb_items_for_plot()\\n for data_key in rgb_color_to_keys.values():\\n if data_key in self.dict_to_plot:\\n selected_name.append(data_key)\\n\\n if self.scaler_data is not None:\\n if np.count_nonzero(self.scaler_data) == 0:\\n logger.warning(\\\"scaler is zero - scaling was not applied\\\")\\n elif len(self.scaler_data[self.scaler_data == 0]) > 0:\\n logger.warning(\\\"scaler data has zero values\\\")\\n\\n for i, k in enumerate(selected_name):\\n q_norm_applied = False\\n if self.quantitative_normalization:\\n # Quantitative normalization\\n (\\n data_arr,\\n q_norm_applied,\\n ) = self.img_model_adv.param_quant_analysis.apply_quantitative_normalization(\\n data_in=self.dict_to_plot[k],\\n scaler_dict=self.scaler_norm_dict,\\n scaler_name_default=self.get_selected_scaler_name(),\\n data_name=k,\\n ref_name=self.quantitative_ref_eline,\\n name_not_scalable=self.name_not_scalable,\\n )\\n else:\\n # Normalize by the selected scaler in a regular way\\n data_arr = normalize_data_by_scaler(\\n data_in=self.dict_to_plot[k],\\n scaler=self.scaler_data,\\n data_name=k,\\n name_not_scalable=self.name_not_scalable,\\n )\\n\\n selected_data.append(data_arr)\\n quant_norm_applied.append(q_norm_applied)\\n\\n return selected_data, selected_name, rgb_color_to_keys, quant_norm_applied\",\n \"def allreduce( # pylint:disable=invalid-name\\n data: np.ndarray, op: Op, prepare_fun: Optional[Callable[[np.ndarray], None]] = None\\n) -> np.ndarray:\\n if prepare_fun is None:\\n return collective.allreduce(data, collective.Op(op))\\n raise Exception(\\\"preprocessing function is no longer supported\\\")\",\n \"def classical_preprocessing(*args, **kwargs):\\r\\n qnode.construct(args, kwargs)\\r\\n return qml.math.stack(qnode.qtape.get_parameters())\",\n \"def preprocessing_input(self, df, prepro_kwargs=None):\\n if prepro_kwargs is None:\\n assert hasattr(self,\\n 'experiment'), 'Set up the prepro_kwargs argument'\\n if 'feature_config' in self.experiment.keys():\\n prepro_kwargs = self.experiment.feature_config.validation_augmentation\\n elif self.experiment['data_config'] is not None:\\n prepro_kwargs = self.experiment.data_config.validation_augmentation\\n\\n prepro = MetaDataGenerator(**prepro_kwargs)\\n return prepro.standardize(df)\",\n \"def preprocess_data(data):\\n def deal_line(line):\\n pos, rating = line.split(',')\\n row, col = pos.split(\\\"_\\\")\\n row = row.replace(\\\"r\\\", \\\"\\\")\\n col = col.replace(\\\"c\\\", \\\"\\\")\\n return int(row), int(col), float(rating)\\n\\n def statistics(data):\\n row = set([line[0] for line in data])\\n col = set([line[1] for line in data])\\n return min(row), max(row), min(col), max(col)\\n\\n # parse each line\\n data = [deal_line(line) for line in data]\\n\\n # do statistics on the dataset.\\n min_row, max_row, min_col, max_col = statistics(data)\\n print(\\\"number of items: {}, number of users: {}\\\".format(max_row, max_col))\\n\\n # build rating matrix.\\n ratings = sp.lil_matrix((max_row, max_col))\\n for row, col, rating in data:\\n ratings[row - 1, col - 1] = rating\\n return ratings\",\n \"def preprocess(args):\\n prism.preprocess.run(\\n input_fp=args.input,\\n output_fp=args.output,\\n no_prefilter=args.no_prefilter,\\n full_pattern_proportion=args.full_pattern_proportion,\\n error=args.error,\\n bisulfite_conversion_rate=args.bisulfite_conversion_rate,\\n processivity=args.processivity,\\n recruitment_efficiency=args.recruitment_efficiency,\\n threads=args.threads,\\n seed=args.seed,\\n verbose=args.verbose,\\n )\",\n \"def _preprocess(self, feature_dict):\\n return feature_dict\",\n \"def preprocess(N, sigma2, R, f_def, params):\\n\\n #\\n if 'scale' in params:\\n if params['scale']:\\n\\n #\\n N0 = np.sum(R * f_def, axis=1)\\n\\n #\\n f_def *= np.average(N / N0)\\n\\n return N, sigma2, R, f_def, params\",\n \"def preprocess(data):\\n\\n #remove urls and convert to lowercase\\n #used this thread for help on urls: https://stackoverflow.com/questions/11331982/how-to-remove-any-url-within-a-string-in-python\\n remove_url = [re.sub(r'^https?:\\\\/\\\\/.*[\\\\r\\\\n]*', '', x) for x in data]\\n lower=[x.lower() for x in remove_url]\\n\\n #remove all non alphanumeric chars and empty strings\\n return filter(None, [re.sub(r'\\\\W','',x) for x in lower])\",\n \"def _preprocess_values(self,Y):\\n return Y\",\n \"def preprocess_sample(qid_raw, condition_raw, output_raw):\\n qid, condition, output = split_to_words(qid_raw, condition_raw, output_raw)\\n \\n qid, condition, output, dictionary_standardization = standardize_words(qid, condition, output)\\n\\n return qid, condition, output, dictionary_standardization\",\n \"def apply_preprocessing(\\n data: List[np.ndarray],\\n sample_rate: Union[int, List[int]],\\n funcs: List[str],\\n *,\\n kwargs: dict = {},\\n) -> np.ndarray:\\n if isinstance(sample_rate, int):\\n sample_rate = [sample_rate] * len(data)\\n try:\\n assert len(data) == len(sample_rate)\\n except AssertionError:\\n raise ValueError(\\n \\\"The number of sample rates must be the same as the number of data\\\"\\n )\\n for func in funcs:\\n if hasattr(preprocessing, func):\\n preproc: Callable = getattr(preprocessing, func, **kwargs)\\n data = p_map(preproc, data, sample_rate,\\n desc=f\\\"Applying {func}...\\\")\\n else:\\n raise ValueError(f\\\"{func} is not a valid preprocessing function\\\")\\n return data\",\n \"def pre_processing_(data_df , serialized_objects):\\n max_recency_acc_dig = serialized_objects['max_recency_acc_dig'] # These values are taken from trained model values\\n max_recency_dig_2yr = serialized_objects['max_recency_dig_2yr'] # These values are taken from trained model values\\n max_acc_recency_mf = serialized_objects['max_acc_recency_mf'] #These are values imported in training dataset. Same values needs to be used to impute missing values in unseen data\\n\\n data_df = data_df.na.fill({\\n 'recency_acc_dig' : max_recency_acc_dig, # Filling missing values\\n 'recency_dig_2yr' : max_recency_dig_2yr,\\n 'acc_recency_mf' : max_acc_recency_mf\\n })\\n\\n freq_acc_upg_2yrs_split = [-float('inf'), 0, 1, 2, float('inf')]\\n bucketizer_freq_acc_upg_2yrs = Bucketizer(splits=freq_acc_upg_2yrs_split, inputCol='freq_acc_upg_acc_2yrs', outputCol='freq_acc_upg_acc_2yrs_bkt')\\n data_df = bucketizer_freq_acc_upg_2yrs.setHandleInvalid('keep').transform(data_df) # Binning the freq_acc_upg_acc_2yrs column\\n\\n tot_purchase_split = [-float('inf'), 0, 1, 2, 3, float('inf')]\\n bucketizer_tot_purchase = Bucketizer(splits=tot_purchase_split, inputCol='tot_accsry_purchse', outputCol='tot_accsry_purchse_bkt')\\n data_df = bucketizer_tot_purchase.setHandleInvalid('keep').transform(data_df) # Binning the tot_accsry_purchse column\\n\\n del_cols_new = ['freq_acc_upg_acc_2yrs', 'tot_accsry_purchse']\\n data_df = data_df.drop(*del_cols_new) # Dropping the older continuous columns\\n return data_df\",\n \"def prepareData(self, *data):\\n arguments = 8\\n (self.X, self.X_name, self.Y, self.Y_name, self.alignment,\\n self.model, self.annotations, self.args) = tuple(data[:arguments])\\n \\n self.width = self.args.beam_width\\n self.mathType = self.args.mathType\\n self.io_files = {\\n 'input': self.args.intermediate_input_files,\\n 'output': self.args.intermediate_output_files\\n }\\n self.repeat_width = self.args.repeat_width\\n self.cons_count = self.args.cons_count\\n self.posterior_processors = self.args.posterior_processors \\n\\n self.positionGenerator = \\\\\\n list(AlignmentBeamGenerator(self.alignment, self.width))\\n \\n for i in range(len(self.model.states)):\\n self.model.states[i].computeHints(self)\\n\\n return data[arguments:]\",\n \"def stage_three_preprocessing(data: pd.Series) -> pd.Series:\\n data_ = data.dropna()\\n data_ = shrink_whitespace(data_)\\n #data_ = lemmatize(data_)\\n return data_\",\n \"def _common_preprocess(self, data):\\n\\n data = data.drop('id', axis=1) \\n data = data.drop(['17', '488', 'B01AF', 'H01AB'], axis=1, errors='ignore')\\n\\n # drop age outliers\\n idx = data[(data['age'] > 99)].index\\n data = data.drop(idx)\\n\\n # drop rows with CKD\\n idx = data[((data['585'] != 0) | (data['586'] != 0)) &\\n (data['ckd'] == 0)].index\\n data = data.drop(idx)\\n data = data.drop(['585', '586'], axis=1)\\n\\n return data\",\n \"def preprocess_func(cls, func):\\n return func\",\n \"def preprocess_fn(self, X_data, Y_data):\\n # Normalize image data to [0,1]\\n X_data = tf.math.divide(tf.math.subtract(X_data, tf.math.reduce_min(\\n X_data)), tf.math.subtract(tf.math.reduce_max(X_data), tf.math.reduce_min(X_data)))\\n Y_data = tf.math.divide(tf.math.subtract(Y_data, tf.math.reduce_min(\\n Y_data)), tf.math.subtract(tf.math.reduce_max(Y_data), tf.math.reduce_min(Y_data)))\\n\\n return X_data, Y_data\",\n \"def preprocess_inference(df, path_pipeline=\\\"data/pipeline/pipe_01/\\\", preprocess_pars={}, cols_group=None):\\n from util_feature import load, load_function_uri, load_dataset\\n\\n #### Pipeline Execution ####################################################\\n pipe_default = [\\n {'uri' : 'source/prepro.py::pd_colnum_bin', 'pars': {}, 'cols_family': 'colnum', 'type': '' },\\n {'uri' : 'source/prepro.py::pd_colnum_binto_onehot', 'pars': {}, 'cols_family': 'colnum_bin', 'type': '' },\\n {'uri': 'source/prepro.py::pd_colcat_bin', 'pars': {}, 'cols_family': 'colcat', 'type': '' },\\n {'uri': 'source/prepro.py::pd_colcat_to_onehot', 'pars': {}, 'cols_family': 'colcat_bin', 'type': '' },\\n {'uri' : 'source/prepro.py::pd_colcross', 'pars': {}, 'cols_family': 'colcross', 'type': 'cross' }\\n ]\\n pipe_list = preprocess_pars.get('pipe_list', pipe_default)\\n pipe_list_X = [ task for task in pipe_list if task.get('type', '') not in ['coly', 'filter'] ]\\n pipe_filter = [ task for task in pipe_list if task.get('type', '') in ['filter'] ]\\n\\n\\n log(\\\"########### Load column by column type ##################################\\\")\\n cols_group = preprocess_pars['cols_group']\\n log(cols_group) ### list of model columns familty\\n colid = cols_group['colid'] # \\\"jobId\\\"\\n coly = cols_group['coly']\\n colcat = cols_group['colcat'] # [ 'companyId', 'jobType', 'degree', 'major', 'industry' ]\\n colnum = cols_group['colnum'] # ['yearsExperience', 'milesFromMetropolis']\\n\\n\\n ##### Generate features ########################################################################\\n dfi_all = {} ### Dict of all features\\n cols_family_full = {'coly':coly}\\n\\n if len(pipe_filter) > 0 :\\n log(\\\"##### Filter #######################################################################\\\")\\n pipe_i = pipe_filter[ 0 ]\\n pipe_fun = load_function_uri(pipe_i['uri'])\\n df, col_pars = pipe_fun(df, list(df.columns), pars=pipe_i.get('pars', {}))\\n\\n\\n ##### Processors #############################################################################\\n #for colg, colg_list in cols_group.items() :\\n # if colg not in ['colid', 'coly' ]:\\n # dfi_all[colg] = df[colg_list] ## colnum colcat, coly\\n\\n\\n for pipe_i in pipe_list_X :\\n log(\\\"###################\\\", pipe_i, \\\"#######################################################\\\")\\n pipe_fun = load_function_uri(pipe_i['uri']) ### Load the code definition into pipe_fun\\n cols_name = pipe_i['cols_family']\\n col_type = pipe_i['type']\\n pars = pipe_i.get('pars', {})\\n\\n ### Load data from disk : inference time\\n pars['path_pipeline'] = path_pipeline\\n\\n cols_list = cols_group[cols_name] if cols_name in cols_group else cols_family_full[cols_name]\\n df_ = df[ cols_group[cols_name]] if cols_name in cols_group else dfi_all[cols_name]\\n # cols_list = list(dfi_all[cols_name].columns)\\n # df_ = dfi_all[cols_name]\\n logs(df_, cols_list)\\n\\n if col_type == 'cross':\\n pars['dfnum_hot'] = dfi_all['colnum_onehot'] ### dfnum_hot --> dfcross\\n pars['dfcat_hot'] = dfi_all['colcat_onehot']\\n pars['colid'] = colid\\n pars['colcross_single'] = cols_group.get('colcross', [])\\n elif col_type == 'add_coly':\\n pass\\n\\n dfi, col_pars = pipe_fun(df_, cols_list, pars= pars)\\n\\n ### Concatenate colnum, colnum_bin into cols_family_all\\n for colj, colist in col_pars['cols_new'].items() :\\n ### Merge sub-family\\n cols_family_full[colj] = cols_family_full.get(colj, []) + colist\\n dfi_all[colj] = pd.concat((dfi_all[colj], dfi), axis=1) if colj in dfi_all else dfi\\n\\n\\n log(\\\"###### Merge AlL int dfXy #############################################################\\\")\\n dfXy = df[ colnum + colcat ]\\n for t in dfi_all.keys():\\n if t not in [ 'colnum', 'colcat'] :\\n dfXy = pd.concat((dfXy, dfi_all[t] ), axis=1)\\n\\n\\n colXy = list(dfXy.columns)\\n if len(colid)>0:\\n cols_family_full['colid']=colid\\n cols_family_full['colX'] = colXy\\n\\n return dfXy, cols_family_full\",\n \"def preprocess(self, X):\\n X = X.copy()\\n predictor_subset = self.predictor_subset.copy()\\n if 'all' in predictor_subset:\\n predictor_subset = add_all_predictors(predictor_subset, X.columns)\\n \\n use_temporal = 'temporal' in predictor_subset\\n if use_temporal:\\n X_temporal = get_temporal_predictors(\\n X['TIMESTAMP_END']\\n )\\n predictor_subset.remove('temporal')\\n\\n X = X[predictor_subset]\\n\\n if use_temporal:\\n X = pd.concat([X, X_temporal], axis=1)\\n\\n if 'WD' in predictor_subset:\\n X = process_wind_direction_predictor(X)\\n\\n return X\",\n \"def data_preprocessing():\\n lineid_content = get_lineid_content()\\n print('Read movie_lines.txt file complete...')\\n convos = get_convos()\\n print('Read movie_conversations.txt file complete...')\\n print('Building dataset')\\n get_data(lineid_content, convos)\",\n \"def preprocess(self):\\n\\n mm_magcoord.add_aacgm_coordinates(self)\\n mm_magcoord.add_quasi_dipole_coordinates(self)\\n mm_sc.calculate_ecef_velocity(self)\\n mm_sc.add_ram_pointing_sc_attitude_vectors(self)\\n\\n return\",\n \"def preprocess(self, data, era):\\n return data / np.max(data)\",\n \"def preProcess(self, datum):\\n pass\",\n \"def data_preprocessing(dat: pd.DataFrame, art='C', y=None, logger=None, remove=True):\\n if logger == None:\\n logging.basicConfig(\\n level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')\\n logger = logging.getLogger(__name__)\\n \\n logger.info('Start data preprocessing')\\n # replace original indeices with default ones\\n dat = dat.reset_index(drop=True)\\n\\n if art == 'C':\\n logger.info('Start to label target feature y for classification task')\\n dat.iloc[:, -1] = LabelEncoder().fit_transform(dat.iloc[:, -1])\\n logger.info('End with label encoding the target feature')\\n if remove:\\n # remove columns with more than 1/2 na\\n dat = dat.loc[:, dat.isna().sum()/len(dat) < .5]\\n logger.info('Following features are removed from the dataframe because half of their value are NA: %s' %\\n (dat.columns[dat.isna().sum()/len(dat) > .5].to_list()))\\n # Encoding\\n oe = OneHotEncoder(drop='first')\\n # get categorical columns\\n if y:\\n dat_y = dat[[y]]\\n cols = dat.columns.to_list()\\n cols.remove(y)\\n dat_x = dat[cols]\\n else:\\n dat_y = dat[[dat.columns[-1]]]\\n dat_x = dat[dat.columns[:-1]]\\n dat_categ = dat_x.select_dtypes(include=['object'])\\n # get kterm of categ features\\n for i in dat_categ.columns:\\n # save output to dat\\n tmp = dat_x[i].value_counts()\\n dat_x[i + '_kterm'] = dat_x[i].map(lambda x: tmp[x] if x in tmp.index else 0)\\n # float columns including the k term cols\\n dat_numeric = dat_x.select_dtypes(include=['float32', 'float64', 'int32', 'int64'])\\n # onehot encoding and label encoding\\n dat_categ_onehot = dat_categ.iloc[:, dat_categ.apply(lambda x: len(x.unique())).values < 8]\\n dat_categ_label = dat_categ.iloc[:, dat_categ.apply(lambda x: len(x.unique())).values >= 8]\\n flag_onehot = False\\n flag_label = False\\n # oe\\n if dat_categ_onehot.shape[1] > 0:\\n logger.info('Start to do onehot to the following categoric features: %s' %\\n (str(dat_categ_onehot.columns.to_list())))\\n dat_onehot = pd.DataFrame(oe.fit_transform(dat_categ_onehot.astype(str)).toarray(),\\n columns=oe.get_feature_names(dat_categ_onehot.columns))\\n logger.info('End with onehot')\\n flag_onehot = True\\n else:\\n dat_onehot = None\\n # le\\n if dat_categ_label.shape[1] > 0:\\n logger.info('Start to do label encoding to the following categoric features: %s' %\\n (str(dat_categ_label.columns.to_list())))\\n dat_categ_label = dat_categ_label.fillna('NULL')\\n dat_label = pd.DataFrame(columns=dat_categ_label.columns)\\n for i in dat_categ_label.columns:\\n dat_label[i] = LabelEncoder().fit_transform(dat_categ_label[i].astype(str))\\n flag_label = True\\n logger.info('End with label encoding')\\n else:\\n dat_label = None\\n # scaling\\n # combine\\n dat_new = pd.DataFrame()\\n if flag_onehot and flag_label:\\n dat_new = pd.concat([dat_numeric, dat_onehot, dat_label], axis=1)\\n elif flag_onehot:\\n dat_new = pd.concat([dat_numeric, dat_onehot], axis=1)\\n elif flag_label:\\n dat_new = pd.concat([dat_numeric, dat_label], axis=1)\\n else:\\n dat_new = dat_numeric\\n dat_new = pd.concat([dat_new, dat_y], axis=1)\\n # imputation\\n dat_new = dat_new.dropna(axis=1, how='all')\\n if dat_new.isna().sum().sum() > 0:\\n logger.info('Nan value exist, start to fill na with iterative imputer: ' +\\n str(dat_new.isna().sum().sum()))\\n # include na value, impute with iterative Imputer or simple imputer\\n columns = dat_new.columns\\n imp = IterativeImputer(max_iter=10, random_state=0)\\n # imp = SimpleImputer(missing_values=np.nan, strategy='mean')\\n dat_new = imp.fit_transform(dat_new)\\n dat_new = pd.DataFrame(dat_new, columns=columns)\\n dat_numeric = dat_new.iloc[:, :-1].select_dtypes(include=['float32', 'float64', 'int32', 'int64'])\\n logger.info('End with fill nan')\\n return dat_new, dat_numeric.columns\",\n \"def pre_processing_single(dataset_file_list, pre_process_paras, type='csv'):\\r\\n # parameters\\r\\n take_log = pre_process_paras['take_log']\\r\\n scaling = pre_process_paras['scaling']\\r\\n dataset_list = []\\r\\n data_file = dataset_file_list\\r\\n\\r\\n if type == 'csv':\\r\\n dataset = read_csv(data_file, take_log)\\r\\n elif type == 'txt':\\r\\n dataset = read_txt(data_file, take_log)\\r\\n\\r\\n dataset['gene_exp'] = dataset['gene_exp'].astype(np.float)\\r\\n\\r\\n if scaling: # scale to [0,1]\\r\\n minmax_scale(dataset['gene_exp'], feature_range=(0, 1), axis=1, copy=False)\\r\\n\\r\\n\\r\\n dataset_list.append(dataset)\\r\\n return dataset_list\",\n \"def preprocessing(self, preprocessing):\\n\\n self._preprocessing = preprocessing\",\n \"def preprocess_valid_data(self):\\r\\n print(\\\"* Preprocessing validation data.\\\", flush=True)\\r\\n prep.create_HDF_file(self.C.validation_set)\\r\\n\\r\\n self.print_time_elapsed()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.83073246","0.7156899","0.70585245","0.6997039","0.6968472","0.6931928","0.69065046","0.6890153","0.67705256","0.67405057","0.67354226","0.67354226","0.67354226","0.66801184","0.6675895","0.6633443","0.6612644","0.6601693","0.65921974","0.6591618","0.6570279","0.64980185","0.64963394","0.64728403","0.64538294","0.6446611","0.64443666","0.6439421","0.6407282","0.63361824","0.62836355","0.6238093","0.62354475","0.62324715","0.62279963","0.6220456","0.62096786","0.61837476","0.6147534","0.61120814","0.61117625","0.60978395","0.60891205","0.60791653","0.60737973","0.6058649","0.6044622","0.604278","0.6041766","0.6022969","0.60153943","0.6013667","0.60071856","0.5989812","0.5989812","0.5989812","0.5989812","0.5986198","0.5985986","0.59721535","0.5966576","0.5963805","0.5947322","0.5932107","0.5930237","0.59260905","0.59153146","0.59143776","0.59143776","0.5911202","0.59096014","0.58997995","0.5895835","0.5874311","0.58668375","0.5852233","0.5845279","0.5837454","0.5830396","0.5828041","0.582158","0.5810849","0.5808568","0.58085567","0.5804862","0.5802699","0.5800358","0.57993335","0.5794227","0.5786247","0.5775519","0.57748675","0.57701594","0.575707","0.57514596","0.57495624","0.5740627","0.57398665","0.57319003","0.5715382"],"string":"[\n \"0.83073246\",\n \"0.7156899\",\n \"0.70585245\",\n \"0.6997039\",\n \"0.6968472\",\n \"0.6931928\",\n \"0.69065046\",\n \"0.6890153\",\n \"0.67705256\",\n \"0.67405057\",\n \"0.67354226\",\n \"0.67354226\",\n \"0.67354226\",\n \"0.66801184\",\n \"0.6675895\",\n \"0.6633443\",\n \"0.6612644\",\n \"0.6601693\",\n \"0.65921974\",\n \"0.6591618\",\n \"0.6570279\",\n \"0.64980185\",\n \"0.64963394\",\n \"0.64728403\",\n \"0.64538294\",\n \"0.6446611\",\n \"0.64443666\",\n \"0.6439421\",\n \"0.6407282\",\n \"0.63361824\",\n \"0.62836355\",\n \"0.6238093\",\n \"0.62354475\",\n \"0.62324715\",\n \"0.62279963\",\n \"0.6220456\",\n \"0.62096786\",\n \"0.61837476\",\n \"0.6147534\",\n \"0.61120814\",\n \"0.61117625\",\n \"0.60978395\",\n \"0.60891205\",\n \"0.60791653\",\n \"0.60737973\",\n \"0.6058649\",\n \"0.6044622\",\n \"0.604278\",\n \"0.6041766\",\n \"0.6022969\",\n \"0.60153943\",\n \"0.6013667\",\n \"0.60071856\",\n \"0.5989812\",\n \"0.5989812\",\n \"0.5989812\",\n \"0.5989812\",\n \"0.5986198\",\n \"0.5985986\",\n \"0.59721535\",\n \"0.5966576\",\n \"0.5963805\",\n \"0.5947322\",\n \"0.5932107\",\n \"0.5930237\",\n \"0.59260905\",\n \"0.59153146\",\n \"0.59143776\",\n \"0.59143776\",\n \"0.5911202\",\n \"0.59096014\",\n \"0.58997995\",\n \"0.5895835\",\n \"0.5874311\",\n \"0.58668375\",\n \"0.5852233\",\n \"0.5845279\",\n \"0.5837454\",\n \"0.5830396\",\n \"0.5828041\",\n \"0.582158\",\n \"0.5810849\",\n \"0.5808568\",\n \"0.58085567\",\n \"0.5804862\",\n \"0.5802699\",\n \"0.5800358\",\n \"0.57993335\",\n \"0.5794227\",\n \"0.5786247\",\n \"0.5775519\",\n \"0.57748675\",\n \"0.57701594\",\n \"0.575707\",\n \"0.57514596\",\n \"0.57495624\",\n \"0.5740627\",\n \"0.57398665\",\n \"0.57319003\",\n \"0.5715382\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5916439"},"document_rank":{"kind":"string","value":"66"}}},{"rowIdx":81987,"cells":{"query":{"kind":"string","value":"Generic preprocessing appropriate for text data"},"document":{"kind":"string","value":"def any_text_preprocessing(name):\n return hp.choice('%s' % name, [\n [tfidf(name + '.tfidf')],\n ])"},"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 preprocess(data):\n raise NotImplementedError","def preprocess(self, text):\r\n return text","def _preprocess(self):\n self.data['sentences'] = self.data['text'].apply(self._tokenize_sent)\n self.data['nouns'] = self.data['sentences'].apply(self._get_nouns)\n # self._get_frequent_features()\n # self._compactness_pruning()\n # self._redundancy_pruning()\n # self._get_features()\n self._extract_opinions()","def preprocess(text):\n text = remove_space(text)\n text = clean_special_punctuations(text)\n text = handle_emojis(text)\n text = clean_number(text)\n text = spacing_punctuation(text)\n text = clean_repeat_words(text)\n text = remove_space(text)\n #text = stop(text)# if changing this, then chnage the dims \n #(not to be done yet as its effecting the embeddings..,we might be\n #loosing words)...\n return text","def preprocess(text):\n text = remove_space(text)\n text = clean_special_punctuations(text)\n text = clean_number(text)\n text = decontracted(text)\n text = correct_spelling(text)\n text = spacing_punctuation(text)\n text = spacing_some_connect_words(text)\n text = clean_repeat_words(text)\n text = remove_space(text)\n text = text.lower()\n return text","def preprocess(self, data, label):\n\t\traise NotImplementedError","def preprocess_text(self, seq):\n if self.text_preprocess_fn:\n seq = list(map(self.text_preprocess_fn, seq))\n return seq","def preprocess(self, data):\n logger.info(str(data))\n text = data[0].get(\"data\")\n if text is None:\n text = data[0].get(\"body\") # with txt file\n if isinstance(text, dict):\n logger.info(\" ############## Got Dict !! ##########################\")\n input_text = text['text']\n else:\n input_text = text.decode('utf-8')\n max_length = int(self.setup_config[\"max_length\"])\n logger.info(\"Received text: '%s'\", input_text)\n\n logger.info(input_text)\n # input_text = \"안녕하세요? 반갑습니다. 오늘 날씨가 정말 끝내줘요. 너 너무 사랑스러워요\"\n inputs = self.tokenizer.encode(input_text, max_char_length=max_length, return_attention_mask=True)\n return inputs","def preprocess_data(raw_text):\n try:\n raw_text = raw_text.replace(\"?\", \"Unknown\")\n raw_text = raw_text.replace(\" or \", \", \")\n raw_text = raw_text.replace(\" and \", \", \")\n raw_text = re.sub(\"\\[.*?\\]\", \"\", raw_text)\n raw_text = re.sub(\"\\(.*?\\)\", \"\", raw_text)\n return raw_text.strip().lower()\n except Exception as e:\n print(e.__str__())\n raise e","def preprocess(self,text):\n return preprocess.get_tokens(text)","def preprocess(self,data):\n preprocessObj = PreprocessData()\n preprocess_data = preprocessObj.preprocess(data)\n return preprocess_data","def small_preprocess(data):\r\n \r\n # Remove new line characters\r\n data = [re.sub('\\s+', ' ', sent) for sent in data]\r\n # Remove distracting single quotes\r\n data = [re.sub(\"\\'\", \"\", sent) for sent in data]\r\n\r\n return data","def preprocess(self):","def preprocess_text(text: str) -> Tuple[List[str], Dict]:\n raise NotImplementedError","def _preprocess_training_model(self, data):\n def _pre_process(raw_data):\n \"\"\" Pre-process raw data. \"\"\"\n pattern = re.compile(\n r\"((?<=')\\w\\d.*?(?=')|(?<=\\\")\\w\\d.*?(?=\\\")|[\\w\\d]+)\")\n words = re.findall(pattern, raw_data)\n return ' '.join(list(map(string_utils.snake_case_to_camel, words)))\n\n data_list = []\n # Preprocess the dataset with naming convention, etc.\n with Progress() as progress:\n preprocess_task = progress.add_task('Pre-processing dataset...',\n total=data.shape[0])\n for idx, row in data.iterrows():\n row_data = {}\n for column in ['text', 'key', 'value']:\n row_data[column] = _pre_process(row[column])\n data_list.append(row_data)\n progress.update(preprocess_task, advance=1)\n return pd.DataFrame(data=data_list)","def process_text(self):\n prp1 = preprocessor.Preprocess()\n processed_text = prp1.clean_data(self.text)\n self.vec1 = self.vec.transform(pd.Series(processed_text))","def stage_two_preprocessing(data: pd.Series) -> pd.Series:\n # designed to be run after remove_contractions\n data_ = data.dropna()\n data_ = remove_punctuation(data_)\n data_ = numbers_to_words(data_)\n data_ = remove_stopwords(data_)\n return data_","def preprocessing_a1(self, text):\n # clean description\n cleaned_text = self.text_cleaning(text)\n # preprocess description\n preprocessed_text = self.text_preprocessing_a1(cleaned_text)\n\n return preprocessed_text","def preprocess(sent):\n return sent","def _preprocess(self, txt_seq):\n input = []\n label = []\n punc = \" \"\n for token in txt_seq.split():\n if token in self.punc2id:\n punc = token\n else:\n input.append(self.word2id.get(token, self.word2id[\"<UNK>\"]))\n label.append(self.punc2id[punc])\n punc = \" \"\n input.append(self.word2id[\"<END>\"])\n label.append(self.punc2id[punc])\n input = torch.LongTensor(input)\n label = torch.LongTensor(label)\n # input = np.array(input)\n # label = np.array(label)\n return input, label","def preprocess(text):\n return text.lower()","def preprocess(self):\n pass","def preprocess(self):\n pass","def preprocess(self):\n pass","def preprocessing(text, tokenization=0, rm_stopwords=0, numbers_to_text=0, to_tfidf=0):\n\ttrain_data = pd.DataFrame(columns=['text', 'response'])\n\n\tprep_0 = [strip_non_alphanum(line) for line in text]\n\tprep_1 = [line for line in prep_0 if line.rstrip()]\n\tprep_2 = [strip_multiple_whitespaces(line) for line in prep_1]\n\tprep_3 = [line.lower() for line in prep_2]\n\n\tif to_tfidf == 1:\n\t\t#when using tf_idf, removes single character words given that they are ignored by sklearn's TfidfVectorizer\n\t\tprep_3 = [' '.join([word for word in line.split() if len(word) > 1]) for line in prep_3]\n\n\tif tokenization == 1:\n\t\tprep_3 = [line.split(' ') for line in prep_3]\n\t\t#removes whitespaces from the list\n\t\tprep_3 = [list(filter(None, line)) for line in prep_3]\n\telse:\n\t\tprep_3 = [line[:-1] if line[-1] == \" \" else line for line in prep_3]\n\n\tif numbers_to_text == 1 and tokenization == 1:\n\t\t#convert all numbers to integers and convert these numbers to its written form\n\t\ttemp_prep = []\n\t\tfor sentence in prep_3:\n\t\t\ttemporary_sentence = []\n\t\t\tfor word in sentence:\n\t\t\t\tif str(word).isdigit():\n\t\t\t\t\tconverted_words = num2words(int(word), to='cardinal', lang='pt').split(' ')\n\t\t\t\t\tif to_tfidf == 1 and rm_stopwords == 0:\n\t\t\t\t\t\tconverted_words = [word for word in converted_words if word != 'e']\n\t\t\t\t\ttemporary_sentence.extend(converted_words)\n\t\t\t\telse:\n\t\t\t\t\ttemporary_sentence.append(word)\n\t\t\ttemp_prep.append(temporary_sentence)\n\n\t\tprep_3 = temp_prep\n\telif numbers_to_text == 1 and tokenization == 0:\n\t\t#convert all numbers to integers and convert these numbers to its written form\n\t\ttemp_prep = []\n\t\tfor sentence in prep_3:\n\t\t\ttemporary_sentence = []\n\t\t\tfor word in sentence.split(' '):\n\t\t\t\tif str(word).isdigit():\n\t\t\t\t\tconverted_words = num2words(int(word), to='cardinal', lang='pt').split(' ')\n\t\t\t\t\tif to_tfidf == 1 and rm_stopwords == 0:\n\t\t\t\t\t\tconverted_words = [word for word in converted_words if word != 'e']\n\t\t\t\t\ttemporary_sentence.extend(converted_words)\n\t\t\t\telse:\n\t\t\t\t\ttemporary_sentence.append(word)\n\t\t\ttemporary_sentence = ' '.join(temporary_sentence)\n\t\t\ttemp_prep.append(temporary_sentence)\n\t\tprep_3 = temp_prep\n\n\tif rm_stopwords == 1:\n\t\tstp = set(stopwords.words('portuguese') + list(punctuation))\n\t\tif tokenization == 1:\n\t\t\tprep_3 = [[word for word in sentence if word not in stp] for sentence in prep_3]\n\t\telif tokenization == 0:\n\t\t\tprep_3 = [' '.join([word for word in sentence.split(' ') if word not in stp]) for sentence in prep_3]\n\n\ttmp = pd.DataFrame({'text':prep_3[::2], 'response':prep_3[1::2]})\n\ttrain_data = train_data.append(tmp[['text', 'response']], ignore_index=True)\n\n\treturn train_data","def preprocess_training_text(text, accented_chars=True, \n convert_num=False, extra_whitespace=True, \n lemmatization=True, lowercase=True, punctuations=True,\n remove_html=True, remove_num=True, special_chars=True, \n stop_words=True):\n \n\n \"\"\"preprocess text with default option set to true for all steps\"\"\"\n if remove_html == True: #remove html tags\n text = strip_html_tags(text)\n if extra_whitespace == True: #remove extra whitespaces\n text = remove_whitespace(text)\n if accented_chars == True: #remove accented characters\n text = remove_accented_chars(text)\n if lowercase == True: #convert all characters to lowercase\n text = text.lower()\n \n \n doc = nlp(text) #tokenise text\n\n\n clean_text = []\n for token in doc:\n flag = True\n edit = token.text\n # print(\"Word: \", edit, \" Type: \", token.pos_)\n # remove stop words\n if stop_words == True and token.is_stop and token.pos_ != 'NUM': \n flag = False\n # remove punctuations\n if punctuations == True and (token.pos_ == 'PUNCT') and flag == True: \n flag = False\n \n # remove 'X' characters:\n if token.pos_ == 'X':\n flag = False\n # remove special characters\n if special_chars == True and token.pos_ == 'SYM' and flag == True: \n flag = False\n # remove numbers\n if remove_num == True and (token.pos_ == 'NUM' or token.text.isnumeric()) \\\n and flag == True:\n flag = False\n # convert number words to numeric numbers\n if convert_num == True and token.pos_ == 'NUM' and flag == True:\n edit = w2n.word_to_num(token.text)\n # convert tokens to base form\n elif lemmatization == True and token.lemma_ != \"-PRON-\" and flag == True:\n edit = token.lemma_\n # append tokens edited and not removed to list \n if edit != \"\" and flag == True:\n clean_text.append(edit)\n \n # Convert back to string:\n new_text = ' '.join(clean_text)\n regex = re.compile('[^a-zA-Z]')\n new_text = regex.sub(' ', new_text)\n words = re.findall(r'\\w+.', new_text)\n return ' '.join(words)","def preprocess_raw_text(self, lower_case = True, punctuation = \"delete\"):\n\n\n\t\tprocessed_text = []\n\t\tfor line in self.raw:\n\t\t\tprocessed_line = self.process_line(line, lower_case, punctuation)\n\t\t\tif len(processed_line):\n\t\t\t\tprocessed_text.append(processed_line)\n\n\t\tself.processed_text = processed_text","def preprocess(self, text):\n if self.model_name == \"bert-base-arabert\":\n return self._old_preprocess(\n text,\n do_farasa_tokenization=True,\n )\n\n if self.model_name == \"bert-base-arabertv01\":\n return self._old_preprocess(text, do_farasa_tokenization=False)\n\n text = str(text)\n text = html.unescape(text)\n if self.strip_tashkeel:\n text = araby.strip_tashkeel(text)\n if self.strip_tatweel:\n text = araby.strip_tatweel(text)\n\n if self.replace_urls_emails_mentions:\n # replace all possible URLs\n for reg in url_regexes:\n text = re.sub(reg, \" [رابط] \", text)\n # REplace Emails with [بريد]\n for reg in email_regexes:\n text = re.sub(reg, \" [بريد] \", text)\n # replace mentions with [مستخدم]\n text = re.sub(user_mention_regex, \" [مستخدم] \", text)\n\n if self.remove_html_markup:\n # remove html line breaks\n text = re.sub(\"<br />\", \" \", text)\n # remove html markup\n text = re.sub(\"</?[^>]+>\", \" \", text)\n\n # remove repeated characters >2\n if self.remove_elongation:\n text = self._remove_elongation(text)\n\n # insert whitespace before and after all non Arabic digits or English Digits and Alphabet and the 2 brackets\n if self.insert_white_spaces:\n text = re.sub(\n \"([^0-9\\u0621-\\u063A\\u0641-\\u064A\\u0660-\\u0669a-zA-Z\\[\\]])\",\n r\" \\1 \",\n text,\n )\n\n # insert whitespace between words and numbers or numbers and words\n text = re.sub(\n \"(\\d+)([\\u0621-\\u063A\\u0641-\\u064A\\u0660-\\u066C]+)\", r\" \\1 \\2 \", text\n )\n text = re.sub(\n \"([\\u0621-\\u063A\\u0641-\\u064A\\u0660-\\u066C]+)(\\d+)\", r\" \\1 \\2 \", text\n )\n\n # remove unwanted characters\n if self.keep_emojis:\n emoji_regex = \"\".join(list(self.emoji.UNICODE_EMOJI[\"en\"].keys()))\n rejected_chars_regex2 = \"[^%s%s]\" % (chars_regex, emoji_regex)\n text = re.sub(rejected_chars_regex2, \" \", text)\n else:\n text = re.sub(rejected_chars_regex, \" \", text)\n\n # remove extra spaces\n text = \" \".join(text.replace(\"\\uFE0F\", \"\").split())\n\n if (\n self.model_name == \"bert-base-arabertv2\"\n or self.model_name == \"bert-large-arabertv2\"\n ):\n if self.keep_emojis:\n new_text = []\n for word in text.split():\n if word in list(self.emoji.UNICODE_EMOJI[\"en\"].keys()):\n new_text.append(word)\n else:\n new_text.append(self.farasa_segmenter.segment(word))\n text = \" \".join(new_text)\n else:\n text = self.farasa_segmenter.segment(text)\n return self._farasa_segment(text)\n\n # ALl the other models dont require Farasa Segmentation\n return text","def preprocess(data):\n\n #remove urls and convert to lowercase\n #used this thread for help on urls: https://stackoverflow.com/questions/11331982/how-to-remove-any-url-within-a-string-in-python\n remove_url = [re.sub(r'^https?:\\/\\/.*[\\r\\n]*', '', x) for x in data]\n lower=[x.lower() for x in remove_url]\n\n #remove all non alphanumeric chars and empty strings\n return filter(None, [re.sub(r'\\W','',x) for x in lower])","def preprocess_text(text: str):\n # remove trailing/leading whitespace\n text = text.strip()\n\n # .lower() depends on model so doing this in collate function\n\n # TODO other preprocessing - punctuation/ascii etc.\n text = text.replace(\"\\\\n\", \" \")\n # text = text.replace(\"\\\\'\", \"\\'\")\n # text = text.replace('\\\\\"', \"\\'\")\n text = text.encode('ascii', 'ignore').decode()\n\n return text","def preprocess_text(text):\n \n preprocessed = text.lower()\n preprocessed = re.sub('[%s]' % re.escape(string.punctuation), '', preprocessed)\n preprocessed = re.sub('\\w*\\d\\w*','', preprocessed)\n \n return [preprocessed]","def preprocess_raw(self):\n pass","def bert_preprocess(raw_text):\n nlp = English()\n nlp.add_pipe(nlp.create_pipe('sentencizer')) # updated\n doc = nlp(raw_text)\n sentences = [sent.string.strip() for sent in doc.sents][0:2] \n new_sentences = []\n for i, sentence in enumerate(sentences):\n if i==0:\n new_sentences.append(\"[CLS] \" + sentence + \" [SEP]\")\n else:\n new_sentences.append(sentence + \" [SEP]\")\n \n preprocessed_text = ' '.join(new_sentences)\n \n if \"[CLS]\" not in preprocessed_text:\n raise Exception(\"[CLS] not found in preprocessed text\")\n if \"[SEP]\" not in preprocessed_text:\n raise Exception(\"[SEP] not found in preprocessed text\")\n \n return","def stage_one_preprocessing(data: pd.Series) -> pd.Series:\n data_ = data.dropna()\n print('ascii')\n data_ = remove_non_ascii(data)\n print('lower')\n data_ = to_lowercase(data_)\n print('slash')\n data_ = underscore_and_slash_to_space(data_)\n print('ellipse')\n data_ = remove_ellipses(data_)\n print('white')\n data_ = shrink_whitespace(data_)\n #print('contracts')\n #data_ = remove_contractions(data_)\n return data_","def preprocessing(raw_text_df):\r\n \r\n stemmer = nltk.stem.porter.PorterStemmer()\r\n tokenizer = RegexpTokenizer(r'\\w+')\r\n # iterate over all lines for preprocessing\r\n for index, line in enumerate(raw_text_df):\r\n \r\n # if there is mention of stars from 1-5, change the integer into\r\n # text and combine the number and the word \"star\" to make a new word\r\n # example: \"I give this product 1 star\" is now \"I give this product onestar\"\r\n # why? numbers are removed as part of preprocessing\r\n if \"1 star\" in line:\r\n line = line.replace(\"1 star\", \"onestar\")\r\n if \"1 stars\" in line:\r\n line = line.replace(\"1 stars\", \"onestar\")\r\n if \"2 star\" in line:\r\n line = line.replace(\"2 star\", \"twostars\")\r\n if \"2 stars\" in line:\r\n line = line.replace(\"2 stars\", \"twostars\")\r\n if \"3 star\" in line:\r\n line = line.replace(\"3 star\", \"threestars\")\r\n if \"3 stars\" in line:\r\n line = line.replace(\"3 stars\", \"threestars\")\r\n if \"4 star\" in line:\r\n line = line.replace(\"4 star\", \"fourstars\")\r\n if \"4 stars\" in line:\r\n line = line.replace(\"4 stars\", \"fourstars\")\r\n if \"5 star\" in line:\r\n line = line.replace(\"5 star\", \"fivestars\")\r\n if \"5 stars\" in line:\r\n line = line.replace(\"5 stars\", \"fivestars\")\r\n \r\n # tokenize lines\r\n tokens = re.split('(\\d+)',line)\r\n # remove numbers\r\n no_digits = [w for w in tokens if not w.isdigit()]\r\n # join tokens\r\n joined_text = \" \".join(no_digits)\r\n # re tokenize\r\n tokens = tokenizer.tokenize(joined_text)\r\n # make tokens lowercase\r\n lower_tokens = [w.lower() for w in tokens if type(w) == str] \r\n # remove stopwords\r\n stopped_tokens = [w for w in lower_tokens if not w in stopwords.words('english')]\r\n # stem words\r\n clean_tokens = [stemmer.stem(w) for w in stopped_tokens]\r\n # join text\r\n joined_text = \" \".join(clean_tokens)\r\n # replace line with preprocessed line\r\n raw_text_df[index] = joined_text\r\n print(index)","def preprocess_text(text: str, normalize=True, lowercase=True, stopwords=True, contractions=True, vulgar_words=True,\n emails=True, punctuation=True, ngrams='uni', ngrams_model_func: Callable = None, lemmatize=True,\n stem=False, apostrophes=True, chars=True) -> str:\n\n if normalize:\n # TODO: Problem: Here we can have 'USA,' and the 'USA' in the .txt file doesn't match that.\n text = normalize_words(text)\n if lowercase:\n text = to_lowercase(text)\n if stopwords:\n text = remove_stopwords(text)\n if contractions:\n text = expand_contractions(text)\n if vulgar_words:\n text = substitute_vulgar_words(text)\n if emails:\n text = remove_emails(text)\n if punctuation:\n text = substitute_punctuation(text)\n if stopwords:\n text = remove_stopwords(text)\n if ngrams == 'bi' or ngrams == 'tri':\n text = ' '.join(ngrams_model_func(text.split()))\n if lemmatize:\n text = lemmatize_words(text)\n elif stem:\n text = stem_words(text)\n if apostrophes: # TODO: Move below substitute_punctuation?\n text = remove_apostrophes(text)\n if chars:\n text = remove_single_chars(text)\n\n return text","def preprocessing(data):\n #tokenizer = RegexpTokenizer(r'\\w+') # allow charachter only\n #words = tokenizer.tokenize(data) # tokenize : convert to words\n words = word_tokenize(data)\n # remove stop words & stemming\n new_words = []\n for word in words:\n if word not in stop_words:\n new_words.append(stemmer.stem(word)) # append to new words with stemming\n \n if '' in new_words: new_words.remove('') # remove space from list\n #print(\"Preprocessing : {}\".format(new_words))\n return new_words","def process_text(document):\n return preprocess_string(document,\n filters=[strip_tags, strip_punctuation,\n strip_multiple_whitespaces,\n strip_numeric, remove_stopwords,\n strip_short]\n )","def preprocessing(ct):\n return value_preprocessing(ct, False)","def preProcess(text):\n\ttext = text.lower() # lower case the text\n\t# Q4 replace the word with expanded contractions\n\tfor k,v in general_contraction.items():\n\t\tif k in text.split():\n\t\t\ttext = text.replace(k,v)\n\t# Q4 remove speacial char including all puncuattions and replace it with a space\n\ttext = re.sub('[^A-Za-z0-9]+',' ',text) \n\t# tokenise\n\ttokens = text.split()\n\t# stop word removal\n\ttokens = [w for w in tokens if w not in stopwords ]\n\t# Q4 Stemming\n\ttokens = [str(porter.stem(w)) for w in tokens]\n\t# if word is non-english return its english form # too much time-complexity\n\t# tokens = [porter.stem(w) if porter.stem(w) in set(words.words()) else w for w in tokens ]\n\t# for words having digits such as 12gb, 1st, etc expanding the token list\n\tfor k in tokens:\n\t\tif len(k) >2 and re.match(r'[0-9]+',k):\t\t\t\n\t\t\tif len(k) >2 and not k.isdigit():\n\t\t\t\tl = re.split(r'(\\d+)',k)\n\t\t\t\tl = [w for w in l if w is not '' ]\n\t\t\t\tif l and len(l) <= 3:\n\t\t\t\t\tfor i in l:\n\t\t\t\t\t\tif i in digit_contractions.keys():\n\t\t\t\t\t\t\tl = list(map(lambda b: b.replace(i,digit_contractions[i]), l))\n\t\t\t\t\ttokens.remove(k)\n\t\t\t\t\ttokens = tokens+l\n\t\t\t\telse:\n\t\t\t\t\ttokens.remove(k)\n\tfor k,v in digit_contractions.items():\n\t\tif k in tokens:\n\t\t\tif tokens[tokens.index(k)-1].isdigit():\t\n\t\t\t\ttokens = list(map(lambda b: b.replace(k,v), tokens))\n\t# remove tokens of size less than 2\n\ttokens = [t for t in tokens if len(t) > 2]\n\treturn tokens","def preprocess_text(self):\n self.text_received = self.text_received.replace(\" \", \"\").lower()","def test_text_preprocesing(self):\n input_text = \"ABCabc123!@#\"\n processed_text = (\n preprocessing.preprocess_text(input_text, remove_punctuation=True, to_lower=True)\n .numpy()\n .decode(\"utf-8\")\n )\n\n # Converting to lower case\n assert processed_text.lower() == processed_text\n\n # Removing punctuation\n assert (\n processed_text.translate(str.maketrans(\"\", \"\", string.punctuation)) == processed_text\n )\n\n # Overall\n assert processed_text.replace(\"\\x00\", \"\") == input_text.lower().translate(\n str.maketrans(\"\", \"\", string.punctuation)\n )\n assert processed_text.replace(\"\\x00\", \"\") == \"abcabc123\"","def text_preprocessing_pdf(self,p):\n #remover_end_paragraphs=np.vectorize(self.remove_end_paragraphs,otypes=[str])\n cleaner=np.vectorize(self.remove_non_alpha,otypes=[str])\n cut_text=np.vectorize(self.cut_text,otypes=[str])\n cut_text_raw=np.vectorize(self.cut_text_raw,otypes=[str])\n assert len(self.parser)==len(self.parser_raw), \"Length of the treated sentence treated list does not match length of raw text list: {} / {}\".format(len(self.parser),len(self.parser_raw))\n cut_text_raw(p)\n p=cleaner(p)\n cut_text(p)\n return p","def _build_preprocessing(self):\n\n # For now, do nothing\n pass","def convert_txt_to_data():\n pass","def parse_preproc(key, content):\n if inspect.isclass(key):\n pp = key(**content)\n key = pp.__class__.__name__.lower()\n elif key.lower() == 'none':\n pp = DummyNone()\n elif key.lower() == 'recenter':\n pp = StandardScaler(with_mean=True, with_std=False)\n elif key.lower() == 'standardize':\n pp = StandardScaler(with_mean=True, with_std=True)\n elif key.lower() == 'normalize':\n content.setdefault('norm', 'l2')\n # pp = Normalizer(norm=content[1][0])\n pp = Normalizer(**content)\n elif key.lower() == 'minmax':\n content.setdefault('feature_range', (0, 1))\n pp = MinMaxScaler(**content)\n else:\n pp = DummyNone()\n return (key, pp, 'preproc')","def preprocess_input(x, data_format=None): # pylint: disable=unused-argument\n return x","def preprocess(words):\n words = to_lowercase(words)\n words = remove_punctuation(words)\n words = replace_numbers(words)\n return words","def _preprocess(self, txt_seq):\n input = []\n for token in txt_seq.split():\n input.append(self.word2id.get(token, self.word2id[\"<UNK>\"]))\n input.append(self.word2id[\"<END>\"])\n input = torch.LongTensor(input)\n return input","def preprocess_input(self, text):\n text = re.sub(r\"([^a-zA-Z0-9 -]+ +[^a-zA-Z0-9 -]*|[^a-zA-Z0-9 -]*\" +\n \" +[^a-zA-Z0-9 -]+)\", ' ', text, flags=re.UNICODE)\n text = re.sub(r\"([^a-zA-Z0-9 -]+$|^[^a-zA-Z0-9 -]+)\", '', text)\n text = re.sub(r\"([a-zA-Z0-9 -]+?)([^a-zA-Z0-9 -])([a-zA-Z0-9 -]+?)\",\n r\"\\1'\\3\", text, flags=re.UNICODE)\n text = re.sub(r\"([\\x00-\\x7F -]+?)([^a-zA-Z0-9 -]+)([\\x00-\\x7F -]+?)\",\n r\"\\1'\\3\", text, flags=re.UNICODE).encode(\"utf-8\")\n return re.sub(r\"([^a-zA-Z0-9 \\-\\'])\", '', text, flags=re.UNICODE)","def preprocessing_transform(self, x):\n if isinstance(self.column_text, int) and self.column_text not in x.columns:\n col = self.column_text\n else:\n col = list(x.columns).index(self.column_text)\n\n ct = x.shape[0]\n # INPUTS\n if self.method_embedding.lower() in ['roberta', \"camembert\", \"xlm-roberta\"]:\n ids = np.ones((ct, self.maxlen), dtype='int32')\n else:\n ids = np.zeros((ct, self.maxlen), dtype='int32')\n att = np.zeros((ct, self.maxlen), dtype='int32')\n tok = np.zeros((ct, self.maxlen), dtype='int32')\n\n for k in range(ct):\n text = \" \" + \" \".join(x.iloc[k, col].split())\n\n if self.method_embedding == 'RoBERTa':\n enc = self.tokenizer.encode(text)\n else:\n enc = self.tokenizer.encode(text, max_length=self.maxlen, truncation=True)\n\n # CREATE BERT INPUTS\n if self.method_embedding == 'RoBERTa':\n ids[k, :len(enc.ids)] = enc.ids[:self.maxlen]\n att[k, :len(enc.ids)] = 1\n else:\n ids[k, :len(enc)] = enc\n att[k, :len(enc)] = 1\n\n x_preprocessed = [ids, att, tok]\n if self.dimension_embedding == 'word_embedding':\n return x_preprocessed\n else:\n model_extractor = self.model_extract_document_embedding()\n document_embedding = model_extractor.predict(x_preprocessed)\n return document_embedding","def preprocessing(raw_text):\n words_list = tokenize(raw_text)\n words_list = remove_stop_words(words_list)\n words_list = remove_punctuations(words_list)\n words_list = lemmatization(words_list)\n return words_list","def process_text(self, text, language):","def _preprocess_text(text: List[str], tokenizer: Any, max_length: int=512, truncation: bool=True, sort_according_length: bool=True, own_tokenizer: bool=False) ->Tuple[Dict[str, Tensor], Optional[Tensor]]:\n if not own_tokenizer:\n tokenized_data = tokenizer(text, padding='max_length', max_length=max_length, truncation=truncation, return_tensors='pt')\n else:\n try:\n tokenized_data = tokenizer(text, max_length)\n except BaseException as e:\n raise BaseException(f'Tokenization was not successful: {e}')\n if sort_according_length:\n input_ids, attention_mask, sorting_indices = _sort_data_according_length(tokenized_data['input_ids'], tokenized_data['attention_mask'])\n input_dict = {'input_ids': input_ids, 'attention_mask': attention_mask}\n else:\n input_dict = {'input_ids': tokenized_data['input_ids'], 'attention_mask': tokenized_data['attention_mask']}\n sorting_indices = None\n return input_dict, sorting_indices","def small_preprocess_singlerow(data):\r\n # Remove new line characters\r\n data = re.sub('\\s+', ' ', data) \r\n # Remove distracting single quotes\r\n data = re.sub(\"\\'\", \"\", data)\r\n\r\n return data","def process_single_text(self, text, punctuation_remover, digit_remover, word_prepro_func, stopwords):\n data = {}\n sents = sent_tokenize(text.lower())\n words = []\n for sent in sents:\n # remove punctuation content\n sent = self.handle_punctuation(sent, punctuation_remover)\n words.extend(word_tokenize(sent))\n # words = text_to_word_sequence(text, filters=filt, lower=True, split=' ')\n # words = [w.lower() for w in self.nltk_tokenizer.tokenize(text)]\n\n # remove stopwords and numbers\n # words = [w.translate(digit_remover) for w in words if w not in stopwords and w.isalpha()]\n # remove empty \"words\"\n words = [w for w in words if w]\n if self.remove_digits:\n words = [w for w in [w.translate(digit_remover) for w in words] if w]\n if self.filter_stopwords:\n words = [w for w in words if w not in stopwords]\n data[\"words\"] = words\n if self.config.extract_pos:\n # pos tagging\n data[\"pos\"] = nltk.pos_tag(words)\n # stemming / lemmatization\n if self.config.prepro is not None:\n data[\"words\"] = [word_prepro_func((w, p)) for (w, p) in zip(words, data[\"pos\"])]\n # if not data[\"words\"]:\n # # warning(\"Text preprocessed to an empty list:\\n{}\".format(text))\n # return None\n return data","def preprocess(text, freq=5):\n text = re.sub(r\"[^A-Za-z0-9(),!?\\'\\`]\", \" \", text)\n text = re.sub(r\"\\'s\", \" \\'s\", text)\n text = re.sub(r\"\\'ve\", \" \\'ve\", text)\n text = re.sub(r\"n\\'t\", \" n\\'t\", text)\n text = re.sub(r\"\\'re\", \" \\'re\", text)\n text = re.sub(r\"\\'d\", \" \\'d\", text)\n text = re.sub(r\"\\'ll\", \" \\'ll\", text)\n text = re.sub(r\",\", \" , \", text)\n text = re.sub(r\"!\", \" ! \", text)\n text = re.sub(r\"\\(\", \" \\( \", text)\n text = re.sub(r\"\\)\", \" \\) \", text)\n text = re.sub(r\"\\?\", \" \\? \", text)\n text = re.sub(r\"\\s{2,}\", \" \", text)\n\n words_raw = text.strip().lower().split()\n word_counts = Counter(words_raw)\n words = [w for w in words_raw if word_counts[w] > freq]\n vocab = set(words)\n vocab2index = {w: idx for idx, w in enumerate(vocab)}\n index2vocab = {idx: w for idx, w in enumerate(vocab)}\n words_int = [vocab2index[w] for w in words]\n return words_int, vocab2index, index2vocab","def preprocess_data(self, data, scale_data=True):\n print(\"preprocess_data not implemented\")\n return data","def create_clean_text(data, text_type):\n stop = stopwords.words('english')\n data['{}'.format(text_type)] = data['{}'.format(text_type)].apply(lambda x: x.replace(' $end$', \".\"))\n data['{}'.format(text_type)] = data['{}'.format(text_type)].apply(\n lambda x: x.replace(' $acceptance criteria:$', \".\"))\n data['clean_text'] = data.apply(lambda x: clean_text(x['{}'.format(text_type)], x['project_key']), axis=1)\n basic_pre_processing(data)","def preprocess_text(text, tokenize=False, ner=False, stem=False, stopw=False, all_lower=False, strip_punct=True):\n\n # Clean the text\n text = re.sub(r\"what's\", \"what is \", text)\n text = re.sub(r\"\\'s\", \" \", text)\n text = re.sub(r\"\\'ve\", \" have \", text)\n text = re.sub(r\"can't\", \"cannot \", text)\n text = re.sub(r\"n't\", \" not \", text)\n text = re.sub(r\"i'm\", \"i am \", text)\n text = re.sub(r\"\\'re\", \" are \", text)\n text = re.sub(r\"\\'d\", \" would \", text)\n text = re.sub(r\"\\'ll\", \" will \", text)\n text = re.sub(r\"i\\.e\\.\", \"\", text)\n text = re.sub(r\"\\.\", \" . \", text)\n text = re.sub(r\"!\", \" ! \", text)\n text = re.sub(r\"\\/\", \" \", text)\n text = re.sub(r\"\\^\", \" ^ \", text)\n text = re.sub(r\"\\+\", \" + \", text)\n text = re.sub(r\"\\-\", \" - \", text)\n text = re.sub(r\"\\=\", \" = \", text)\n text = re.sub(r\"'\", \" \", text)\n text = re.sub(r'\"', \" \", text)\n text = re.sub(r\"(\\d+)(k)\", r\"\\g<1>000\", text)\n text = re.sub(r\":\", \" : \", text)\n text = re.sub(r\" e g \", \" eg \", text)\n text = re.sub(r\"^e g \", \" eg \", text)\n text = re.sub(r\" b g \", \" bg \", text)\n text = re.sub(r\"^b g \", \" bg \", text)\n text = re.sub(r\" u s \", \" american \", text)\n text = re.sub(r\"^u s \", \" american \", text)\n text = re.sub(r\"\\0s\", \"0\", text)\n text = re.sub(r\" 9 11 \", \"911\", text)\n text = re.sub(r\"e - mail\", \"email\", text)\n text = re.sub(r\"j k\", \"jk\", text)\n text = re.sub(r\"\\s{2,}\", \" \", text)\n text = re.sub(r\"\\b[a-zA-Z]\\b\", \"\", text)\n\n if ner:\n tokenized_text = word_tokenize(text)\n tagged_text = pos_tag(tokenized_text)\n chunked_text = ne_chunk(tagged_text, binary=True)\n\n named_entities = extract_entity_names(chunked_text)\n for named_entity in named_entities:\n entity = named_entity.replace(\".\", \"\")\n entity = re.sub(r'\\s+', \"_\", entity)\n text = text.replace(named_entity, entity)\n\n if all_lower:\n text = text.lower()\n\n if stopw:\n global stops\n if stops is None:\n try:\n stops = set(stopwords.words(\"english\"))\n except Exception as e:\n print(\"%s - Please download english stopwords from NLTK\" % e)\n exit()\n text = [word.strip() for word in text.split() if word not in stops]\n text = \" \".join(text)\n\n if tokenize:\n text = word_tokenize(text)\n text = \" \".join(text)\n\n # shorten words to their stems\n if stem:\n text = text.split()\n stemmer = SnowballStemmer('english')\n stemmed_words = [stemmer.stem(word) for word in text]\n text = \" \".join(stemmed_words)\n\n if strip_punct:\n text = text.translate(str.maketrans('', '', string.punctuation))\n\n text = text.strip()\n\n # Empty string\n if text == '':\n return EMPTY_TOKEN\n\n return text","def preprocess(doc_in, doc_out):\n def output(text, doc_id):\n doc_out.write(doc_id + \"\\n\")\n doc_out.write(text.replace(\"\\n\", \" \") + \"\\n\\n\")\n\n def filter_text(t):\n filtered_out = [\"<P>\", \"</P>\"]\n r = t\n for f in filtered_out:\n r = r.replace(f, \" \")\n return r\n\n\n doc_id = None\n reading_text = False\n text = \"\"\n for line in doc_in:\n if(str_text_start in line):\n if(reading_text):\n warning(\"Found \" + str_text_start + \" in text\")\n if(not doc_id):\n warning(\"Reading text without knowing id\")\n continue\n reading_text = True\n continue\n if((str_text_stop in line) and reading_text):\n output(text, doc_id)\n text = \"\"\n reading_text = False\n doc_id = None\n doc_id_match = pat_doc_no.match(line)\n if(doc_id_match):\n doc_id = doc_id_match.group(1)\n if(reading_text):\n warning(\"Found doc id in text\")\n continue\n if(reading_text):\n text = text + filter_text(line)","def preprocess(self, data_f):\n \n return self.vec.transform(data_f.review)","def pre_process(text):\n # replace (,.'\") with ''\n text = text.replace(',', '')\n text = text.replace('.', '')\n text = text.replace(\"'\", '')\n text = text.replace(\"\\\"\", '')\n\n # tokenize into words\n tokens = [word for sent in sent_tokenize(text) for word in word_tokenize(sent)]\n\n # remove stopwords\n stop = stopwords.words('english')\n tokens = [token for token in tokens if token not in stop]\n\n # remove words less than three letters\n tokens = [word for word in tokens if len(word) >= 3]\n\n # lower capitalization\n tokens = [word.lower() for word in tokens]\n\n # lemmatize\n lmtzr = WordNetLemmatizer()\n tokens = [lmtzr.lemmatize(word) for word in tokens]\n\n return tokens","def preprocess_note(text):\n # replace redacted info with tokens\n text = replace_redacted(text)\n \n # misc scrubbing\n text = replace_misc(text) \n return text","def transform(self, data):","def post_process_text(self, text):\n\t\treturn text","def preProcessText(col):\n reponct = string.punctuation.replace(\"?\",\"\").replace(\"/\",\"\")\n rehtml = re.compile('<.*>')\n extr = col.str.strip()\n extr = extr.str.replace(rehtml, '', regex=True)\n extr = extr.str.translate(str.maketrans('','',reponct))\n extr = extr.str.replace('[^0-9a-zA-Z?/ ]+', ' ', regex=True)\n extr = extr.str.replace('\\s+', ' ', regex=True)\n extr = extr.str.lower()\n return extr","def preprocess(inpString):\n\n figure = re.compile(r'\\([^\\W\\d_]+ [0-9]+\\.[0-9]+\\)') # i.e (Tablo 3.2)\n out_string = figure.sub('', inpString)\n\n digit_dot = re.compile(r'([0-9]+)\\.([0-9]{3})') # i.e 19.000 --> 19000\n out_string = digit_dot.sub(r'\\1\\2', out_string)\n out_string = digit_dot.sub(r'\\1\\2', out_string)\n\n centigrade = re.compile(r'(°C)|(°c)|(0C)') # °C --> santigrat\n out_string = centigrade.sub(r' santigrat', out_string)\n\n out_string = re.sub(r'°', ' derece', out_string) # ° --> derece\n\n digit_space = re.compile(r'([0-9]+) ([0-9]+)') # 19 000 --> 19000\n out_string = digit_space.sub(r'\\1\\2', out_string)\n\n out_string = re.sub(r'â', 'a', out_string) # Elâzig --> Elazig\n\n spec_hyphen = re.compile(r'([A-Za-z])-([0-9]+)') # G-20 --> G20\n out_string = spec_hyphen.sub(r'\\1\\2', out_string)\n\n out_string = re.sub(r'-', ' ', out_string) # replace hyphen with space\n\n out_string = re.sub(r'%|‰', 'yüzde ', out_string) # % --> yuzde\n\n year = re.compile(\"([0-9]{4})(’|')([a-z]+)\") # 1815'te --> 1815 yilinda\n out_string = year.sub(r'\\1 yılında', out_string)\n\n out_string = re.sub(r' km2', ' kilometrekare', out_string) # converting km2, m, km\n out_string = re.sub(r' m ', ' metre ', out_string)\n out_string = re.sub(r' km ', ' kilometre ', out_string)\n\n out_string = re.sub(r\"(’|')([a-züşöıç]+)\", '', out_string) # turkiye'de --> turkiye\n\n out_string = re.sub(r'([0-9]+),([0-9]+)', r'\\1CBN\\2', out_string) # replacing comma between\n # digits with a placeholder\n\n puncs = string.punctuation + '”' + '“' + '’' + '‘'\n translator = str.maketrans('', '', puncs)\n out_string = out_string.translate(translator) # removing pucntuations\n\n out_string = re.sub(r'CBN', ',', out_string) # bringing back the comma between numbers\n # out_string= out_string.split(' ') #[s.split(' ') for s in out_string.split('#')] #splitting from end of sentences\n # end sentence into words\n\n return out_string","def normalize(data):\n data = lowercase(data)\n data = remove_punct(data)\n data = remove_apostrophes(data)\n data = remove_stopwords(data)\n data = num_to_words(data)\n data = lemmatize(data)\n data = stemming(data)\n data = remove_punct(data)\n data = num_to_words(data)\n data = lemmatize(data)\n data = stemming(data)\n data = remove_punct(data) #done again to remove hyphens produced by num2words\n data = remove_stopwords(data) #done agan to remove stopwords produced by num2words\n return data","def preprocess(\n self, data: List[Dict[str, Any]]\n ) -> Generator[Dict[str, Any], None, None]:\n raise NotImplementedError","def preprocessing_for_bert(self, data):\n # Create empty lists to store outputs\n input_ids = []\n attention_masks = []\n MAX_LEN = self.opt.MAX_QUESTION_LEN\n # For every sentence...\n for sent in data:\n \n encoded_sent = self.tokenizer.encode_plus(\n text=self.text_preprocessing(sent), # Preprocess sentence\n add_special_tokens=True, # Add `[CLS]` and `[SEP]`\n max_length=MAX_LEN, # Max length to truncate/pad\n pad_to_max_length=True, # Pad sentence to max length\n #return_tensors='pt', # Return PyTorch tensor\n truncation=True,\n return_attention_mask=True # Return attention mask\n )\n \n # Add the outputs to the lists\n input_ids.append(encoded_sent.get('input_ids'))\n attention_masks.append(encoded_sent.get('attention_mask'))\n\n # Convert lists to tensors\n input_ids = torch.tensor(input_ids)\n attention_masks = torch.tensor(attention_masks)\n\n return input_ids, attention_masks","def preprocess_sent(sent):\n #tokenized = word_tokenize(sent.lower())\n tokenizer = Tok()\n tokenized = tokenizer.tokenize(sent.lower())\n return tokenized","def process_text(text):\n text = re.sub(r'<@>\\s+|<s>\\s+|</s>\\s+|<p>\\s+|</p>\\s+|\\s+\\,|\\'s|\\'|\\;|\\(|\\)|\\-\\-\\s+|\\s+\\.', '', text)\n text = re.sub(r'\\.\\,', '. ,', text)\n text = re.sub(r'\\,', '', text)\n text = re.sub(r'\\$', '$ ', text)\n text = re.sub(r'\\%', ' %', text)\n text = re.sub(r'\\s\\\"\\s', ' ', text)\n text = re.sub(r'\\.\\s+', '. ', text)\n text = text.lower()\n return text","def process_text(text):\n no_split_dict = {'u . s': 'u.s', 'u . n': 'u.n', 'u . k': 'u.k', 'l . a': 'l.a', 'j . k': 'j.k', 'a . m': 'a.m',\n 'p . m': 'p.m', 'd . j': 'd.j', 'd . a': 'd.a'}\n\n text = re.sub(\".*--\", \"\", text, count=1) # Removing cnn from start of text\n if text.startswith('(CNN)'): # Remove cnn from articles that starts with only cnn\n text = re.sub('\\(CNN\\)', '', text, count=1)\n text = re.sub(r'(?<=[^?!.0-9])(?=[.,!?])', ' ', text) # 4\n text = re.sub(r'(?![0-9])(?<=[.,])(?=[^\\s])', r' ', text) # 4\n text = text.lower() # 2\n text = re.sub('[^A-Za-z0-9 .!?,øæå]+', '', text) # 3\n text = re.sub(r'((?<=[a-z])(?=[.]))|((?=[a-z])(?<=[.]))(?=[^\\s])', r' ', text) # space a-z.a-z\n text = re.sub(r'((?=[0-9])(?<=[a-z]))|((?=[a-z])(?<=[0-9]))(?=[^\\s])', r' ', text) # space 0-9a-z\n for key in no_split_dict:\n text = text.replace(key, no_split_dict[key]) # Fixing word splits\n text = re.sub('[0-9]', '#', text) # 8\n text = \" \".join(text.split()) # 5, 6, 7 - i think\n return text","def _preprocess_fn(data):\n\n # Validate input\n if not isinstance(data, dict) or 'image' not in data:\n raise ValueError('Argument `data` must be a dictionary, '\n 'not %s' % str(type(data)))\n\n # Apply all the individual steps in sequence.\n image = data['image']\n image = decode_image(image)\n image = normalize_value_range(image)\n image = get_multiscale_patches(image, **preprocessing_kwargs)\n\n data['image'] = image\n return data","def prepare_data(self, lines: List[str]) -> List[str]:\n if self.is_tokenized:\n if self.parser == \"spacy\":\n lines = [l.split() for l in lines]\n elif self.parser == \"udpipe\":\n lines = [[l.split()] for l in lines]\n\n return lines","def preprocess_text(text):\n # replace non characers with space and lower case\n temp = re.sub(r\"[/W/D/S.,-]+\", \" \", str(text).lower())\n # merge multiple spaces to a single one\n return re.sub(r\"[ ]+\", \" \", temp)","def preprocess(item):\n item = feature_engineering(item)\n item = encode_features(item)\n return item","def preprocess_and_save_data(self, dataset_path):\n # File starts with copyright line - irrelevant information so remove\n text = self._load_data(dataset_path)\n text = text[81:]\n\n # Replace punctuation as tokens for text processing\n token_dict = self.token_lookup()\n for key, value in token_dict.items():\n text = text.replace(key, ' {} '.format(value))\n\n # Transform text for use in lookup tables\n text = text.lower()\n text = text.split()\n\n # Create lookup tables\n vocab_to_int, int_to_vocab = self._create_lookup_tables(text)\n int_text = [vocab_to_int[word] for word in text]\n\n pickle.dump((int_text, vocab_to_int, int_to_vocab, token_dict),\n open(\"preprocess.p\", \"wb\"))","def preprocess(self, collection: List[str]) -> List[List[str]]:\n # remove bad characters\n col_clean = self.remove_bad_chars(collection)\n # make lower case if applicable\n if self.lowercase:\n col_l = self.lower_case_corpus(col_clean)\n else:\n col_l = col_clean\n if self.n_grams == 1:\n return [s.split() for s in col_l]\n else:\n corpus_tokenized = [s.split() for s in col_l]\n col_n_grams = list()\n for doc in corpus_tokenized:\n# print(f\"doc is: {doc}\")\n if self.n_grams > len(doc):\n raise ValueError(\"n-grams value to large, choose\\\n smaller value\")\n doc_n_grams = list()\n for i in range(len(doc)):\n end_idx = self.n_grams + i\n doc_tmp = \"\"\n if end_idx <= len(doc):\n# print(f\"token added is: {' '.join(doc[i:end_idx])}\")\n doc_tmp = \" \".join(doc[i:end_idx])\n doc_n_grams.append(doc_tmp)\n else:\n break\n col_n_grams.append(doc_n_grams)\n# print(f\"final: {col_n_grams}\")\n return col_n_grams","def process_text(input_txt):\r\n # if input is string\r\n tidy_txt = remove_pattern(input_txt,\"@[\\w]*\")\r\n ##=============================== if input is dataframe ====================##\r\n # tidy_txt = np.vectorize(remove_pattern)(input_txt,\"@[\\w]*\") #\r\n ##==========================================================================##\r\n # remove special characters\r\n tidy_txt = tidy_txt.replace(\"[^a-zA-Z#]\",\" \")\r\n # split into words\r\n tokenized_txt = tidy_txt.split()\r\n # perform stemming\r\n stemmer = PorterStemmer()\r\n tokenized_txt = [stemmer.stem(i) for i in tokenized_txt]\r\n print(tokenized_txt)\r\n # joining words back\r\n tokenized_txt = ' '.join(tokenized_txt)\r\n return tokenized_txt","def preprocess(text):\n\tX = []\n\tsent_detector = nltk.data.load('tokenizers/punkt/english.pickle')\n\tfor t in text:\n\t\tsents = sent_detector.tokenize(t)\n\t\tresult = ''\n\t\tfor s in sents:\n\t\t\ttokens = word_tokenize(s)\n\t\t\tresult += ' ' + ' '.join(tokens)\n\t\tX.append(result)\n\treturn X","def apply(self, text):","def postprocess(self, text):\r\n return text","def preprocess(self):\n\n self._build_labels_dict(['one', 'two', 'three', 'four', 'five'])\n\n with open(self.data_path + self.file_name, 'rb') as csvfile:\n\n reader = csv.reader(csvfile, delimiter=\",\")\n for row in reader:\n self.texts.append(row[1])\n self.labels.append(self.labels_index[row[0]])\n\n print('Found %s texts.' % len(self.texts))","def preprocess_data(self):\n\n self._preprocess_train_data()\n self._preprocess_test_data()","def preprocess(text):\n text_index = list(range(0, len(text), SEG_SIZE))\n segments = [\n text[i: i + SEG_SIZE] + PLACEHOLDER_TEMPLATE.format(PLACEHOLDER, i//SEG_SIZE)\n for i in text_index\n ]\n text_index.append(len(text))\n return text_index[1:], ''.join(segments)","def preprocess(series):\n def delimit(sent):\n \"\"\"Inserts special symbols for start and end into sentence\"\"\"\n arr = sent.split()\n if arr:\n arr.insert(0, '<START>')\n arr.append('<END>')\n else:\n arr = ['<EMPTY>']\n return arr\n return series.apply(delimit)","def preprocess_terms(df, dataType='testNames'):\n pass","def process_text(text, tokenize=tokenize1, filter=filter1, stem=None, lower=True):\n assert tokenize, \"Must provide tokenize method for preprocess_text\"\n if not text: return []\n if lower: text = text.lower()\n words = tokenize(text)\n if filter: words = [w for w in words if filter(w)]\n if stem: words = [stem(w) for w in words]\n return words","def preprocess_document(raw,sentence_level):\r\n\r\n\t# raw = raw.decode(\"utf-8\")\r\n\t# raw = raw.encode(\"ascii\",\"ignore\")\r\n\t\r\n\tfrom nltk.tokenize.punkt import PunktSentenceTokenizer, PunktParameters\r\n\tparam = PunktParameters()\r\n\ttokenizer = PunktSentenceTokenizer(param)\r\n\tif sentence_level:\r\n\t\tsentences = tokenizer.tokenize(raw)\r\n\t\tsentences_words = list()\r\n\t\tfor s in sentences:\r\n\t\t\tsentences_words.append((s.strip(),preprocess_sentence(s)))\r\n\t\treturn sentences_words\r\n\telse:\r\n\t\treturn [(raw.strip(),preprocess_sentence(raw))]","def normalize(self, text: str) -> str:","def preprocess(x):\n\n\tres = re.sub(r'[^\\w\\s]', '', x)\n\tres = res.strip('\\n')\n\n\treturn res","def processText(text_data):\n\tclean_texts = []\n\tfor text in text_data:\n\t\tno_parens = removeParentheses(text)\n\t\tonly_alpha_spaces = removeNonAlphabet(no_parens)\n\t\tone_space = removeExtraSpaces(only_alpha_spaces)\n\n\t\tstemmed_text = stemWords(one_space)\n\n\t\tclean_texts.append(stemmed_text.lower())\n\treturn clean_texts","def preprocessing(self, dataset: tf.data.Dataset) -> tf.data.Dataset:\n # Teacher forcing.\n def preprocess(input_sentence, output_sentence):\n return ((input_sentence, output_sentence[:-1]), output_sentence[1:])\n\n return dataset.map(preprocess)","def preprocess_sub_units(self):\n if self.unit == \"char\":\n self.preprocess_char()\n elif self.unit == \"char-ngram\":\n self.preprocess_char_ngram()\n elif self.unit == \"morpheme\":\n self.preprocess_morpheme()\n elif self.unit == \"oracle\":\n self.preprocess_oracle()\n else:\n sys.exit(\"Unknown unit\")","def preprocess(text):\n text = text.translate(None, string.punctuation)\n words = filter(None, re.split('\\s+', text))\n words = nltk.pos_tag(words)\n words = [(word.lower(), nltk.simplify_wsj_tag(tag)) for word, tag in words]\n words = [(word, 'V') if tag.startswith('V') else (word, tag)\n for word, tag in words]\n return words","def pre_process(cls, *args, **kwargs):\n pass","def pre_process(cls, *args, **kwargs):\n pass","def pre_process(cls, *args, **kwargs):\n pass"],"string":"[\n \"def preprocess(data):\\n raise NotImplementedError\",\n \"def preprocess(self, text):\\r\\n return text\",\n \"def _preprocess(self):\\n self.data['sentences'] = self.data['text'].apply(self._tokenize_sent)\\n self.data['nouns'] = self.data['sentences'].apply(self._get_nouns)\\n # self._get_frequent_features()\\n # self._compactness_pruning()\\n # self._redundancy_pruning()\\n # self._get_features()\\n self._extract_opinions()\",\n \"def preprocess(text):\\n text = remove_space(text)\\n text = clean_special_punctuations(text)\\n text = handle_emojis(text)\\n text = clean_number(text)\\n text = spacing_punctuation(text)\\n text = clean_repeat_words(text)\\n text = remove_space(text)\\n #text = stop(text)# if changing this, then chnage the dims \\n #(not to be done yet as its effecting the embeddings..,we might be\\n #loosing words)...\\n return text\",\n \"def preprocess(text):\\n text = remove_space(text)\\n text = clean_special_punctuations(text)\\n text = clean_number(text)\\n text = decontracted(text)\\n text = correct_spelling(text)\\n text = spacing_punctuation(text)\\n text = spacing_some_connect_words(text)\\n text = clean_repeat_words(text)\\n text = remove_space(text)\\n text = text.lower()\\n return text\",\n \"def preprocess(self, data, label):\\n\\t\\traise NotImplementedError\",\n \"def preprocess_text(self, seq):\\n if self.text_preprocess_fn:\\n seq = list(map(self.text_preprocess_fn, seq))\\n return seq\",\n \"def preprocess(self, data):\\n logger.info(str(data))\\n text = data[0].get(\\\"data\\\")\\n if text is None:\\n text = data[0].get(\\\"body\\\") # with txt file\\n if isinstance(text, dict):\\n logger.info(\\\" ############## Got Dict !! ##########################\\\")\\n input_text = text['text']\\n else:\\n input_text = text.decode('utf-8')\\n max_length = int(self.setup_config[\\\"max_length\\\"])\\n logger.info(\\\"Received text: '%s'\\\", input_text)\\n\\n logger.info(input_text)\\n # input_text = \\\"안녕하세요? 반갑습니다. 오늘 날씨가 정말 끝내줘요. 너 너무 사랑스러워요\\\"\\n inputs = self.tokenizer.encode(input_text, max_char_length=max_length, return_attention_mask=True)\\n return inputs\",\n \"def preprocess_data(raw_text):\\n try:\\n raw_text = raw_text.replace(\\\"?\\\", \\\"Unknown\\\")\\n raw_text = raw_text.replace(\\\" or \\\", \\\", \\\")\\n raw_text = raw_text.replace(\\\" and \\\", \\\", \\\")\\n raw_text = re.sub(\\\"\\\\[.*?\\\\]\\\", \\\"\\\", raw_text)\\n raw_text = re.sub(\\\"\\\\(.*?\\\\)\\\", \\\"\\\", raw_text)\\n return raw_text.strip().lower()\\n except Exception as e:\\n print(e.__str__())\\n raise e\",\n \"def preprocess(self,text):\\n return preprocess.get_tokens(text)\",\n \"def preprocess(self,data):\\n preprocessObj = PreprocessData()\\n preprocess_data = preprocessObj.preprocess(data)\\n return preprocess_data\",\n \"def small_preprocess(data):\\r\\n \\r\\n # Remove new line characters\\r\\n data = [re.sub('\\\\s+', ' ', sent) for sent in data]\\r\\n # Remove distracting single quotes\\r\\n data = [re.sub(\\\"\\\\'\\\", \\\"\\\", sent) for sent in data]\\r\\n\\r\\n return data\",\n \"def preprocess(self):\",\n \"def preprocess_text(text: str) -> Tuple[List[str], Dict]:\\n raise NotImplementedError\",\n \"def _preprocess_training_model(self, data):\\n def _pre_process(raw_data):\\n \\\"\\\"\\\" Pre-process raw data. \\\"\\\"\\\"\\n pattern = re.compile(\\n r\\\"((?<=')\\\\w\\\\d.*?(?=')|(?<=\\\\\\\")\\\\w\\\\d.*?(?=\\\\\\\")|[\\\\w\\\\d]+)\\\")\\n words = re.findall(pattern, raw_data)\\n return ' '.join(list(map(string_utils.snake_case_to_camel, words)))\\n\\n data_list = []\\n # Preprocess the dataset with naming convention, etc.\\n with Progress() as progress:\\n preprocess_task = progress.add_task('Pre-processing dataset...',\\n total=data.shape[0])\\n for idx, row in data.iterrows():\\n row_data = {}\\n for column in ['text', 'key', 'value']:\\n row_data[column] = _pre_process(row[column])\\n data_list.append(row_data)\\n progress.update(preprocess_task, advance=1)\\n return pd.DataFrame(data=data_list)\",\n \"def process_text(self):\\n prp1 = preprocessor.Preprocess()\\n processed_text = prp1.clean_data(self.text)\\n self.vec1 = self.vec.transform(pd.Series(processed_text))\",\n \"def stage_two_preprocessing(data: pd.Series) -> pd.Series:\\n # designed to be run after remove_contractions\\n data_ = data.dropna()\\n data_ = remove_punctuation(data_)\\n data_ = numbers_to_words(data_)\\n data_ = remove_stopwords(data_)\\n return data_\",\n \"def preprocessing_a1(self, text):\\n # clean description\\n cleaned_text = self.text_cleaning(text)\\n # preprocess description\\n preprocessed_text = self.text_preprocessing_a1(cleaned_text)\\n\\n return preprocessed_text\",\n \"def preprocess(sent):\\n return sent\",\n \"def _preprocess(self, txt_seq):\\n input = []\\n label = []\\n punc = \\\" \\\"\\n for token in txt_seq.split():\\n if token in self.punc2id:\\n punc = token\\n else:\\n input.append(self.word2id.get(token, self.word2id[\\\"<UNK>\\\"]))\\n label.append(self.punc2id[punc])\\n punc = \\\" \\\"\\n input.append(self.word2id[\\\"<END>\\\"])\\n label.append(self.punc2id[punc])\\n input = torch.LongTensor(input)\\n label = torch.LongTensor(label)\\n # input = np.array(input)\\n # label = np.array(label)\\n return input, label\",\n \"def preprocess(text):\\n return text.lower()\",\n \"def preprocess(self):\\n pass\",\n \"def preprocess(self):\\n pass\",\n \"def preprocess(self):\\n pass\",\n \"def preprocessing(text, tokenization=0, rm_stopwords=0, numbers_to_text=0, to_tfidf=0):\\n\\ttrain_data = pd.DataFrame(columns=['text', 'response'])\\n\\n\\tprep_0 = [strip_non_alphanum(line) for line in text]\\n\\tprep_1 = [line for line in prep_0 if line.rstrip()]\\n\\tprep_2 = [strip_multiple_whitespaces(line) for line in prep_1]\\n\\tprep_3 = [line.lower() for line in prep_2]\\n\\n\\tif to_tfidf == 1:\\n\\t\\t#when using tf_idf, removes single character words given that they are ignored by sklearn's TfidfVectorizer\\n\\t\\tprep_3 = [' '.join([word for word in line.split() if len(word) > 1]) for line in prep_3]\\n\\n\\tif tokenization == 1:\\n\\t\\tprep_3 = [line.split(' ') for line in prep_3]\\n\\t\\t#removes whitespaces from the list\\n\\t\\tprep_3 = [list(filter(None, line)) for line in prep_3]\\n\\telse:\\n\\t\\tprep_3 = [line[:-1] if line[-1] == \\\" \\\" else line for line in prep_3]\\n\\n\\tif numbers_to_text == 1 and tokenization == 1:\\n\\t\\t#convert all numbers to integers and convert these numbers to its written form\\n\\t\\ttemp_prep = []\\n\\t\\tfor sentence in prep_3:\\n\\t\\t\\ttemporary_sentence = []\\n\\t\\t\\tfor word in sentence:\\n\\t\\t\\t\\tif str(word).isdigit():\\n\\t\\t\\t\\t\\tconverted_words = num2words(int(word), to='cardinal', lang='pt').split(' ')\\n\\t\\t\\t\\t\\tif to_tfidf == 1 and rm_stopwords == 0:\\n\\t\\t\\t\\t\\t\\tconverted_words = [word for word in converted_words if word != 'e']\\n\\t\\t\\t\\t\\ttemporary_sentence.extend(converted_words)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\ttemporary_sentence.append(word)\\n\\t\\t\\ttemp_prep.append(temporary_sentence)\\n\\n\\t\\tprep_3 = temp_prep\\n\\telif numbers_to_text == 1 and tokenization == 0:\\n\\t\\t#convert all numbers to integers and convert these numbers to its written form\\n\\t\\ttemp_prep = []\\n\\t\\tfor sentence in prep_3:\\n\\t\\t\\ttemporary_sentence = []\\n\\t\\t\\tfor word in sentence.split(' '):\\n\\t\\t\\t\\tif str(word).isdigit():\\n\\t\\t\\t\\t\\tconverted_words = num2words(int(word), to='cardinal', lang='pt').split(' ')\\n\\t\\t\\t\\t\\tif to_tfidf == 1 and rm_stopwords == 0:\\n\\t\\t\\t\\t\\t\\tconverted_words = [word for word in converted_words if word != 'e']\\n\\t\\t\\t\\t\\ttemporary_sentence.extend(converted_words)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\ttemporary_sentence.append(word)\\n\\t\\t\\ttemporary_sentence = ' '.join(temporary_sentence)\\n\\t\\t\\ttemp_prep.append(temporary_sentence)\\n\\t\\tprep_3 = temp_prep\\n\\n\\tif rm_stopwords == 1:\\n\\t\\tstp = set(stopwords.words('portuguese') + list(punctuation))\\n\\t\\tif tokenization == 1:\\n\\t\\t\\tprep_3 = [[word for word in sentence if word not in stp] for sentence in prep_3]\\n\\t\\telif tokenization == 0:\\n\\t\\t\\tprep_3 = [' '.join([word for word in sentence.split(' ') if word not in stp]) for sentence in prep_3]\\n\\n\\ttmp = pd.DataFrame({'text':prep_3[::2], 'response':prep_3[1::2]})\\n\\ttrain_data = train_data.append(tmp[['text', 'response']], ignore_index=True)\\n\\n\\treturn train_data\",\n \"def preprocess_training_text(text, accented_chars=True, \\n convert_num=False, extra_whitespace=True, \\n lemmatization=True, lowercase=True, punctuations=True,\\n remove_html=True, remove_num=True, special_chars=True, \\n stop_words=True):\\n \\n\\n \\\"\\\"\\\"preprocess text with default option set to true for all steps\\\"\\\"\\\"\\n if remove_html == True: #remove html tags\\n text = strip_html_tags(text)\\n if extra_whitespace == True: #remove extra whitespaces\\n text = remove_whitespace(text)\\n if accented_chars == True: #remove accented characters\\n text = remove_accented_chars(text)\\n if lowercase == True: #convert all characters to lowercase\\n text = text.lower()\\n \\n \\n doc = nlp(text) #tokenise text\\n\\n\\n clean_text = []\\n for token in doc:\\n flag = True\\n edit = token.text\\n # print(\\\"Word: \\\", edit, \\\" Type: \\\", token.pos_)\\n # remove stop words\\n if stop_words == True and token.is_stop and token.pos_ != 'NUM': \\n flag = False\\n # remove punctuations\\n if punctuations == True and (token.pos_ == 'PUNCT') and flag == True: \\n flag = False\\n \\n # remove 'X' characters:\\n if token.pos_ == 'X':\\n flag = False\\n # remove special characters\\n if special_chars == True and token.pos_ == 'SYM' and flag == True: \\n flag = False\\n # remove numbers\\n if remove_num == True and (token.pos_ == 'NUM' or token.text.isnumeric()) \\\\\\n and flag == True:\\n flag = False\\n # convert number words to numeric numbers\\n if convert_num == True and token.pos_ == 'NUM' and flag == True:\\n edit = w2n.word_to_num(token.text)\\n # convert tokens to base form\\n elif lemmatization == True and token.lemma_ != \\\"-PRON-\\\" and flag == True:\\n edit = token.lemma_\\n # append tokens edited and not removed to list \\n if edit != \\\"\\\" and flag == True:\\n clean_text.append(edit)\\n \\n # Convert back to string:\\n new_text = ' '.join(clean_text)\\n regex = re.compile('[^a-zA-Z]')\\n new_text = regex.sub(' ', new_text)\\n words = re.findall(r'\\\\w+.', new_text)\\n return ' '.join(words)\",\n \"def preprocess_raw_text(self, lower_case = True, punctuation = \\\"delete\\\"):\\n\\n\\n\\t\\tprocessed_text = []\\n\\t\\tfor line in self.raw:\\n\\t\\t\\tprocessed_line = self.process_line(line, lower_case, punctuation)\\n\\t\\t\\tif len(processed_line):\\n\\t\\t\\t\\tprocessed_text.append(processed_line)\\n\\n\\t\\tself.processed_text = processed_text\",\n \"def preprocess(self, text):\\n if self.model_name == \\\"bert-base-arabert\\\":\\n return self._old_preprocess(\\n text,\\n do_farasa_tokenization=True,\\n )\\n\\n if self.model_name == \\\"bert-base-arabertv01\\\":\\n return self._old_preprocess(text, do_farasa_tokenization=False)\\n\\n text = str(text)\\n text = html.unescape(text)\\n if self.strip_tashkeel:\\n text = araby.strip_tashkeel(text)\\n if self.strip_tatweel:\\n text = araby.strip_tatweel(text)\\n\\n if self.replace_urls_emails_mentions:\\n # replace all possible URLs\\n for reg in url_regexes:\\n text = re.sub(reg, \\\" [رابط] \\\", text)\\n # REplace Emails with [بريد]\\n for reg in email_regexes:\\n text = re.sub(reg, \\\" [بريد] \\\", text)\\n # replace mentions with [مستخدم]\\n text = re.sub(user_mention_regex, \\\" [مستخدم] \\\", text)\\n\\n if self.remove_html_markup:\\n # remove html line breaks\\n text = re.sub(\\\"<br />\\\", \\\" \\\", text)\\n # remove html markup\\n text = re.sub(\\\"</?[^>]+>\\\", \\\" \\\", text)\\n\\n # remove repeated characters >2\\n if self.remove_elongation:\\n text = self._remove_elongation(text)\\n\\n # insert whitespace before and after all non Arabic digits or English Digits and Alphabet and the 2 brackets\\n if self.insert_white_spaces:\\n text = re.sub(\\n \\\"([^0-9\\\\u0621-\\\\u063A\\\\u0641-\\\\u064A\\\\u0660-\\\\u0669a-zA-Z\\\\[\\\\]])\\\",\\n r\\\" \\\\1 \\\",\\n text,\\n )\\n\\n # insert whitespace between words and numbers or numbers and words\\n text = re.sub(\\n \\\"(\\\\d+)([\\\\u0621-\\\\u063A\\\\u0641-\\\\u064A\\\\u0660-\\\\u066C]+)\\\", r\\\" \\\\1 \\\\2 \\\", text\\n )\\n text = re.sub(\\n \\\"([\\\\u0621-\\\\u063A\\\\u0641-\\\\u064A\\\\u0660-\\\\u066C]+)(\\\\d+)\\\", r\\\" \\\\1 \\\\2 \\\", text\\n )\\n\\n # remove unwanted characters\\n if self.keep_emojis:\\n emoji_regex = \\\"\\\".join(list(self.emoji.UNICODE_EMOJI[\\\"en\\\"].keys()))\\n rejected_chars_regex2 = \\\"[^%s%s]\\\" % (chars_regex, emoji_regex)\\n text = re.sub(rejected_chars_regex2, \\\" \\\", text)\\n else:\\n text = re.sub(rejected_chars_regex, \\\" \\\", text)\\n\\n # remove extra spaces\\n text = \\\" \\\".join(text.replace(\\\"\\\\uFE0F\\\", \\\"\\\").split())\\n\\n if (\\n self.model_name == \\\"bert-base-arabertv2\\\"\\n or self.model_name == \\\"bert-large-arabertv2\\\"\\n ):\\n if self.keep_emojis:\\n new_text = []\\n for word in text.split():\\n if word in list(self.emoji.UNICODE_EMOJI[\\\"en\\\"].keys()):\\n new_text.append(word)\\n else:\\n new_text.append(self.farasa_segmenter.segment(word))\\n text = \\\" \\\".join(new_text)\\n else:\\n text = self.farasa_segmenter.segment(text)\\n return self._farasa_segment(text)\\n\\n # ALl the other models dont require Farasa Segmentation\\n return text\",\n \"def preprocess(data):\\n\\n #remove urls and convert to lowercase\\n #used this thread for help on urls: https://stackoverflow.com/questions/11331982/how-to-remove-any-url-within-a-string-in-python\\n remove_url = [re.sub(r'^https?:\\\\/\\\\/.*[\\\\r\\\\n]*', '', x) for x in data]\\n lower=[x.lower() for x in remove_url]\\n\\n #remove all non alphanumeric chars and empty strings\\n return filter(None, [re.sub(r'\\\\W','',x) for x in lower])\",\n \"def preprocess_text(text: str):\\n # remove trailing/leading whitespace\\n text = text.strip()\\n\\n # .lower() depends on model so doing this in collate function\\n\\n # TODO other preprocessing - punctuation/ascii etc.\\n text = text.replace(\\\"\\\\\\\\n\\\", \\\" \\\")\\n # text = text.replace(\\\"\\\\\\\\'\\\", \\\"\\\\'\\\")\\n # text = text.replace('\\\\\\\\\\\"', \\\"\\\\'\\\")\\n text = text.encode('ascii', 'ignore').decode()\\n\\n return text\",\n \"def preprocess_text(text):\\n \\n preprocessed = text.lower()\\n preprocessed = re.sub('[%s]' % re.escape(string.punctuation), '', preprocessed)\\n preprocessed = re.sub('\\\\w*\\\\d\\\\w*','', preprocessed)\\n \\n return [preprocessed]\",\n \"def preprocess_raw(self):\\n pass\",\n \"def bert_preprocess(raw_text):\\n nlp = English()\\n nlp.add_pipe(nlp.create_pipe('sentencizer')) # updated\\n doc = nlp(raw_text)\\n sentences = [sent.string.strip() for sent in doc.sents][0:2] \\n new_sentences = []\\n for i, sentence in enumerate(sentences):\\n if i==0:\\n new_sentences.append(\\\"[CLS] \\\" + sentence + \\\" [SEP]\\\")\\n else:\\n new_sentences.append(sentence + \\\" [SEP]\\\")\\n \\n preprocessed_text = ' '.join(new_sentences)\\n \\n if \\\"[CLS]\\\" not in preprocessed_text:\\n raise Exception(\\\"[CLS] not found in preprocessed text\\\")\\n if \\\"[SEP]\\\" not in preprocessed_text:\\n raise Exception(\\\"[SEP] not found in preprocessed text\\\")\\n \\n return\",\n \"def stage_one_preprocessing(data: pd.Series) -> pd.Series:\\n data_ = data.dropna()\\n print('ascii')\\n data_ = remove_non_ascii(data)\\n print('lower')\\n data_ = to_lowercase(data_)\\n print('slash')\\n data_ = underscore_and_slash_to_space(data_)\\n print('ellipse')\\n data_ = remove_ellipses(data_)\\n print('white')\\n data_ = shrink_whitespace(data_)\\n #print('contracts')\\n #data_ = remove_contractions(data_)\\n return data_\",\n \"def preprocessing(raw_text_df):\\r\\n \\r\\n stemmer = nltk.stem.porter.PorterStemmer()\\r\\n tokenizer = RegexpTokenizer(r'\\\\w+')\\r\\n # iterate over all lines for preprocessing\\r\\n for index, line in enumerate(raw_text_df):\\r\\n \\r\\n # if there is mention of stars from 1-5, change the integer into\\r\\n # text and combine the number and the word \\\"star\\\" to make a new word\\r\\n # example: \\\"I give this product 1 star\\\" is now \\\"I give this product onestar\\\"\\r\\n # why? numbers are removed as part of preprocessing\\r\\n if \\\"1 star\\\" in line:\\r\\n line = line.replace(\\\"1 star\\\", \\\"onestar\\\")\\r\\n if \\\"1 stars\\\" in line:\\r\\n line = line.replace(\\\"1 stars\\\", \\\"onestar\\\")\\r\\n if \\\"2 star\\\" in line:\\r\\n line = line.replace(\\\"2 star\\\", \\\"twostars\\\")\\r\\n if \\\"2 stars\\\" in line:\\r\\n line = line.replace(\\\"2 stars\\\", \\\"twostars\\\")\\r\\n if \\\"3 star\\\" in line:\\r\\n line = line.replace(\\\"3 star\\\", \\\"threestars\\\")\\r\\n if \\\"3 stars\\\" in line:\\r\\n line = line.replace(\\\"3 stars\\\", \\\"threestars\\\")\\r\\n if \\\"4 star\\\" in line:\\r\\n line = line.replace(\\\"4 star\\\", \\\"fourstars\\\")\\r\\n if \\\"4 stars\\\" in line:\\r\\n line = line.replace(\\\"4 stars\\\", \\\"fourstars\\\")\\r\\n if \\\"5 star\\\" in line:\\r\\n line = line.replace(\\\"5 star\\\", \\\"fivestars\\\")\\r\\n if \\\"5 stars\\\" in line:\\r\\n line = line.replace(\\\"5 stars\\\", \\\"fivestars\\\")\\r\\n \\r\\n # tokenize lines\\r\\n tokens = re.split('(\\\\d+)',line)\\r\\n # remove numbers\\r\\n no_digits = [w for w in tokens if not w.isdigit()]\\r\\n # join tokens\\r\\n joined_text = \\\" \\\".join(no_digits)\\r\\n # re tokenize\\r\\n tokens = tokenizer.tokenize(joined_text)\\r\\n # make tokens lowercase\\r\\n lower_tokens = [w.lower() for w in tokens if type(w) == str] \\r\\n # remove stopwords\\r\\n stopped_tokens = [w for w in lower_tokens if not w in stopwords.words('english')]\\r\\n # stem words\\r\\n clean_tokens = [stemmer.stem(w) for w in stopped_tokens]\\r\\n # join text\\r\\n joined_text = \\\" \\\".join(clean_tokens)\\r\\n # replace line with preprocessed line\\r\\n raw_text_df[index] = joined_text\\r\\n print(index)\",\n \"def preprocess_text(text: str, normalize=True, lowercase=True, stopwords=True, contractions=True, vulgar_words=True,\\n emails=True, punctuation=True, ngrams='uni', ngrams_model_func: Callable = None, lemmatize=True,\\n stem=False, apostrophes=True, chars=True) -> str:\\n\\n if normalize:\\n # TODO: Problem: Here we can have 'USA,' and the 'USA' in the .txt file doesn't match that.\\n text = normalize_words(text)\\n if lowercase:\\n text = to_lowercase(text)\\n if stopwords:\\n text = remove_stopwords(text)\\n if contractions:\\n text = expand_contractions(text)\\n if vulgar_words:\\n text = substitute_vulgar_words(text)\\n if emails:\\n text = remove_emails(text)\\n if punctuation:\\n text = substitute_punctuation(text)\\n if stopwords:\\n text = remove_stopwords(text)\\n if ngrams == 'bi' or ngrams == 'tri':\\n text = ' '.join(ngrams_model_func(text.split()))\\n if lemmatize:\\n text = lemmatize_words(text)\\n elif stem:\\n text = stem_words(text)\\n if apostrophes: # TODO: Move below substitute_punctuation?\\n text = remove_apostrophes(text)\\n if chars:\\n text = remove_single_chars(text)\\n\\n return text\",\n \"def preprocessing(data):\\n #tokenizer = RegexpTokenizer(r'\\\\w+') # allow charachter only\\n #words = tokenizer.tokenize(data) # tokenize : convert to words\\n words = word_tokenize(data)\\n # remove stop words & stemming\\n new_words = []\\n for word in words:\\n if word not in stop_words:\\n new_words.append(stemmer.stem(word)) # append to new words with stemming\\n \\n if '' in new_words: new_words.remove('') # remove space from list\\n #print(\\\"Preprocessing : {}\\\".format(new_words))\\n return new_words\",\n \"def process_text(document):\\n return preprocess_string(document,\\n filters=[strip_tags, strip_punctuation,\\n strip_multiple_whitespaces,\\n strip_numeric, remove_stopwords,\\n strip_short]\\n )\",\n \"def preprocessing(ct):\\n return value_preprocessing(ct, False)\",\n \"def preProcess(text):\\n\\ttext = text.lower() # lower case the text\\n\\t# Q4 replace the word with expanded contractions\\n\\tfor k,v in general_contraction.items():\\n\\t\\tif k in text.split():\\n\\t\\t\\ttext = text.replace(k,v)\\n\\t# Q4 remove speacial char including all puncuattions and replace it with a space\\n\\ttext = re.sub('[^A-Za-z0-9]+',' ',text) \\n\\t# tokenise\\n\\ttokens = text.split()\\n\\t# stop word removal\\n\\ttokens = [w for w in tokens if w not in stopwords ]\\n\\t# Q4 Stemming\\n\\ttokens = [str(porter.stem(w)) for w in tokens]\\n\\t# if word is non-english return its english form # too much time-complexity\\n\\t# tokens = [porter.stem(w) if porter.stem(w) in set(words.words()) else w for w in tokens ]\\n\\t# for words having digits such as 12gb, 1st, etc expanding the token list\\n\\tfor k in tokens:\\n\\t\\tif len(k) >2 and re.match(r'[0-9]+',k):\\t\\t\\t\\n\\t\\t\\tif len(k) >2 and not k.isdigit():\\n\\t\\t\\t\\tl = re.split(r'(\\\\d+)',k)\\n\\t\\t\\t\\tl = [w for w in l if w is not '' ]\\n\\t\\t\\t\\tif l and len(l) <= 3:\\n\\t\\t\\t\\t\\tfor i in l:\\n\\t\\t\\t\\t\\t\\tif i in digit_contractions.keys():\\n\\t\\t\\t\\t\\t\\t\\tl = list(map(lambda b: b.replace(i,digit_contractions[i]), l))\\n\\t\\t\\t\\t\\ttokens.remove(k)\\n\\t\\t\\t\\t\\ttokens = tokens+l\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\ttokens.remove(k)\\n\\tfor k,v in digit_contractions.items():\\n\\t\\tif k in tokens:\\n\\t\\t\\tif tokens[tokens.index(k)-1].isdigit():\\t\\n\\t\\t\\t\\ttokens = list(map(lambda b: b.replace(k,v), tokens))\\n\\t# remove tokens of size less than 2\\n\\ttokens = [t for t in tokens if len(t) > 2]\\n\\treturn tokens\",\n \"def preprocess_text(self):\\n self.text_received = self.text_received.replace(\\\" \\\", \\\"\\\").lower()\",\n \"def test_text_preprocesing(self):\\n input_text = \\\"ABCabc123!@#\\\"\\n processed_text = (\\n preprocessing.preprocess_text(input_text, remove_punctuation=True, to_lower=True)\\n .numpy()\\n .decode(\\\"utf-8\\\")\\n )\\n\\n # Converting to lower case\\n assert processed_text.lower() == processed_text\\n\\n # Removing punctuation\\n assert (\\n processed_text.translate(str.maketrans(\\\"\\\", \\\"\\\", string.punctuation)) == processed_text\\n )\\n\\n # Overall\\n assert processed_text.replace(\\\"\\\\x00\\\", \\\"\\\") == input_text.lower().translate(\\n str.maketrans(\\\"\\\", \\\"\\\", string.punctuation)\\n )\\n assert processed_text.replace(\\\"\\\\x00\\\", \\\"\\\") == \\\"abcabc123\\\"\",\n \"def text_preprocessing_pdf(self,p):\\n #remover_end_paragraphs=np.vectorize(self.remove_end_paragraphs,otypes=[str])\\n cleaner=np.vectorize(self.remove_non_alpha,otypes=[str])\\n cut_text=np.vectorize(self.cut_text,otypes=[str])\\n cut_text_raw=np.vectorize(self.cut_text_raw,otypes=[str])\\n assert len(self.parser)==len(self.parser_raw), \\\"Length of the treated sentence treated list does not match length of raw text list: {} / {}\\\".format(len(self.parser),len(self.parser_raw))\\n cut_text_raw(p)\\n p=cleaner(p)\\n cut_text(p)\\n return p\",\n \"def _build_preprocessing(self):\\n\\n # For now, do nothing\\n pass\",\n \"def convert_txt_to_data():\\n pass\",\n \"def parse_preproc(key, content):\\n if inspect.isclass(key):\\n pp = key(**content)\\n key = pp.__class__.__name__.lower()\\n elif key.lower() == 'none':\\n pp = DummyNone()\\n elif key.lower() == 'recenter':\\n pp = StandardScaler(with_mean=True, with_std=False)\\n elif key.lower() == 'standardize':\\n pp = StandardScaler(with_mean=True, with_std=True)\\n elif key.lower() == 'normalize':\\n content.setdefault('norm', 'l2')\\n # pp = Normalizer(norm=content[1][0])\\n pp = Normalizer(**content)\\n elif key.lower() == 'minmax':\\n content.setdefault('feature_range', (0, 1))\\n pp = MinMaxScaler(**content)\\n else:\\n pp = DummyNone()\\n return (key, pp, 'preproc')\",\n \"def preprocess_input(x, data_format=None): # pylint: disable=unused-argument\\n return x\",\n \"def preprocess(words):\\n words = to_lowercase(words)\\n words = remove_punctuation(words)\\n words = replace_numbers(words)\\n return words\",\n \"def _preprocess(self, txt_seq):\\n input = []\\n for token in txt_seq.split():\\n input.append(self.word2id.get(token, self.word2id[\\\"<UNK>\\\"]))\\n input.append(self.word2id[\\\"<END>\\\"])\\n input = torch.LongTensor(input)\\n return input\",\n \"def preprocess_input(self, text):\\n text = re.sub(r\\\"([^a-zA-Z0-9 -]+ +[^a-zA-Z0-9 -]*|[^a-zA-Z0-9 -]*\\\" +\\n \\\" +[^a-zA-Z0-9 -]+)\\\", ' ', text, flags=re.UNICODE)\\n text = re.sub(r\\\"([^a-zA-Z0-9 -]+$|^[^a-zA-Z0-9 -]+)\\\", '', text)\\n text = re.sub(r\\\"([a-zA-Z0-9 -]+?)([^a-zA-Z0-9 -])([a-zA-Z0-9 -]+?)\\\",\\n r\\\"\\\\1'\\\\3\\\", text, flags=re.UNICODE)\\n text = re.sub(r\\\"([\\\\x00-\\\\x7F -]+?)([^a-zA-Z0-9 -]+)([\\\\x00-\\\\x7F -]+?)\\\",\\n r\\\"\\\\1'\\\\3\\\", text, flags=re.UNICODE).encode(\\\"utf-8\\\")\\n return re.sub(r\\\"([^a-zA-Z0-9 \\\\-\\\\'])\\\", '', text, flags=re.UNICODE)\",\n \"def preprocessing_transform(self, x):\\n if isinstance(self.column_text, int) and self.column_text not in x.columns:\\n col = self.column_text\\n else:\\n col = list(x.columns).index(self.column_text)\\n\\n ct = x.shape[0]\\n # INPUTS\\n if self.method_embedding.lower() in ['roberta', \\\"camembert\\\", \\\"xlm-roberta\\\"]:\\n ids = np.ones((ct, self.maxlen), dtype='int32')\\n else:\\n ids = np.zeros((ct, self.maxlen), dtype='int32')\\n att = np.zeros((ct, self.maxlen), dtype='int32')\\n tok = np.zeros((ct, self.maxlen), dtype='int32')\\n\\n for k in range(ct):\\n text = \\\" \\\" + \\\" \\\".join(x.iloc[k, col].split())\\n\\n if self.method_embedding == 'RoBERTa':\\n enc = self.tokenizer.encode(text)\\n else:\\n enc = self.tokenizer.encode(text, max_length=self.maxlen, truncation=True)\\n\\n # CREATE BERT INPUTS\\n if self.method_embedding == 'RoBERTa':\\n ids[k, :len(enc.ids)] = enc.ids[:self.maxlen]\\n att[k, :len(enc.ids)] = 1\\n else:\\n ids[k, :len(enc)] = enc\\n att[k, :len(enc)] = 1\\n\\n x_preprocessed = [ids, att, tok]\\n if self.dimension_embedding == 'word_embedding':\\n return x_preprocessed\\n else:\\n model_extractor = self.model_extract_document_embedding()\\n document_embedding = model_extractor.predict(x_preprocessed)\\n return document_embedding\",\n \"def preprocessing(raw_text):\\n words_list = tokenize(raw_text)\\n words_list = remove_stop_words(words_list)\\n words_list = remove_punctuations(words_list)\\n words_list = lemmatization(words_list)\\n return words_list\",\n \"def process_text(self, text, language):\",\n \"def _preprocess_text(text: List[str], tokenizer: Any, max_length: int=512, truncation: bool=True, sort_according_length: bool=True, own_tokenizer: bool=False) ->Tuple[Dict[str, Tensor], Optional[Tensor]]:\\n if not own_tokenizer:\\n tokenized_data = tokenizer(text, padding='max_length', max_length=max_length, truncation=truncation, return_tensors='pt')\\n else:\\n try:\\n tokenized_data = tokenizer(text, max_length)\\n except BaseException as e:\\n raise BaseException(f'Tokenization was not successful: {e}')\\n if sort_according_length:\\n input_ids, attention_mask, sorting_indices = _sort_data_according_length(tokenized_data['input_ids'], tokenized_data['attention_mask'])\\n input_dict = {'input_ids': input_ids, 'attention_mask': attention_mask}\\n else:\\n input_dict = {'input_ids': tokenized_data['input_ids'], 'attention_mask': tokenized_data['attention_mask']}\\n sorting_indices = None\\n return input_dict, sorting_indices\",\n \"def small_preprocess_singlerow(data):\\r\\n # Remove new line characters\\r\\n data = re.sub('\\\\s+', ' ', data) \\r\\n # Remove distracting single quotes\\r\\n data = re.sub(\\\"\\\\'\\\", \\\"\\\", data)\\r\\n\\r\\n return data\",\n \"def process_single_text(self, text, punctuation_remover, digit_remover, word_prepro_func, stopwords):\\n data = {}\\n sents = sent_tokenize(text.lower())\\n words = []\\n for sent in sents:\\n # remove punctuation content\\n sent = self.handle_punctuation(sent, punctuation_remover)\\n words.extend(word_tokenize(sent))\\n # words = text_to_word_sequence(text, filters=filt, lower=True, split=' ')\\n # words = [w.lower() for w in self.nltk_tokenizer.tokenize(text)]\\n\\n # remove stopwords and numbers\\n # words = [w.translate(digit_remover) for w in words if w not in stopwords and w.isalpha()]\\n # remove empty \\\"words\\\"\\n words = [w for w in words if w]\\n if self.remove_digits:\\n words = [w for w in [w.translate(digit_remover) for w in words] if w]\\n if self.filter_stopwords:\\n words = [w for w in words if w not in stopwords]\\n data[\\\"words\\\"] = words\\n if self.config.extract_pos:\\n # pos tagging\\n data[\\\"pos\\\"] = nltk.pos_tag(words)\\n # stemming / lemmatization\\n if self.config.prepro is not None:\\n data[\\\"words\\\"] = [word_prepro_func((w, p)) for (w, p) in zip(words, data[\\\"pos\\\"])]\\n # if not data[\\\"words\\\"]:\\n # # warning(\\\"Text preprocessed to an empty list:\\\\n{}\\\".format(text))\\n # return None\\n return data\",\n \"def preprocess(text, freq=5):\\n text = re.sub(r\\\"[^A-Za-z0-9(),!?\\\\'\\\\`]\\\", \\\" \\\", text)\\n text = re.sub(r\\\"\\\\'s\\\", \\\" \\\\'s\\\", text)\\n text = re.sub(r\\\"\\\\'ve\\\", \\\" \\\\'ve\\\", text)\\n text = re.sub(r\\\"n\\\\'t\\\", \\\" n\\\\'t\\\", text)\\n text = re.sub(r\\\"\\\\'re\\\", \\\" \\\\'re\\\", text)\\n text = re.sub(r\\\"\\\\'d\\\", \\\" \\\\'d\\\", text)\\n text = re.sub(r\\\"\\\\'ll\\\", \\\" \\\\'ll\\\", text)\\n text = re.sub(r\\\",\\\", \\\" , \\\", text)\\n text = re.sub(r\\\"!\\\", \\\" ! \\\", text)\\n text = re.sub(r\\\"\\\\(\\\", \\\" \\\\( \\\", text)\\n text = re.sub(r\\\"\\\\)\\\", \\\" \\\\) \\\", text)\\n text = re.sub(r\\\"\\\\?\\\", \\\" \\\\? \\\", text)\\n text = re.sub(r\\\"\\\\s{2,}\\\", \\\" \\\", text)\\n\\n words_raw = text.strip().lower().split()\\n word_counts = Counter(words_raw)\\n words = [w for w in words_raw if word_counts[w] > freq]\\n vocab = set(words)\\n vocab2index = {w: idx for idx, w in enumerate(vocab)}\\n index2vocab = {idx: w for idx, w in enumerate(vocab)}\\n words_int = [vocab2index[w] for w in words]\\n return words_int, vocab2index, index2vocab\",\n \"def preprocess_data(self, data, scale_data=True):\\n print(\\\"preprocess_data not implemented\\\")\\n return data\",\n \"def create_clean_text(data, text_type):\\n stop = stopwords.words('english')\\n data['{}'.format(text_type)] = data['{}'.format(text_type)].apply(lambda x: x.replace(' $end$', \\\".\\\"))\\n data['{}'.format(text_type)] = data['{}'.format(text_type)].apply(\\n lambda x: x.replace(' $acceptance criteria:$', \\\".\\\"))\\n data['clean_text'] = data.apply(lambda x: clean_text(x['{}'.format(text_type)], x['project_key']), axis=1)\\n basic_pre_processing(data)\",\n \"def preprocess_text(text, tokenize=False, ner=False, stem=False, stopw=False, all_lower=False, strip_punct=True):\\n\\n # Clean the text\\n text = re.sub(r\\\"what's\\\", \\\"what is \\\", text)\\n text = re.sub(r\\\"\\\\'s\\\", \\\" \\\", text)\\n text = re.sub(r\\\"\\\\'ve\\\", \\\" have \\\", text)\\n text = re.sub(r\\\"can't\\\", \\\"cannot \\\", text)\\n text = re.sub(r\\\"n't\\\", \\\" not \\\", text)\\n text = re.sub(r\\\"i'm\\\", \\\"i am \\\", text)\\n text = re.sub(r\\\"\\\\'re\\\", \\\" are \\\", text)\\n text = re.sub(r\\\"\\\\'d\\\", \\\" would \\\", text)\\n text = re.sub(r\\\"\\\\'ll\\\", \\\" will \\\", text)\\n text = re.sub(r\\\"i\\\\.e\\\\.\\\", \\\"\\\", text)\\n text = re.sub(r\\\"\\\\.\\\", \\\" . \\\", text)\\n text = re.sub(r\\\"!\\\", \\\" ! \\\", text)\\n text = re.sub(r\\\"\\\\/\\\", \\\" \\\", text)\\n text = re.sub(r\\\"\\\\^\\\", \\\" ^ \\\", text)\\n text = re.sub(r\\\"\\\\+\\\", \\\" + \\\", text)\\n text = re.sub(r\\\"\\\\-\\\", \\\" - \\\", text)\\n text = re.sub(r\\\"\\\\=\\\", \\\" = \\\", text)\\n text = re.sub(r\\\"'\\\", \\\" \\\", text)\\n text = re.sub(r'\\\"', \\\" \\\", text)\\n text = re.sub(r\\\"(\\\\d+)(k)\\\", r\\\"\\\\g<1>000\\\", text)\\n text = re.sub(r\\\":\\\", \\\" : \\\", text)\\n text = re.sub(r\\\" e g \\\", \\\" eg \\\", text)\\n text = re.sub(r\\\"^e g \\\", \\\" eg \\\", text)\\n text = re.sub(r\\\" b g \\\", \\\" bg \\\", text)\\n text = re.sub(r\\\"^b g \\\", \\\" bg \\\", text)\\n text = re.sub(r\\\" u s \\\", \\\" american \\\", text)\\n text = re.sub(r\\\"^u s \\\", \\\" american \\\", text)\\n text = re.sub(r\\\"\\\\0s\\\", \\\"0\\\", text)\\n text = re.sub(r\\\" 9 11 \\\", \\\"911\\\", text)\\n text = re.sub(r\\\"e - mail\\\", \\\"email\\\", text)\\n text = re.sub(r\\\"j k\\\", \\\"jk\\\", text)\\n text = re.sub(r\\\"\\\\s{2,}\\\", \\\" \\\", text)\\n text = re.sub(r\\\"\\\\b[a-zA-Z]\\\\b\\\", \\\"\\\", text)\\n\\n if ner:\\n tokenized_text = word_tokenize(text)\\n tagged_text = pos_tag(tokenized_text)\\n chunked_text = ne_chunk(tagged_text, binary=True)\\n\\n named_entities = extract_entity_names(chunked_text)\\n for named_entity in named_entities:\\n entity = named_entity.replace(\\\".\\\", \\\"\\\")\\n entity = re.sub(r'\\\\s+', \\\"_\\\", entity)\\n text = text.replace(named_entity, entity)\\n\\n if all_lower:\\n text = text.lower()\\n\\n if stopw:\\n global stops\\n if stops is None:\\n try:\\n stops = set(stopwords.words(\\\"english\\\"))\\n except Exception as e:\\n print(\\\"%s - Please download english stopwords from NLTK\\\" % e)\\n exit()\\n text = [word.strip() for word in text.split() if word not in stops]\\n text = \\\" \\\".join(text)\\n\\n if tokenize:\\n text = word_tokenize(text)\\n text = \\\" \\\".join(text)\\n\\n # shorten words to their stems\\n if stem:\\n text = text.split()\\n stemmer = SnowballStemmer('english')\\n stemmed_words = [stemmer.stem(word) for word in text]\\n text = \\\" \\\".join(stemmed_words)\\n\\n if strip_punct:\\n text = text.translate(str.maketrans('', '', string.punctuation))\\n\\n text = text.strip()\\n\\n # Empty string\\n if text == '':\\n return EMPTY_TOKEN\\n\\n return text\",\n \"def preprocess(doc_in, doc_out):\\n def output(text, doc_id):\\n doc_out.write(doc_id + \\\"\\\\n\\\")\\n doc_out.write(text.replace(\\\"\\\\n\\\", \\\" \\\") + \\\"\\\\n\\\\n\\\")\\n\\n def filter_text(t):\\n filtered_out = [\\\"<P>\\\", \\\"</P>\\\"]\\n r = t\\n for f in filtered_out:\\n r = r.replace(f, \\\" \\\")\\n return r\\n\\n\\n doc_id = None\\n reading_text = False\\n text = \\\"\\\"\\n for line in doc_in:\\n if(str_text_start in line):\\n if(reading_text):\\n warning(\\\"Found \\\" + str_text_start + \\\" in text\\\")\\n if(not doc_id):\\n warning(\\\"Reading text without knowing id\\\")\\n continue\\n reading_text = True\\n continue\\n if((str_text_stop in line) and reading_text):\\n output(text, doc_id)\\n text = \\\"\\\"\\n reading_text = False\\n doc_id = None\\n doc_id_match = pat_doc_no.match(line)\\n if(doc_id_match):\\n doc_id = doc_id_match.group(1)\\n if(reading_text):\\n warning(\\\"Found doc id in text\\\")\\n continue\\n if(reading_text):\\n text = text + filter_text(line)\",\n \"def preprocess(self, data_f):\\n \\n return self.vec.transform(data_f.review)\",\n \"def pre_process(text):\\n # replace (,.'\\\") with ''\\n text = text.replace(',', '')\\n text = text.replace('.', '')\\n text = text.replace(\\\"'\\\", '')\\n text = text.replace(\\\"\\\\\\\"\\\", '')\\n\\n # tokenize into words\\n tokens = [word for sent in sent_tokenize(text) for word in word_tokenize(sent)]\\n\\n # remove stopwords\\n stop = stopwords.words('english')\\n tokens = [token for token in tokens if token not in stop]\\n\\n # remove words less than three letters\\n tokens = [word for word in tokens if len(word) >= 3]\\n\\n # lower capitalization\\n tokens = [word.lower() for word in tokens]\\n\\n # lemmatize\\n lmtzr = WordNetLemmatizer()\\n tokens = [lmtzr.lemmatize(word) for word in tokens]\\n\\n return tokens\",\n \"def preprocess_note(text):\\n # replace redacted info with tokens\\n text = replace_redacted(text)\\n \\n # misc scrubbing\\n text = replace_misc(text) \\n return text\",\n \"def transform(self, data):\",\n \"def post_process_text(self, text):\\n\\t\\treturn text\",\n \"def preProcessText(col):\\n reponct = string.punctuation.replace(\\\"?\\\",\\\"\\\").replace(\\\"/\\\",\\\"\\\")\\n rehtml = re.compile('<.*>')\\n extr = col.str.strip()\\n extr = extr.str.replace(rehtml, '', regex=True)\\n extr = extr.str.translate(str.maketrans('','',reponct))\\n extr = extr.str.replace('[^0-9a-zA-Z?/ ]+', ' ', regex=True)\\n extr = extr.str.replace('\\\\s+', ' ', regex=True)\\n extr = extr.str.lower()\\n return extr\",\n \"def preprocess(inpString):\\n\\n figure = re.compile(r'\\\\([^\\\\W\\\\d_]+ [0-9]+\\\\.[0-9]+\\\\)') # i.e (Tablo 3.2)\\n out_string = figure.sub('', inpString)\\n\\n digit_dot = re.compile(r'([0-9]+)\\\\.([0-9]{3})') # i.e 19.000 --> 19000\\n out_string = digit_dot.sub(r'\\\\1\\\\2', out_string)\\n out_string = digit_dot.sub(r'\\\\1\\\\2', out_string)\\n\\n centigrade = re.compile(r'(°C)|(°c)|(0C)') # °C --> santigrat\\n out_string = centigrade.sub(r' santigrat', out_string)\\n\\n out_string = re.sub(r'°', ' derece', out_string) # ° --> derece\\n\\n digit_space = re.compile(r'([0-9]+) ([0-9]+)') # 19 000 --> 19000\\n out_string = digit_space.sub(r'\\\\1\\\\2', out_string)\\n\\n out_string = re.sub(r'â', 'a', out_string) # Elâzig --> Elazig\\n\\n spec_hyphen = re.compile(r'([A-Za-z])-([0-9]+)') # G-20 --> G20\\n out_string = spec_hyphen.sub(r'\\\\1\\\\2', out_string)\\n\\n out_string = re.sub(r'-', ' ', out_string) # replace hyphen with space\\n\\n out_string = re.sub(r'%|‰', 'yüzde ', out_string) # % --> yuzde\\n\\n year = re.compile(\\\"([0-9]{4})(’|')([a-z]+)\\\") # 1815'te --> 1815 yilinda\\n out_string = year.sub(r'\\\\1 yılında', out_string)\\n\\n out_string = re.sub(r' km2', ' kilometrekare', out_string) # converting km2, m, km\\n out_string = re.sub(r' m ', ' metre ', out_string)\\n out_string = re.sub(r' km ', ' kilometre ', out_string)\\n\\n out_string = re.sub(r\\\"(’|')([a-züşöıç]+)\\\", '', out_string) # turkiye'de --> turkiye\\n\\n out_string = re.sub(r'([0-9]+),([0-9]+)', r'\\\\1CBN\\\\2', out_string) # replacing comma between\\n # digits with a placeholder\\n\\n puncs = string.punctuation + '”' + '“' + '’' + '‘'\\n translator = str.maketrans('', '', puncs)\\n out_string = out_string.translate(translator) # removing pucntuations\\n\\n out_string = re.sub(r'CBN', ',', out_string) # bringing back the comma between numbers\\n # out_string= out_string.split(' ') #[s.split(' ') for s in out_string.split('#')] #splitting from end of sentences\\n # end sentence into words\\n\\n return out_string\",\n \"def normalize(data):\\n data = lowercase(data)\\n data = remove_punct(data)\\n data = remove_apostrophes(data)\\n data = remove_stopwords(data)\\n data = num_to_words(data)\\n data = lemmatize(data)\\n data = stemming(data)\\n data = remove_punct(data)\\n data = num_to_words(data)\\n data = lemmatize(data)\\n data = stemming(data)\\n data = remove_punct(data) #done again to remove hyphens produced by num2words\\n data = remove_stopwords(data) #done agan to remove stopwords produced by num2words\\n return data\",\n \"def preprocess(\\n self, data: List[Dict[str, Any]]\\n ) -> Generator[Dict[str, Any], None, None]:\\n raise NotImplementedError\",\n \"def preprocessing_for_bert(self, data):\\n # Create empty lists to store outputs\\n input_ids = []\\n attention_masks = []\\n MAX_LEN = self.opt.MAX_QUESTION_LEN\\n # For every sentence...\\n for sent in data:\\n \\n encoded_sent = self.tokenizer.encode_plus(\\n text=self.text_preprocessing(sent), # Preprocess sentence\\n add_special_tokens=True, # Add `[CLS]` and `[SEP]`\\n max_length=MAX_LEN, # Max length to truncate/pad\\n pad_to_max_length=True, # Pad sentence to max length\\n #return_tensors='pt', # Return PyTorch tensor\\n truncation=True,\\n return_attention_mask=True # Return attention mask\\n )\\n \\n # Add the outputs to the lists\\n input_ids.append(encoded_sent.get('input_ids'))\\n attention_masks.append(encoded_sent.get('attention_mask'))\\n\\n # Convert lists to tensors\\n input_ids = torch.tensor(input_ids)\\n attention_masks = torch.tensor(attention_masks)\\n\\n return input_ids, attention_masks\",\n \"def preprocess_sent(sent):\\n #tokenized = word_tokenize(sent.lower())\\n tokenizer = Tok()\\n tokenized = tokenizer.tokenize(sent.lower())\\n return tokenized\",\n \"def process_text(text):\\n text = re.sub(r'<@>\\\\s+|<s>\\\\s+|</s>\\\\s+|<p>\\\\s+|</p>\\\\s+|\\\\s+\\\\,|\\\\'s|\\\\'|\\\\;|\\\\(|\\\\)|\\\\-\\\\-\\\\s+|\\\\s+\\\\.', '', text)\\n text = re.sub(r'\\\\.\\\\,', '. ,', text)\\n text = re.sub(r'\\\\,', '', text)\\n text = re.sub(r'\\\\$', '$ ', text)\\n text = re.sub(r'\\\\%', ' %', text)\\n text = re.sub(r'\\\\s\\\\\\\"\\\\s', ' ', text)\\n text = re.sub(r'\\\\.\\\\s+', '. ', text)\\n text = text.lower()\\n return text\",\n \"def process_text(text):\\n no_split_dict = {'u . s': 'u.s', 'u . n': 'u.n', 'u . k': 'u.k', 'l . a': 'l.a', 'j . k': 'j.k', 'a . m': 'a.m',\\n 'p . m': 'p.m', 'd . j': 'd.j', 'd . a': 'd.a'}\\n\\n text = re.sub(\\\".*--\\\", \\\"\\\", text, count=1) # Removing cnn from start of text\\n if text.startswith('(CNN)'): # Remove cnn from articles that starts with only cnn\\n text = re.sub('\\\\(CNN\\\\)', '', text, count=1)\\n text = re.sub(r'(?<=[^?!.0-9])(?=[.,!?])', ' ', text) # 4\\n text = re.sub(r'(?![0-9])(?<=[.,])(?=[^\\\\s])', r' ', text) # 4\\n text = text.lower() # 2\\n text = re.sub('[^A-Za-z0-9 .!?,øæå]+', '', text) # 3\\n text = re.sub(r'((?<=[a-z])(?=[.]))|((?=[a-z])(?<=[.]))(?=[^\\\\s])', r' ', text) # space a-z.a-z\\n text = re.sub(r'((?=[0-9])(?<=[a-z]))|((?=[a-z])(?<=[0-9]))(?=[^\\\\s])', r' ', text) # space 0-9a-z\\n for key in no_split_dict:\\n text = text.replace(key, no_split_dict[key]) # Fixing word splits\\n text = re.sub('[0-9]', '#', text) # 8\\n text = \\\" \\\".join(text.split()) # 5, 6, 7 - i think\\n return text\",\n \"def _preprocess_fn(data):\\n\\n # Validate input\\n if not isinstance(data, dict) or 'image' not in data:\\n raise ValueError('Argument `data` must be a dictionary, '\\n 'not %s' % str(type(data)))\\n\\n # Apply all the individual steps in sequence.\\n image = data['image']\\n image = decode_image(image)\\n image = normalize_value_range(image)\\n image = get_multiscale_patches(image, **preprocessing_kwargs)\\n\\n data['image'] = image\\n return data\",\n \"def prepare_data(self, lines: List[str]) -> List[str]:\\n if self.is_tokenized:\\n if self.parser == \\\"spacy\\\":\\n lines = [l.split() for l in lines]\\n elif self.parser == \\\"udpipe\\\":\\n lines = [[l.split()] for l in lines]\\n\\n return lines\",\n \"def preprocess_text(text):\\n # replace non characers with space and lower case\\n temp = re.sub(r\\\"[/W/D/S.,-]+\\\", \\\" \\\", str(text).lower())\\n # merge multiple spaces to a single one\\n return re.sub(r\\\"[ ]+\\\", \\\" \\\", temp)\",\n \"def preprocess(item):\\n item = feature_engineering(item)\\n item = encode_features(item)\\n return item\",\n \"def preprocess_and_save_data(self, dataset_path):\\n # File starts with copyright line - irrelevant information so remove\\n text = self._load_data(dataset_path)\\n text = text[81:]\\n\\n # Replace punctuation as tokens for text processing\\n token_dict = self.token_lookup()\\n for key, value in token_dict.items():\\n text = text.replace(key, ' {} '.format(value))\\n\\n # Transform text for use in lookup tables\\n text = text.lower()\\n text = text.split()\\n\\n # Create lookup tables\\n vocab_to_int, int_to_vocab = self._create_lookup_tables(text)\\n int_text = [vocab_to_int[word] for word in text]\\n\\n pickle.dump((int_text, vocab_to_int, int_to_vocab, token_dict),\\n open(\\\"preprocess.p\\\", \\\"wb\\\"))\",\n \"def preprocess(self, collection: List[str]) -> List[List[str]]:\\n # remove bad characters\\n col_clean = self.remove_bad_chars(collection)\\n # make lower case if applicable\\n if self.lowercase:\\n col_l = self.lower_case_corpus(col_clean)\\n else:\\n col_l = col_clean\\n if self.n_grams == 1:\\n return [s.split() for s in col_l]\\n else:\\n corpus_tokenized = [s.split() for s in col_l]\\n col_n_grams = list()\\n for doc in corpus_tokenized:\\n# print(f\\\"doc is: {doc}\\\")\\n if self.n_grams > len(doc):\\n raise ValueError(\\\"n-grams value to large, choose\\\\\\n smaller value\\\")\\n doc_n_grams = list()\\n for i in range(len(doc)):\\n end_idx = self.n_grams + i\\n doc_tmp = \\\"\\\"\\n if end_idx <= len(doc):\\n# print(f\\\"token added is: {' '.join(doc[i:end_idx])}\\\")\\n doc_tmp = \\\" \\\".join(doc[i:end_idx])\\n doc_n_grams.append(doc_tmp)\\n else:\\n break\\n col_n_grams.append(doc_n_grams)\\n# print(f\\\"final: {col_n_grams}\\\")\\n return col_n_grams\",\n \"def process_text(input_txt):\\r\\n # if input is string\\r\\n tidy_txt = remove_pattern(input_txt,\\\"@[\\\\w]*\\\")\\r\\n ##=============================== if input is dataframe ====================##\\r\\n # tidy_txt = np.vectorize(remove_pattern)(input_txt,\\\"@[\\\\w]*\\\") #\\r\\n ##==========================================================================##\\r\\n # remove special characters\\r\\n tidy_txt = tidy_txt.replace(\\\"[^a-zA-Z#]\\\",\\\" \\\")\\r\\n # split into words\\r\\n tokenized_txt = tidy_txt.split()\\r\\n # perform stemming\\r\\n stemmer = PorterStemmer()\\r\\n tokenized_txt = [stemmer.stem(i) for i in tokenized_txt]\\r\\n print(tokenized_txt)\\r\\n # joining words back\\r\\n tokenized_txt = ' '.join(tokenized_txt)\\r\\n return tokenized_txt\",\n \"def preprocess(text):\\n\\tX = []\\n\\tsent_detector = nltk.data.load('tokenizers/punkt/english.pickle')\\n\\tfor t in text:\\n\\t\\tsents = sent_detector.tokenize(t)\\n\\t\\tresult = ''\\n\\t\\tfor s in sents:\\n\\t\\t\\ttokens = word_tokenize(s)\\n\\t\\t\\tresult += ' ' + ' '.join(tokens)\\n\\t\\tX.append(result)\\n\\treturn X\",\n \"def apply(self, text):\",\n \"def postprocess(self, text):\\r\\n return text\",\n \"def preprocess(self):\\n\\n self._build_labels_dict(['one', 'two', 'three', 'four', 'five'])\\n\\n with open(self.data_path + self.file_name, 'rb') as csvfile:\\n\\n reader = csv.reader(csvfile, delimiter=\\\",\\\")\\n for row in reader:\\n self.texts.append(row[1])\\n self.labels.append(self.labels_index[row[0]])\\n\\n print('Found %s texts.' % len(self.texts))\",\n \"def preprocess_data(self):\\n\\n self._preprocess_train_data()\\n self._preprocess_test_data()\",\n \"def preprocess(text):\\n text_index = list(range(0, len(text), SEG_SIZE))\\n segments = [\\n text[i: i + SEG_SIZE] + PLACEHOLDER_TEMPLATE.format(PLACEHOLDER, i//SEG_SIZE)\\n for i in text_index\\n ]\\n text_index.append(len(text))\\n return text_index[1:], ''.join(segments)\",\n \"def preprocess(series):\\n def delimit(sent):\\n \\\"\\\"\\\"Inserts special symbols for start and end into sentence\\\"\\\"\\\"\\n arr = sent.split()\\n if arr:\\n arr.insert(0, '<START>')\\n arr.append('<END>')\\n else:\\n arr = ['<EMPTY>']\\n return arr\\n return series.apply(delimit)\",\n \"def preprocess_terms(df, dataType='testNames'):\\n pass\",\n \"def process_text(text, tokenize=tokenize1, filter=filter1, stem=None, lower=True):\\n assert tokenize, \\\"Must provide tokenize method for preprocess_text\\\"\\n if not text: return []\\n if lower: text = text.lower()\\n words = tokenize(text)\\n if filter: words = [w for w in words if filter(w)]\\n if stem: words = [stem(w) for w in words]\\n return words\",\n \"def preprocess_document(raw,sentence_level):\\r\\n\\r\\n\\t# raw = raw.decode(\\\"utf-8\\\")\\r\\n\\t# raw = raw.encode(\\\"ascii\\\",\\\"ignore\\\")\\r\\n\\t\\r\\n\\tfrom nltk.tokenize.punkt import PunktSentenceTokenizer, PunktParameters\\r\\n\\tparam = PunktParameters()\\r\\n\\ttokenizer = PunktSentenceTokenizer(param)\\r\\n\\tif sentence_level:\\r\\n\\t\\tsentences = tokenizer.tokenize(raw)\\r\\n\\t\\tsentences_words = list()\\r\\n\\t\\tfor s in sentences:\\r\\n\\t\\t\\tsentences_words.append((s.strip(),preprocess_sentence(s)))\\r\\n\\t\\treturn sentences_words\\r\\n\\telse:\\r\\n\\t\\treturn [(raw.strip(),preprocess_sentence(raw))]\",\n \"def normalize(self, text: str) -> str:\",\n \"def preprocess(x):\\n\\n\\tres = re.sub(r'[^\\\\w\\\\s]', '', x)\\n\\tres = res.strip('\\\\n')\\n\\n\\treturn res\",\n \"def processText(text_data):\\n\\tclean_texts = []\\n\\tfor text in text_data:\\n\\t\\tno_parens = removeParentheses(text)\\n\\t\\tonly_alpha_spaces = removeNonAlphabet(no_parens)\\n\\t\\tone_space = removeExtraSpaces(only_alpha_spaces)\\n\\n\\t\\tstemmed_text = stemWords(one_space)\\n\\n\\t\\tclean_texts.append(stemmed_text.lower())\\n\\treturn clean_texts\",\n \"def preprocessing(self, dataset: tf.data.Dataset) -> tf.data.Dataset:\\n # Teacher forcing.\\n def preprocess(input_sentence, output_sentence):\\n return ((input_sentence, output_sentence[:-1]), output_sentence[1:])\\n\\n return dataset.map(preprocess)\",\n \"def preprocess_sub_units(self):\\n if self.unit == \\\"char\\\":\\n self.preprocess_char()\\n elif self.unit == \\\"char-ngram\\\":\\n self.preprocess_char_ngram()\\n elif self.unit == \\\"morpheme\\\":\\n self.preprocess_morpheme()\\n elif self.unit == \\\"oracle\\\":\\n self.preprocess_oracle()\\n else:\\n sys.exit(\\\"Unknown unit\\\")\",\n \"def preprocess(text):\\n text = text.translate(None, string.punctuation)\\n words = filter(None, re.split('\\\\s+', text))\\n words = nltk.pos_tag(words)\\n words = [(word.lower(), nltk.simplify_wsj_tag(tag)) for word, tag in words]\\n words = [(word, 'V') if tag.startswith('V') else (word, tag)\\n for word, tag in words]\\n return words\",\n \"def pre_process(cls, *args, **kwargs):\\n pass\",\n \"def pre_process(cls, *args, **kwargs):\\n pass\",\n \"def pre_process(cls, *args, **kwargs):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7779607","0.7526521","0.7176781","0.7096829","0.7073286","0.6976883","0.6929176","0.6907419","0.687628","0.68656975","0.67926234","0.6746842","0.6743114","0.6733834","0.6726861","0.6723832","0.67099166","0.66652983","0.6643692","0.65456325","0.65281934","0.6511876","0.6511876","0.6511876","0.6505743","0.65004766","0.6489804","0.64775616","0.64499414","0.64313585","0.64125496","0.63815016","0.6365297","0.63486135","0.63425314","0.6341673","0.633346","0.6331922","0.63089716","0.6305836","0.6302036","0.6299555","0.6285553","0.6248946","0.6240101","0.6235976","0.6235632","0.6204653","0.62006813","0.6196608","0.6183711","0.6183593","0.61811036","0.6170721","0.6162687","0.6144603","0.6138069","0.60851276","0.6083717","0.6080867","0.6073662","0.60612774","0.60489583","0.6048816","0.6028785","0.60201085","0.601374","0.6012928","0.6009124","0.59986764","0.5979245","0.5961425","0.5960328","0.59570843","0.5954249","0.5943923","0.59416157","0.59149","0.591162","0.5885754","0.5868583","0.586369","0.58598363","0.58568275","0.58523744","0.5848514","0.5833614","0.58327633","0.5831394","0.58254445","0.58030987","0.5800202","0.579782","0.57927275","0.5792694","0.57806337","0.5775611","0.57686424","0.57686424","0.57686424"],"string":"[\n \"0.7779607\",\n \"0.7526521\",\n \"0.7176781\",\n \"0.7096829\",\n \"0.7073286\",\n \"0.6976883\",\n \"0.6929176\",\n \"0.6907419\",\n \"0.687628\",\n \"0.68656975\",\n \"0.67926234\",\n \"0.6746842\",\n \"0.6743114\",\n \"0.6733834\",\n \"0.6726861\",\n \"0.6723832\",\n \"0.67099166\",\n \"0.66652983\",\n \"0.6643692\",\n \"0.65456325\",\n \"0.65281934\",\n \"0.6511876\",\n \"0.6511876\",\n \"0.6511876\",\n \"0.6505743\",\n \"0.65004766\",\n \"0.6489804\",\n \"0.64775616\",\n \"0.64499414\",\n \"0.64313585\",\n \"0.64125496\",\n \"0.63815016\",\n \"0.6365297\",\n \"0.63486135\",\n \"0.63425314\",\n \"0.6341673\",\n \"0.633346\",\n \"0.6331922\",\n \"0.63089716\",\n \"0.6305836\",\n \"0.6302036\",\n \"0.6299555\",\n \"0.6285553\",\n \"0.6248946\",\n \"0.6240101\",\n \"0.6235976\",\n \"0.6235632\",\n \"0.6204653\",\n \"0.62006813\",\n \"0.6196608\",\n \"0.6183711\",\n \"0.6183593\",\n \"0.61811036\",\n \"0.6170721\",\n \"0.6162687\",\n \"0.6144603\",\n \"0.6138069\",\n \"0.60851276\",\n \"0.6083717\",\n \"0.6080867\",\n \"0.6073662\",\n \"0.60612774\",\n \"0.60489583\",\n \"0.6048816\",\n \"0.6028785\",\n \"0.60201085\",\n \"0.601374\",\n \"0.6012928\",\n \"0.6009124\",\n \"0.59986764\",\n \"0.5979245\",\n \"0.5961425\",\n \"0.5960328\",\n \"0.59570843\",\n \"0.5954249\",\n \"0.5943923\",\n \"0.59416157\",\n \"0.59149\",\n \"0.591162\",\n \"0.5885754\",\n \"0.5868583\",\n \"0.586369\",\n \"0.58598363\",\n \"0.58568275\",\n \"0.58523744\",\n \"0.5848514\",\n \"0.5833614\",\n \"0.58327633\",\n \"0.5831394\",\n \"0.58254445\",\n \"0.58030987\",\n \"0.5800202\",\n \"0.579782\",\n \"0.57927275\",\n \"0.5792694\",\n \"0.57806337\",\n \"0.5775611\",\n \"0.57686424\",\n \"0.57686424\",\n \"0.57686424\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6244845"},"document_rank":{"kind":"string","value":"44"}}},{"rowIdx":81988,"cells":{"query":{"kind":"string","value":"Call an arbitrary management method on this entity"},"document":{"kind":"string","value":"def call(self, operation, expect=error.OK, **arguments):\n request = self._node.request(\n operation=operation, type=self.type, identity=self.identity, **arguments)\n return self._node.call(request, expect=expect).body"},"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 run_manage(self, expanded, unexpanded) :\n\t\treturn self.manage_view_properties(expanded, unexpanded, \"/manage\", roles = \"Manager\")","def management(self):\r\n return management.Management(self)","def manage(ctx, user_cmd):\n ScalingoInterface(ctx.obj).manage_py(user_cmd)","def __getattr__(self, key):\n if key in self.cmdmanager:\n action = self.cmdmanager[key]\n def call(*args):\n try:\n action(self, *args)\n except:\n traceback.print_exc()\n return call\n try:\n return self.__getattr__(key)\n except:\n return self.__getattribute__(key)","def management(self) -> Optional[pulumi.Input['NodeManagementArgs']]:\n return pulumi.get(self, \"management\")","def management(self) -> Optional[pulumi.Input['NodeManagementArgs']]:\n return pulumi.get(self, \"management\")","def test_public_manager_call(self):\n\n # GIVEN public access method to model's manager\n\n # WHEN fetching data listing using unsupported call method\n response = self.api.GET(self.app_label, self.model_name2, params={'call': 'call2'})\n\n # THEN it should fail\n self.assertTrue(response.error)\n\n # -----\n\n # WHEN fetching data listing using supported call method\n response = self.api.GET(self.app_label, self.model_name2, params={'call': 'call'})\n\n # THEN it should succeed\n self.assertTrue(response.success)","def __getattr__(self, name):\n\n value = rec_getattr(self.managedObject, name)\n\n if value:\n return value\n else:\n return getattr(self.managedObject, name)","def manage_py(self, management_command_name, **options):\n cmd = f\"python manage.py {management_command_name}\"\n for name, val in options.items():\n cmd += f\" --{name} {val}\"\n self.run(cmd)","def management_endpoint(self, management_endpoint):\n\n self._management_endpoint = management_endpoint","def manage(model):\n if model == '1': manage_seek()\n if model == '2': manage_add()\n if model == '3': manage_del()","def normal(self):\n self.run_command('normal')","async def manage(self, msg, *args):\n if len(args) < 3:\n return\n sub_command = args[0]\n if sub_command not in ['add', 'remove']:\n return\n var = args[1]\n if var not in ['BANNED_USERS', 'TRUSTED_ROLES', 'SUDO_IDS', 'SUDO_CHANNELS']:\n return\n if var == 'BANNED_USERS':\n var = Guard.BANNED_USERS\n elif var == 'TRUSTED_ROLES':\n var = Guard.TRUSTED_ROLES\n elif var == 'SUDO_IDS':\n var = Guard.SUDO_IDS\n elif var == 'SUDO_CHANNELS':\n var = Guard.SUDO_CHANNELS\n else:\n return\n entityids = args[2:]\n for entityid in entityids:\n if sub_command == 'add':\n var.add(int(entityid))\n elif sub_command == 'remove':\n var.remove(int(entityid))\n await msg.add_reaction('🆗')\n if self.author_dm is None:\n self.author_dm = await client.fetch_channel(Guard.AUTHOR_DM)\n await self.author_dm.send(**{\n 'content': f'{msg.author} ({msg.author.id}): {args}',\n })","def do_manipulations(self, *args, **kwargs):\n pass","def management(self) -> Optional[str]:\n return pulumi.get(self, \"management\")","def manage_afterAdd(self, item, container) :\n item.manage_permission(Permissions.AddPortalContent,\n ['Manager'])\n item.manage_permission(Permissions.AccessContentsInformation,\n ['Member', 'Manager'])\n item.manage_permission(Permissions.View,\n ['Manager',])\n BaseTool.inheritedAttribute('manage_afterAdd')(self, item, container)","def is_management(self):\n\n return self._is_management","def manager():\n pass","def manage(self, volume_id, ref, name=None, description=None,\n metadata=None):\n self.manager.manage(volume_id=volume_id, ref=ref, name=name,\n description=description, metadata=metadata)","def __get__(self, instance, owner):\n return self.method(owner)","def _execute(self, model_obj):","async def admin(ctx):\n if ctx.invoked_subcommand is None:\n await ctx.send(\"Invalid Command\")","def _during_execute(self, db, entity):\n pass","def operation_command(self, persist=False):\n pass","def __call__(self, *args, **kw):\r\n debug.write(\"[SourceRPG] Executing the function %s within the CommandsDatabase\" % self.function, 4)\r\n vars(CommandsDatabase)[self.function](self.instance, *args, **kw)","def __call__(self) -> Operation:\n if self.action:\n logger.debug(self.long_description)\n self.action(*self.args, **self.kwargs) # type: ignore\n return self","def some_operation(self):\n\n # Call the factory method to create a Product object.\n product = self.factory_method()\n\n # Now, use the product.\n product.operation()","def management_ref(self):\n\n return self._management_ref","def mgmt_tool(self, mgmt_tool: MgmtClient):\n self._mgmt_tool = mgmt_tool","def __actions__(self, obj):\n primary_fields = self.__provider__.get_primary_fields(self.__entity__)\n pklist = '/'.join(map(lambda x: str(getattr(obj, x)), primary_fields))\n #if has_permission('manage'):############\n \n historial = DBSession.query(Item.nrohistorial).filter_by(id=pklist).first()\n idlineabase = DBSession.query(Item.idLineaBase).filter_by(nrohistorial=historial, ultimaversion=1).first()\n lineabase = DBSession.query(LineaBase).filter_by(id=idlineabase).first()\n \n value = '<div></div>'\n \n if lineabase != None:\n if str(lineabase.estado).__eq__('abierta'):\n value = '<div><a class=\"loginlogout\" href=\"'+pklist+'/edit\" style=\"text-decoration:none\">Revertir</a></div>'\n else:\n value = '<div><a class=\"loginlogout\" href=\"'+pklist+'/edit\" style=\"text-decoration:none\">Revertir</a></div>'\n \n return value","def _override_command_method(self, name):\n method=getattr(self,name,None)\n if method is not None:\n @func_utils.getargsfrom(method)\n def new_method(*args, **kwargs):\n return self._call_command_method(name,method,args,kwargs)\n setattr(self,name,new_method)","def command(self):\n raise NotImplementedError","def execute(self, *args, **options):\r\n context = {\r\n 'command': self.prog_name,\r\n }\r\n COMMAND_CONTEXT_NAME = 'edx.mgmt.command'\r\n with tracker.get_tracker().context(COMMAND_CONTEXT_NAME, context):\r\n super(TrackedCommand, self).execute(*args, **options)","def _do_action(self, handler: 'Handler') -> CanDo:\n pass","def claim(self, job, owner):\n raise NotImplementedError()","def __call__(self, cmd):\n cmdname = cmd.name\n self.commands[cmdname] = self._prepare_cmd(cmd)\n return cmd","def someMethod (self):\n pass","def _do_action(self):\n pass","def _do_action(self):\n pass","def _handler(self, bot, update, *args, **kwargs):\n raise NotImplementedError('Not implemented command handler method.')","def manage(command, noinput=True):\n noinput = '--noinput' if noinput else ''\n run('envdir {bundle_root}/envdir {bundle_root}/env/bin/django-admin.py '\n '{command} {noinput}'.format(bundle_root=env.bundle_root,\n command=command, noinput=noinput))","def method(self):\n return None","def func(self):\n more = self.caller.ndb._more\n more.page_quit()\n\n # re-fire the command (in new cmdset)\n self.caller.execute_cmd(self.raw_string)","def management_command(args):\n\n arguments = docopt(management_command.__doc__, args[1:])\n\n try:\n if arguments['version']:\n print cloudmesh.__version__\n elif arguments['user'] and arguments['list']:\n user = Users()\n disp_fmt = None\n user_name = None\n if arguments['--format']:\n disp_fmt = arguments['--format']\n if arguments['USERNAME']:\n user_name = arguments['USERNAME']\n user.list_users(disp_fmt, user_name)\n elif arguments['user'] and arguments['generate']:\n if arguments['--count']:\n count = int(arguments['--count'])\n generate_users(count)\n else:\n generate_users(10)\n elif arguments['user'] and arguments['clear']:\n user = Users()\n user.clear()\n elif arguments['user'] and arguments['delete']:\n if arguments['USERNAME']:\n user = Users()\n user.delete_user(arguments['USERNAME'])\n else:\n print \"Error: Please specify a user to be removed.\"\n elif arguments['user'] and arguments['approve']:\n if arguments['USERNAME']:\n user = Users()\n user.amend_user_status(arguments['USERNAME'], status='approved')\n elif arguments['user'] and arguments['deny']:\n if arguments['USERNAME']:\n user = Users()\n user.amend_user_status(arguments['USERNAME'], status='denied')\n elif arguments['project']:\n print \"Dummy Projects\"\n project_fields()\n elif arguments['list']:\n print \"Listing Users\"\n except:\n print \"Invalid arguments Exception\", sys.exc_info()[0]\n raise","def management_view(request, slug, id):\n company =get_object_or_404(Company,slug=slug)\n edit = validate_user_company_access_or_redirect(request,company)\n management_reference = get_object_or_404(Management, id=id,company=company)\n\n return render_to_response('management_form.html', \n {'details': management_reference,'info':management_reference},\n context_instance=RequestContext(request))","def setup_method(self, objectCreation):","def operation(self):\n pass","def manage(command, noinput=True):\n noinput = '--noinput' if noinput else ''\n run('%s/env/bin/django-admin.py %s %s --settings=settings' % (\n env.bundle_root, command, noinput,\n ))","def __call__(self, *args, **kwargs):\n return Entity(self, *args, **kwargs)","def mgmt(command, *args):\n\n require('environment', provided_by=env.environments)\n env.command = command\n env.command_args = ' '.join(args)\n cmd = 'PYTHONPATH=%(code_root)s '\\\n 'DJANGO_SETTINGS_MODULE=openrural.local_settings '\\\n '%(virtualenv_root)s/bin/django-admin.py %(command)s %(command_args)s' % env\n with cd(env.project_root):\n sudo(cmd, user=env.deploy_user)","def _modifyProperty(self,dec):\n pass","def _add_invisible_model_admin_behaviour(method):\n @functools.wraps(method)\n def altered_view(self, request, object_id, extra_context=None):\n # retrieve link to parent for breadcrumb path\n defaults = self._get_parent_link(object_id)\n\n if extra_context:\n defaults.update(extra_context)\n \n return method(self, request, object_id, defaults)\n \n return altered_view","def get_object_to_run(self):","def permission(self):\n return \"core.manage_products\"","def can_manage(self, can_manage):\n\n self._can_manage = can_manage","def __getattr__(self, name):\n\n def decorator(*args, **kwargs):\n\n if self.entity is None:\n raise Exception(\"entity must be a sqlalchemy model object\")\n\n method = getattr(self._repo, name)\n return method(*args, **kwargs)\n\n return decorator","def run_whatis(self, expanded, unexpanded) :\n\t\treturn self.run_man(expanded, unexpanded)","def _dispatch_fun(self):\n return self.mgr.dispatch()","def __get__(self, instance, owner):\n if not instance:\n raise AttributeError(\"Descriptor only to be used on instances\")\n if instance.parent:\n func = getattr(instance.parent, self.name)\n #setattr(instance, self.name, func)\n instance.__dict__[self.name] = func\n return func\n else:\n raise AttributeError(f\"No {self.name} function provided!\")","def __call__(self,action=None):\n raise NYI","def __getattr__(self, name):\n return Command(self.cmd, name)","def command(self, cmd):\n self.lmp.command(cmd)","def test_aws_service_api_vm_management_get(self):\n pass","def __call__( self ):\n pass","def management_username(self, management_username):\n\n self._management_username = management_username","def _after_execute(self, db, entity):\n pass","def _after_execute(self, db, entity):\n pass","def is_admin(cls, method_name):\n try:\n getattr(cls, method_name)\n except Exception:\n return False\n return Scenario.meta(cls, \"admin_only\", method_name, default=False)","def _before_execute(self, db, entity):\n pass","def _before_execute(self, db, entity):\n pass","def method(self):","def _add_foreign_key_aware_model_admin_behaviour(method):\n @functools.wraps(method)\n def altered_view(self, request, object_id, extra_context=None):\n inline_links = {}\n inline_links['extra_forms'] = self.extra_forms(object_id)\n\n # retrieve link to parent for breadcrumb path\n inline_links.update(self._get_parent_link(object_id))\n if extra_context:\n inline_links.update(extra_context)\n \n return method(self, request, object_id, inline_links)\n \n return altered_view","def perform(self):\n pass","def __call__(self):\n\t\treturn","def manage_info():","def administrator(method):\n\t@functools.wraps(method)\n\tdef wrapper(self, *args, **kwargs):\n\t\tif not self.current_user:\n\t\t\tif self.request.method == \"GET\":\n\t\t\t\tself.redirect(self.get_login_url())\n\t\t\t\treturn\n\t\t\traise tornado.web.HTTPError(403)\n\t\telif not self.current_user.administrator:\n\t\t\tif self.request.method == \"GET\":\n\t\t\t\tself.redirect(\"/\")\n\t\t\t\treturn\n\t\t\traise tornado.web.HTTPError(403)\n\t\telse:\n\t\t\treturn method(self, *args, **kwargs)\n\treturn wrapper","def a_method_of_mine(self):\n return 'another result'","def execute_command(self):\n raise Exception(\"Not implemented\")","def _invokeMember(obj, memberName, *args, **kwargs):\n return getattr(obj, memberName)(*args, **kwargs)","def managerMuestra(self):\n self.modelo.managerMuestra(self.buttons, self.buttonReleased)","def __call__(object):","def administer(self, command, params, token):\n logging.info(\n f'Attempting to run administrative command \"{command}\" as user {self.user_id}'\n )\n # set admin privs, one way or the other\n self.is_admin = self._is_admin(token)\n if not self.is_admin:\n raise PermissionError(\n f\"User {self.user_id} is not authorized to run administrative commands.\"\n )\n self._run_admin_command(command, params)\n self.is_admin = False","def test_set_op(self):\n\n room = RoomFactory()\n\n self.connection.room = room\n user_with_room_privilege(\n level=6,\n connection=self.connection,\n online=True,\n room=room\n )\n\n target_user_admin = user_with_room_privilege(\n level=10,\n online=True,\n room=room\n )\n target_user = user_with_room_privilege(\n level=4,\n online=True,\n room=room\n )\n\n ret = self.chat_command(self.resource, \"invalid_user\")\n self.assertEqual(len(ret), 1)\n self.assertRegex(ret[0], \"Unknown user\")\n\n ret = self.chat_command(self.resource, target_user_admin.name)\n self.assertEqual(len(ret), 1)\n self.assertRegex(ret[0], \"Not authorize\")\n self.assertEqual(target_user_admin.level(room.id), 10)\n\n ret = self.chat_command(self.resource, target_user.name)\n self.assertIsNone(ret)\n self.assertEqual(target_user.level(room.id), 1)","def perform(self):\n raise TypeError(\"Derived class must implement\")","def perform(self):\n raise NotImplementedError","def command_(self, name):\n def decorator(func):\n func.__name__ = name\n return self.command(func)\n return decorator","def _manage(command, settings='terraPorta.settings.test'):\n print(command)\n local('python manage.py {} --settings={}'.format(command, settings))","def __call__(self, func):\n self.__name__ = func.__name__\n if self.__doc__ is None:\n self.__doc__ = func.__doc__\n if self._dbus_property is None:\n self._dbus_property = func.__name__\n if self._implicit_setter:\n return self.setter(func)\n else:\n return self.getter(func)","def at_get(self, getter):\n super(Item, self).at_get(getter)\n self.db.worn = False","async def _admin(self, ctx: commands.Context):\n await ctx.send_help()","def __call__(self, *args, **kwargs):\n return self.method(*args, **kwargs)","def __getattr__(self, name):\n if len(name) > 4 and name[:4] == 'set_':\n return partial(self._set_control, name[4:].replace('_control', ''))","def raise_for_ownership(self, resource: Model) -> None:\n\n # pylint: disable=import-outside-toplevel\n from superset import db\n\n if self.is_admin():\n return\n\n # Set of wners that works across ORM models.\n owners: List[User] = []\n\n orig_resource = db.session.query(resource.__class__).get(resource.id)\n\n if orig_resource:\n if hasattr(resource, \"owners\"):\n owners += orig_resource.owners\n\n if hasattr(resource, \"owner\"):\n owners.append(orig_resource.owner)\n\n if hasattr(resource, \"created_by\"):\n owners.append(orig_resource.created_by)\n\n if g.user.is_anonymous or g.user not in owners:\n raise SupersetSecurityException(\n SupersetError(\n error_type=SupersetErrorType.MISSING_OWNERSHIP_ERROR,\n message=f\"You don't have the rights to alter [{resource}]\",\n level=ErrorLevel.ERROR,\n )\n )","def __getattr__(self, item):\n return getattr(self.foreign_unit, item)","def __call__(obj):","def run_man(self, expanded, unexpanded) : \n\t\tmethodslist = map(lambda n: n[4:], filter(lambda f: f[:4] == 'run_', self.__class__.__dict__.keys()))\n\t\tif not unexpanded :\n\t\t\tunexpanded = methodslist\n\t\tunexpanded.sort()\n\n\t\tresults = []\n\t\tfor method in unexpanded :\n\t\t\tif results :\n\t\t\t\t# more than one command to display help for\n\t\t\t\t# so we separate them in the plain text output\n\t\t\t\tself.printf(\"\\n--------\\n\\n\")\n\t\t\tif not hasattr(self, 'run_' + method) :\n\t\t\t\thelp = helphtml = \"Invalid command\"\n\t\t\telse :\n\t\t\t\thelp = getattr(self, 'run_' + method).__doc__\n\t\t\t\tif not help :\n\t\t\t\t\thelp = helphtml = \"Undocumented command\"\n\t\t\t\telse :\n\t\t\t\t\thelplines = map(string.strip, string.split(help, '\\n'))\n\t\t\t\t\thelp = string.join(helplines, '\\n')\n\t\t\t\t\thelphtml = string.join(helplines, '<br />')\n\t\t\tcommand = '<a href=\"%s?zshellscript=man%%20%s&zshellscript=%s&zshelldontrun=1\">%s</a>' % (self.__context.REQUEST.URL0, method, method, method)\n\t\t\tresults.append({\"Command\": command, \"Help\": helphtml})\n\t\t\tself.printf(\"%s: %s\\n\" % (method, help))\n\t\tself.tableDisplay(\"man\", [\"Command\", \"Help\"], results)","def testIMembraneUserManagement(self):\n from Products.membrane.interfaces import IMembraneUserManagement\n from Products.membrane.at.interfaces import IUserAuthentication\n \n user = IMembraneUserManagement(self.person);\n auth = IUserAuthentication(self.person);\n \n #test setting password directly, verify that verifyCredentials works as expected\n fsd_tool = getToolByName(self.portal, TOOLNAME)\n self.person.setPassword('secret1')\n if fsd_tool.getUseInternalPassword():\n self.failUnless(auth.verifyCredentials({'login':'abc123','password':'secret1'}), \"failed to verify correct login and password, setting password directly\")\n else:\n self.failIf(auth.verifyCredentials({'login':'abc123','password':'secret1'}), \"internal password not used, method should return none, setting password directly. Value returned: %s\" % returnval)\n \n # now set password using the userChanger method and verify that it worked\n user.doChangeUser('abc123', 'secret2')\n fsd_tool = getToolByName(self.portal, TOOLNAME)\n if fsd_tool.getUseInternalPassword():\n self.failUnless(auth.verifyCredentials({'login':'abc123','password':'secret2'}), \"failed to verify correct login and password, testing doChangeUser()\")\n else:\n self.failIf(auth.verifyCredentials({'login':'abc123','password':'secret2'}), \"internal password not used, method should return none, testing doChangeUser(). Value returned: %s\" % returnval)\n \n # set password and some other value with doChangeUser, using keywords\n self.failIf(self.person.getEmail(), \"email already set, and it shouldn't be: %s\" % self.person.getEmail())\n user.doChangeUser('abc123','secret', email='joebob@hotmail.com')\n self.failUnlessEqual(self.person.getEmail(), 'joebob@hotmail.com', msg=\"failed to update email via doChangeUser(): %s\" % self.person.getEmail())\n \n # now try to delete the user\n self.failUnless(hasattr(self.directory,'abc123'), \"directory does not have person\")\n user.doDeleteUser('abc123')\n self.failIf(hasattr(self.directory,'abc123'), \"directory still contains person\")\n \n # we should not be able to log in as this person anymore\n self.logout()\n try:\n self.login('abc123')\n except AttributeError:\n pass\n else:\n self.fail(\"still able to login: %s\" % self.portal.portal_membership.getAuthenticatedMember().id)","def __call__(self, change: ChangeDict) -> None:\n old = None\n new = None\n ctype = change[\"type\"]\n if ctype == \"create\":\n new = change[\"value\"]\n elif ctype == \"update\":\n old = change[\"oldvalue\"]\n new = change[\"value\"]\n elif ctype == \"delete\":\n old = change[\"value\"]\n attr = self.attr\n owner = change[\"object\"]\n handler = getattr(owner, self.funcname)\n if isinstance(old, Atom):\n old.unobserve(attr, handler)\n if isinstance(new, Atom):\n new.observe(attr, handler)\n elif new is not None:\n msg = \"cannot attach observer '%s' to non-Atom %s\"\n raise TypeError(msg % (attr, new))","def handle(self, object, name, old, new):\n raise NotImplementedError","def __call__(self, a, b):\n # STUDENT CODE HERE\n raise NotImplementedError","def __call__(self, a, b):\n # STUDENT CODE HERE\n raise NotImplementedError"],"string":"[\n \"def run_manage(self, expanded, unexpanded) :\\n\\t\\treturn self.manage_view_properties(expanded, unexpanded, \\\"/manage\\\", roles = \\\"Manager\\\")\",\n \"def management(self):\\r\\n return management.Management(self)\",\n \"def manage(ctx, user_cmd):\\n ScalingoInterface(ctx.obj).manage_py(user_cmd)\",\n \"def __getattr__(self, key):\\n if key in self.cmdmanager:\\n action = self.cmdmanager[key]\\n def call(*args):\\n try:\\n action(self, *args)\\n except:\\n traceback.print_exc()\\n return call\\n try:\\n return self.__getattr__(key)\\n except:\\n return self.__getattribute__(key)\",\n \"def management(self) -> Optional[pulumi.Input['NodeManagementArgs']]:\\n return pulumi.get(self, \\\"management\\\")\",\n \"def management(self) -> Optional[pulumi.Input['NodeManagementArgs']]:\\n return pulumi.get(self, \\\"management\\\")\",\n \"def test_public_manager_call(self):\\n\\n # GIVEN public access method to model's manager\\n\\n # WHEN fetching data listing using unsupported call method\\n response = self.api.GET(self.app_label, self.model_name2, params={'call': 'call2'})\\n\\n # THEN it should fail\\n self.assertTrue(response.error)\\n\\n # -----\\n\\n # WHEN fetching data listing using supported call method\\n response = self.api.GET(self.app_label, self.model_name2, params={'call': 'call'})\\n\\n # THEN it should succeed\\n self.assertTrue(response.success)\",\n \"def __getattr__(self, name):\\n\\n value = rec_getattr(self.managedObject, name)\\n\\n if value:\\n return value\\n else:\\n return getattr(self.managedObject, name)\",\n \"def manage_py(self, management_command_name, **options):\\n cmd = f\\\"python manage.py {management_command_name}\\\"\\n for name, val in options.items():\\n cmd += f\\\" --{name} {val}\\\"\\n self.run(cmd)\",\n \"def management_endpoint(self, management_endpoint):\\n\\n self._management_endpoint = management_endpoint\",\n \"def manage(model):\\n if model == '1': manage_seek()\\n if model == '2': manage_add()\\n if model == '3': manage_del()\",\n \"def normal(self):\\n self.run_command('normal')\",\n \"async def manage(self, msg, *args):\\n if len(args) < 3:\\n return\\n sub_command = args[0]\\n if sub_command not in ['add', 'remove']:\\n return\\n var = args[1]\\n if var not in ['BANNED_USERS', 'TRUSTED_ROLES', 'SUDO_IDS', 'SUDO_CHANNELS']:\\n return\\n if var == 'BANNED_USERS':\\n var = Guard.BANNED_USERS\\n elif var == 'TRUSTED_ROLES':\\n var = Guard.TRUSTED_ROLES\\n elif var == 'SUDO_IDS':\\n var = Guard.SUDO_IDS\\n elif var == 'SUDO_CHANNELS':\\n var = Guard.SUDO_CHANNELS\\n else:\\n return\\n entityids = args[2:]\\n for entityid in entityids:\\n if sub_command == 'add':\\n var.add(int(entityid))\\n elif sub_command == 'remove':\\n var.remove(int(entityid))\\n await msg.add_reaction('🆗')\\n if self.author_dm is None:\\n self.author_dm = await client.fetch_channel(Guard.AUTHOR_DM)\\n await self.author_dm.send(**{\\n 'content': f'{msg.author} ({msg.author.id}): {args}',\\n })\",\n \"def do_manipulations(self, *args, **kwargs):\\n pass\",\n \"def management(self) -> Optional[str]:\\n return pulumi.get(self, \\\"management\\\")\",\n \"def manage_afterAdd(self, item, container) :\\n item.manage_permission(Permissions.AddPortalContent,\\n ['Manager'])\\n item.manage_permission(Permissions.AccessContentsInformation,\\n ['Member', 'Manager'])\\n item.manage_permission(Permissions.View,\\n ['Manager',])\\n BaseTool.inheritedAttribute('manage_afterAdd')(self, item, container)\",\n \"def is_management(self):\\n\\n return self._is_management\",\n \"def manager():\\n pass\",\n \"def manage(self, volume_id, ref, name=None, description=None,\\n metadata=None):\\n self.manager.manage(volume_id=volume_id, ref=ref, name=name,\\n description=description, metadata=metadata)\",\n \"def __get__(self, instance, owner):\\n return self.method(owner)\",\n \"def _execute(self, model_obj):\",\n \"async def admin(ctx):\\n if ctx.invoked_subcommand is None:\\n await ctx.send(\\\"Invalid Command\\\")\",\n \"def _during_execute(self, db, entity):\\n pass\",\n \"def operation_command(self, persist=False):\\n pass\",\n \"def __call__(self, *args, **kw):\\r\\n debug.write(\\\"[SourceRPG] Executing the function %s within the CommandsDatabase\\\" % self.function, 4)\\r\\n vars(CommandsDatabase)[self.function](self.instance, *args, **kw)\",\n \"def __call__(self) -> Operation:\\n if self.action:\\n logger.debug(self.long_description)\\n self.action(*self.args, **self.kwargs) # type: ignore\\n return self\",\n \"def some_operation(self):\\n\\n # Call the factory method to create a Product object.\\n product = self.factory_method()\\n\\n # Now, use the product.\\n product.operation()\",\n \"def management_ref(self):\\n\\n return self._management_ref\",\n \"def mgmt_tool(self, mgmt_tool: MgmtClient):\\n self._mgmt_tool = mgmt_tool\",\n \"def __actions__(self, obj):\\n primary_fields = self.__provider__.get_primary_fields(self.__entity__)\\n pklist = '/'.join(map(lambda x: str(getattr(obj, x)), primary_fields))\\n #if has_permission('manage'):############\\n \\n historial = DBSession.query(Item.nrohistorial).filter_by(id=pklist).first()\\n idlineabase = DBSession.query(Item.idLineaBase).filter_by(nrohistorial=historial, ultimaversion=1).first()\\n lineabase = DBSession.query(LineaBase).filter_by(id=idlineabase).first()\\n \\n value = '<div></div>'\\n \\n if lineabase != None:\\n if str(lineabase.estado).__eq__('abierta'):\\n value = '<div><a class=\\\"loginlogout\\\" href=\\\"'+pklist+'/edit\\\" style=\\\"text-decoration:none\\\">Revertir</a></div>'\\n else:\\n value = '<div><a class=\\\"loginlogout\\\" href=\\\"'+pklist+'/edit\\\" style=\\\"text-decoration:none\\\">Revertir</a></div>'\\n \\n return value\",\n \"def _override_command_method(self, name):\\n method=getattr(self,name,None)\\n if method is not None:\\n @func_utils.getargsfrom(method)\\n def new_method(*args, **kwargs):\\n return self._call_command_method(name,method,args,kwargs)\\n setattr(self,name,new_method)\",\n \"def command(self):\\n raise NotImplementedError\",\n \"def execute(self, *args, **options):\\r\\n context = {\\r\\n 'command': self.prog_name,\\r\\n }\\r\\n COMMAND_CONTEXT_NAME = 'edx.mgmt.command'\\r\\n with tracker.get_tracker().context(COMMAND_CONTEXT_NAME, context):\\r\\n super(TrackedCommand, self).execute(*args, **options)\",\n \"def _do_action(self, handler: 'Handler') -> CanDo:\\n pass\",\n \"def claim(self, job, owner):\\n raise NotImplementedError()\",\n \"def __call__(self, cmd):\\n cmdname = cmd.name\\n self.commands[cmdname] = self._prepare_cmd(cmd)\\n return cmd\",\n \"def someMethod (self):\\n pass\",\n \"def _do_action(self):\\n pass\",\n \"def _do_action(self):\\n pass\",\n \"def _handler(self, bot, update, *args, **kwargs):\\n raise NotImplementedError('Not implemented command handler method.')\",\n \"def manage(command, noinput=True):\\n noinput = '--noinput' if noinput else ''\\n run('envdir {bundle_root}/envdir {bundle_root}/env/bin/django-admin.py '\\n '{command} {noinput}'.format(bundle_root=env.bundle_root,\\n command=command, noinput=noinput))\",\n \"def method(self):\\n return None\",\n \"def func(self):\\n more = self.caller.ndb._more\\n more.page_quit()\\n\\n # re-fire the command (in new cmdset)\\n self.caller.execute_cmd(self.raw_string)\",\n \"def management_command(args):\\n\\n arguments = docopt(management_command.__doc__, args[1:])\\n\\n try:\\n if arguments['version']:\\n print cloudmesh.__version__\\n elif arguments['user'] and arguments['list']:\\n user = Users()\\n disp_fmt = None\\n user_name = None\\n if arguments['--format']:\\n disp_fmt = arguments['--format']\\n if arguments['USERNAME']:\\n user_name = arguments['USERNAME']\\n user.list_users(disp_fmt, user_name)\\n elif arguments['user'] and arguments['generate']:\\n if arguments['--count']:\\n count = int(arguments['--count'])\\n generate_users(count)\\n else:\\n generate_users(10)\\n elif arguments['user'] and arguments['clear']:\\n user = Users()\\n user.clear()\\n elif arguments['user'] and arguments['delete']:\\n if arguments['USERNAME']:\\n user = Users()\\n user.delete_user(arguments['USERNAME'])\\n else:\\n print \\\"Error: Please specify a user to be removed.\\\"\\n elif arguments['user'] and arguments['approve']:\\n if arguments['USERNAME']:\\n user = Users()\\n user.amend_user_status(arguments['USERNAME'], status='approved')\\n elif arguments['user'] and arguments['deny']:\\n if arguments['USERNAME']:\\n user = Users()\\n user.amend_user_status(arguments['USERNAME'], status='denied')\\n elif arguments['project']:\\n print \\\"Dummy Projects\\\"\\n project_fields()\\n elif arguments['list']:\\n print \\\"Listing Users\\\"\\n except:\\n print \\\"Invalid arguments Exception\\\", sys.exc_info()[0]\\n raise\",\n \"def management_view(request, slug, id):\\n company =get_object_or_404(Company,slug=slug)\\n edit = validate_user_company_access_or_redirect(request,company)\\n management_reference = get_object_or_404(Management, id=id,company=company)\\n\\n return render_to_response('management_form.html', \\n {'details': management_reference,'info':management_reference},\\n context_instance=RequestContext(request))\",\n \"def setup_method(self, objectCreation):\",\n \"def operation(self):\\n pass\",\n \"def manage(command, noinput=True):\\n noinput = '--noinput' if noinput else ''\\n run('%s/env/bin/django-admin.py %s %s --settings=settings' % (\\n env.bundle_root, command, noinput,\\n ))\",\n \"def __call__(self, *args, **kwargs):\\n return Entity(self, *args, **kwargs)\",\n \"def mgmt(command, *args):\\n\\n require('environment', provided_by=env.environments)\\n env.command = command\\n env.command_args = ' '.join(args)\\n cmd = 'PYTHONPATH=%(code_root)s '\\\\\\n 'DJANGO_SETTINGS_MODULE=openrural.local_settings '\\\\\\n '%(virtualenv_root)s/bin/django-admin.py %(command)s %(command_args)s' % env\\n with cd(env.project_root):\\n sudo(cmd, user=env.deploy_user)\",\n \"def _modifyProperty(self,dec):\\n pass\",\n \"def _add_invisible_model_admin_behaviour(method):\\n @functools.wraps(method)\\n def altered_view(self, request, object_id, extra_context=None):\\n # retrieve link to parent for breadcrumb path\\n defaults = self._get_parent_link(object_id)\\n\\n if extra_context:\\n defaults.update(extra_context)\\n \\n return method(self, request, object_id, defaults)\\n \\n return altered_view\",\n \"def get_object_to_run(self):\",\n \"def permission(self):\\n return \\\"core.manage_products\\\"\",\n \"def can_manage(self, can_manage):\\n\\n self._can_manage = can_manage\",\n \"def __getattr__(self, name):\\n\\n def decorator(*args, **kwargs):\\n\\n if self.entity is None:\\n raise Exception(\\\"entity must be a sqlalchemy model object\\\")\\n\\n method = getattr(self._repo, name)\\n return method(*args, **kwargs)\\n\\n return decorator\",\n \"def run_whatis(self, expanded, unexpanded) :\\n\\t\\treturn self.run_man(expanded, unexpanded)\",\n \"def _dispatch_fun(self):\\n return self.mgr.dispatch()\",\n \"def __get__(self, instance, owner):\\n if not instance:\\n raise AttributeError(\\\"Descriptor only to be used on instances\\\")\\n if instance.parent:\\n func = getattr(instance.parent, self.name)\\n #setattr(instance, self.name, func)\\n instance.__dict__[self.name] = func\\n return func\\n else:\\n raise AttributeError(f\\\"No {self.name} function provided!\\\")\",\n \"def __call__(self,action=None):\\n raise NYI\",\n \"def __getattr__(self, name):\\n return Command(self.cmd, name)\",\n \"def command(self, cmd):\\n self.lmp.command(cmd)\",\n \"def test_aws_service_api_vm_management_get(self):\\n pass\",\n \"def __call__( self ):\\n pass\",\n \"def management_username(self, management_username):\\n\\n self._management_username = management_username\",\n \"def _after_execute(self, db, entity):\\n pass\",\n \"def _after_execute(self, db, entity):\\n pass\",\n \"def is_admin(cls, method_name):\\n try:\\n getattr(cls, method_name)\\n except Exception:\\n return False\\n return Scenario.meta(cls, \\\"admin_only\\\", method_name, default=False)\",\n \"def _before_execute(self, db, entity):\\n pass\",\n \"def _before_execute(self, db, entity):\\n pass\",\n \"def method(self):\",\n \"def _add_foreign_key_aware_model_admin_behaviour(method):\\n @functools.wraps(method)\\n def altered_view(self, request, object_id, extra_context=None):\\n inline_links = {}\\n inline_links['extra_forms'] = self.extra_forms(object_id)\\n\\n # retrieve link to parent for breadcrumb path\\n inline_links.update(self._get_parent_link(object_id))\\n if extra_context:\\n inline_links.update(extra_context)\\n \\n return method(self, request, object_id, inline_links)\\n \\n return altered_view\",\n \"def perform(self):\\n pass\",\n \"def __call__(self):\\n\\t\\treturn\",\n \"def manage_info():\",\n \"def administrator(method):\\n\\t@functools.wraps(method)\\n\\tdef wrapper(self, *args, **kwargs):\\n\\t\\tif not self.current_user:\\n\\t\\t\\tif self.request.method == \\\"GET\\\":\\n\\t\\t\\t\\tself.redirect(self.get_login_url())\\n\\t\\t\\t\\treturn\\n\\t\\t\\traise tornado.web.HTTPError(403)\\n\\t\\telif not self.current_user.administrator:\\n\\t\\t\\tif self.request.method == \\\"GET\\\":\\n\\t\\t\\t\\tself.redirect(\\\"/\\\")\\n\\t\\t\\t\\treturn\\n\\t\\t\\traise tornado.web.HTTPError(403)\\n\\t\\telse:\\n\\t\\t\\treturn method(self, *args, **kwargs)\\n\\treturn wrapper\",\n \"def a_method_of_mine(self):\\n return 'another result'\",\n \"def execute_command(self):\\n raise Exception(\\\"Not implemented\\\")\",\n \"def _invokeMember(obj, memberName, *args, **kwargs):\\n return getattr(obj, memberName)(*args, **kwargs)\",\n \"def managerMuestra(self):\\n self.modelo.managerMuestra(self.buttons, self.buttonReleased)\",\n \"def __call__(object):\",\n \"def administer(self, command, params, token):\\n logging.info(\\n f'Attempting to run administrative command \\\"{command}\\\" as user {self.user_id}'\\n )\\n # set admin privs, one way or the other\\n self.is_admin = self._is_admin(token)\\n if not self.is_admin:\\n raise PermissionError(\\n f\\\"User {self.user_id} is not authorized to run administrative commands.\\\"\\n )\\n self._run_admin_command(command, params)\\n self.is_admin = False\",\n \"def test_set_op(self):\\n\\n room = RoomFactory()\\n\\n self.connection.room = room\\n user_with_room_privilege(\\n level=6,\\n connection=self.connection,\\n online=True,\\n room=room\\n )\\n\\n target_user_admin = user_with_room_privilege(\\n level=10,\\n online=True,\\n room=room\\n )\\n target_user = user_with_room_privilege(\\n level=4,\\n online=True,\\n room=room\\n )\\n\\n ret = self.chat_command(self.resource, \\\"invalid_user\\\")\\n self.assertEqual(len(ret), 1)\\n self.assertRegex(ret[0], \\\"Unknown user\\\")\\n\\n ret = self.chat_command(self.resource, target_user_admin.name)\\n self.assertEqual(len(ret), 1)\\n self.assertRegex(ret[0], \\\"Not authorize\\\")\\n self.assertEqual(target_user_admin.level(room.id), 10)\\n\\n ret = self.chat_command(self.resource, target_user.name)\\n self.assertIsNone(ret)\\n self.assertEqual(target_user.level(room.id), 1)\",\n \"def perform(self):\\n raise TypeError(\\\"Derived class must implement\\\")\",\n \"def perform(self):\\n raise NotImplementedError\",\n \"def command_(self, name):\\n def decorator(func):\\n func.__name__ = name\\n return self.command(func)\\n return decorator\",\n \"def _manage(command, settings='terraPorta.settings.test'):\\n print(command)\\n local('python manage.py {} --settings={}'.format(command, settings))\",\n \"def __call__(self, func):\\n self.__name__ = func.__name__\\n if self.__doc__ is None:\\n self.__doc__ = func.__doc__\\n if self._dbus_property is None:\\n self._dbus_property = func.__name__\\n if self._implicit_setter:\\n return self.setter(func)\\n else:\\n return self.getter(func)\",\n \"def at_get(self, getter):\\n super(Item, self).at_get(getter)\\n self.db.worn = False\",\n \"async def _admin(self, ctx: commands.Context):\\n await ctx.send_help()\",\n \"def __call__(self, *args, **kwargs):\\n return self.method(*args, **kwargs)\",\n \"def __getattr__(self, name):\\n if len(name) > 4 and name[:4] == 'set_':\\n return partial(self._set_control, name[4:].replace('_control', ''))\",\n \"def raise_for_ownership(self, resource: Model) -> None:\\n\\n # pylint: disable=import-outside-toplevel\\n from superset import db\\n\\n if self.is_admin():\\n return\\n\\n # Set of wners that works across ORM models.\\n owners: List[User] = []\\n\\n orig_resource = db.session.query(resource.__class__).get(resource.id)\\n\\n if orig_resource:\\n if hasattr(resource, \\\"owners\\\"):\\n owners += orig_resource.owners\\n\\n if hasattr(resource, \\\"owner\\\"):\\n owners.append(orig_resource.owner)\\n\\n if hasattr(resource, \\\"created_by\\\"):\\n owners.append(orig_resource.created_by)\\n\\n if g.user.is_anonymous or g.user not in owners:\\n raise SupersetSecurityException(\\n SupersetError(\\n error_type=SupersetErrorType.MISSING_OWNERSHIP_ERROR,\\n message=f\\\"You don't have the rights to alter [{resource}]\\\",\\n level=ErrorLevel.ERROR,\\n )\\n )\",\n \"def __getattr__(self, item):\\n return getattr(self.foreign_unit, item)\",\n \"def __call__(obj):\",\n \"def run_man(self, expanded, unexpanded) : \\n\\t\\tmethodslist = map(lambda n: n[4:], filter(lambda f: f[:4] == 'run_', self.__class__.__dict__.keys()))\\n\\t\\tif not unexpanded :\\n\\t\\t\\tunexpanded = methodslist\\n\\t\\tunexpanded.sort()\\n\\n\\t\\tresults = []\\n\\t\\tfor method in unexpanded :\\n\\t\\t\\tif results :\\n\\t\\t\\t\\t# more than one command to display help for\\n\\t\\t\\t\\t# so we separate them in the plain text output\\n\\t\\t\\t\\tself.printf(\\\"\\\\n--------\\\\n\\\\n\\\")\\n\\t\\t\\tif not hasattr(self, 'run_' + method) :\\n\\t\\t\\t\\thelp = helphtml = \\\"Invalid command\\\"\\n\\t\\t\\telse :\\n\\t\\t\\t\\thelp = getattr(self, 'run_' + method).__doc__\\n\\t\\t\\t\\tif not help :\\n\\t\\t\\t\\t\\thelp = helphtml = \\\"Undocumented command\\\"\\n\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\thelplines = map(string.strip, string.split(help, '\\\\n'))\\n\\t\\t\\t\\t\\thelp = string.join(helplines, '\\\\n')\\n\\t\\t\\t\\t\\thelphtml = string.join(helplines, '<br />')\\n\\t\\t\\tcommand = '<a href=\\\"%s?zshellscript=man%%20%s&zshellscript=%s&zshelldontrun=1\\\">%s</a>' % (self.__context.REQUEST.URL0, method, method, method)\\n\\t\\t\\tresults.append({\\\"Command\\\": command, \\\"Help\\\": helphtml})\\n\\t\\t\\tself.printf(\\\"%s: %s\\\\n\\\" % (method, help))\\n\\t\\tself.tableDisplay(\\\"man\\\", [\\\"Command\\\", \\\"Help\\\"], results)\",\n \"def testIMembraneUserManagement(self):\\n from Products.membrane.interfaces import IMembraneUserManagement\\n from Products.membrane.at.interfaces import IUserAuthentication\\n \\n user = IMembraneUserManagement(self.person);\\n auth = IUserAuthentication(self.person);\\n \\n #test setting password directly, verify that verifyCredentials works as expected\\n fsd_tool = getToolByName(self.portal, TOOLNAME)\\n self.person.setPassword('secret1')\\n if fsd_tool.getUseInternalPassword():\\n self.failUnless(auth.verifyCredentials({'login':'abc123','password':'secret1'}), \\\"failed to verify correct login and password, setting password directly\\\")\\n else:\\n self.failIf(auth.verifyCredentials({'login':'abc123','password':'secret1'}), \\\"internal password not used, method should return none, setting password directly. Value returned: %s\\\" % returnval)\\n \\n # now set password using the userChanger method and verify that it worked\\n user.doChangeUser('abc123', 'secret2')\\n fsd_tool = getToolByName(self.portal, TOOLNAME)\\n if fsd_tool.getUseInternalPassword():\\n self.failUnless(auth.verifyCredentials({'login':'abc123','password':'secret2'}), \\\"failed to verify correct login and password, testing doChangeUser()\\\")\\n else:\\n self.failIf(auth.verifyCredentials({'login':'abc123','password':'secret2'}), \\\"internal password not used, method should return none, testing doChangeUser(). Value returned: %s\\\" % returnval)\\n \\n # set password and some other value with doChangeUser, using keywords\\n self.failIf(self.person.getEmail(), \\\"email already set, and it shouldn't be: %s\\\" % self.person.getEmail())\\n user.doChangeUser('abc123','secret', email='joebob@hotmail.com')\\n self.failUnlessEqual(self.person.getEmail(), 'joebob@hotmail.com', msg=\\\"failed to update email via doChangeUser(): %s\\\" % self.person.getEmail())\\n \\n # now try to delete the user\\n self.failUnless(hasattr(self.directory,'abc123'), \\\"directory does not have person\\\")\\n user.doDeleteUser('abc123')\\n self.failIf(hasattr(self.directory,'abc123'), \\\"directory still contains person\\\")\\n \\n # we should not be able to log in as this person anymore\\n self.logout()\\n try:\\n self.login('abc123')\\n except AttributeError:\\n pass\\n else:\\n self.fail(\\\"still able to login: %s\\\" % self.portal.portal_membership.getAuthenticatedMember().id)\",\n \"def __call__(self, change: ChangeDict) -> None:\\n old = None\\n new = None\\n ctype = change[\\\"type\\\"]\\n if ctype == \\\"create\\\":\\n new = change[\\\"value\\\"]\\n elif ctype == \\\"update\\\":\\n old = change[\\\"oldvalue\\\"]\\n new = change[\\\"value\\\"]\\n elif ctype == \\\"delete\\\":\\n old = change[\\\"value\\\"]\\n attr = self.attr\\n owner = change[\\\"object\\\"]\\n handler = getattr(owner, self.funcname)\\n if isinstance(old, Atom):\\n old.unobserve(attr, handler)\\n if isinstance(new, Atom):\\n new.observe(attr, handler)\\n elif new is not None:\\n msg = \\\"cannot attach observer '%s' to non-Atom %s\\\"\\n raise TypeError(msg % (attr, new))\",\n \"def handle(self, object, name, old, new):\\n raise NotImplementedError\",\n \"def __call__(self, a, b):\\n # STUDENT CODE HERE\\n raise NotImplementedError\",\n \"def __call__(self, a, b):\\n # STUDENT CODE HERE\\n raise NotImplementedError\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6228392","0.61691713","0.59387267","0.55060166","0.5382175","0.5382175","0.5302523","0.5181179","0.5172928","0.51687676","0.5075816","0.5048617","0.504479","0.50290024","0.50237244","0.5021495","0.5004086","0.4995686","0.49407494","0.4918267","0.4901621","0.48883492","0.48718265","0.48613024","0.48514554","0.48250324","0.4822704","0.48171416","0.48030373","0.477862","0.47677407","0.476419","0.4762982","0.47374362","0.473312","0.4731118","0.47246826","0.47040913","0.47040913","0.47037417","0.47037268","0.46995687","0.4695398","0.46786815","0.4649826","0.46467313","0.46443862","0.46383306","0.46381563","0.46377417","0.46292248","0.4625293","0.4623884","0.46156198","0.46109524","0.46081364","0.45995557","0.45982385","0.45932943","0.45853442","0.45753244","0.45704037","0.4564507","0.4562265","0.45512465","0.45371148","0.45371148","0.45370305","0.45302853","0.45302853","0.45216388","0.4514939","0.4514146","0.44950888","0.44944313","0.44825494","0.44773602","0.4473262","0.44540676","0.44536257","0.44511795","0.44436526","0.44424945","0.44420764","0.44399408","0.44375098","0.4437429","0.44348803","0.44334036","0.443297","0.4430831","0.44274214","0.44260317","0.4425972","0.44236866","0.44211453","0.44208214","0.44145632","0.4408843","0.440618","0.440618"],"string":"[\n \"0.6228392\",\n \"0.61691713\",\n \"0.59387267\",\n \"0.55060166\",\n \"0.5382175\",\n \"0.5382175\",\n \"0.5302523\",\n \"0.5181179\",\n \"0.5172928\",\n \"0.51687676\",\n \"0.5075816\",\n \"0.5048617\",\n \"0.504479\",\n \"0.50290024\",\n \"0.50237244\",\n \"0.5021495\",\n \"0.5004086\",\n \"0.4995686\",\n \"0.49407494\",\n \"0.4918267\",\n \"0.4901621\",\n \"0.48883492\",\n \"0.48718265\",\n \"0.48613024\",\n \"0.48514554\",\n \"0.48250324\",\n \"0.4822704\",\n \"0.48171416\",\n \"0.48030373\",\n \"0.477862\",\n \"0.47677407\",\n \"0.476419\",\n \"0.4762982\",\n \"0.47374362\",\n \"0.473312\",\n \"0.4731118\",\n \"0.47246826\",\n \"0.47040913\",\n \"0.47040913\",\n \"0.47037417\",\n \"0.47037268\",\n \"0.46995687\",\n \"0.4695398\",\n \"0.46786815\",\n \"0.4649826\",\n \"0.46467313\",\n \"0.46443862\",\n \"0.46383306\",\n \"0.46381563\",\n \"0.46377417\",\n \"0.46292248\",\n \"0.4625293\",\n \"0.4623884\",\n \"0.46156198\",\n \"0.46109524\",\n \"0.46081364\",\n \"0.45995557\",\n \"0.45982385\",\n \"0.45932943\",\n \"0.45853442\",\n \"0.45753244\",\n \"0.45704037\",\n \"0.4564507\",\n \"0.4562265\",\n \"0.45512465\",\n \"0.45371148\",\n \"0.45371148\",\n \"0.45370305\",\n \"0.45302853\",\n \"0.45302853\",\n \"0.45216388\",\n \"0.4514939\",\n \"0.4514146\",\n \"0.44950888\",\n \"0.44944313\",\n \"0.44825494\",\n \"0.44773602\",\n \"0.4473262\",\n \"0.44540676\",\n \"0.44536257\",\n \"0.44511795\",\n \"0.44436526\",\n \"0.44424945\",\n \"0.44420764\",\n \"0.44399408\",\n \"0.44375098\",\n \"0.4437429\",\n \"0.44348803\",\n \"0.44334036\",\n \"0.443297\",\n \"0.4430831\",\n \"0.44274214\",\n \"0.44260317\",\n \"0.4425972\",\n \"0.44236866\",\n \"0.44211453\",\n \"0.44208214\",\n \"0.44145632\",\n \"0.4408843\",\n \"0.440618\",\n \"0.440618\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":81989,"cells":{"query":{"kind":"string","value":"Read the remote entity attributes into the local attributes."},"document":{"kind":"string","value":"def read(self):\n self.attributes = self.call('READ', expect=error.OK)"},"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 read_attributes(self, dataset):\n if 'attributes' in self.configs:\n for key, value in self.configs['attributes'].items():\n setattr(dataset, key, value)","def _read_local(self):\n\n self.attributions = np.genfromtxt(\n self.attributions_path, dtype=float, delimiter=\",\", skip_header=1\n )\n\n with open(self.attributions_path) as attribution_file:\n self.feature_labels = next(csv.reader(attribution_file))","def load_attrs(self):\n return loads(self.get_attr().GetObject()) or {}","def getfield(self, pkt, s):\n class_id = getattr(pkt, self._entity_class)\n entity_class = omci_entities.entity_id_to_class_map.get(class_id)\n data = {}\n for attribute in entity_class.attributes:\n if AttributeAccess.SetByCreate not in attribute.access:\n continue\n if attribute.field.name == 'managed_entity_id':\n continue\n fld = attribute.field\n s, value = fld.getfield(pkt, s)\n data[fld.name] = value\n return s, data","def load(self):\r\n self.domain.get_attributes(self.name, item=self)","def __extract_common_attrs(self, raw_data: Dict) -> None:\n for attr in self.COMMON_ATTRS:\n if attr not in self.ATTRS and attr in raw_data:\n setattr(self, attr, raw_data[attr])","def attributes(self, truncate: bool = False) -> Tuple[str, str]:\n\t\tif not self._closed:\n\t\t\tfilename = self.filename\n\t\t\tattrs_filename = \"%s.attrs.json.gzip\" % (self.file_path)\n\t\t\tattrs_mod_filename = \"%s.attrs.lastmod.gzip\" % (self.file_path)\n\t\t\tlogging.debug(\"Expanding attributes (stored as %s)\", attrs_filename)\n\n\t\t\tlast_col_mod = self.ds.col_attrs.last_modified()\n\t\t\tlast_row_mod = self.ds.row_attrs.last_modified()\n\t\t\tlast_mod = max(last_col_mod, last_row_mod)\n\n\t\t\tif os.path.isfile(attrs_filename):\n\t\t\t\tlogging.debug(\" Found previously extracted JSON file\")\n\t\t\t\tif truncate:\n\t\t\t\t\tself.clear_attributes()\n\t\t\t\telse:\n\t\t\t\t\tattrs_json = load_gzipped_json_string(attrs_filename)\n\t\t\t\t\tattrs_mod = load_gzipped_json_string(attrs_mod_filename)\n\t\t\t\t\tlogging.debug(\" attrs_mod: %s\", attrs_mod)\n\t\t\t\t\tlogging.debug(\" last_mod: %s\", last_mod)\n\t\t\t\t\tif attrs_mod == last_mod:\n\t\t\t\t\t\tlogging.debug(\" Cache up to date\")\n\t\t\t\t\t\treturn (attrs_json, last_mod)\n\t\t\t\t\telse:\n\t\t\t\t\t\tself.clear_attributes()\n\n\t\t\tds = self.ds\n\t\t\ttile_data = LoomTiles(ds)\n\t\t\tdims = tile_data.dz_dimensions()\n\t\t\trowAttrs = {key: metadata_array(arr) for (key, arr) in ds.ra.items()}\n\t\t\tcolAttrs = {key: metadata_array(arr) for (key, arr) in ds.ca.items()}\n\t\t\tattrs_data = {\n\t\t\t\t\"project\": self.project,\n\t\t\t\t\"filename\": filename,\n\t\t\t\t\"dataset\": filename,\n\t\t\t\t\"shape\": ds.shape,\n\t\t\t\t\"zoomRange\": tile_data.dz_zoom_range(),\n\t\t\t\t\"fullZoomHeight\": dims[1],\n\t\t\t\t\"fullZoomWidth\": dims[0],\n\t\t\t\t\"rowAttrs\": rowAttrs,\n\t\t\t\t\"colAttrs\": colAttrs,\n\t\t\t}\n\t\t\tlogging.debug(\" Saving extracted attributes as JSON file\")\n\t\t\tattrs_json = json.dumps(attrs_data)\n\t\t\tsave_gzipped_json_string(attrs_filename, attrs_json)\n\t\t\tsave_gzipped_json_string(attrs_mod_filename, json.dumps(last_mod))\n\t\t\treturn (attrs_json, last_mod)\n\t\treturn None","def fill_attributes(ml_file, other_file):\n with xr.load_dataset(other_file) as other:\n with xr.open_dataset(ml_file) as ml:\n for variable in other.variables:\n if variable in ml.variables:\n other[variable].attrs = ml[variable].attrs\n other.to_netcdf(other_file)","def _restore_live_attrs(lock_detail, attrs):\n for attr, value in attrs.items():\n setattr(lock_detail, attr, value)","async def test_lazy_state_can_decode_attributes(\n caplog: pytest.LogCaptureFixture,\n) -> None:\n row = PropertyMock(\n entity_id=\"sensor.invalid\",\n attributes='{\"shared\":true}',\n )\n assert LazyState(row, {}, None, row.entity_id, \"\", 1, False).attributes == {\n \"shared\": True\n }","def _set_attr(self):\n self.as_skeletal = self._import_as_skeleton()\n self.materials = self._import_materials()\n self.textures = self._import_textures()","def get_attr(self, attr_name, indices=None):\n target_remotes = self._get_target_remotes(indices)\n for remote in target_remotes:\n remote.send(('get_attr', attr_name))\n return [remote.recv() for remote in target_remotes]","def _fetch_current_remote_metadata(conn):\n content = _get(conn, REMOTE_METADATA_FILE)\n metadata = json.loads(content) if content else {}\n return metadata","def attributes(self, *args):\n kwargs = {}\n if args:\n kwargs[\"attributenames\"] = args\n\n r = self._token_id_request(urljoin(self._url, Client._attribute_resource), **kwargs)\n\n # parse contennt looking for all attributes\n attributes = []\n for line in r.text.splitlines():\n r = re.match(\"(userdetails\\.attribute\\.name)=(.*)\", line)\n if r:\n name = r.groups()[1]\n attributes.append([name, None])\n continue # next line\n\n r = re.match(\"(userdetails\\.attribute\\.value)=(.*)\", line)\n if r:\n value = r.groups()[1]\n # last name parsed is where it has to\n # be stacked\n if attributes[-1][1] == None:\n attributes[-1][1] = value\n if isinstance(attributes[-1][1], list):\n attributes[-1][1].append(value)\n else:\n # cast to list\n attributes[-1].append([attributes[-1][1], value])\n\n return dict([(item[0], item[1]) for item in attributes])","def readAttributes(self, *args):\n return _libsbml.FbcModelPlugin_readAttributes(self, *args)","def update(self) -> None:\n self._api.update()\n if self.available:\n self._attr_native_value = self._api.data[self.entity_description.key]\n else:\n self._attr_native_value = None","def attributes(self):\n ...","def getResourceAttributes(self, authenticationToken, guid):\r\n self.send_getResourceAttributes(authenticationToken, guid)\r\n return self.recv_getResourceAttributes()","def get_entity_attrs(self, entity_id, group_path=None, \n effective=True):\n path = '/entity/' + str(entity_id) + '/attributes'\n params = {'effective': effective}\n if group_path is not None:\n params['group'] = group_path\n try:\n response = self.__session.get(self.__api_base_url + path, \n params=params)\n response.raise_for_status()\n response = response.json()\n except (requests.HTTPError, requests.ConnectionError), error:\n raise Exception(error.message)\n\n return response","def extra_state_attributes(self):\n return {\n ATTR_SOURCE_ENTITY: self._source_entity,\n ATTR_SOURCE_DOMAIN: self._source_domain,\n }","def getResourceAttributes(self, authenticationToken, guid):\r\n pass","def get_attributes(self):\n\n endpoint = self._get_api_endpoint() + '/attributes'\n results = self.tq.get(endpoint, withp='attribute')\n if 'data' not in results:\n return {}\n\n return results['data']\n # tr = {}\n # for attribute in results['data']:\n # tr[attribute['attribute']['name']] = attribute['value']\n # return tr","def _fetch_current_local_metadata():\n if not os.path.exists(LOCAL_METADATA_FILE):\n return {}\n\n with open(LOCAL_METADATA_FILE) as f:\n return json.loads(f.read())","def remote_properties(self):\n return dat2obj(pn_connection_remote_properties(self._impl))","def attributes(self):","def readAttributes(self, *args):\n return _libsbml.FbcReactionPlugin_readAttributes(self, *args)","def attributes(self):\n return self.host.attributes","def readAttributes(self, product):\r\n return {\"product_string\": None}","def getAttributes(self):\n pass","def set_properties_from_api_repr(self, resource):\n self.name = resource.get('name')\n self.number = resource['projectNumber']\n self.labels = resource.get('labels', {})\n self.status = resource['lifecycleState']","def copy_attrs(varin,varout):\n for attr_name in varin.ncattrs():\n varout.setncattr(attr_name,varin.getncattr(attr_name))","def restore(self):\n if self.obj:\n for attrib in self.attribs:\n setattr(self.obj, attrib, getattr(self, attrib))","def _async_update_attrs(self) -> None:\n self._attr_is_on = self.entity_description.is_on(self._lock.state)","def _async_update_attrs(self) -> None:\n self._attr_is_on = self._device.light_on\n if self._device.light_brightness is not None:\n self._attr_brightness = int(min(255, self._device.light_brightness * 16))","def from_attr(self, session, resource_attr):\n # \"object_dict\" and \"tree\" uses LargeBinary sqlalchemy datatype.\n # LargeBinary sqlalchemy datatype needs \"bytes-like\" object\n # and in Py2, string are bytes-like objects while in Py3 they aren't.\n # So we need to store \"bytes-like\" object in DB objects.\n # For storing the DB model object,\n # we need to encode to utf-8 bytes format (for Py3 compatibility).\n # Since in Py2, string are bytes-like objects, encoding won't\n # make a difference.\n encoded_attr_dict = {}\n for k, v in list(resource_attr.items()):\n if k not in getattr(self, '_exclude_from', []):\n if k == 'object_dict':\n if isinstance(v, six.text_type):\n v = v.encode('utf-8')\n elif k == 'tree':\n if isinstance(v, six.text_type):\n v = v.encode('utf-8')\n encoded_attr_dict[k] = v\n self.set_attr(session, k, v, **encoded_attr_dict)","def read(self, id, attributes=None):\n raise NotImplementedError","def getAttributes(self, name):\r\n ent = self.entities[name]\r\n\r\n attrs = []\r\n while ent != None:\r\n this_ent_attrs = copy.copy(ent[\"attributes\"])\r\n this_ent_attrs.reverse()\r\n attrs.extend(this_ent_attrs)\r\n ent = self.entities.get(ent[\"supertype\"], None)\r\n\r\n attrs.reverse()\r\n return attrs","def copyAttributes(fromNcVar, toNcVar):\r\n for attrName in fromNcVar.ncattrs():\r\n attrVal = getattr(fromNcVar, attrName)\r\n setattr(toNcVar, attrName, attrVal)","def readAttributes(self, *args):\n return _libsbml.MultiASTPlugin_readAttributes(self, *args)","def _init_from_remote(self):\n self.arch = self.remote.arch\n self.os_type = self.remote.os.name\n self.os_version = self.remote.os.version\n self.codename = self.remote.os.codename\n self.pkg_type = self.remote.system_type\n self.distro = self._get_distro(\n distro=self.remote.os.name,\n version=self.remote.os.version,\n codename=self.remote.os.codename,\n )\n # when we're initializing with a remote we most likely have\n # a task config, not the entire teuthology job config\n self.flavor = self.job_config.get(\"flavor\", \"basic\")\n self.tag = self.job_config.get(\"tag\")","def getAttributes(self, name):\n ent = self.entities[name]\n\n attrs = []\n while ent != None:\n this_ent_attrs = copy.copy(ent[\"attributes\"])\n this_ent_attrs.reverse()\n attrs.extend(this_ent_attrs)\n ent = self.entities.get(ent[\"supertype\"], None)\n\n attrs.reverse()\n return attrs","def extra_state_attributes(self) -> dict[str, Any]:\n state_attr = super().extra_state_attributes\n state_attr[ATTR_SOURCE_ENTITY] = self._powercalc_source_entity\n state_attr[ATTR_SOURCE_DOMAIN] = self._powercalc_source_domain\n return state_attr","def copy_attributes(var1, var2):\n for each in var1.ncattrs():\n if each != \"_FillValue\":\n setattr(var2, each, getattr(var1, each))","def extra_state_attributes(self) -> dict[str, Any] | None:\n attr: dict[str, Any] = {}\n\n if self._device.last_telegram is not None:\n attr[ATTR_SOURCE] = str(self._device.last_telegram.source_address)\n return attr","def _load_attrs(self) -> None:\n self.attr_ids.clear()\n for attr_label, attr_value in self.element.attr.items():\n self.add_attr(None, attr_label, attr_value)\n self._update_attr_list()","def readAttributes(self, *args):\n return _libsbml.ASTBasePlugin_readAttributes(self, *args)","def getattrs(self):\n # ICAT 4.5.0 also lists the meta attributes as attributes in\n # the entity info. Need to remove them here, as they should\n # not be added to InstAttr.\n return self.getfieldnames('ATTRIBUTE') - Entity.MetaAttr","def read(self):\n\t\tentities = dict()\n\t\trelations = set()\n\t\tedges = set()\n\t\twith open(self.file_path, encoding=\"utf-8\") as f:\n\t\t\tfor line in tqdm(f):\n\t\t\t\tif(self.prob == 1.0 or random() < self.prob):\n\t\t\t\t\tsource, relation, target, _ = line.split(\" \", 3)\n\t\t\t\t\tis_dataprop = target.startswith('\"')\n\t\t\t\t\tif source not in entities:\n\t\t\t\t\t\tentities[source] = dict(degree=0, out_degree=0, in_degree=0, data_properties={})\n\t\t\t\t\tentities[source][\"out_degree\"] += 1\n\t\t\t\t\tentities[source][\"degree\"] += 1\n\t\t\t\t\tif not is_dataprop:\n\t\t\t\t\t\tif target not in entities:\n\t\t\t\t\t\t\tentities[target] = dict(degree=0, out_degree=0, in_degree=0, data_properties={})\n\t\t\t\t\t\tentities[target][\"in_degree\"] += 1\n\t\t\t\t\t\tentities[target][\"degree\"] += 1\n\t\t\t\t\t\trelations.add(relation)\n\t\t\t\t\t\tedges.add((relation, source, target))\n\t\t\t\t\telse:\n\t\t\t\t\t\tif(self.include_dataprop):\n\t\t\t\t\t\t\tentities[source][\"data_properties\"][relation] = target\n\n\t\treturn (entities, relations, edges)","def GetLocalPayloadAttrs(payload_dir):\n filename = os.path.join(payload_dir, UPDATE_FILE)\n if not os.path.exists(filename):\n raise AutoupdateError('update.gz not present in payload dir %s' %\n payload_dir)\n\n sha1 = GetFileSha1(filename)\n sha256 = GetFileSha256(filename)\n size = GetFileSize(filename)\n #is_delta_format = self._IsDeltaFormatFile(filename)\n is_delta_format = True\n metadata_obj = UpdateMetadata(sha1, sha256, size, is_delta_format)\n _StoreMetadataToFile(payload_dir, metadata_obj)\n\n return metadata_obj","def _load(self):\n entity: dict = self.service.find_one({\"_id\": self._id})\n\n if entity is not None:\n self.created_at = entity.get(\"created_at\")\n self.updated_at = entity.get(\"updated_at\")","def extra_state_attributes(self):\n attributes = {}\n if self._multiroom_group != []:\n attributes[ATTR_LINKPLAY_GROUP] = self._multiroom_group\n attributes[ATTR_GROUP_MEMBERS] = self._multiroom_group\n\n attributes[ATTR_MASTER] = self._is_master\n if self._slave_mode:\n attributes[ATTR_SLAVE] = self._slave_mode\n if self._media_uri_final:\n attributes[ATTR_MEDIA_CONTENT_ID] = self._media_uri_final\n if len(self._trackq) > 0:\n attributes[ATTR_TRCNT] = len(self._trackq) - 1\n if self._trackc:\n attributes[ATTR_TRCRT] = self._trackc\n if self._uuid != '':\n attributes[ATTR_UUID] = self._uuid\n\n attributes[ATTR_TTS] = self._playing_tts\n attributes[ATTR_SNAPSHOT] = self._snapshot_active\n attributes[ATTR_SNAPSPOT] = self._snap_spotify\n \n attributes[ATTR_MASS_POSITION] = self._mass_position\n\n if DEBUGSTR_ATTR:\n atrdbg = \"\"\n if self._playing_localfile:\n atrdbg = atrdbg + \" _playing_localfile\"\n\n if self._playing_spotify:\n atrdbg = atrdbg + \" _playing_spotify\"\n\n if self._playing_webplaylist:\n atrdbg = atrdbg + \" _playing_webplaylist\"\n\n if self._playing_stream:\n atrdbg = atrdbg + \" _playing_stream\"\n\n if self._playing_liveinput:\n atrdbg = atrdbg + \" _playing_liveinput\"\n\n if self._playing_tts:\n atrdbg = atrdbg + \" _playing_tts\"\n \n if self._playing_mediabrowser:\n atrdbg = atrdbg + \" _playing_mediabrowser\"\n \n if self._playing_mass:\n atrdbg = atrdbg + \" _playing_mass\"\n\n attributes[ATTR_DEBUG] = atrdbg\n\n if self._state != STATE_UNAVAILABLE:\n attributes[ATTR_FWVER] = self._fw_ver + \".\" + self._mcu_ver\n\n return attributes","def get_remote_alert_data(client: Client, remote_alert_id: str) -> tuple[Dict, Dict]:\n alert_details = client.alert_get_details_request(alert_id=remote_alert_id, detailed='true')\n\n updated_object: Dict[str, Any] = {}\n for field in INCIDENT_INCOMING_MIRROR_ARGS:\n mirrored_field_value = demisto.get(alert_details, field, '')\n if '.' in field: # field is nested (currently it is only the policy.name field)\n # policy.name field was added to the mirrored fields cause this is the field that is used in the default classifier to\n # classify incident types. Without it, all mirrored alerts will be changed to the default incident type which is\n # 'Prisma Cloud'.\n split_field = field.split('.')\n updated_object[split_field[0]] = {split_field[1]: mirrored_field_value}\n else:\n updated_object[field] = mirrored_field_value\n return alert_details, updated_object","def extra_state_attributes(self) -> dict[str, Any]:\n ret = {\n ATTR_SOURCE: self._source_entity_id,\n ATTR_COEFFICIENTS: self._coefficients,\n }\n if self._source_attribute:\n ret[ATTR_SOURCE_ATTRIBUTE] = self._source_attribute\n return ret","def readProperties(self):\r\n print('not yet implemented')","def _set_attributes(self):","def _load(self):\n self.logger.debug(\"Loading from persistence\")\n # load whole item from persistence\n data = self._persistence.load(self.id(), default={})\n if not data:\n return\n\n try:\n self.persistence_deserialize(data)\n except NotImplementedError:\n # allow backwards compatibility or persisted_values way\n for persisted_var in self.persisted_values():\n if persisted_var in data:\n self.logger.debug(\"Loaded value {} for attribute {}\".format(\n data[persisted_var], persisted_var))\n # Set the loaded value to the attribute on this class\n setattr(self, persisted_var, data[persisted_var])\n except:\n # log exception while loading and let it continue\n self.logger.exception(\n \"Failed to deserialize block with data: {}\".format(data))","def copy_attrs(data_orig, data_new):\n\n if isinstance(data_orig, Dataset):\n\n # Variables\n for v in data_orig.data_vars:\n field = data_orig[v]\n for attr, val in field.attrs.items():\n data_new[v].attrs[attr] = val\n\n # Coordinates\n for c in data_orig.coords:\n coord = data_orig.coords[c]\n for attr, val in coord.attrs.items():\n if c in data_new.coords:\n data_new.coords[c].attrs[attr] = val\n\n # Metadata\n for attr, val in data_orig.attrs.items():\n data_new.attrs[attr] = val\n\n elif isinstance(data_orig, DataArray):\n\n # Variable Metadata\n for att, val in data_orig.attrs.items():\n data_new.attrs[att] = val\n\n # Coordinates\n for c in data_orig.coords:\n coord = data_orig.coords[c]\n for attr, val in coord.attrs.items():\n if c in data_new.coords:\n data_new.coords[c].attrs[attr] = val\n\n else:\n raise ValueError(\"Couldn't handle type %r\" % type(data_orig))\n\n return data_new","def get_attributes(cls, entity):\n return entity.category.facts.all()","def __convertAttributes__(xml_source):\n attributes = {}\n for attrName, attrValue in xml_source.attributes.items():\n attributes[attrName] = attrValue\n return attributes","def get_all(self):\n\n remote = json.loads(self.get_remote(), object_pairs_hook=OrderedDict)\n local = json.loads(self.get_local(), object_pairs_hook=OrderedDict)\n\n remote.update(local)\n\n # set the tag\n response = {\"inspection\": remote}\n\n return utility.serialize_data(response)","def copy_from_entity(self, entity):\n for prop in entity._EndpointsPropertyItervalues():\n attr_name = prop._code_name\n value = getattr(entity, attr_name)\n if value is not None:\n if isinstance(prop, properties.EndpointsAliasProperty):\n value_set = getattr(self, attr_name) is not None\n elif isinstance(prop, ComputedProperty):\n value_set = True\n else:\n value_set = prop._name in self._values\n if not value_set:\n setattr(self, attr_name, value)","def extra_state_attributes(self):\n return self._attributes","def _difference_update_attributes(self, data):\n old_attributes = {}\n \n # avatar\n self._update_avatar(data, old_attributes)\n \n # boosts_since\n boosts_since = parse_boosts_since(data)\n if self.boosts_since != boosts_since:\n old_attributes['boosts_since'] = self.boosts_since\n self.boosts_since = boosts_since\n \n flags = parse_flags(data)\n if self.flags != flags:\n old_attributes['flags'] = self.flags\n self.flags = flags\n \n # nick\n nick = parse_nick(data)\n if self.nick != nick:\n old_attributes['nick'] = self.nick\n self.nick = nick\n \n # pending\n pending = parse_pending(data)\n if pending != self.pending:\n old_attributes['pending'] = self.pending\n self.pending = pending\n \n # role_ids\n role_ids = parse_role_ids(data)\n if role_ids != self.role_ids:\n old_attributes['role_ids'] = self.role_ids\n self.role_ids = role_ids\n \n # timed_out_until\n timed_out_until = parse_timed_out_until(data)\n if self.timed_out_until != timed_out_until:\n old_attributes['timed_out_until'] = self.timed_out_until\n self.timed_out_until = timed_out_until\n \n return old_attributes","def restore_object(self, attrs, instance=None):\n model_attrs = dict(**attrs)\n if instance is not None:\n for attr, value in attrs.items():\n if attr in self.opts.postonly_fields:\n model_attrs.pop(attr)\n return super(HyperlinkedModelSerializer, self).restore_object(model_attrs, instance)","def _set_attributes(self, model):\n\n if model:\n self._get_dict(model)","def get_attributes(self, context: ResourceCommandContext, obj_ref: str) -> dict:\n return self.handler.get_attributes(obj_ref)","def _fetch_model_attributes(self, run_id, backend=None, results_dir=None, attributes_dump_name=None):\n run_dir = self._fetch_run_dir(run_id, backend, results_dir)\n if attributes_dump_name is None:\n attributes_dump_name = Config.default_log_name('model_attributes', run_id=run_id)\n model_attributes_path = os.path.join(run_dir, attributes_dump_name)\n if not os.path.isfile(model_attributes_path):\n raise ResultsNotFoundError('Model attributes not found in \"{}\"!'.format(model_attributes_path))\n with open(model_attributes_path) as stream:\n model_attributes = yaml.load(stream=stream, Loader=yaml.FullLoader)\n return model_attributes","def _load_metadata(self, result_dir: Path) -> str:\n id_path = result_dir / SerializationAttributes.ID_FILENAME\n with open(id_path, 'r') as f:\n self.id = json.load(f)[SerializationAttributes.ID_KEY]\n\n version_path = result_dir / SerializationAttributes.VERSION_FILENAME\n with open(version_path, 'r') as f:\n self.version = json.load(f)[SerializationAttributes.VERSION_KEY]","def get_attributes():\n bot_id = socket.gethostname().lower().split('.', 1)[0]\n return os_utilities.get_attributes(bot_id)","def update_from_latest_data(self) -> None:\n self._attr_is_on = self.coordinator.data[self.entity_description.data_key]","async def test_entity_attribute_entity_reference(self):\n test_name = 'test_entity_attribute_entity_reference'\n entity_name = 'TestEntityAttributeEntityReference'\n\n corpus = TestHelper.get_local_corpus(self.tests_subpath, test_name)\n expected_output_path = TestHelper.get_expected_output_folder_path(self.tests_subpath, test_name)\n manifest = await corpus.fetch_object_async('local:/default.manifest.cdm.json')\n\n ent_test_entity_attribute_entity_reference = await corpus.fetch_object_async('local:/{}.cdm.json/{}'.format(entity_name, entity_name), manifest)\n self.assertIsNotNone(ent_test_entity_attribute_entity_reference)\n resolved_test_entity_attribute_entity_reference = await ProjectionTestUtils.get_resolved_entity(corpus, ent_test_entity_attribute_entity_reference, [])\n self.assertIsNotNone(resolved_test_entity_attribute_entity_reference)\n await AttributeContextUtil.validate_attribute_context(self, corpus, expected_output_path, entity_name, resolved_test_entity_attribute_entity_reference)","def __getattribute__(self, name: str) -> Any:\n if name in (FLD_TITLE, FLD_ABSTRACT, FLD_FEES, FLD_ACCESS_CONSTRAINTS, FLD_CONTACT_POSITION, FLD_CONTACT_ORGANISATION):\n return self.read_local_metadata(name)\n elif name == FLD_KEYWORDS:\n kw = self.read_local_metadata(FLD_KEYWORDS)\n if kw:\n return set(kw.split(\",\"))\n else:\n return set()\n elif name == FLD_ATTRIBUTION:\n return self.read_local_metadata(FLD_ATTRIBUTION)\n else:\n return super().__getattribute__(name)","def extract_meta_from_remote(paper_id):\n # $ Query Paper\n paper = arxiv.query(id_list=[paper_id])[0]\n # $ Set the Arxiv Object to ensure Proper extraction\n return ArxivIdentity.from_arxiv_response(paper),paper","def restore(self):\n self.comments, vars = self.parse_config(self.fname)\n\n # Sanity checks.\n num_targets = len(vars['t'])\n if num_targets != 1:\n raise BadFeatureConfig(\n 'feature config should specify 1 target; got %d; check for'\n 'the semi-colon at the end of the t:<target> line' % num_targets)\n\n num_entity = len(vars['e'])\n if not num_entity:\n raise BadFeatureConfig('0 entity variables given; need at least 1')\n\n # num_features = len(vars['c']) + len(vars['r'])\n # if not num_features > 0:\n # raise BadFeatureConfig('no predictors specified')\n\n # Store extracted field names as instance variables.\n logging.info('read the following feature guide:')\n for k, field_name in self.config_guide.items():\n logging.info('%s: %s' % (field_name, ', '.join(vars[k])))\n\n # convert to OrderedSet before setting attribute\n setattr(self, field_name, OrderedSet(vars[k]))\n\n # Extract target variable from its list and store solo.\n self.target = self.target[0]","def extractAttrs(data):\n\treturn [instance[1:] for instance in data]","def _update_attributes(self, data):\n self._set_avatar(data)\n self.boosts_since = parse_boosts_since(data)\n self.flags = parse_flags(data)\n self.nick = parse_nick(data)\n self.pending = parse_pending(data)\n self.role_ids = parse_role_ids(data)\n self.timed_out_until = parse_timed_out_until(data)","def get_attributes(self) -> Dict[str, str]:\n pass","def store_attrs(self, attrs):\n self.get_attr().SetObject(dumps(attrs), False)","def merge_attrs(self):\n for aid in self.attrs:\n new_val = self.attrs[aid]\n if aid in self.attributes:\n if ('value' in self.attributes[aid] and\n self.attributes[aid]['value'] != new_val):\n pass\n # print \"Updating attribute %s[%s] %s -> %s\" % (\n # self.name, aid, self.attributes[aid]['value'], new_val)\n else:\n # print \"** Warning: non-declaired attribute %s['%s'] set to:\\n'%s'\" % (\n # self.name, aid, new_val)\n self.remember_custom_attribute(self.name, aid, new_val)\n self.attributes[aid] = {}\n self.attributes[aid]['nv'] = new_val","def parse_attributes(cls):\n cls._fields = []\n cls._tables = []\n for attr_k in dir(cls):\n try:\n attr = object.__getattribute__(cls, attr_k)\n except AttributeError:\n continue\n if issubclass(attr.__class__, ReferenceManyField):\n cls._tables.append(attr_k)\n elif issubclass(attr.__class__, Field):\n cls._fields.append(attr_k)","def __getattr__(self, attr):\n for resource in lineage(self):\n if attr in resource.__initial_attrs__:\n value = self.__dict__[attr] = getattr(resource, attr)\n return value\n raise AttributeError(\n '{!r} object has no attribute {!r}'.format(self, attr))","def test_get_attributes(self):\n pass","def test_get_attributes(test_common_dao):\n _session = test_common_dao.RAMSTK_SESSION(\n bind=test_common_dao.engine, autoflush=False, expire_on_commit=False)\n DUT = _session.query(RAMSTKSiteInfo).first()\n\n assert DUT.get_attributes() == ATTRIBUTES","async def _parse_entities(self, responses: SourceResponses) -> Entities:\n entity_attributes = [\n {\n \"url\": str(row[\"URL\"]),\n \"violation_type\": row[\"Violation Type\"],\n \"impact\": row[\"Impact\"],\n \"element\": row[\"DOM Element\"],\n \"page\": re.sub(r\"https?://[^/]+\", \"\", row[\"URL\"]),\n \"description\": row[\"Messages\"],\n \"help\": row[\"Help\"],\n }\n for row in await self.__parse_csv(responses)\n ]\n return Entities(\n Entity(key=md5_hash(\",\".join(str(value) for value in attributes.values())), **attributes)\n for attributes in entity_attributes\n )","def getComputedAttributes(self) -> list:\n if self.loggingEnabled:\n self.logger.debug(f\"Starting getComputedAttributes\")\n path = \"/config/computedAttributes\"\n res = self.connector.getData(self.endpoint + path)\n data = res[\"children\"]\n nextPage = res[\"_page\"].get(\"next\", \"\")\n # while nextPage != \"\":\n # res = self.connector.getData(self.endpoint+path,\n # params=params, headers=self.header)\n # data += res['children']\n # nextPage = res['_page'].get('next','')\n return res","def transform_attributes(attrs):\n transformed = {}\n for key, value in attrs.items():\n if key in [\"raw_message\", \"text\"]:\n transformed[\"raw_content\"] = value\n elif key in [\"diaspora_handle\", \"sender_handle\", \"author\"]:\n transformed[\"handle\"] = value\n elif key == \"recipient_handle\":\n transformed[\"target_handle\"] = value\n elif key == \"parent_guid\":\n transformed[\"target_guid\"] = value\n elif key == \"first_name\":\n transformed[\"name\"] = value\n elif key == \"image_url\":\n if \"image_urls\" not in transformed:\n transformed[\"image_urls\"] = {}\n transformed[\"image_urls\"][\"large\"] = value\n elif key == \"image_url_small\":\n if \"image_urls\" not in transformed:\n transformed[\"image_urls\"] = {}\n transformed[\"image_urls\"][\"small\"] = value\n elif key == \"image_url_medium\":\n if \"image_urls\" not in transformed:\n transformed[\"image_urls\"] = {}\n transformed[\"image_urls\"][\"medium\"] = value\n elif key == \"tag_string\":\n transformed[\"tag_list\"] = value.replace(\"#\", \"\").split(\" \")\n elif key == \"bio\":\n transformed[\"raw_content\"] = value\n elif key == \"searchable\":\n transformed[\"public\"] = True if value == \"true\" else False\n elif key == \"target_type\":\n transformed[\"entity_type\"] = DiasporaRetraction.entity_type_from_remote(value)\n elif key == \"remote_photo_path\":\n transformed[\"remote_path\"] = value\n elif key == \"remote_photo_name\":\n transformed[\"remote_name\"] = value\n elif key == \"status_message_guid\":\n transformed[\"linked_guid\"] = value\n transformed[\"linked_type\"] = \"Post\"\n elif key in BOOLEAN_KEYS:\n transformed[key] = True if value == \"true\" else False\n elif key in DATETIME_KEYS:\n try:\n # New style timestamps since in protocol 0.1.6\n transformed[key] = datetime.strptime(value, \"%Y-%m-%dT%H:%M:%SZ\")\n except ValueError:\n # Legacy style timestamps\n transformed[key] = datetime.strptime(value, \"%Y-%m-%d %H:%M:%S %Z\")\n elif key in INTEGER_KEYS:\n transformed[key] = int(value)\n else:\n transformed[key] = value or \"\"\n return transformed","def get_attributes(self):\n return self.attributes","def get_non_redundant_entity_attributes(self):\n return self.__non_redundant_entity_attributes","def read_affectiva(self, filename=None, *args, **kwargs):\n if not filename:\n try:\n filename = self.filename\n except:\n print(\"filename must be specified.\")\n result = read_affectiva(filename, *args, **kwargs)\n for name in self._metadata:\n attr_value = getattr(self, name, None)\n if attr_value and getattr(result, name, None) == None:\n setattr(result, name, attr_value)\n return result","def test_get_attribute_data(self):\n pass","def getfield(self, pkt, s):\n class_id = getattr(pkt, self._entity_class)\n attribute_mask = getattr(pkt, self._attributes_mask)\n entity_class = omci_entities.entity_id_to_class_map[class_id]\n indices = entity_class.attribute_indices_from_mask(attribute_mask)\n data = {}\n table_attribute_mask = 0\n for index in indices:\n try:\n fld = entity_class.attributes[index].field\n except IndexError as e:\n log.error(\"attribute-decode-failure\", attribute_index=index,\n entity_class=entity_class, e=e)\n continue\n try:\n s, value = fld.getfield(pkt, s)\n except Exception as _e:\n raise\n if isinstance(pkt, OmciGetResponse) and isinstance(fld, OmciTableField):\n data[fld.name + '_size'] = value\n table_attribute_mask = table_attribute_mask | (1 << (16 - index))\n else:\n data[fld.name] = value\n if table_attribute_mask:\n data['table_attribute_mask'] = table_attribute_mask\n return s, data","def overwrite_attrs(self, src_detail, attrs):\n case_tile_configuration_list = [\n 'case_tile_template',\n 'persist_tile_on_forms',\n 'persistent_case_tile_from_module',\n 'pull_down_tile',\n 'persist_case_context',\n 'persistent_case_context_xml',\n 'case_tile_group',\n ]\n for attr in attrs:\n if attr == \"case_tile_configuration\":\n for ele in case_tile_configuration_list:\n setattr(self, ele, getattr(src_detail, ele))\n else:\n setattr(self, attr, getattr(src_detail, attr))","def get(entity, name=None, version=None, lineage=None):","def deserialize(self, source):\n attrs = {}\n for k, v in source.iteritems():\n try:\n attrs[k] = self.deserialize_field(source, k)\n except (AttributeError, FieldDoesNotExist):\n # m2m, abstract\n pass\n\n return self.instanciate(attrs)\n # TODO: we can assign m2ms now","def fetch(args):\n storage, remote_path = split_storage(args.remote)\n\n local_path = args.local\n if local_path is None:\n _, local_path = os.path.split(remote_path)\n\n local_path_exists = os.path.exists(local_path)\n if local_path_exists and not args.force and not args.update:\n sys.exit(\"Local file %s already exists, not overwriting.\" % local_path)\n\n directory, _ = os.path.split(local_path)\n if directory:\n makedirs(directory, exist_ok=True)\n\n osf = _setup_osf(args)\n project = osf.project(args.project)\n\n store = project.storage(storage)\n for file_ in store.files:\n if norm_remote_path(file_.path) == remote_path:\n if local_path_exists and not args.force and args.update:\n if file_.hashes.get('md5') == checksum(local_path):\n print(\"Local file %s already matches remote.\" % local_path)\n break\n with open(local_path, 'wb') as fp:\n file_.write_to(fp)\n\n # only fetching one file so we are done\n break","def extra_state_attributes(self):\r\n return self._attributes","def attributes(self):\n raise NotImplementedError","def get_properties(self):\n geospatial = self.get_geospatial()\n temporal = self.get_temporal()\n\n # File system metadata\n filesystem = super(SAFESentinelBase, self).get_filesystem(self.fname)\n self._update_filesystem_metadata(filesystem)\n\n data_format = {\"format\": \"SAFE\"}\n\n # Gather up extra metadata\n extra_metadata = {}\n for key in (\"platform\", \"product_info\", \"orbit_info\"):\n if self.sections.get(key):\n extra_metadata[key] = self.sections[key]\n\n # Set extra content from existing content and filename\n self._update_extra_metadata(extra_metadata)\n \n props = product.Properties(spatial=geospatial,\n temporal=temporal,\n filesystem=filesystem,\n data_format=data_format,\n **extra_metadata)\n\n return props","def get_redundant_entity_attributes(self):\n return self.__redundant_entity_attributes","def _iterattrs(self, handle=\"\"):\n if not handle:\n handle = self.handle\n attr = gv.firstattr(handle)\n while gv.ok(attr):\n yield gv.nameof(attr), decode_page(gv.getv(handle, attr))\n attr = gv.nextattr(handle, attr)"],"string":"[\n \"def read_attributes(self, dataset):\\n if 'attributes' in self.configs:\\n for key, value in self.configs['attributes'].items():\\n setattr(dataset, key, value)\",\n \"def _read_local(self):\\n\\n self.attributions = np.genfromtxt(\\n self.attributions_path, dtype=float, delimiter=\\\",\\\", skip_header=1\\n )\\n\\n with open(self.attributions_path) as attribution_file:\\n self.feature_labels = next(csv.reader(attribution_file))\",\n \"def load_attrs(self):\\n return loads(self.get_attr().GetObject()) or {}\",\n \"def getfield(self, pkt, s):\\n class_id = getattr(pkt, self._entity_class)\\n entity_class = omci_entities.entity_id_to_class_map.get(class_id)\\n data = {}\\n for attribute in entity_class.attributes:\\n if AttributeAccess.SetByCreate not in attribute.access:\\n continue\\n if attribute.field.name == 'managed_entity_id':\\n continue\\n fld = attribute.field\\n s, value = fld.getfield(pkt, s)\\n data[fld.name] = value\\n return s, data\",\n \"def load(self):\\r\\n self.domain.get_attributes(self.name, item=self)\",\n \"def __extract_common_attrs(self, raw_data: Dict) -> None:\\n for attr in self.COMMON_ATTRS:\\n if attr not in self.ATTRS and attr in raw_data:\\n setattr(self, attr, raw_data[attr])\",\n \"def attributes(self, truncate: bool = False) -> Tuple[str, str]:\\n\\t\\tif not self._closed:\\n\\t\\t\\tfilename = self.filename\\n\\t\\t\\tattrs_filename = \\\"%s.attrs.json.gzip\\\" % (self.file_path)\\n\\t\\t\\tattrs_mod_filename = \\\"%s.attrs.lastmod.gzip\\\" % (self.file_path)\\n\\t\\t\\tlogging.debug(\\\"Expanding attributes (stored as %s)\\\", attrs_filename)\\n\\n\\t\\t\\tlast_col_mod = self.ds.col_attrs.last_modified()\\n\\t\\t\\tlast_row_mod = self.ds.row_attrs.last_modified()\\n\\t\\t\\tlast_mod = max(last_col_mod, last_row_mod)\\n\\n\\t\\t\\tif os.path.isfile(attrs_filename):\\n\\t\\t\\t\\tlogging.debug(\\\" Found previously extracted JSON file\\\")\\n\\t\\t\\t\\tif truncate:\\n\\t\\t\\t\\t\\tself.clear_attributes()\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tattrs_json = load_gzipped_json_string(attrs_filename)\\n\\t\\t\\t\\t\\tattrs_mod = load_gzipped_json_string(attrs_mod_filename)\\n\\t\\t\\t\\t\\tlogging.debug(\\\" attrs_mod: %s\\\", attrs_mod)\\n\\t\\t\\t\\t\\tlogging.debug(\\\" last_mod: %s\\\", last_mod)\\n\\t\\t\\t\\t\\tif attrs_mod == last_mod:\\n\\t\\t\\t\\t\\t\\tlogging.debug(\\\" Cache up to date\\\")\\n\\t\\t\\t\\t\\t\\treturn (attrs_json, last_mod)\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tself.clear_attributes()\\n\\n\\t\\t\\tds = self.ds\\n\\t\\t\\ttile_data = LoomTiles(ds)\\n\\t\\t\\tdims = tile_data.dz_dimensions()\\n\\t\\t\\trowAttrs = {key: metadata_array(arr) for (key, arr) in ds.ra.items()}\\n\\t\\t\\tcolAttrs = {key: metadata_array(arr) for (key, arr) in ds.ca.items()}\\n\\t\\t\\tattrs_data = {\\n\\t\\t\\t\\t\\\"project\\\": self.project,\\n\\t\\t\\t\\t\\\"filename\\\": filename,\\n\\t\\t\\t\\t\\\"dataset\\\": filename,\\n\\t\\t\\t\\t\\\"shape\\\": ds.shape,\\n\\t\\t\\t\\t\\\"zoomRange\\\": tile_data.dz_zoom_range(),\\n\\t\\t\\t\\t\\\"fullZoomHeight\\\": dims[1],\\n\\t\\t\\t\\t\\\"fullZoomWidth\\\": dims[0],\\n\\t\\t\\t\\t\\\"rowAttrs\\\": rowAttrs,\\n\\t\\t\\t\\t\\\"colAttrs\\\": colAttrs,\\n\\t\\t\\t}\\n\\t\\t\\tlogging.debug(\\\" Saving extracted attributes as JSON file\\\")\\n\\t\\t\\tattrs_json = json.dumps(attrs_data)\\n\\t\\t\\tsave_gzipped_json_string(attrs_filename, attrs_json)\\n\\t\\t\\tsave_gzipped_json_string(attrs_mod_filename, json.dumps(last_mod))\\n\\t\\t\\treturn (attrs_json, last_mod)\\n\\t\\treturn None\",\n \"def fill_attributes(ml_file, other_file):\\n with xr.load_dataset(other_file) as other:\\n with xr.open_dataset(ml_file) as ml:\\n for variable in other.variables:\\n if variable in ml.variables:\\n other[variable].attrs = ml[variable].attrs\\n other.to_netcdf(other_file)\",\n \"def _restore_live_attrs(lock_detail, attrs):\\n for attr, value in attrs.items():\\n setattr(lock_detail, attr, value)\",\n \"async def test_lazy_state_can_decode_attributes(\\n caplog: pytest.LogCaptureFixture,\\n) -> None:\\n row = PropertyMock(\\n entity_id=\\\"sensor.invalid\\\",\\n attributes='{\\\"shared\\\":true}',\\n )\\n assert LazyState(row, {}, None, row.entity_id, \\\"\\\", 1, False).attributes == {\\n \\\"shared\\\": True\\n }\",\n \"def _set_attr(self):\\n self.as_skeletal = self._import_as_skeleton()\\n self.materials = self._import_materials()\\n self.textures = self._import_textures()\",\n \"def get_attr(self, attr_name, indices=None):\\n target_remotes = self._get_target_remotes(indices)\\n for remote in target_remotes:\\n remote.send(('get_attr', attr_name))\\n return [remote.recv() for remote in target_remotes]\",\n \"def _fetch_current_remote_metadata(conn):\\n content = _get(conn, REMOTE_METADATA_FILE)\\n metadata = json.loads(content) if content else {}\\n return metadata\",\n \"def attributes(self, *args):\\n kwargs = {}\\n if args:\\n kwargs[\\\"attributenames\\\"] = args\\n\\n r = self._token_id_request(urljoin(self._url, Client._attribute_resource), **kwargs)\\n\\n # parse contennt looking for all attributes\\n attributes = []\\n for line in r.text.splitlines():\\n r = re.match(\\\"(userdetails\\\\.attribute\\\\.name)=(.*)\\\", line)\\n if r:\\n name = r.groups()[1]\\n attributes.append([name, None])\\n continue # next line\\n\\n r = re.match(\\\"(userdetails\\\\.attribute\\\\.value)=(.*)\\\", line)\\n if r:\\n value = r.groups()[1]\\n # last name parsed is where it has to\\n # be stacked\\n if attributes[-1][1] == None:\\n attributes[-1][1] = value\\n if isinstance(attributes[-1][1], list):\\n attributes[-1][1].append(value)\\n else:\\n # cast to list\\n attributes[-1].append([attributes[-1][1], value])\\n\\n return dict([(item[0], item[1]) for item in attributes])\",\n \"def readAttributes(self, *args):\\n return _libsbml.FbcModelPlugin_readAttributes(self, *args)\",\n \"def update(self) -> None:\\n self._api.update()\\n if self.available:\\n self._attr_native_value = self._api.data[self.entity_description.key]\\n else:\\n self._attr_native_value = None\",\n \"def attributes(self):\\n ...\",\n \"def getResourceAttributes(self, authenticationToken, guid):\\r\\n self.send_getResourceAttributes(authenticationToken, guid)\\r\\n return self.recv_getResourceAttributes()\",\n \"def get_entity_attrs(self, entity_id, group_path=None, \\n effective=True):\\n path = '/entity/' + str(entity_id) + '/attributes'\\n params = {'effective': effective}\\n if group_path is not None:\\n params['group'] = group_path\\n try:\\n response = self.__session.get(self.__api_base_url + path, \\n params=params)\\n response.raise_for_status()\\n response = response.json()\\n except (requests.HTTPError, requests.ConnectionError), error:\\n raise Exception(error.message)\\n\\n return response\",\n \"def extra_state_attributes(self):\\n return {\\n ATTR_SOURCE_ENTITY: self._source_entity,\\n ATTR_SOURCE_DOMAIN: self._source_domain,\\n }\",\n \"def getResourceAttributes(self, authenticationToken, guid):\\r\\n pass\",\n \"def get_attributes(self):\\n\\n endpoint = self._get_api_endpoint() + '/attributes'\\n results = self.tq.get(endpoint, withp='attribute')\\n if 'data' not in results:\\n return {}\\n\\n return results['data']\\n # tr = {}\\n # for attribute in results['data']:\\n # tr[attribute['attribute']['name']] = attribute['value']\\n # return tr\",\n \"def _fetch_current_local_metadata():\\n if not os.path.exists(LOCAL_METADATA_FILE):\\n return {}\\n\\n with open(LOCAL_METADATA_FILE) as f:\\n return json.loads(f.read())\",\n \"def remote_properties(self):\\n return dat2obj(pn_connection_remote_properties(self._impl))\",\n \"def attributes(self):\",\n \"def readAttributes(self, *args):\\n return _libsbml.FbcReactionPlugin_readAttributes(self, *args)\",\n \"def attributes(self):\\n return self.host.attributes\",\n \"def readAttributes(self, product):\\r\\n return {\\\"product_string\\\": None}\",\n \"def getAttributes(self):\\n pass\",\n \"def set_properties_from_api_repr(self, resource):\\n self.name = resource.get('name')\\n self.number = resource['projectNumber']\\n self.labels = resource.get('labels', {})\\n self.status = resource['lifecycleState']\",\n \"def copy_attrs(varin,varout):\\n for attr_name in varin.ncattrs():\\n varout.setncattr(attr_name,varin.getncattr(attr_name))\",\n \"def restore(self):\\n if self.obj:\\n for attrib in self.attribs:\\n setattr(self.obj, attrib, getattr(self, attrib))\",\n \"def _async_update_attrs(self) -> None:\\n self._attr_is_on = self.entity_description.is_on(self._lock.state)\",\n \"def _async_update_attrs(self) -> None:\\n self._attr_is_on = self._device.light_on\\n if self._device.light_brightness is not None:\\n self._attr_brightness = int(min(255, self._device.light_brightness * 16))\",\n \"def from_attr(self, session, resource_attr):\\n # \\\"object_dict\\\" and \\\"tree\\\" uses LargeBinary sqlalchemy datatype.\\n # LargeBinary sqlalchemy datatype needs \\\"bytes-like\\\" object\\n # and in Py2, string are bytes-like objects while in Py3 they aren't.\\n # So we need to store \\\"bytes-like\\\" object in DB objects.\\n # For storing the DB model object,\\n # we need to encode to utf-8 bytes format (for Py3 compatibility).\\n # Since in Py2, string are bytes-like objects, encoding won't\\n # make a difference.\\n encoded_attr_dict = {}\\n for k, v in list(resource_attr.items()):\\n if k not in getattr(self, '_exclude_from', []):\\n if k == 'object_dict':\\n if isinstance(v, six.text_type):\\n v = v.encode('utf-8')\\n elif k == 'tree':\\n if isinstance(v, six.text_type):\\n v = v.encode('utf-8')\\n encoded_attr_dict[k] = v\\n self.set_attr(session, k, v, **encoded_attr_dict)\",\n \"def read(self, id, attributes=None):\\n raise NotImplementedError\",\n \"def getAttributes(self, name):\\r\\n ent = self.entities[name]\\r\\n\\r\\n attrs = []\\r\\n while ent != None:\\r\\n this_ent_attrs = copy.copy(ent[\\\"attributes\\\"])\\r\\n this_ent_attrs.reverse()\\r\\n attrs.extend(this_ent_attrs)\\r\\n ent = self.entities.get(ent[\\\"supertype\\\"], None)\\r\\n\\r\\n attrs.reverse()\\r\\n return attrs\",\n \"def copyAttributes(fromNcVar, toNcVar):\\r\\n for attrName in fromNcVar.ncattrs():\\r\\n attrVal = getattr(fromNcVar, attrName)\\r\\n setattr(toNcVar, attrName, attrVal)\",\n \"def readAttributes(self, *args):\\n return _libsbml.MultiASTPlugin_readAttributes(self, *args)\",\n \"def _init_from_remote(self):\\n self.arch = self.remote.arch\\n self.os_type = self.remote.os.name\\n self.os_version = self.remote.os.version\\n self.codename = self.remote.os.codename\\n self.pkg_type = self.remote.system_type\\n self.distro = self._get_distro(\\n distro=self.remote.os.name,\\n version=self.remote.os.version,\\n codename=self.remote.os.codename,\\n )\\n # when we're initializing with a remote we most likely have\\n # a task config, not the entire teuthology job config\\n self.flavor = self.job_config.get(\\\"flavor\\\", \\\"basic\\\")\\n self.tag = self.job_config.get(\\\"tag\\\")\",\n \"def getAttributes(self, name):\\n ent = self.entities[name]\\n\\n attrs = []\\n while ent != None:\\n this_ent_attrs = copy.copy(ent[\\\"attributes\\\"])\\n this_ent_attrs.reverse()\\n attrs.extend(this_ent_attrs)\\n ent = self.entities.get(ent[\\\"supertype\\\"], None)\\n\\n attrs.reverse()\\n return attrs\",\n \"def extra_state_attributes(self) -> dict[str, Any]:\\n state_attr = super().extra_state_attributes\\n state_attr[ATTR_SOURCE_ENTITY] = self._powercalc_source_entity\\n state_attr[ATTR_SOURCE_DOMAIN] = self._powercalc_source_domain\\n return state_attr\",\n \"def copy_attributes(var1, var2):\\n for each in var1.ncattrs():\\n if each != \\\"_FillValue\\\":\\n setattr(var2, each, getattr(var1, each))\",\n \"def extra_state_attributes(self) -> dict[str, Any] | None:\\n attr: dict[str, Any] = {}\\n\\n if self._device.last_telegram is not None:\\n attr[ATTR_SOURCE] = str(self._device.last_telegram.source_address)\\n return attr\",\n \"def _load_attrs(self) -> None:\\n self.attr_ids.clear()\\n for attr_label, attr_value in self.element.attr.items():\\n self.add_attr(None, attr_label, attr_value)\\n self._update_attr_list()\",\n \"def readAttributes(self, *args):\\n return _libsbml.ASTBasePlugin_readAttributes(self, *args)\",\n \"def getattrs(self):\\n # ICAT 4.5.0 also lists the meta attributes as attributes in\\n # the entity info. Need to remove them here, as they should\\n # not be added to InstAttr.\\n return self.getfieldnames('ATTRIBUTE') - Entity.MetaAttr\",\n \"def read(self):\\n\\t\\tentities = dict()\\n\\t\\trelations = set()\\n\\t\\tedges = set()\\n\\t\\twith open(self.file_path, encoding=\\\"utf-8\\\") as f:\\n\\t\\t\\tfor line in tqdm(f):\\n\\t\\t\\t\\tif(self.prob == 1.0 or random() < self.prob):\\n\\t\\t\\t\\t\\tsource, relation, target, _ = line.split(\\\" \\\", 3)\\n\\t\\t\\t\\t\\tis_dataprop = target.startswith('\\\"')\\n\\t\\t\\t\\t\\tif source not in entities:\\n\\t\\t\\t\\t\\t\\tentities[source] = dict(degree=0, out_degree=0, in_degree=0, data_properties={})\\n\\t\\t\\t\\t\\tentities[source][\\\"out_degree\\\"] += 1\\n\\t\\t\\t\\t\\tentities[source][\\\"degree\\\"] += 1\\n\\t\\t\\t\\t\\tif not is_dataprop:\\n\\t\\t\\t\\t\\t\\tif target not in entities:\\n\\t\\t\\t\\t\\t\\t\\tentities[target] = dict(degree=0, out_degree=0, in_degree=0, data_properties={})\\n\\t\\t\\t\\t\\t\\tentities[target][\\\"in_degree\\\"] += 1\\n\\t\\t\\t\\t\\t\\tentities[target][\\\"degree\\\"] += 1\\n\\t\\t\\t\\t\\t\\trelations.add(relation)\\n\\t\\t\\t\\t\\t\\tedges.add((relation, source, target))\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tif(self.include_dataprop):\\n\\t\\t\\t\\t\\t\\t\\tentities[source][\\\"data_properties\\\"][relation] = target\\n\\n\\t\\treturn (entities, relations, edges)\",\n \"def GetLocalPayloadAttrs(payload_dir):\\n filename = os.path.join(payload_dir, UPDATE_FILE)\\n if not os.path.exists(filename):\\n raise AutoupdateError('update.gz not present in payload dir %s' %\\n payload_dir)\\n\\n sha1 = GetFileSha1(filename)\\n sha256 = GetFileSha256(filename)\\n size = GetFileSize(filename)\\n #is_delta_format = self._IsDeltaFormatFile(filename)\\n is_delta_format = True\\n metadata_obj = UpdateMetadata(sha1, sha256, size, is_delta_format)\\n _StoreMetadataToFile(payload_dir, metadata_obj)\\n\\n return metadata_obj\",\n \"def _load(self):\\n entity: dict = self.service.find_one({\\\"_id\\\": self._id})\\n\\n if entity is not None:\\n self.created_at = entity.get(\\\"created_at\\\")\\n self.updated_at = entity.get(\\\"updated_at\\\")\",\n \"def extra_state_attributes(self):\\n attributes = {}\\n if self._multiroom_group != []:\\n attributes[ATTR_LINKPLAY_GROUP] = self._multiroom_group\\n attributes[ATTR_GROUP_MEMBERS] = self._multiroom_group\\n\\n attributes[ATTR_MASTER] = self._is_master\\n if self._slave_mode:\\n attributes[ATTR_SLAVE] = self._slave_mode\\n if self._media_uri_final:\\n attributes[ATTR_MEDIA_CONTENT_ID] = self._media_uri_final\\n if len(self._trackq) > 0:\\n attributes[ATTR_TRCNT] = len(self._trackq) - 1\\n if self._trackc:\\n attributes[ATTR_TRCRT] = self._trackc\\n if self._uuid != '':\\n attributes[ATTR_UUID] = self._uuid\\n\\n attributes[ATTR_TTS] = self._playing_tts\\n attributes[ATTR_SNAPSHOT] = self._snapshot_active\\n attributes[ATTR_SNAPSPOT] = self._snap_spotify\\n \\n attributes[ATTR_MASS_POSITION] = self._mass_position\\n\\n if DEBUGSTR_ATTR:\\n atrdbg = \\\"\\\"\\n if self._playing_localfile:\\n atrdbg = atrdbg + \\\" _playing_localfile\\\"\\n\\n if self._playing_spotify:\\n atrdbg = atrdbg + \\\" _playing_spotify\\\"\\n\\n if self._playing_webplaylist:\\n atrdbg = atrdbg + \\\" _playing_webplaylist\\\"\\n\\n if self._playing_stream:\\n atrdbg = atrdbg + \\\" _playing_stream\\\"\\n\\n if self._playing_liveinput:\\n atrdbg = atrdbg + \\\" _playing_liveinput\\\"\\n\\n if self._playing_tts:\\n atrdbg = atrdbg + \\\" _playing_tts\\\"\\n \\n if self._playing_mediabrowser:\\n atrdbg = atrdbg + \\\" _playing_mediabrowser\\\"\\n \\n if self._playing_mass:\\n atrdbg = atrdbg + \\\" _playing_mass\\\"\\n\\n attributes[ATTR_DEBUG] = atrdbg\\n\\n if self._state != STATE_UNAVAILABLE:\\n attributes[ATTR_FWVER] = self._fw_ver + \\\".\\\" + self._mcu_ver\\n\\n return attributes\",\n \"def get_remote_alert_data(client: Client, remote_alert_id: str) -> tuple[Dict, Dict]:\\n alert_details = client.alert_get_details_request(alert_id=remote_alert_id, detailed='true')\\n\\n updated_object: Dict[str, Any] = {}\\n for field in INCIDENT_INCOMING_MIRROR_ARGS:\\n mirrored_field_value = demisto.get(alert_details, field, '')\\n if '.' in field: # field is nested (currently it is only the policy.name field)\\n # policy.name field was added to the mirrored fields cause this is the field that is used in the default classifier to\\n # classify incident types. Without it, all mirrored alerts will be changed to the default incident type which is\\n # 'Prisma Cloud'.\\n split_field = field.split('.')\\n updated_object[split_field[0]] = {split_field[1]: mirrored_field_value}\\n else:\\n updated_object[field] = mirrored_field_value\\n return alert_details, updated_object\",\n \"def extra_state_attributes(self) -> dict[str, Any]:\\n ret = {\\n ATTR_SOURCE: self._source_entity_id,\\n ATTR_COEFFICIENTS: self._coefficients,\\n }\\n if self._source_attribute:\\n ret[ATTR_SOURCE_ATTRIBUTE] = self._source_attribute\\n return ret\",\n \"def readProperties(self):\\r\\n print('not yet implemented')\",\n \"def _set_attributes(self):\",\n \"def _load(self):\\n self.logger.debug(\\\"Loading from persistence\\\")\\n # load whole item from persistence\\n data = self._persistence.load(self.id(), default={})\\n if not data:\\n return\\n\\n try:\\n self.persistence_deserialize(data)\\n except NotImplementedError:\\n # allow backwards compatibility or persisted_values way\\n for persisted_var in self.persisted_values():\\n if persisted_var in data:\\n self.logger.debug(\\\"Loaded value {} for attribute {}\\\".format(\\n data[persisted_var], persisted_var))\\n # Set the loaded value to the attribute on this class\\n setattr(self, persisted_var, data[persisted_var])\\n except:\\n # log exception while loading and let it continue\\n self.logger.exception(\\n \\\"Failed to deserialize block with data: {}\\\".format(data))\",\n \"def copy_attrs(data_orig, data_new):\\n\\n if isinstance(data_orig, Dataset):\\n\\n # Variables\\n for v in data_orig.data_vars:\\n field = data_orig[v]\\n for attr, val in field.attrs.items():\\n data_new[v].attrs[attr] = val\\n\\n # Coordinates\\n for c in data_orig.coords:\\n coord = data_orig.coords[c]\\n for attr, val in coord.attrs.items():\\n if c in data_new.coords:\\n data_new.coords[c].attrs[attr] = val\\n\\n # Metadata\\n for attr, val in data_orig.attrs.items():\\n data_new.attrs[attr] = val\\n\\n elif isinstance(data_orig, DataArray):\\n\\n # Variable Metadata\\n for att, val in data_orig.attrs.items():\\n data_new.attrs[att] = val\\n\\n # Coordinates\\n for c in data_orig.coords:\\n coord = data_orig.coords[c]\\n for attr, val in coord.attrs.items():\\n if c in data_new.coords:\\n data_new.coords[c].attrs[attr] = val\\n\\n else:\\n raise ValueError(\\\"Couldn't handle type %r\\\" % type(data_orig))\\n\\n return data_new\",\n \"def get_attributes(cls, entity):\\n return entity.category.facts.all()\",\n \"def __convertAttributes__(xml_source):\\n attributes = {}\\n for attrName, attrValue in xml_source.attributes.items():\\n attributes[attrName] = attrValue\\n return attributes\",\n \"def get_all(self):\\n\\n remote = json.loads(self.get_remote(), object_pairs_hook=OrderedDict)\\n local = json.loads(self.get_local(), object_pairs_hook=OrderedDict)\\n\\n remote.update(local)\\n\\n # set the tag\\n response = {\\\"inspection\\\": remote}\\n\\n return utility.serialize_data(response)\",\n \"def copy_from_entity(self, entity):\\n for prop in entity._EndpointsPropertyItervalues():\\n attr_name = prop._code_name\\n value = getattr(entity, attr_name)\\n if value is not None:\\n if isinstance(prop, properties.EndpointsAliasProperty):\\n value_set = getattr(self, attr_name) is not None\\n elif isinstance(prop, ComputedProperty):\\n value_set = True\\n else:\\n value_set = prop._name in self._values\\n if not value_set:\\n setattr(self, attr_name, value)\",\n \"def extra_state_attributes(self):\\n return self._attributes\",\n \"def _difference_update_attributes(self, data):\\n old_attributes = {}\\n \\n # avatar\\n self._update_avatar(data, old_attributes)\\n \\n # boosts_since\\n boosts_since = parse_boosts_since(data)\\n if self.boosts_since != boosts_since:\\n old_attributes['boosts_since'] = self.boosts_since\\n self.boosts_since = boosts_since\\n \\n flags = parse_flags(data)\\n if self.flags != flags:\\n old_attributes['flags'] = self.flags\\n self.flags = flags\\n \\n # nick\\n nick = parse_nick(data)\\n if self.nick != nick:\\n old_attributes['nick'] = self.nick\\n self.nick = nick\\n \\n # pending\\n pending = parse_pending(data)\\n if pending != self.pending:\\n old_attributes['pending'] = self.pending\\n self.pending = pending\\n \\n # role_ids\\n role_ids = parse_role_ids(data)\\n if role_ids != self.role_ids:\\n old_attributes['role_ids'] = self.role_ids\\n self.role_ids = role_ids\\n \\n # timed_out_until\\n timed_out_until = parse_timed_out_until(data)\\n if self.timed_out_until != timed_out_until:\\n old_attributes['timed_out_until'] = self.timed_out_until\\n self.timed_out_until = timed_out_until\\n \\n return old_attributes\",\n \"def restore_object(self, attrs, instance=None):\\n model_attrs = dict(**attrs)\\n if instance is not None:\\n for attr, value in attrs.items():\\n if attr in self.opts.postonly_fields:\\n model_attrs.pop(attr)\\n return super(HyperlinkedModelSerializer, self).restore_object(model_attrs, instance)\",\n \"def _set_attributes(self, model):\\n\\n if model:\\n self._get_dict(model)\",\n \"def get_attributes(self, context: ResourceCommandContext, obj_ref: str) -> dict:\\n return self.handler.get_attributes(obj_ref)\",\n \"def _fetch_model_attributes(self, run_id, backend=None, results_dir=None, attributes_dump_name=None):\\n run_dir = self._fetch_run_dir(run_id, backend, results_dir)\\n if attributes_dump_name is None:\\n attributes_dump_name = Config.default_log_name('model_attributes', run_id=run_id)\\n model_attributes_path = os.path.join(run_dir, attributes_dump_name)\\n if not os.path.isfile(model_attributes_path):\\n raise ResultsNotFoundError('Model attributes not found in \\\"{}\\\"!'.format(model_attributes_path))\\n with open(model_attributes_path) as stream:\\n model_attributes = yaml.load(stream=stream, Loader=yaml.FullLoader)\\n return model_attributes\",\n \"def _load_metadata(self, result_dir: Path) -> str:\\n id_path = result_dir / SerializationAttributes.ID_FILENAME\\n with open(id_path, 'r') as f:\\n self.id = json.load(f)[SerializationAttributes.ID_KEY]\\n\\n version_path = result_dir / SerializationAttributes.VERSION_FILENAME\\n with open(version_path, 'r') as f:\\n self.version = json.load(f)[SerializationAttributes.VERSION_KEY]\",\n \"def get_attributes():\\n bot_id = socket.gethostname().lower().split('.', 1)[0]\\n return os_utilities.get_attributes(bot_id)\",\n \"def update_from_latest_data(self) -> None:\\n self._attr_is_on = self.coordinator.data[self.entity_description.data_key]\",\n \"async def test_entity_attribute_entity_reference(self):\\n test_name = 'test_entity_attribute_entity_reference'\\n entity_name = 'TestEntityAttributeEntityReference'\\n\\n corpus = TestHelper.get_local_corpus(self.tests_subpath, test_name)\\n expected_output_path = TestHelper.get_expected_output_folder_path(self.tests_subpath, test_name)\\n manifest = await corpus.fetch_object_async('local:/default.manifest.cdm.json')\\n\\n ent_test_entity_attribute_entity_reference = await corpus.fetch_object_async('local:/{}.cdm.json/{}'.format(entity_name, entity_name), manifest)\\n self.assertIsNotNone(ent_test_entity_attribute_entity_reference)\\n resolved_test_entity_attribute_entity_reference = await ProjectionTestUtils.get_resolved_entity(corpus, ent_test_entity_attribute_entity_reference, [])\\n self.assertIsNotNone(resolved_test_entity_attribute_entity_reference)\\n await AttributeContextUtil.validate_attribute_context(self, corpus, expected_output_path, entity_name, resolved_test_entity_attribute_entity_reference)\",\n \"def __getattribute__(self, name: str) -> Any:\\n if name in (FLD_TITLE, FLD_ABSTRACT, FLD_FEES, FLD_ACCESS_CONSTRAINTS, FLD_CONTACT_POSITION, FLD_CONTACT_ORGANISATION):\\n return self.read_local_metadata(name)\\n elif name == FLD_KEYWORDS:\\n kw = self.read_local_metadata(FLD_KEYWORDS)\\n if kw:\\n return set(kw.split(\\\",\\\"))\\n else:\\n return set()\\n elif name == FLD_ATTRIBUTION:\\n return self.read_local_metadata(FLD_ATTRIBUTION)\\n else:\\n return super().__getattribute__(name)\",\n \"def extract_meta_from_remote(paper_id):\\n # $ Query Paper\\n paper = arxiv.query(id_list=[paper_id])[0]\\n # $ Set the Arxiv Object to ensure Proper extraction\\n return ArxivIdentity.from_arxiv_response(paper),paper\",\n \"def restore(self):\\n self.comments, vars = self.parse_config(self.fname)\\n\\n # Sanity checks.\\n num_targets = len(vars['t'])\\n if num_targets != 1:\\n raise BadFeatureConfig(\\n 'feature config should specify 1 target; got %d; check for'\\n 'the semi-colon at the end of the t:<target> line' % num_targets)\\n\\n num_entity = len(vars['e'])\\n if not num_entity:\\n raise BadFeatureConfig('0 entity variables given; need at least 1')\\n\\n # num_features = len(vars['c']) + len(vars['r'])\\n # if not num_features > 0:\\n # raise BadFeatureConfig('no predictors specified')\\n\\n # Store extracted field names as instance variables.\\n logging.info('read the following feature guide:')\\n for k, field_name in self.config_guide.items():\\n logging.info('%s: %s' % (field_name, ', '.join(vars[k])))\\n\\n # convert to OrderedSet before setting attribute\\n setattr(self, field_name, OrderedSet(vars[k]))\\n\\n # Extract target variable from its list and store solo.\\n self.target = self.target[0]\",\n \"def extractAttrs(data):\\n\\treturn [instance[1:] for instance in data]\",\n \"def _update_attributes(self, data):\\n self._set_avatar(data)\\n self.boosts_since = parse_boosts_since(data)\\n self.flags = parse_flags(data)\\n self.nick = parse_nick(data)\\n self.pending = parse_pending(data)\\n self.role_ids = parse_role_ids(data)\\n self.timed_out_until = parse_timed_out_until(data)\",\n \"def get_attributes(self) -> Dict[str, str]:\\n pass\",\n \"def store_attrs(self, attrs):\\n self.get_attr().SetObject(dumps(attrs), False)\",\n \"def merge_attrs(self):\\n for aid in self.attrs:\\n new_val = self.attrs[aid]\\n if aid in self.attributes:\\n if ('value' in self.attributes[aid] and\\n self.attributes[aid]['value'] != new_val):\\n pass\\n # print \\\"Updating attribute %s[%s] %s -> %s\\\" % (\\n # self.name, aid, self.attributes[aid]['value'], new_val)\\n else:\\n # print \\\"** Warning: non-declaired attribute %s['%s'] set to:\\\\n'%s'\\\" % (\\n # self.name, aid, new_val)\\n self.remember_custom_attribute(self.name, aid, new_val)\\n self.attributes[aid] = {}\\n self.attributes[aid]['nv'] = new_val\",\n \"def parse_attributes(cls):\\n cls._fields = []\\n cls._tables = []\\n for attr_k in dir(cls):\\n try:\\n attr = object.__getattribute__(cls, attr_k)\\n except AttributeError:\\n continue\\n if issubclass(attr.__class__, ReferenceManyField):\\n cls._tables.append(attr_k)\\n elif issubclass(attr.__class__, Field):\\n cls._fields.append(attr_k)\",\n \"def __getattr__(self, attr):\\n for resource in lineage(self):\\n if attr in resource.__initial_attrs__:\\n value = self.__dict__[attr] = getattr(resource, attr)\\n return value\\n raise AttributeError(\\n '{!r} object has no attribute {!r}'.format(self, attr))\",\n \"def test_get_attributes(self):\\n pass\",\n \"def test_get_attributes(test_common_dao):\\n _session = test_common_dao.RAMSTK_SESSION(\\n bind=test_common_dao.engine, autoflush=False, expire_on_commit=False)\\n DUT = _session.query(RAMSTKSiteInfo).first()\\n\\n assert DUT.get_attributes() == ATTRIBUTES\",\n \"async def _parse_entities(self, responses: SourceResponses) -> Entities:\\n entity_attributes = [\\n {\\n \\\"url\\\": str(row[\\\"URL\\\"]),\\n \\\"violation_type\\\": row[\\\"Violation Type\\\"],\\n \\\"impact\\\": row[\\\"Impact\\\"],\\n \\\"element\\\": row[\\\"DOM Element\\\"],\\n \\\"page\\\": re.sub(r\\\"https?://[^/]+\\\", \\\"\\\", row[\\\"URL\\\"]),\\n \\\"description\\\": row[\\\"Messages\\\"],\\n \\\"help\\\": row[\\\"Help\\\"],\\n }\\n for row in await self.__parse_csv(responses)\\n ]\\n return Entities(\\n Entity(key=md5_hash(\\\",\\\".join(str(value) for value in attributes.values())), **attributes)\\n for attributes in entity_attributes\\n )\",\n \"def getComputedAttributes(self) -> list:\\n if self.loggingEnabled:\\n self.logger.debug(f\\\"Starting getComputedAttributes\\\")\\n path = \\\"/config/computedAttributes\\\"\\n res = self.connector.getData(self.endpoint + path)\\n data = res[\\\"children\\\"]\\n nextPage = res[\\\"_page\\\"].get(\\\"next\\\", \\\"\\\")\\n # while nextPage != \\\"\\\":\\n # res = self.connector.getData(self.endpoint+path,\\n # params=params, headers=self.header)\\n # data += res['children']\\n # nextPage = res['_page'].get('next','')\\n return res\",\n \"def transform_attributes(attrs):\\n transformed = {}\\n for key, value in attrs.items():\\n if key in [\\\"raw_message\\\", \\\"text\\\"]:\\n transformed[\\\"raw_content\\\"] = value\\n elif key in [\\\"diaspora_handle\\\", \\\"sender_handle\\\", \\\"author\\\"]:\\n transformed[\\\"handle\\\"] = value\\n elif key == \\\"recipient_handle\\\":\\n transformed[\\\"target_handle\\\"] = value\\n elif key == \\\"parent_guid\\\":\\n transformed[\\\"target_guid\\\"] = value\\n elif key == \\\"first_name\\\":\\n transformed[\\\"name\\\"] = value\\n elif key == \\\"image_url\\\":\\n if \\\"image_urls\\\" not in transformed:\\n transformed[\\\"image_urls\\\"] = {}\\n transformed[\\\"image_urls\\\"][\\\"large\\\"] = value\\n elif key == \\\"image_url_small\\\":\\n if \\\"image_urls\\\" not in transformed:\\n transformed[\\\"image_urls\\\"] = {}\\n transformed[\\\"image_urls\\\"][\\\"small\\\"] = value\\n elif key == \\\"image_url_medium\\\":\\n if \\\"image_urls\\\" not in transformed:\\n transformed[\\\"image_urls\\\"] = {}\\n transformed[\\\"image_urls\\\"][\\\"medium\\\"] = value\\n elif key == \\\"tag_string\\\":\\n transformed[\\\"tag_list\\\"] = value.replace(\\\"#\\\", \\\"\\\").split(\\\" \\\")\\n elif key == \\\"bio\\\":\\n transformed[\\\"raw_content\\\"] = value\\n elif key == \\\"searchable\\\":\\n transformed[\\\"public\\\"] = True if value == \\\"true\\\" else False\\n elif key == \\\"target_type\\\":\\n transformed[\\\"entity_type\\\"] = DiasporaRetraction.entity_type_from_remote(value)\\n elif key == \\\"remote_photo_path\\\":\\n transformed[\\\"remote_path\\\"] = value\\n elif key == \\\"remote_photo_name\\\":\\n transformed[\\\"remote_name\\\"] = value\\n elif key == \\\"status_message_guid\\\":\\n transformed[\\\"linked_guid\\\"] = value\\n transformed[\\\"linked_type\\\"] = \\\"Post\\\"\\n elif key in BOOLEAN_KEYS:\\n transformed[key] = True if value == \\\"true\\\" else False\\n elif key in DATETIME_KEYS:\\n try:\\n # New style timestamps since in protocol 0.1.6\\n transformed[key] = datetime.strptime(value, \\\"%Y-%m-%dT%H:%M:%SZ\\\")\\n except ValueError:\\n # Legacy style timestamps\\n transformed[key] = datetime.strptime(value, \\\"%Y-%m-%d %H:%M:%S %Z\\\")\\n elif key in INTEGER_KEYS:\\n transformed[key] = int(value)\\n else:\\n transformed[key] = value or \\\"\\\"\\n return transformed\",\n \"def get_attributes(self):\\n return self.attributes\",\n \"def get_non_redundant_entity_attributes(self):\\n return self.__non_redundant_entity_attributes\",\n \"def read_affectiva(self, filename=None, *args, **kwargs):\\n if not filename:\\n try:\\n filename = self.filename\\n except:\\n print(\\\"filename must be specified.\\\")\\n result = read_affectiva(filename, *args, **kwargs)\\n for name in self._metadata:\\n attr_value = getattr(self, name, None)\\n if attr_value and getattr(result, name, None) == None:\\n setattr(result, name, attr_value)\\n return result\",\n \"def test_get_attribute_data(self):\\n pass\",\n \"def getfield(self, pkt, s):\\n class_id = getattr(pkt, self._entity_class)\\n attribute_mask = getattr(pkt, self._attributes_mask)\\n entity_class = omci_entities.entity_id_to_class_map[class_id]\\n indices = entity_class.attribute_indices_from_mask(attribute_mask)\\n data = {}\\n table_attribute_mask = 0\\n for index in indices:\\n try:\\n fld = entity_class.attributes[index].field\\n except IndexError as e:\\n log.error(\\\"attribute-decode-failure\\\", attribute_index=index,\\n entity_class=entity_class, e=e)\\n continue\\n try:\\n s, value = fld.getfield(pkt, s)\\n except Exception as _e:\\n raise\\n if isinstance(pkt, OmciGetResponse) and isinstance(fld, OmciTableField):\\n data[fld.name + '_size'] = value\\n table_attribute_mask = table_attribute_mask | (1 << (16 - index))\\n else:\\n data[fld.name] = value\\n if table_attribute_mask:\\n data['table_attribute_mask'] = table_attribute_mask\\n return s, data\",\n \"def overwrite_attrs(self, src_detail, attrs):\\n case_tile_configuration_list = [\\n 'case_tile_template',\\n 'persist_tile_on_forms',\\n 'persistent_case_tile_from_module',\\n 'pull_down_tile',\\n 'persist_case_context',\\n 'persistent_case_context_xml',\\n 'case_tile_group',\\n ]\\n for attr in attrs:\\n if attr == \\\"case_tile_configuration\\\":\\n for ele in case_tile_configuration_list:\\n setattr(self, ele, getattr(src_detail, ele))\\n else:\\n setattr(self, attr, getattr(src_detail, attr))\",\n \"def get(entity, name=None, version=None, lineage=None):\",\n \"def deserialize(self, source):\\n attrs = {}\\n for k, v in source.iteritems():\\n try:\\n attrs[k] = self.deserialize_field(source, k)\\n except (AttributeError, FieldDoesNotExist):\\n # m2m, abstract\\n pass\\n\\n return self.instanciate(attrs)\\n # TODO: we can assign m2ms now\",\n \"def fetch(args):\\n storage, remote_path = split_storage(args.remote)\\n\\n local_path = args.local\\n if local_path is None:\\n _, local_path = os.path.split(remote_path)\\n\\n local_path_exists = os.path.exists(local_path)\\n if local_path_exists and not args.force and not args.update:\\n sys.exit(\\\"Local file %s already exists, not overwriting.\\\" % local_path)\\n\\n directory, _ = os.path.split(local_path)\\n if directory:\\n makedirs(directory, exist_ok=True)\\n\\n osf = _setup_osf(args)\\n project = osf.project(args.project)\\n\\n store = project.storage(storage)\\n for file_ in store.files:\\n if norm_remote_path(file_.path) == remote_path:\\n if local_path_exists and not args.force and args.update:\\n if file_.hashes.get('md5') == checksum(local_path):\\n print(\\\"Local file %s already matches remote.\\\" % local_path)\\n break\\n with open(local_path, 'wb') as fp:\\n file_.write_to(fp)\\n\\n # only fetching one file so we are done\\n break\",\n \"def extra_state_attributes(self):\\r\\n return self._attributes\",\n \"def attributes(self):\\n raise NotImplementedError\",\n \"def get_properties(self):\\n geospatial = self.get_geospatial()\\n temporal = self.get_temporal()\\n\\n # File system metadata\\n filesystem = super(SAFESentinelBase, self).get_filesystem(self.fname)\\n self._update_filesystem_metadata(filesystem)\\n\\n data_format = {\\\"format\\\": \\\"SAFE\\\"}\\n\\n # Gather up extra metadata\\n extra_metadata = {}\\n for key in (\\\"platform\\\", \\\"product_info\\\", \\\"orbit_info\\\"):\\n if self.sections.get(key):\\n extra_metadata[key] = self.sections[key]\\n\\n # Set extra content from existing content and filename\\n self._update_extra_metadata(extra_metadata)\\n \\n props = product.Properties(spatial=geospatial,\\n temporal=temporal,\\n filesystem=filesystem,\\n data_format=data_format,\\n **extra_metadata)\\n\\n return props\",\n \"def get_redundant_entity_attributes(self):\\n return self.__redundant_entity_attributes\",\n \"def _iterattrs(self, handle=\\\"\\\"):\\n if not handle:\\n handle = self.handle\\n attr = gv.firstattr(handle)\\n while gv.ok(attr):\\n yield gv.nameof(attr), decode_page(gv.getv(handle, attr))\\n attr = gv.nextattr(handle, attr)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5523847","0.55163735","0.5404263","0.53723055","0.5261947","0.52431804","0.5242798","0.5209427","0.51474196","0.5137612","0.51318413","0.50730455","0.50500995","0.5048805","0.5024441","0.49533403","0.49302346","0.49292526","0.49168682","0.49107","0.49033284","0.49016514","0.4865974","0.48555458","0.4855137","0.48537794","0.48523307","0.485052","0.48495385","0.4837493","0.4833591","0.48172793","0.48127687","0.4809575","0.4804256","0.47854","0.4782812","0.47684136","0.47597572","0.4754303","0.47331774","0.47287923","0.4727361","0.47218826","0.4712551","0.47118908","0.47019395","0.46891463","0.46862486","0.46821308","0.466816","0.46602407","0.4656546","0.4644909","0.46434236","0.46416426","0.4638796","0.4622243","0.4621878","0.46191788","0.46104404","0.4598712","0.45880276","0.45876002","0.45820683","0.4580744","0.4578261","0.45724675","0.45696482","0.45692214","0.45645583","0.45596","0.45570132","0.4540166","0.45373324","0.45310897","0.45267197","0.45211476","0.4516948","0.4507666","0.4507525","0.45057157","0.4495946","0.44908577","0.4489391","0.44870362","0.44813955","0.4480631","0.447667","0.4473912","0.44718516","0.44660035","0.4463493","0.44630536","0.4461968","0.446048","0.44555375","0.44547367","0.445357","0.44533947"],"string":"[\n \"0.5523847\",\n \"0.55163735\",\n \"0.5404263\",\n \"0.53723055\",\n \"0.5261947\",\n \"0.52431804\",\n \"0.5242798\",\n \"0.5209427\",\n \"0.51474196\",\n \"0.5137612\",\n \"0.51318413\",\n \"0.50730455\",\n \"0.50500995\",\n \"0.5048805\",\n \"0.5024441\",\n \"0.49533403\",\n \"0.49302346\",\n \"0.49292526\",\n \"0.49168682\",\n \"0.49107\",\n \"0.49033284\",\n \"0.49016514\",\n \"0.4865974\",\n \"0.48555458\",\n \"0.4855137\",\n \"0.48537794\",\n \"0.48523307\",\n \"0.485052\",\n \"0.48495385\",\n \"0.4837493\",\n \"0.4833591\",\n \"0.48172793\",\n \"0.48127687\",\n \"0.4809575\",\n \"0.4804256\",\n \"0.47854\",\n \"0.4782812\",\n \"0.47684136\",\n \"0.47597572\",\n \"0.4754303\",\n \"0.47331774\",\n \"0.47287923\",\n \"0.4727361\",\n \"0.47218826\",\n \"0.4712551\",\n \"0.47118908\",\n \"0.47019395\",\n \"0.46891463\",\n \"0.46862486\",\n \"0.46821308\",\n \"0.466816\",\n \"0.46602407\",\n \"0.4656546\",\n \"0.4644909\",\n \"0.46434236\",\n \"0.46416426\",\n \"0.4638796\",\n \"0.4622243\",\n \"0.4621878\",\n \"0.46191788\",\n \"0.46104404\",\n \"0.4598712\",\n \"0.45880276\",\n \"0.45876002\",\n \"0.45820683\",\n \"0.4580744\",\n \"0.4578261\",\n \"0.45724675\",\n \"0.45696482\",\n \"0.45692214\",\n \"0.45645583\",\n \"0.45596\",\n \"0.45570132\",\n \"0.4540166\",\n \"0.45373324\",\n \"0.45310897\",\n \"0.45267197\",\n \"0.45211476\",\n \"0.4516948\",\n \"0.4507666\",\n \"0.4507525\",\n \"0.45057157\",\n \"0.4495946\",\n \"0.44908577\",\n \"0.4489391\",\n \"0.44870362\",\n \"0.44813955\",\n \"0.4480631\",\n \"0.447667\",\n \"0.4473912\",\n \"0.44718516\",\n \"0.44660035\",\n \"0.4463493\",\n \"0.44630536\",\n \"0.4461968\",\n \"0.446048\",\n \"0.44555375\",\n \"0.44547367\",\n \"0.445357\",\n \"0.44533947\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5443011"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":81990,"cells":{"query":{"kind":"string","value":"Update the remote entity attributes from the local attributes."},"document":{"kind":"string","value":"def update(self):\n self.attributes = self.call('UPDATE', expect=error.OK, body=self.attributes)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def update(self) -> None:\n self._api.update()\n if self.available:\n self._attr_native_value = self._api.data[self.entity_description.key]\n else:\n self._attr_native_value = None","def _async_update_attrs(self) -> None:\n self._attr_is_on = self.entity_description.is_on(self._lock.state)","def update_attributes(self, attrs):\n try:\n _dict = self.extract_request(attrs)\n for key in _dict:\n setattr(self, key, _dict[key])\n db.session.add(self)\n db.session.commit()\n except Exception as e:\n print(e)","def update_attrs(self, is_replace_attrs=True, is_allow_none=True,\n is_replace_dicts_values=False, **attrs):\n from lib.entities import entities_factory\n return (entities_factory.EntitiesFactory().\n update_objs_attrs_values_by_entered_data(\n objs=self, is_replace_attrs_values=is_replace_attrs,\n is_allow_none_values=is_allow_none,\n is_replace_values_of_dicts=is_replace_dicts_values, **attrs))","def update(self, new_attrs):\n self.last_update = round(time())\n self.attrs.update(new_attrs)","def update_entities(self):\n raise NotImplementedError()","def update_from_latest_data(self) -> None:\n self._attr_is_on = self.coordinator.data[self.entity_description.data_key]","def _async_update_attrs(self) -> None:\n self._attr_is_on = self._device.light_on\n if self._device.light_brightness is not None:\n self._attr_brightness = int(min(255, self._device.light_brightness * 16))","def set_attr(self, attr_name, value, indices=None):\n target_remotes = self._get_target_remotes(indices)\n for remote in target_remotes:\n remote.send(('set_attr', (attr_name, value)))\n for remote in target_remotes:\n remote.recv()","def merge_attrs(self):\n for aid in self.attrs:\n new_val = self.attrs[aid]\n if aid in self.attributes:\n if ('value' in self.attributes[aid] and\n self.attributes[aid]['value'] != new_val):\n pass\n # print \"Updating attribute %s[%s] %s -> %s\" % (\n # self.name, aid, self.attributes[aid]['value'], new_val)\n else:\n # print \"** Warning: non-declaired attribute %s['%s'] set to:\\n'%s'\" % (\n # self.name, aid, new_val)\n self.remember_custom_attribute(self.name, aid, new_val)\n self.attributes[aid] = {}\n self.attributes[aid]['nv'] = new_val","def _update_from_rest_data(self) -> None:","def update(self):\n self._state = status\n attributes['host'] = host\n attributes['port'] = port\n self.custom_attributes = attributes","def soft_update(self, local_model, target_model, rho):\r\n for target_param, local_param in zip(target_model.parameters(), local_model.parameters()):\r\n target_param.data.copy_(rho*target_param.data + (1.0-rho)*local_param.data)","def update(self, attributes, type=None, name=None, identity=None):\n attributes = attributes or {}\n type = type or attributes.get('type')\n name = name or attributes.get('name')\n identity = identity or attributes.get('identity')\n if name and identity:\n name = None # Only send one\n request = self.request(operation='UPDATE', type=type, name=name,\n identity=identity, body=self.clean_attrs(attributes))\n return Entity(self, self.call(request).body)","def update(self) -> None:\n try:\n sensor_type = self.entity_description.key\n if sensor_type == \"status\":\n self._attr_native_value = self.charger.getStatus()\n elif sensor_type == \"charge_time\":\n self._attr_native_value = self.charger.getChargeTimeElapsed() / 60\n elif sensor_type == \"ambient_temp\":\n self._attr_native_value = self.charger.getAmbientTemperature()\n elif sensor_type == \"ir_temp\":\n self._attr_native_value = self.charger.getIRTemperature()\n elif sensor_type == \"rtc_temp\":\n self._attr_native_value = self.charger.getRTCTemperature()\n elif sensor_type == \"usage_session\":\n self._attr_native_value = float(self.charger.getUsageSession()) / 1000\n elif sensor_type == \"usage_total\":\n self._attr_native_value = float(self.charger.getUsageTotal()) / 1000\n else:\n self._attr_native_value = \"Unknown\"\n except (RequestException, ValueError, KeyError):\n _LOGGER.warning(\"Could not update status for %s\", self.name)","def entityUpdates(self, *args):\n\t\tfor entity in self.members.values():\n\t\t\tentity.update(*args)","def _update_attributes(self, data):\n self._set_avatar(data)\n self.boosts_since = parse_boosts_since(data)\n self.flags = parse_flags(data)\n self.nick = parse_nick(data)\n self.pending = parse_pending(data)\n self.role_ids = parse_role_ids(data)\n self.timed_out_until = parse_timed_out_until(data)","def update_from_latest_data(self) -> None:\n data = self.coordinator.data[self.entity_description.uid]\n\n self._attr_is_on = bool(data[\"status\"])\n\n next_run: str | None\n if data.get(\"nextRun\") is None:\n next_run = None\n else:\n next_run = datetime.strptime(\n f\"{data['nextRun']} {data['startTime']}\",\n \"%Y-%m-%d %H:%M\",\n ).isoformat()\n\n self._attr_extra_state_attributes.update(\n {\n ATTR_ID: self.entity_description.uid,\n ATTR_NEXT_RUN: next_run,\n ATTR_SOAK: data.get(\"soak\"),\n ATTR_STATUS: RUN_STATE_MAP[data[\"status\"]],\n ATTR_ZONES: [z for z in data[\"wateringTimes\"] if z[\"active\"]],\n }\n )","def test_update_attribute_data(self):\n pass","def refresh(self, context=None):\n current = self.__class__.get_by_uuid(self._context,\n cluster=self.cluster_id,\n uuid=self.uuid)\n for field in self.fields:\n if self.obj_attr_is_set(field) and self[field] != current[field]:\n self[field] = current[field]","def update(self, attributes):\n for key in attributes:\n k = key.lower()\n if not isinstance(attributes[key], str) or attributes[key] != '':\n k_ = k.strip(' =:\\t\\n').replace('', '')\n self.attributes.update({k_: attributes[key]})\n elif k in self.attributes:\n del self.attributes[k]","def merge(self, new_attributes):\n for k, v in new_attributes.items():\n setattr(self, k, v)","def update_from_latest_data(self) -> None:\n self._attr_is_on = self.coordinator.data[self.entity_description.uid][\"active\"]","def _difference_update_attributes(self, data):\n old_attributes = {}\n \n # avatar\n self._update_avatar(data, old_attributes)\n \n # boosts_since\n boosts_since = parse_boosts_since(data)\n if self.boosts_since != boosts_since:\n old_attributes['boosts_since'] = self.boosts_since\n self.boosts_since = boosts_since\n \n flags = parse_flags(data)\n if self.flags != flags:\n old_attributes['flags'] = self.flags\n self.flags = flags\n \n # nick\n nick = parse_nick(data)\n if self.nick != nick:\n old_attributes['nick'] = self.nick\n self.nick = nick\n \n # pending\n pending = parse_pending(data)\n if pending != self.pending:\n old_attributes['pending'] = self.pending\n self.pending = pending\n \n # role_ids\n role_ids = parse_role_ids(data)\n if role_ids != self.role_ids:\n old_attributes['role_ids'] = self.role_ids\n self.role_ids = role_ids\n \n # timed_out_until\n timed_out_until = parse_timed_out_until(data)\n if self.timed_out_until != timed_out_until:\n old_attributes['timed_out_until'] = self.timed_out_until\n self.timed_out_until = timed_out_until\n \n return old_attributes","def _restore_live_attrs(lock_detail, attrs):\n for attr, value in attrs.items():\n setattr(lock_detail, attr, value)","def update(self):\n if self._data_provider_state is not None:\n self._state = self._data_provider_state()\n \n if self._data_provider_attributes is not None:\n self._attributes = self._data_provider_attributes()","async def update(self):\n\t\tstate = await self._client.get_state('command.cgi?cmd=getObject&oid={0}&ot={1}'.format(self._oid,self._ot))\n\t\tif state is not None:\n\t\t\tself._raw_result = state","def update(self, verbose=True):\n params = flask.request.json\n for key, value in params.items():\n\n if value == 'None':\n value = None\n\n if key == 'updated_on':\n value = datetime.now()\n\n if key in self.data_model.keys():\n\n # unfuck javascript-style date strings\n if self.data_model[key] == datetime:\n if isinstance(value, datetime):\n pass\n elif isinstance(value, dict):\n value = datetime.fromtimestamp(value['$date'] / 1000.0)\n else:\n try:\n value = datetime.strptime(value, '%Y-%m-%dT%H:%M:%S.000Z')\n except ValueError:\n try:\n value = datetime.strptime(value, '%Y-%m-%d %H:%M:%S')\n except Exception as e:\n raise\n except TypeError as e:\n err_msg = \"Incoming attribute '%s' must be datetime!\"\n self.logger.error(err_msg % key)\n self.logger.error(\"Got value '%s' instead...\" % value)\n raise Exception(err_msg % key)\n\n # set the self.attribute values\n setattr(self, key, value)\n\n self.save(verbose)","def update_server_engine_attributes(ServerName=None, AttributeName=None, AttributeValue=None):\n pass","def update(self, **values):\r\n if self.__abstract__:\r\n raise ThunderdomeException('cant update abstract elements')\r\n self.pre_update(**values)\r\n for key in values.keys():\r\n if key not in self._columns:\r\n raise TypeError(\"unrecognized attribute name: '{}'\".format(key))\r\n\r\n for k,v in values.items():\r\n setattr(self, k, v)\r\n\r\n return self.save()","def update(self, f):\n\n for p in self.__mapper__.attrs:\n\n if p.key == 'oid':\n continue\n try:\n setattr(self, p.key, getattr(f, p.key))\n\n except AttributeError:\n # The dict() method copies data property values into the main dict,\n # and these don't have associated class properties.\n continue","def update(self, f):\n\n for p in self.__mapper__.attrs:\n\n if p.key == 'oid':\n continue\n try:\n setattr(self, p.key, getattr(f, p.key))\n\n except AttributeError:\n # The dict() method copies data property values into the main dict,\n # and these don't have associated class properties.\n continue","def hard_update(self,target, source):\n\t\tfor target_param, param in zip(target.parameters(), source.parameters()):\n\t\t\t\ttarget_param.data.copy_(param.data)","def update_entity(self, device_id, data):\n url = '{}/ngsi-ld/v1/entities/{}/attrs'.format(self.url, device_id)\n return self.post(url, data=data, headers=self.headers_ld)","def updateAttrs(self, kwargs):\n for k, v in kwargs.iteritems():\n setattr(self, k, v)","def update_from_latest_data(self) -> None:\n data = self.coordinator.data[self.entity_description.uid]\n\n self._attr_is_on = bool(data[\"state\"])\n\n attrs = {\n ATTR_CURRENT_CYCLE: data[\"cycle\"],\n ATTR_ID: data[\"uid\"],\n ATTR_NO_CYCLES: data[\"noOfCycles\"],\n ATTR_RESTRICTIONS: data[\"restriction\"],\n ATTR_SLOPE: SLOPE_TYPE_MAP.get(data[\"slope\"], 99),\n ATTR_SOIL_TYPE: SOIL_TYPE_MAP.get(data[\"soil\"], 99),\n ATTR_SPRINKLER_TYPE: SPRINKLER_TYPE_MAP.get(data[\"group_id\"], 99),\n ATTR_STATUS: RUN_STATE_MAP[data[\"state\"]],\n ATTR_SUN_EXPOSURE: SUN_EXPOSURE_MAP.get(data.get(\"sun\")),\n ATTR_VEGETATION_TYPE: VEGETATION_MAP.get(data[\"type\"], 99),\n }\n\n if \"waterSense\" in data:\n if \"area\" in data[\"waterSense\"]:\n attrs[ATTR_AREA] = round(data[\"waterSense\"][\"area\"], 2)\n if \"fieldCapacity\" in data[\"waterSense\"]:\n attrs[ATTR_FIELD_CAPACITY] = round(\n data[\"waterSense\"][\"fieldCapacity\"], 2\n )\n if \"precipitationRate\" in data[\"waterSense\"]:\n attrs[ATTR_PRECIP_RATE] = round(\n data[\"waterSense\"][\"precipitationRate\"], 2\n )\n\n if self._entry.options[CONF_USE_APP_RUN_TIMES]:\n provision_data = self._data.coordinators[DATA_PROVISION_SETTINGS].data\n if zone_durations := provision_data.get(\"system\", {}).get(\"zoneDuration\"):\n attrs[ATTR_ZONE_RUN_TIME] = zone_durations[\n list(self.coordinator.data).index(self.entity_description.uid)\n ]\n\n self._attr_extra_state_attributes.update(attrs)","def update(self):\n # Variable returned\n modified = False\n\n bgp_neighbor_data = utils.get_attrs(self, self.config_attrs)\n\n # Get ISL port uri\n if self.local_interface is not None:\n bgp_neighbor_data[\n \"local_interface\"\n ] = self.local_interface.get_info_format()\n\n uri = \"{0}/{1}\".format(self.base_uri, self.ip_or_ifname_or_group_name)\n\n # Compare dictionaries\n if bgp_neighbor_data == self.__original_attributes:\n # Object was not modified\n modified = False\n\n else:\n put_data = json.dumps(bgp_neighbor_data)\n\n try:\n response = self.session.request(\"PUT\", uri, data=put_data)\n\n except Exception as e:\n raise ResponseError(\"PUT\", e)\n\n if not utils._response_ok(response, \"PUT\"):\n raise GenericOperationError(\n response.text, response.status_code\n )\n\n logging.info(\"SUCCESS: Updating %s\", self)\n # Set new original attributes\n self.__original_attributes = bgp_neighbor_data\n # Object was modified\n modified = True\n return modified","def update_model_fields(self, model, payload):\n fk_fields = model.fk_field_names()\n models_fields = {\n i: payload[i]\n for i, mapping in model.fields.items()\n if i not in fk_fields\n }\n for i, mapping in model.fields.items():\n if i in fk_fields:\n try:\n models_fields[i] = self.render_relation_field(\n mapping, payload[i]\n )\n except SkipField:\n models_fields.pop(i, None)\n model.update(models_fields)\n model.remote_instance = self.create_remote_instance(payload)\n return model","def _set_attributes(self):","def _update_from_feature_set(self, feature_set):\n\n self.name = feature_set.name\n self.project = feature_set.project\n self.source = feature_set.source\n self.max_age = feature_set.max_age\n self.features = feature_set.features\n self.entities = feature_set.entities\n self.source = feature_set.source\n self.status = feature_set.status\n self.created_timestamp = feature_set.created_timestamp","def update_attr(self):\n\n # Retrieve all current values\n all_values = nx.get_node_attributes(self.G, 'value')\n\n new_values = {}\n\n # Loop over all nodes\n for i in range(self.n_v):\n\n # Obtain list of neighbors\n neighbors = list(nx.all_neighbors(self.G, i))\n\n # Compute part dependent on own node\n val_i = all_values[i]\n new_value = (1 - self.eps) * (1 - self.a * val_i * val_i)\n\n # Compute part dependent on neighbor nodes\n neighbors_value = 0\n for neighbor in neighbors:\n val_n = all_values[neighbor]\n neighbors_value += (1 - self.a * val_n * val_n)\n\n # Catch nodes without neighbors\n try:\n new_value += neighbors_value * (self.eps/len(neighbors))\n except ZeroDivisionError:\n pass\n\n # Save new value\n new_values[i] = {'value': new_value}\n\n nx.set_node_attributes(self.G, new_values)","def update_attr_par(self):\n\n # Retrieve all current values\n self.all_values_temp = nx.get_node_attributes(self.G, 'value')\n\n # Calculate all new values\n new_values_list = Parallel(n_jobs=2)(delayed(self.single_node_update)(i) \\\n for i in range(self.n_v))\n\n # # Set list to dict as needed for node update\n # new_values_dict = {}\n # for i, value in enumerate(new_values_list):\n # new_values_dict[i] = {'value': value}\n #\n # # Update node value\n # nx.set_node_attributes(self.G, new_values_dict)","def update_obj(obj, attributes, params):\n for key in params.keys():\n if key in attributes:\n try:\n set_attribute(obj, key, params[key])\n except:\n abort(400)\n \n Session.flush()\n Session.commit()","def sync_remote(self, other):\n pass # TODO","def _async_update_attrs(self) -> None:\n super()._async_update_attrs()\n self._attr_color_temp = color_temperature_kelvin_to_mired(\n self._device.light_color_temp\n )","def _update_attrs(self) -> None:\n self._attr_is_locked = self._lock.is_locked\n self._attr_is_jammed = self._lock.is_jammed\n # Only update changed_by if we get a valid value. This way a previous\n # value will stay intact if the latest log message isn't related to a\n # lock state change.\n if changed_by := self._lock.last_changed_by(self._lock_data.logs):\n self._attr_changed_by = changed_by","def update(self, **kwargs):\n print(\"Updating model\")\n print(kwargs)\n for key in kwargs:\n setattr(self, key, kwargs[key])","def set_attrs(self, location, attr_dict):\r\n for attr in attr_dict.iterkeys():\r\n if attr in ['_id', 'md5', 'uploadDate', 'length']:\r\n raise AttributeError(\"{} is a protected attribute.\".format(attr))\r\n asset_db_key = self.asset_db_key(location)\r\n # FIXME remove fetch and use a form of update which fails if doesn't exist\r\n item = self.fs_files.find_one(asset_db_key)\r\n if item is None:\r\n raise NotFoundError(asset_db_key)\r\n self.fs_files.update(asset_db_key, {\"$set\": attr_dict})","def update(self, datastore, model, **kwargs):\n for k, v in self._preprocess_params(kwargs).items():\n setattr(model, k, v)\n self.save(datastore, model)\n return model","async def refresh_entity_state(self):","def restore(self):\n if self.obj:\n for attrib in self.attribs:\n setattr(self.obj, attrib, getattr(self, attrib))","def update(self):\n self.data_service.update()\n self._state = self.data_service.data[self._json_key]\n self._attributes = self.data_service.attributes[self._json_key]","def update_flow_metadata(self, update_with):\n if update_with:\n source, clone = self._fetch_flowdetail(clone=True)\n clone.meta.update(update_with)\n self._with_connection(self._save_flow_detail, source, clone)","def set_local_coordinates(self, entity_id, x, y):\n position = getattr(self.entities[entitiy_id],\n self.local_position_system)\n position.x = x \n position.y = y","def sync_local(self, other):\n pass # TODO","def store_attrs(self, attrs):\n self.get_attr().SetObject(dumps(attrs), False)","def update_latent(self):\n self.scenario.update_latent()","def OnAttributesUpdated():\n pass","def overwrite_attrs(self, src_detail, attrs):\n case_tile_configuration_list = [\n 'case_tile_template',\n 'persist_tile_on_forms',\n 'persistent_case_tile_from_module',\n 'pull_down_tile',\n 'persist_case_context',\n 'persistent_case_context_xml',\n 'case_tile_group',\n ]\n for attr in attrs:\n if attr == \"case_tile_configuration\":\n for ele in case_tile_configuration_list:\n setattr(self, ele, getattr(src_detail, ele))\n else:\n setattr(self, attr, getattr(src_detail, attr))","def forward_attributes(src, dst):\n dst.set_tag(src.get_tag())\n dst.set_debug(src.get_debug())\n dst.set_handle(src.get_handle())\n if hasattr(src.attributes, \"init_stage\"):\n forward_stage_attributes(src, dst)\n if isinstance(src, BooleanOperation) and isinstance(dst, BooleanOperation):\n dst.likely = src.likely","def update(object, **attrs):\n updated = {}\n for key, value in attrs.items():\n if not hasattr(object, key) or getattr(object, key) != attrs[key]:\n updated[key] = value\n setattr(object, key, value)\n return updated","def setAttributes(self, attrDict):\n self.graph.saveExtendedAttributes(self.entityId, attrDict)","def modified(self, **attributes):\n new_obj = deepcopy(self)\n new_obj.__dict__.update(attributes)\n new_obj.initialize()\n return new_obj","def update_original_data(self):\n pass","def update(self, new_data):\n all_keys = [key for key in self.__dict__]\n keys = [key for key in new_data]\n for key in keys:\n if key in all_keys:\n setattr(self, key, new_data[key])\n else:\n return {\n \"message\": \"Error encountered when setting attributes.\",\n \"help\": \"Ensure all fields you're updating are valid.\"\n }\n self.save()","def fill_attributes(ml_file, other_file):\n with xr.load_dataset(other_file) as other:\n with xr.open_dataset(ml_file) as ml:\n for variable in other.variables:\n if variable in ml.variables:\n other[variable].attrs = ml[variable].attrs\n other.to_netcdf(other_file)","def update(self):\n #self._switch.odlclient._request_json(self._path, method=\"put\", json={\n # \"flow\": self._odl_inventory()\n #})\n self.remove() # actually, remove only uses self.switch and self.id, so this removes the other entry as well.\n self.deploy()","def test_update_metadata_by_attribute(self):\n pass","def sync(self):\n if not self.is_readonly():\n deser = self._deserialize()\n orig = getattr(self.model, self.name)\n if (orig != deser):\n if isinstance(orig, list):\n # first remove the original triples, instead of doing sophisticated\n # set manipulations\n setattr(self.model, self.name, [])\n setattr(self.model, self.name, deser)","def copy_from_entity(self, entity):\n for prop in entity._EndpointsPropertyItervalues():\n attr_name = prop._code_name\n value = getattr(entity, attr_name)\n if value is not None:\n if isinstance(prop, properties.EndpointsAliasProperty):\n value_set = getattr(self, attr_name) is not None\n elif isinstance(prop, ComputedProperty):\n value_set = True\n else:\n value_set = prop._name in self._values\n if not value_set:\n setattr(self, attr_name, value)","def _set_attr(self):\n self.as_skeletal = self._import_as_skeleton()\n self.materials = self._import_materials()\n self.textures = self._import_textures()","def _set_attributes(self, model):\n\n if model:\n self._get_dict(model)","def updateFromContext(self, other):\n value = self.valueType.set(self.value, other.value)\n self.set(value)\n self.origins.extend(other.origins)","def update_times(self, remote_time, local_time):\n self.remote_time = remote_time\n self.local_time = local_time\n for process in self.processes.values():\n process.update_times(self.address_name, remote_time)","def copyAttributes(fromNcVar, toNcVar):\r\n for attrName in fromNcVar.ncattrs():\r\n attrVal = getattr(fromNcVar, attrName)\r\n setattr(toNcVar, attrName, attrVal)","def update(self, **kwargs):\n for k, v in kwargs.iteritems():\n if hasattr(self, k):\n setattr(self, k, v)","def hard_update(target, source):\n for target_param, param in zip(target.parameters(), source.parameters()):\n target_param.data.copy_(param.data)","def update(self) -> None:\n try:\n client = self._client\n\n if client.state == \"Playing\":\n self._attr_state = MediaPlayerState.PLAYING\n elif client.state == \"Paused\":\n self._attr_state = MediaPlayerState.PAUSED\n elif client.state == \"Disconnected\":\n self._attr_state = MediaPlayerState.OFF\n else:\n self._attr_state = MediaPlayerState.PAUSED\n\n if client.last_update and (time.time() - client.last_update > 40):\n self._attr_state = MediaPlayerState.OFF\n\n volume = float(client.volume) if client.volume else 0.0\n self._attr_volume_level = volume / 100.0\n if client.active_playlist_id in client.playlists:\n self._attr_source = client.playlists[client.active_playlist_id][\"name\"]\n else:\n self._attr_source = \"Unknown\"\n self._attr_source_list = [s[\"name\"] for s in client.playlists.values()]\n\n if client.current_track:\n self._attr_media_title = client.current_track[\"title\"]\n self._attr_media_artist = client.current_track[\"track_artist\"]\n self._attr_media_album_name = client.current_track[\"track_album\"]\n self._attr_media_image_hash = client.current_track[\"track_id\"]\n else:\n self._attr_media_image_hash = None\n\n except Exception:\n self._attr_state = MediaPlayerState.OFF\n raise","def set_attributes(self, new_attributes=None):\n self.attributes = new_attributes","def update(self):\n if self._skip_update:\n self._skip_update = False\n return\n\n try:\n for prop in AIRER_PROPS:\n self.status[prop] = self.send('get_prop', [prop])[0]\n _LOGGER.debug(\"MiioDevice update: %s\", self.status)\n self.available = True\n self._retry = 0\n except Exception as exc:\n _LOGGER.error(\"Error on update: %s\", exc)\n self._retry += 1\n if self._retry > 3:\n self.available = False\n\n for entity in self.update_entities:\n entity.async_schedule_update_ha_state()","def update(self, class_name, args, stored_objects):\n id_list = [k.split(\".\")[1] for k in stored_objects]\n instance = \"{}.{}\".format(class_name, args[0])\n obj = stored_objects[instance]\n '''convert to the right attribute value type'''\n setattr(obj, args[1], args[2])\n models.storage.save()","def update_from_latest_data(self) -> None:\n self._attr_is_on = (\n self._ambient.stations[self._mac_address][ATTR_LAST_DATA][\n self.entity_description.key\n ]\n == self.entity_description.on_state\n )","def set_attrs(self, **kwargs) -> None:\n self._obj.coords[GEO_MAP_COORD].attrs.update(**kwargs)","def updateAttributesAfterAdding(self):\n layer = self.sender()\n while self.addedFeatures:\n featureId = self.addedFeatures.pop()\n #begining the edit command\n # layer.beginEditCommand(self.tr(\"DSG Tools reclassification tool: adjusting feature's attributes\"))\n #accessing added features\n editBuffer = layer.editBuffer()\n features = editBuffer.addedFeatures()\n for key in features.keys():\n #just checking the newly added feature, the other I don't care\n if key == featureId:\n feature = features[key]\n #setting the attributes using the reclassification dictionary\n self.setFeatureAttributes(feature, editBuffer)\n layer.endEditCommand()","def update(self, instance, validated_data):\n for attr, value in list(validated_data.items()):\n if attr == 'part_details':\n for a, v in list(value.items()):\n setattr(instance.part_details, attr, value)\n else:\n setattr(instance, attr, value)\n instance.save()\n return instance","def put_attributes(self, attrs):\r\n assert(isinstance(attrs, dict)), \"Argument must be a dict of key->values to save\"\r\n for prop_name in attrs:\r\n value = attrs[prop_name]\r\n prop = self.find_property(prop_name)\r\n assert(prop), \"Property not found: %s\" % prop_name\r\n self._manager.set_property(prop, self, prop_name, value)\r\n self.reload()\r\n return self","def update(self, update_fields=None):\n instance = self.get_object() \n if not update_fields: \n update_fields=self.request.PUT.keys()\n try: \n for field in update_fields:\n update_value = self.request.PUT.get(field) # get value from PUT\n setattr(instance, field, update_value) # renew fields\n instance.save() # save updates\n except IntegrityError: # catch error\n return self.response(status='Failed to Update.') \n return self.response(\n status='Successfully Update')","def test_addMgmtObjAttribute(self) -> None:\n\t\tdct = \t{ 'm2m:bat' : {\n\t\t\t\t\t'aa' : [ 'btl', 'bts']\n\t\t\t\t}}\n\t\tr, rsc = UPDATE(batURL, ORIGINATOR, dct)\n\t\tself.assertEqual(rsc, RC.updated)\n\t\tself.assertEqual(findXPath(r, 'm2m:bat/btl'), 42)\n\t\tself.assertEqual(findXPath(r, 'm2m:bat/bts'), 2)\n\t\tself.assertIsNotNone(findXPath(r, 'm2m:bat/aa'))\n\t\tself.assertEqual(len(findXPath(r, 'm2m:bat/aa')), 2)\n\t\tself.assertIn('btl', findXPath(r, 'm2m:bat/aa'))\n\t\tself.assertIn('bts', findXPath(r, 'm2m:bat/aa'))\n\n\t\tr, rsc = RETRIEVE(f'{REMOTEURL}/~{TestRemote_Annc.remoteBatRI}', ORIGINATOR)\n\t\tself.assertEqual(rsc, RC.OK)\n\t\tself.assertIsNotNone(findXPath(r, 'm2m:batA/btl'))\n\t\tself.assertEqual(findXPath(r, 'm2m:batA/btl'), 42)\n\t\tself.assertIsNotNone(findXPath(r, 'm2m:batA/bts'))\n\t\tself.assertEqual(findXPath(r, 'm2m:batA/bts'), 2)","def test_removeMgmtObjAttribute(self) -> None:\n\t\tdct = \t{ 'm2m:bat' : {\n\t\t\t\t\t'aa' : [ 'bts']\n\t\t\t\t}}\n\t\tr, rsc = UPDATE(batURL, ORIGINATOR, dct)\n\t\tself.assertEqual(rsc, RC.updated)\n\t\tself.assertEqual(findXPath(r, 'm2m:bat/btl'), 42)\n\t\tself.assertEqual(findXPath(r, 'm2m:bat/bts'), 2)\n\t\tself.assertIsNotNone(findXPath(r, 'm2m:bat/aa'))\n\t\tself.assertEqual(len(findXPath(r, 'm2m:bat/aa')), 1)\n\t\tself.assertNotIn('btl', findXPath(r, 'm2m:bat/aa'))\n\t\tself.assertIn('bts', findXPath(r, 'm2m:bat/aa'))\n\n\t\tr, rsc = RETRIEVE(f'{REMOTEURL}/~{TestRemote_Annc.remoteBatRI}', ORIGINATOR)\n\t\tself.assertEqual(rsc, RC.OK)\n\t\tself.assertIsNone(findXPath(r, 'm2m:batA/btl'))\n\t\tself.assertIsNotNone(findXPath(r, 'm2m:batA/bts'))\n\t\tself.assertEqual(findXPath(r, 'm2m:batA/bts'), 2)","def modify(self, context: Context):\n data = attr.asdict(self)\n\n yield self\n self.last_author = context.user.nickname\n self.updated_at = pendulum.now()\n\n try:\n attr.validate(self)\n except TypeError:\n logger.warning(\"failed to validate {}\", self)\n for key, value in data.items():\n # since we can't overwrite self we will need to roll back one by one\n setattr(self, key, value)\n raise","def update(self):\n self._state = get_local_ip()","def update(self, attributes=None):\n\n if attributes is None:\n attributes = {}\n\n headers = self.__class__.create_headers(attributes)\n headers.update(self._update_headers())\n\n result = self._client._put(\n self.__class__.base_url(\n self.sys['id']\n ),\n self.__class__.create_attributes(attributes, self),\n headers=headers\n )\n\n self._update_from_resource(result)\n\n return self","def update(self):\n with managed_session() as session:\n session.merge(self)","def set_attributes(self, attributes):\n self.attributes = attributes","def update_entity(self, username, entity_data):\n\t\treturn self._send_command_to_entity_server(us.SERVER_COMMAND_UPDATE_ENTITY, username + '|' + str(entity_data))","def test_api_object_update_property(self, api_object):\n attrs_dict = {'uuid_': 'CREATING'}\n api_object.update_public_attrs(attrs_dict)\n assert api_object.uuid_ != 'CREATING'","def test_set_attributes(test_common_dao):\n _session = test_common_dao.RAMSTK_SESSION(\n bind=test_common_dao.engine, autoflush=False, expire_on_commit=False)\n DUT = _session.query(RAMSTKSiteInfo).first()\n\n _error_code, _msg = DUT.set_attributes(ATTRIBUTES)\n\n assert _error_code == 0\n assert _msg == (\"RAMSTK SUCCESS: Updating RAMSTKSiteInfo attributes.\")","def update(self):\n self._state = None\n self._attributes = {}\n\n vehicles = self._api.get_vehicles(self._latitude, self._longitude)\n scooter = {}\n\n if vehicles:\n for vehicle in vehicles:\n location_vehicle = (vehicle[\"location\"][0], vehicle[\"location\"][1])\n location_hass = (self._latitude, self._longitude)\n vehicle[\"distance\"] = distance(location_vehicle, location_hass).m\n\n scooter = sorted(vehicles, key=lambda item: item[\"distance\"])[0]\n\n if scooter:\n self._state = round(scooter[\"distance\"])\n self._attributes[ATTR_LATITUDE] = round(scooter[\"location\"][0], 5)\n self._attributes[ATTR_LONGITUDE] = round(scooter[\"location\"][1], 5)\n self._attributes[ATTR_BATTERY_LEVEL] = round(scooter[\"battery\"])\n self._attributes[ATTR_ATTRIBUTION] = ATTRIBUTION","def update(entity_list):\n for entity in entity_list:\n # Only moveable entities should have the dest field\n if \"dest\" in entity:\n # If no destination, pick a new random one\n if entity[\"dest\"] == None:\n entity[\"dest\"] = random_pos(100, 100)\n \n # Move one step towards destination\n cpos = entity[\"position\"]\n dest = entity[\"dest\"]\n entity[\"position\"] = move(cpos, dest) \n\n # Clear destination if it has been reached\n if entity[\"dest\"] == entity[\"position\"]:\n entity[\"dest\"] = None","def update(self, **kwargs):\n for key, value in kwargs.items():\n key = key.upper()\n if not hasattr(self, key):\n self.logger.info(f'[✗] Ignore unknown attribute \"{key}\"')\n else:\n setattr(self, key, value)\n self.logger.info(f'[✓] Attribute \"{key}\" has been updated to \"{value}\"')\n\n assert self.UI in self._SUPPORT_UI, 'unsupported UI'\n assert self.MODE in self._SUPPORT_MODE, 'unsupported MODE'"],"string":"[\n \"def update(self) -> None:\\n self._api.update()\\n if self.available:\\n self._attr_native_value = self._api.data[self.entity_description.key]\\n else:\\n self._attr_native_value = None\",\n \"def _async_update_attrs(self) -> None:\\n self._attr_is_on = self.entity_description.is_on(self._lock.state)\",\n \"def update_attributes(self, attrs):\\n try:\\n _dict = self.extract_request(attrs)\\n for key in _dict:\\n setattr(self, key, _dict[key])\\n db.session.add(self)\\n db.session.commit()\\n except Exception as e:\\n print(e)\",\n \"def update_attrs(self, is_replace_attrs=True, is_allow_none=True,\\n is_replace_dicts_values=False, **attrs):\\n from lib.entities import entities_factory\\n return (entities_factory.EntitiesFactory().\\n update_objs_attrs_values_by_entered_data(\\n objs=self, is_replace_attrs_values=is_replace_attrs,\\n is_allow_none_values=is_allow_none,\\n is_replace_values_of_dicts=is_replace_dicts_values, **attrs))\",\n \"def update(self, new_attrs):\\n self.last_update = round(time())\\n self.attrs.update(new_attrs)\",\n \"def update_entities(self):\\n raise NotImplementedError()\",\n \"def update_from_latest_data(self) -> None:\\n self._attr_is_on = self.coordinator.data[self.entity_description.data_key]\",\n \"def _async_update_attrs(self) -> None:\\n self._attr_is_on = self._device.light_on\\n if self._device.light_brightness is not None:\\n self._attr_brightness = int(min(255, self._device.light_brightness * 16))\",\n \"def set_attr(self, attr_name, value, indices=None):\\n target_remotes = self._get_target_remotes(indices)\\n for remote in target_remotes:\\n remote.send(('set_attr', (attr_name, value)))\\n for remote in target_remotes:\\n remote.recv()\",\n \"def merge_attrs(self):\\n for aid in self.attrs:\\n new_val = self.attrs[aid]\\n if aid in self.attributes:\\n if ('value' in self.attributes[aid] and\\n self.attributes[aid]['value'] != new_val):\\n pass\\n # print \\\"Updating attribute %s[%s] %s -> %s\\\" % (\\n # self.name, aid, self.attributes[aid]['value'], new_val)\\n else:\\n # print \\\"** Warning: non-declaired attribute %s['%s'] set to:\\\\n'%s'\\\" % (\\n # self.name, aid, new_val)\\n self.remember_custom_attribute(self.name, aid, new_val)\\n self.attributes[aid] = {}\\n self.attributes[aid]['nv'] = new_val\",\n \"def _update_from_rest_data(self) -> None:\",\n \"def update(self):\\n self._state = status\\n attributes['host'] = host\\n attributes['port'] = port\\n self.custom_attributes = attributes\",\n \"def soft_update(self, local_model, target_model, rho):\\r\\n for target_param, local_param in zip(target_model.parameters(), local_model.parameters()):\\r\\n target_param.data.copy_(rho*target_param.data + (1.0-rho)*local_param.data)\",\n \"def update(self, attributes, type=None, name=None, identity=None):\\n attributes = attributes or {}\\n type = type or attributes.get('type')\\n name = name or attributes.get('name')\\n identity = identity or attributes.get('identity')\\n if name and identity:\\n name = None # Only send one\\n request = self.request(operation='UPDATE', type=type, name=name,\\n identity=identity, body=self.clean_attrs(attributes))\\n return Entity(self, self.call(request).body)\",\n \"def update(self) -> None:\\n try:\\n sensor_type = self.entity_description.key\\n if sensor_type == \\\"status\\\":\\n self._attr_native_value = self.charger.getStatus()\\n elif sensor_type == \\\"charge_time\\\":\\n self._attr_native_value = self.charger.getChargeTimeElapsed() / 60\\n elif sensor_type == \\\"ambient_temp\\\":\\n self._attr_native_value = self.charger.getAmbientTemperature()\\n elif sensor_type == \\\"ir_temp\\\":\\n self._attr_native_value = self.charger.getIRTemperature()\\n elif sensor_type == \\\"rtc_temp\\\":\\n self._attr_native_value = self.charger.getRTCTemperature()\\n elif sensor_type == \\\"usage_session\\\":\\n self._attr_native_value = float(self.charger.getUsageSession()) / 1000\\n elif sensor_type == \\\"usage_total\\\":\\n self._attr_native_value = float(self.charger.getUsageTotal()) / 1000\\n else:\\n self._attr_native_value = \\\"Unknown\\\"\\n except (RequestException, ValueError, KeyError):\\n _LOGGER.warning(\\\"Could not update status for %s\\\", self.name)\",\n \"def entityUpdates(self, *args):\\n\\t\\tfor entity in self.members.values():\\n\\t\\t\\tentity.update(*args)\",\n \"def _update_attributes(self, data):\\n self._set_avatar(data)\\n self.boosts_since = parse_boosts_since(data)\\n self.flags = parse_flags(data)\\n self.nick = parse_nick(data)\\n self.pending = parse_pending(data)\\n self.role_ids = parse_role_ids(data)\\n self.timed_out_until = parse_timed_out_until(data)\",\n \"def update_from_latest_data(self) -> None:\\n data = self.coordinator.data[self.entity_description.uid]\\n\\n self._attr_is_on = bool(data[\\\"status\\\"])\\n\\n next_run: str | None\\n if data.get(\\\"nextRun\\\") is None:\\n next_run = None\\n else:\\n next_run = datetime.strptime(\\n f\\\"{data['nextRun']} {data['startTime']}\\\",\\n \\\"%Y-%m-%d %H:%M\\\",\\n ).isoformat()\\n\\n self._attr_extra_state_attributes.update(\\n {\\n ATTR_ID: self.entity_description.uid,\\n ATTR_NEXT_RUN: next_run,\\n ATTR_SOAK: data.get(\\\"soak\\\"),\\n ATTR_STATUS: RUN_STATE_MAP[data[\\\"status\\\"]],\\n ATTR_ZONES: [z for z in data[\\\"wateringTimes\\\"] if z[\\\"active\\\"]],\\n }\\n )\",\n \"def test_update_attribute_data(self):\\n pass\",\n \"def refresh(self, context=None):\\n current = self.__class__.get_by_uuid(self._context,\\n cluster=self.cluster_id,\\n uuid=self.uuid)\\n for field in self.fields:\\n if self.obj_attr_is_set(field) and self[field] != current[field]:\\n self[field] = current[field]\",\n \"def update(self, attributes):\\n for key in attributes:\\n k = key.lower()\\n if not isinstance(attributes[key], str) or attributes[key] != '':\\n k_ = k.strip(' =:\\\\t\\\\n').replace('', '')\\n self.attributes.update({k_: attributes[key]})\\n elif k in self.attributes:\\n del self.attributes[k]\",\n \"def merge(self, new_attributes):\\n for k, v in new_attributes.items():\\n setattr(self, k, v)\",\n \"def update_from_latest_data(self) -> None:\\n self._attr_is_on = self.coordinator.data[self.entity_description.uid][\\\"active\\\"]\",\n \"def _difference_update_attributes(self, data):\\n old_attributes = {}\\n \\n # avatar\\n self._update_avatar(data, old_attributes)\\n \\n # boosts_since\\n boosts_since = parse_boosts_since(data)\\n if self.boosts_since != boosts_since:\\n old_attributes['boosts_since'] = self.boosts_since\\n self.boosts_since = boosts_since\\n \\n flags = parse_flags(data)\\n if self.flags != flags:\\n old_attributes['flags'] = self.flags\\n self.flags = flags\\n \\n # nick\\n nick = parse_nick(data)\\n if self.nick != nick:\\n old_attributes['nick'] = self.nick\\n self.nick = nick\\n \\n # pending\\n pending = parse_pending(data)\\n if pending != self.pending:\\n old_attributes['pending'] = self.pending\\n self.pending = pending\\n \\n # role_ids\\n role_ids = parse_role_ids(data)\\n if role_ids != self.role_ids:\\n old_attributes['role_ids'] = self.role_ids\\n self.role_ids = role_ids\\n \\n # timed_out_until\\n timed_out_until = parse_timed_out_until(data)\\n if self.timed_out_until != timed_out_until:\\n old_attributes['timed_out_until'] = self.timed_out_until\\n self.timed_out_until = timed_out_until\\n \\n return old_attributes\",\n \"def _restore_live_attrs(lock_detail, attrs):\\n for attr, value in attrs.items():\\n setattr(lock_detail, attr, value)\",\n \"def update(self):\\n if self._data_provider_state is not None:\\n self._state = self._data_provider_state()\\n \\n if self._data_provider_attributes is not None:\\n self._attributes = self._data_provider_attributes()\",\n \"async def update(self):\\n\\t\\tstate = await self._client.get_state('command.cgi?cmd=getObject&oid={0}&ot={1}'.format(self._oid,self._ot))\\n\\t\\tif state is not None:\\n\\t\\t\\tself._raw_result = state\",\n \"def update(self, verbose=True):\\n params = flask.request.json\\n for key, value in params.items():\\n\\n if value == 'None':\\n value = None\\n\\n if key == 'updated_on':\\n value = datetime.now()\\n\\n if key in self.data_model.keys():\\n\\n # unfuck javascript-style date strings\\n if self.data_model[key] == datetime:\\n if isinstance(value, datetime):\\n pass\\n elif isinstance(value, dict):\\n value = datetime.fromtimestamp(value['$date'] / 1000.0)\\n else:\\n try:\\n value = datetime.strptime(value, '%Y-%m-%dT%H:%M:%S.000Z')\\n except ValueError:\\n try:\\n value = datetime.strptime(value, '%Y-%m-%d %H:%M:%S')\\n except Exception as e:\\n raise\\n except TypeError as e:\\n err_msg = \\\"Incoming attribute '%s' must be datetime!\\\"\\n self.logger.error(err_msg % key)\\n self.logger.error(\\\"Got value '%s' instead...\\\" % value)\\n raise Exception(err_msg % key)\\n\\n # set the self.attribute values\\n setattr(self, key, value)\\n\\n self.save(verbose)\",\n \"def update_server_engine_attributes(ServerName=None, AttributeName=None, AttributeValue=None):\\n pass\",\n \"def update(self, **values):\\r\\n if self.__abstract__:\\r\\n raise ThunderdomeException('cant update abstract elements')\\r\\n self.pre_update(**values)\\r\\n for key in values.keys():\\r\\n if key not in self._columns:\\r\\n raise TypeError(\\\"unrecognized attribute name: '{}'\\\".format(key))\\r\\n\\r\\n for k,v in values.items():\\r\\n setattr(self, k, v)\\r\\n\\r\\n return self.save()\",\n \"def update(self, f):\\n\\n for p in self.__mapper__.attrs:\\n\\n if p.key == 'oid':\\n continue\\n try:\\n setattr(self, p.key, getattr(f, p.key))\\n\\n except AttributeError:\\n # The dict() method copies data property values into the main dict,\\n # and these don't have associated class properties.\\n continue\",\n \"def update(self, f):\\n\\n for p in self.__mapper__.attrs:\\n\\n if p.key == 'oid':\\n continue\\n try:\\n setattr(self, p.key, getattr(f, p.key))\\n\\n except AttributeError:\\n # The dict() method copies data property values into the main dict,\\n # and these don't have associated class properties.\\n continue\",\n \"def hard_update(self,target, source):\\n\\t\\tfor target_param, param in zip(target.parameters(), source.parameters()):\\n\\t\\t\\t\\ttarget_param.data.copy_(param.data)\",\n \"def update_entity(self, device_id, data):\\n url = '{}/ngsi-ld/v1/entities/{}/attrs'.format(self.url, device_id)\\n return self.post(url, data=data, headers=self.headers_ld)\",\n \"def updateAttrs(self, kwargs):\\n for k, v in kwargs.iteritems():\\n setattr(self, k, v)\",\n \"def update_from_latest_data(self) -> None:\\n data = self.coordinator.data[self.entity_description.uid]\\n\\n self._attr_is_on = bool(data[\\\"state\\\"])\\n\\n attrs = {\\n ATTR_CURRENT_CYCLE: data[\\\"cycle\\\"],\\n ATTR_ID: data[\\\"uid\\\"],\\n ATTR_NO_CYCLES: data[\\\"noOfCycles\\\"],\\n ATTR_RESTRICTIONS: data[\\\"restriction\\\"],\\n ATTR_SLOPE: SLOPE_TYPE_MAP.get(data[\\\"slope\\\"], 99),\\n ATTR_SOIL_TYPE: SOIL_TYPE_MAP.get(data[\\\"soil\\\"], 99),\\n ATTR_SPRINKLER_TYPE: SPRINKLER_TYPE_MAP.get(data[\\\"group_id\\\"], 99),\\n ATTR_STATUS: RUN_STATE_MAP[data[\\\"state\\\"]],\\n ATTR_SUN_EXPOSURE: SUN_EXPOSURE_MAP.get(data.get(\\\"sun\\\")),\\n ATTR_VEGETATION_TYPE: VEGETATION_MAP.get(data[\\\"type\\\"], 99),\\n }\\n\\n if \\\"waterSense\\\" in data:\\n if \\\"area\\\" in data[\\\"waterSense\\\"]:\\n attrs[ATTR_AREA] = round(data[\\\"waterSense\\\"][\\\"area\\\"], 2)\\n if \\\"fieldCapacity\\\" in data[\\\"waterSense\\\"]:\\n attrs[ATTR_FIELD_CAPACITY] = round(\\n data[\\\"waterSense\\\"][\\\"fieldCapacity\\\"], 2\\n )\\n if \\\"precipitationRate\\\" in data[\\\"waterSense\\\"]:\\n attrs[ATTR_PRECIP_RATE] = round(\\n data[\\\"waterSense\\\"][\\\"precipitationRate\\\"], 2\\n )\\n\\n if self._entry.options[CONF_USE_APP_RUN_TIMES]:\\n provision_data = self._data.coordinators[DATA_PROVISION_SETTINGS].data\\n if zone_durations := provision_data.get(\\\"system\\\", {}).get(\\\"zoneDuration\\\"):\\n attrs[ATTR_ZONE_RUN_TIME] = zone_durations[\\n list(self.coordinator.data).index(self.entity_description.uid)\\n ]\\n\\n self._attr_extra_state_attributes.update(attrs)\",\n \"def update(self):\\n # Variable returned\\n modified = False\\n\\n bgp_neighbor_data = utils.get_attrs(self, self.config_attrs)\\n\\n # Get ISL port uri\\n if self.local_interface is not None:\\n bgp_neighbor_data[\\n \\\"local_interface\\\"\\n ] = self.local_interface.get_info_format()\\n\\n uri = \\\"{0}/{1}\\\".format(self.base_uri, self.ip_or_ifname_or_group_name)\\n\\n # Compare dictionaries\\n if bgp_neighbor_data == self.__original_attributes:\\n # Object was not modified\\n modified = False\\n\\n else:\\n put_data = json.dumps(bgp_neighbor_data)\\n\\n try:\\n response = self.session.request(\\\"PUT\\\", uri, data=put_data)\\n\\n except Exception as e:\\n raise ResponseError(\\\"PUT\\\", e)\\n\\n if not utils._response_ok(response, \\\"PUT\\\"):\\n raise GenericOperationError(\\n response.text, response.status_code\\n )\\n\\n logging.info(\\\"SUCCESS: Updating %s\\\", self)\\n # Set new original attributes\\n self.__original_attributes = bgp_neighbor_data\\n # Object was modified\\n modified = True\\n return modified\",\n \"def update_model_fields(self, model, payload):\\n fk_fields = model.fk_field_names()\\n models_fields = {\\n i: payload[i]\\n for i, mapping in model.fields.items()\\n if i not in fk_fields\\n }\\n for i, mapping in model.fields.items():\\n if i in fk_fields:\\n try:\\n models_fields[i] = self.render_relation_field(\\n mapping, payload[i]\\n )\\n except SkipField:\\n models_fields.pop(i, None)\\n model.update(models_fields)\\n model.remote_instance = self.create_remote_instance(payload)\\n return model\",\n \"def _set_attributes(self):\",\n \"def _update_from_feature_set(self, feature_set):\\n\\n self.name = feature_set.name\\n self.project = feature_set.project\\n self.source = feature_set.source\\n self.max_age = feature_set.max_age\\n self.features = feature_set.features\\n self.entities = feature_set.entities\\n self.source = feature_set.source\\n self.status = feature_set.status\\n self.created_timestamp = feature_set.created_timestamp\",\n \"def update_attr(self):\\n\\n # Retrieve all current values\\n all_values = nx.get_node_attributes(self.G, 'value')\\n\\n new_values = {}\\n\\n # Loop over all nodes\\n for i in range(self.n_v):\\n\\n # Obtain list of neighbors\\n neighbors = list(nx.all_neighbors(self.G, i))\\n\\n # Compute part dependent on own node\\n val_i = all_values[i]\\n new_value = (1 - self.eps) * (1 - self.a * val_i * val_i)\\n\\n # Compute part dependent on neighbor nodes\\n neighbors_value = 0\\n for neighbor in neighbors:\\n val_n = all_values[neighbor]\\n neighbors_value += (1 - self.a * val_n * val_n)\\n\\n # Catch nodes without neighbors\\n try:\\n new_value += neighbors_value * (self.eps/len(neighbors))\\n except ZeroDivisionError:\\n pass\\n\\n # Save new value\\n new_values[i] = {'value': new_value}\\n\\n nx.set_node_attributes(self.G, new_values)\",\n \"def update_attr_par(self):\\n\\n # Retrieve all current values\\n self.all_values_temp = nx.get_node_attributes(self.G, 'value')\\n\\n # Calculate all new values\\n new_values_list = Parallel(n_jobs=2)(delayed(self.single_node_update)(i) \\\\\\n for i in range(self.n_v))\\n\\n # # Set list to dict as needed for node update\\n # new_values_dict = {}\\n # for i, value in enumerate(new_values_list):\\n # new_values_dict[i] = {'value': value}\\n #\\n # # Update node value\\n # nx.set_node_attributes(self.G, new_values_dict)\",\n \"def update_obj(obj, attributes, params):\\n for key in params.keys():\\n if key in attributes:\\n try:\\n set_attribute(obj, key, params[key])\\n except:\\n abort(400)\\n \\n Session.flush()\\n Session.commit()\",\n \"def sync_remote(self, other):\\n pass # TODO\",\n \"def _async_update_attrs(self) -> None:\\n super()._async_update_attrs()\\n self._attr_color_temp = color_temperature_kelvin_to_mired(\\n self._device.light_color_temp\\n )\",\n \"def _update_attrs(self) -> None:\\n self._attr_is_locked = self._lock.is_locked\\n self._attr_is_jammed = self._lock.is_jammed\\n # Only update changed_by if we get a valid value. This way a previous\\n # value will stay intact if the latest log message isn't related to a\\n # lock state change.\\n if changed_by := self._lock.last_changed_by(self._lock_data.logs):\\n self._attr_changed_by = changed_by\",\n \"def update(self, **kwargs):\\n print(\\\"Updating model\\\")\\n print(kwargs)\\n for key in kwargs:\\n setattr(self, key, kwargs[key])\",\n \"def set_attrs(self, location, attr_dict):\\r\\n for attr in attr_dict.iterkeys():\\r\\n if attr in ['_id', 'md5', 'uploadDate', 'length']:\\r\\n raise AttributeError(\\\"{} is a protected attribute.\\\".format(attr))\\r\\n asset_db_key = self.asset_db_key(location)\\r\\n # FIXME remove fetch and use a form of update which fails if doesn't exist\\r\\n item = self.fs_files.find_one(asset_db_key)\\r\\n if item is None:\\r\\n raise NotFoundError(asset_db_key)\\r\\n self.fs_files.update(asset_db_key, {\\\"$set\\\": attr_dict})\",\n \"def update(self, datastore, model, **kwargs):\\n for k, v in self._preprocess_params(kwargs).items():\\n setattr(model, k, v)\\n self.save(datastore, model)\\n return model\",\n \"async def refresh_entity_state(self):\",\n \"def restore(self):\\n if self.obj:\\n for attrib in self.attribs:\\n setattr(self.obj, attrib, getattr(self, attrib))\",\n \"def update(self):\\n self.data_service.update()\\n self._state = self.data_service.data[self._json_key]\\n self._attributes = self.data_service.attributes[self._json_key]\",\n \"def update_flow_metadata(self, update_with):\\n if update_with:\\n source, clone = self._fetch_flowdetail(clone=True)\\n clone.meta.update(update_with)\\n self._with_connection(self._save_flow_detail, source, clone)\",\n \"def set_local_coordinates(self, entity_id, x, y):\\n position = getattr(self.entities[entitiy_id],\\n self.local_position_system)\\n position.x = x \\n position.y = y\",\n \"def sync_local(self, other):\\n pass # TODO\",\n \"def store_attrs(self, attrs):\\n self.get_attr().SetObject(dumps(attrs), False)\",\n \"def update_latent(self):\\n self.scenario.update_latent()\",\n \"def OnAttributesUpdated():\\n pass\",\n \"def overwrite_attrs(self, src_detail, attrs):\\n case_tile_configuration_list = [\\n 'case_tile_template',\\n 'persist_tile_on_forms',\\n 'persistent_case_tile_from_module',\\n 'pull_down_tile',\\n 'persist_case_context',\\n 'persistent_case_context_xml',\\n 'case_tile_group',\\n ]\\n for attr in attrs:\\n if attr == \\\"case_tile_configuration\\\":\\n for ele in case_tile_configuration_list:\\n setattr(self, ele, getattr(src_detail, ele))\\n else:\\n setattr(self, attr, getattr(src_detail, attr))\",\n \"def forward_attributes(src, dst):\\n dst.set_tag(src.get_tag())\\n dst.set_debug(src.get_debug())\\n dst.set_handle(src.get_handle())\\n if hasattr(src.attributes, \\\"init_stage\\\"):\\n forward_stage_attributes(src, dst)\\n if isinstance(src, BooleanOperation) and isinstance(dst, BooleanOperation):\\n dst.likely = src.likely\",\n \"def update(object, **attrs):\\n updated = {}\\n for key, value in attrs.items():\\n if not hasattr(object, key) or getattr(object, key) != attrs[key]:\\n updated[key] = value\\n setattr(object, key, value)\\n return updated\",\n \"def setAttributes(self, attrDict):\\n self.graph.saveExtendedAttributes(self.entityId, attrDict)\",\n \"def modified(self, **attributes):\\n new_obj = deepcopy(self)\\n new_obj.__dict__.update(attributes)\\n new_obj.initialize()\\n return new_obj\",\n \"def update_original_data(self):\\n pass\",\n \"def update(self, new_data):\\n all_keys = [key for key in self.__dict__]\\n keys = [key for key in new_data]\\n for key in keys:\\n if key in all_keys:\\n setattr(self, key, new_data[key])\\n else:\\n return {\\n \\\"message\\\": \\\"Error encountered when setting attributes.\\\",\\n \\\"help\\\": \\\"Ensure all fields you're updating are valid.\\\"\\n }\\n self.save()\",\n \"def fill_attributes(ml_file, other_file):\\n with xr.load_dataset(other_file) as other:\\n with xr.open_dataset(ml_file) as ml:\\n for variable in other.variables:\\n if variable in ml.variables:\\n other[variable].attrs = ml[variable].attrs\\n other.to_netcdf(other_file)\",\n \"def update(self):\\n #self._switch.odlclient._request_json(self._path, method=\\\"put\\\", json={\\n # \\\"flow\\\": self._odl_inventory()\\n #})\\n self.remove() # actually, remove only uses self.switch and self.id, so this removes the other entry as well.\\n self.deploy()\",\n \"def test_update_metadata_by_attribute(self):\\n pass\",\n \"def sync(self):\\n if not self.is_readonly():\\n deser = self._deserialize()\\n orig = getattr(self.model, self.name)\\n if (orig != deser):\\n if isinstance(orig, list):\\n # first remove the original triples, instead of doing sophisticated\\n # set manipulations\\n setattr(self.model, self.name, [])\\n setattr(self.model, self.name, deser)\",\n \"def copy_from_entity(self, entity):\\n for prop in entity._EndpointsPropertyItervalues():\\n attr_name = prop._code_name\\n value = getattr(entity, attr_name)\\n if value is not None:\\n if isinstance(prop, properties.EndpointsAliasProperty):\\n value_set = getattr(self, attr_name) is not None\\n elif isinstance(prop, ComputedProperty):\\n value_set = True\\n else:\\n value_set = prop._name in self._values\\n if not value_set:\\n setattr(self, attr_name, value)\",\n \"def _set_attr(self):\\n self.as_skeletal = self._import_as_skeleton()\\n self.materials = self._import_materials()\\n self.textures = self._import_textures()\",\n \"def _set_attributes(self, model):\\n\\n if model:\\n self._get_dict(model)\",\n \"def updateFromContext(self, other):\\n value = self.valueType.set(self.value, other.value)\\n self.set(value)\\n self.origins.extend(other.origins)\",\n \"def update_times(self, remote_time, local_time):\\n self.remote_time = remote_time\\n self.local_time = local_time\\n for process in self.processes.values():\\n process.update_times(self.address_name, remote_time)\",\n \"def copyAttributes(fromNcVar, toNcVar):\\r\\n for attrName in fromNcVar.ncattrs():\\r\\n attrVal = getattr(fromNcVar, attrName)\\r\\n setattr(toNcVar, attrName, attrVal)\",\n \"def update(self, **kwargs):\\n for k, v in kwargs.iteritems():\\n if hasattr(self, k):\\n setattr(self, k, v)\",\n \"def hard_update(target, source):\\n for target_param, param in zip(target.parameters(), source.parameters()):\\n target_param.data.copy_(param.data)\",\n \"def update(self) -> None:\\n try:\\n client = self._client\\n\\n if client.state == \\\"Playing\\\":\\n self._attr_state = MediaPlayerState.PLAYING\\n elif client.state == \\\"Paused\\\":\\n self._attr_state = MediaPlayerState.PAUSED\\n elif client.state == \\\"Disconnected\\\":\\n self._attr_state = MediaPlayerState.OFF\\n else:\\n self._attr_state = MediaPlayerState.PAUSED\\n\\n if client.last_update and (time.time() - client.last_update > 40):\\n self._attr_state = MediaPlayerState.OFF\\n\\n volume = float(client.volume) if client.volume else 0.0\\n self._attr_volume_level = volume / 100.0\\n if client.active_playlist_id in client.playlists:\\n self._attr_source = client.playlists[client.active_playlist_id][\\\"name\\\"]\\n else:\\n self._attr_source = \\\"Unknown\\\"\\n self._attr_source_list = [s[\\\"name\\\"] for s in client.playlists.values()]\\n\\n if client.current_track:\\n self._attr_media_title = client.current_track[\\\"title\\\"]\\n self._attr_media_artist = client.current_track[\\\"track_artist\\\"]\\n self._attr_media_album_name = client.current_track[\\\"track_album\\\"]\\n self._attr_media_image_hash = client.current_track[\\\"track_id\\\"]\\n else:\\n self._attr_media_image_hash = None\\n\\n except Exception:\\n self._attr_state = MediaPlayerState.OFF\\n raise\",\n \"def set_attributes(self, new_attributes=None):\\n self.attributes = new_attributes\",\n \"def update(self):\\n if self._skip_update:\\n self._skip_update = False\\n return\\n\\n try:\\n for prop in AIRER_PROPS:\\n self.status[prop] = self.send('get_prop', [prop])[0]\\n _LOGGER.debug(\\\"MiioDevice update: %s\\\", self.status)\\n self.available = True\\n self._retry = 0\\n except Exception as exc:\\n _LOGGER.error(\\\"Error on update: %s\\\", exc)\\n self._retry += 1\\n if self._retry > 3:\\n self.available = False\\n\\n for entity in self.update_entities:\\n entity.async_schedule_update_ha_state()\",\n \"def update(self, class_name, args, stored_objects):\\n id_list = [k.split(\\\".\\\")[1] for k in stored_objects]\\n instance = \\\"{}.{}\\\".format(class_name, args[0])\\n obj = stored_objects[instance]\\n '''convert to the right attribute value type'''\\n setattr(obj, args[1], args[2])\\n models.storage.save()\",\n \"def update_from_latest_data(self) -> None:\\n self._attr_is_on = (\\n self._ambient.stations[self._mac_address][ATTR_LAST_DATA][\\n self.entity_description.key\\n ]\\n == self.entity_description.on_state\\n )\",\n \"def set_attrs(self, **kwargs) -> None:\\n self._obj.coords[GEO_MAP_COORD].attrs.update(**kwargs)\",\n \"def updateAttributesAfterAdding(self):\\n layer = self.sender()\\n while self.addedFeatures:\\n featureId = self.addedFeatures.pop()\\n #begining the edit command\\n # layer.beginEditCommand(self.tr(\\\"DSG Tools reclassification tool: adjusting feature's attributes\\\"))\\n #accessing added features\\n editBuffer = layer.editBuffer()\\n features = editBuffer.addedFeatures()\\n for key in features.keys():\\n #just checking the newly added feature, the other I don't care\\n if key == featureId:\\n feature = features[key]\\n #setting the attributes using the reclassification dictionary\\n self.setFeatureAttributes(feature, editBuffer)\\n layer.endEditCommand()\",\n \"def update(self, instance, validated_data):\\n for attr, value in list(validated_data.items()):\\n if attr == 'part_details':\\n for a, v in list(value.items()):\\n setattr(instance.part_details, attr, value)\\n else:\\n setattr(instance, attr, value)\\n instance.save()\\n return instance\",\n \"def put_attributes(self, attrs):\\r\\n assert(isinstance(attrs, dict)), \\\"Argument must be a dict of key->values to save\\\"\\r\\n for prop_name in attrs:\\r\\n value = attrs[prop_name]\\r\\n prop = self.find_property(prop_name)\\r\\n assert(prop), \\\"Property not found: %s\\\" % prop_name\\r\\n self._manager.set_property(prop, self, prop_name, value)\\r\\n self.reload()\\r\\n return self\",\n \"def update(self, update_fields=None):\\n instance = self.get_object() \\n if not update_fields: \\n update_fields=self.request.PUT.keys()\\n try: \\n for field in update_fields:\\n update_value = self.request.PUT.get(field) # get value from PUT\\n setattr(instance, field, update_value) # renew fields\\n instance.save() # save updates\\n except IntegrityError: # catch error\\n return self.response(status='Failed to Update.') \\n return self.response(\\n status='Successfully Update')\",\n \"def test_addMgmtObjAttribute(self) -> None:\\n\\t\\tdct = \\t{ 'm2m:bat' : {\\n\\t\\t\\t\\t\\t'aa' : [ 'btl', 'bts']\\n\\t\\t\\t\\t}}\\n\\t\\tr, rsc = UPDATE(batURL, ORIGINATOR, dct)\\n\\t\\tself.assertEqual(rsc, RC.updated)\\n\\t\\tself.assertEqual(findXPath(r, 'm2m:bat/btl'), 42)\\n\\t\\tself.assertEqual(findXPath(r, 'm2m:bat/bts'), 2)\\n\\t\\tself.assertIsNotNone(findXPath(r, 'm2m:bat/aa'))\\n\\t\\tself.assertEqual(len(findXPath(r, 'm2m:bat/aa')), 2)\\n\\t\\tself.assertIn('btl', findXPath(r, 'm2m:bat/aa'))\\n\\t\\tself.assertIn('bts', findXPath(r, 'm2m:bat/aa'))\\n\\n\\t\\tr, rsc = RETRIEVE(f'{REMOTEURL}/~{TestRemote_Annc.remoteBatRI}', ORIGINATOR)\\n\\t\\tself.assertEqual(rsc, RC.OK)\\n\\t\\tself.assertIsNotNone(findXPath(r, 'm2m:batA/btl'))\\n\\t\\tself.assertEqual(findXPath(r, 'm2m:batA/btl'), 42)\\n\\t\\tself.assertIsNotNone(findXPath(r, 'm2m:batA/bts'))\\n\\t\\tself.assertEqual(findXPath(r, 'm2m:batA/bts'), 2)\",\n \"def test_removeMgmtObjAttribute(self) -> None:\\n\\t\\tdct = \\t{ 'm2m:bat' : {\\n\\t\\t\\t\\t\\t'aa' : [ 'bts']\\n\\t\\t\\t\\t}}\\n\\t\\tr, rsc = UPDATE(batURL, ORIGINATOR, dct)\\n\\t\\tself.assertEqual(rsc, RC.updated)\\n\\t\\tself.assertEqual(findXPath(r, 'm2m:bat/btl'), 42)\\n\\t\\tself.assertEqual(findXPath(r, 'm2m:bat/bts'), 2)\\n\\t\\tself.assertIsNotNone(findXPath(r, 'm2m:bat/aa'))\\n\\t\\tself.assertEqual(len(findXPath(r, 'm2m:bat/aa')), 1)\\n\\t\\tself.assertNotIn('btl', findXPath(r, 'm2m:bat/aa'))\\n\\t\\tself.assertIn('bts', findXPath(r, 'm2m:bat/aa'))\\n\\n\\t\\tr, rsc = RETRIEVE(f'{REMOTEURL}/~{TestRemote_Annc.remoteBatRI}', ORIGINATOR)\\n\\t\\tself.assertEqual(rsc, RC.OK)\\n\\t\\tself.assertIsNone(findXPath(r, 'm2m:batA/btl'))\\n\\t\\tself.assertIsNotNone(findXPath(r, 'm2m:batA/bts'))\\n\\t\\tself.assertEqual(findXPath(r, 'm2m:batA/bts'), 2)\",\n \"def modify(self, context: Context):\\n data = attr.asdict(self)\\n\\n yield self\\n self.last_author = context.user.nickname\\n self.updated_at = pendulum.now()\\n\\n try:\\n attr.validate(self)\\n except TypeError:\\n logger.warning(\\\"failed to validate {}\\\", self)\\n for key, value in data.items():\\n # since we can't overwrite self we will need to roll back one by one\\n setattr(self, key, value)\\n raise\",\n \"def update(self):\\n self._state = get_local_ip()\",\n \"def update(self, attributes=None):\\n\\n if attributes is None:\\n attributes = {}\\n\\n headers = self.__class__.create_headers(attributes)\\n headers.update(self._update_headers())\\n\\n result = self._client._put(\\n self.__class__.base_url(\\n self.sys['id']\\n ),\\n self.__class__.create_attributes(attributes, self),\\n headers=headers\\n )\\n\\n self._update_from_resource(result)\\n\\n return self\",\n \"def update(self):\\n with managed_session() as session:\\n session.merge(self)\",\n \"def set_attributes(self, attributes):\\n self.attributes = attributes\",\n \"def update_entity(self, username, entity_data):\\n\\t\\treturn self._send_command_to_entity_server(us.SERVER_COMMAND_UPDATE_ENTITY, username + '|' + str(entity_data))\",\n \"def test_api_object_update_property(self, api_object):\\n attrs_dict = {'uuid_': 'CREATING'}\\n api_object.update_public_attrs(attrs_dict)\\n assert api_object.uuid_ != 'CREATING'\",\n \"def test_set_attributes(test_common_dao):\\n _session = test_common_dao.RAMSTK_SESSION(\\n bind=test_common_dao.engine, autoflush=False, expire_on_commit=False)\\n DUT = _session.query(RAMSTKSiteInfo).first()\\n\\n _error_code, _msg = DUT.set_attributes(ATTRIBUTES)\\n\\n assert _error_code == 0\\n assert _msg == (\\\"RAMSTK SUCCESS: Updating RAMSTKSiteInfo attributes.\\\")\",\n \"def update(self):\\n self._state = None\\n self._attributes = {}\\n\\n vehicles = self._api.get_vehicles(self._latitude, self._longitude)\\n scooter = {}\\n\\n if vehicles:\\n for vehicle in vehicles:\\n location_vehicle = (vehicle[\\\"location\\\"][0], vehicle[\\\"location\\\"][1])\\n location_hass = (self._latitude, self._longitude)\\n vehicle[\\\"distance\\\"] = distance(location_vehicle, location_hass).m\\n\\n scooter = sorted(vehicles, key=lambda item: item[\\\"distance\\\"])[0]\\n\\n if scooter:\\n self._state = round(scooter[\\\"distance\\\"])\\n self._attributes[ATTR_LATITUDE] = round(scooter[\\\"location\\\"][0], 5)\\n self._attributes[ATTR_LONGITUDE] = round(scooter[\\\"location\\\"][1], 5)\\n self._attributes[ATTR_BATTERY_LEVEL] = round(scooter[\\\"battery\\\"])\\n self._attributes[ATTR_ATTRIBUTION] = ATTRIBUTION\",\n \"def update(entity_list):\\n for entity in entity_list:\\n # Only moveable entities should have the dest field\\n if \\\"dest\\\" in entity:\\n # If no destination, pick a new random one\\n if entity[\\\"dest\\\"] == None:\\n entity[\\\"dest\\\"] = random_pos(100, 100)\\n \\n # Move one step towards destination\\n cpos = entity[\\\"position\\\"]\\n dest = entity[\\\"dest\\\"]\\n entity[\\\"position\\\"] = move(cpos, dest) \\n\\n # Clear destination if it has been reached\\n if entity[\\\"dest\\\"] == entity[\\\"position\\\"]:\\n entity[\\\"dest\\\"] = None\",\n \"def update(self, **kwargs):\\n for key, value in kwargs.items():\\n key = key.upper()\\n if not hasattr(self, key):\\n self.logger.info(f'[✗] Ignore unknown attribute \\\"{key}\\\"')\\n else:\\n setattr(self, key, value)\\n self.logger.info(f'[✓] Attribute \\\"{key}\\\" has been updated to \\\"{value}\\\"')\\n\\n assert self.UI in self._SUPPORT_UI, 'unsupported UI'\\n assert self.MODE in self._SUPPORT_MODE, 'unsupported MODE'\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62692803","0.58587396","0.5731269","0.5658316","0.5653894","0.5645511","0.56131625","0.5568307","0.5567129","0.55060637","0.54385704","0.54360443","0.5434658","0.5410549","0.5394486","0.5393542","0.5386407","0.5382385","0.5378643","0.5375315","0.53516144","0.5321536","0.5320785","0.5288833","0.52673966","0.5236479","0.5233591","0.5230909","0.5222458","0.52157646","0.5211616","0.5211616","0.5205868","0.5204247","0.520409","0.5198996","0.5190449","0.5185971","0.5181022","0.5156658","0.5155633","0.5154289","0.5140876","0.51229817","0.5119208","0.5117638","0.50980264","0.5093665","0.5080393","0.5069506","0.50636387","0.50611734","0.50554127","0.50422436","0.5026177","0.5023244","0.50207007","0.5012313","0.500965","0.49991992","0.49836025","0.49794054","0.49756742","0.4970982","0.496993","0.49677435","0.49667928","0.49484646","0.49460208","0.49440604","0.49437147","0.4941183","0.4936724","0.49345064","0.49344385","0.49294198","0.49290577","0.49275094","0.49254566","0.4920553","0.49191532","0.4918316","0.49179238","0.49169967","0.49118888","0.4904185","0.48890272","0.4887142","0.48821357","0.48791122","0.48776585","0.48727882","0.48676693","0.48534504","0.48466557","0.4846584","0.4837288","0.48329538","0.4831409","0.48221177"],"string":"[\n \"0.62692803\",\n \"0.58587396\",\n \"0.5731269\",\n \"0.5658316\",\n \"0.5653894\",\n \"0.5645511\",\n \"0.56131625\",\n \"0.5568307\",\n \"0.5567129\",\n \"0.55060637\",\n \"0.54385704\",\n \"0.54360443\",\n \"0.5434658\",\n \"0.5410549\",\n \"0.5394486\",\n \"0.5393542\",\n \"0.5386407\",\n \"0.5382385\",\n \"0.5378643\",\n \"0.5375315\",\n \"0.53516144\",\n \"0.5321536\",\n \"0.5320785\",\n \"0.5288833\",\n \"0.52673966\",\n \"0.5236479\",\n \"0.5233591\",\n \"0.5230909\",\n \"0.5222458\",\n \"0.52157646\",\n \"0.5211616\",\n \"0.5211616\",\n \"0.5205868\",\n \"0.5204247\",\n \"0.520409\",\n \"0.5198996\",\n \"0.5190449\",\n \"0.5185971\",\n \"0.5181022\",\n \"0.5156658\",\n \"0.5155633\",\n \"0.5154289\",\n \"0.5140876\",\n \"0.51229817\",\n \"0.5119208\",\n \"0.5117638\",\n \"0.50980264\",\n \"0.5093665\",\n \"0.5080393\",\n \"0.5069506\",\n \"0.50636387\",\n \"0.50611734\",\n \"0.50554127\",\n \"0.50422436\",\n \"0.5026177\",\n \"0.5023244\",\n \"0.50207007\",\n \"0.5012313\",\n \"0.500965\",\n \"0.49991992\",\n \"0.49836025\",\n \"0.49794054\",\n \"0.49756742\",\n \"0.4970982\",\n \"0.496993\",\n \"0.49677435\",\n \"0.49667928\",\n \"0.49484646\",\n \"0.49460208\",\n \"0.49440604\",\n \"0.49437147\",\n \"0.4941183\",\n \"0.4936724\",\n \"0.49345064\",\n \"0.49344385\",\n \"0.49294198\",\n \"0.49290577\",\n \"0.49275094\",\n \"0.49254566\",\n \"0.4920553\",\n \"0.49191532\",\n \"0.4918316\",\n \"0.49179238\",\n \"0.49169967\",\n \"0.49118888\",\n \"0.4904185\",\n \"0.48890272\",\n \"0.4887142\",\n \"0.48821357\",\n \"0.48791122\",\n \"0.48776585\",\n \"0.48727882\",\n \"0.48676693\",\n \"0.48534504\",\n \"0.48466557\",\n \"0.4846584\",\n \"0.4837288\",\n \"0.48329538\",\n \"0.4831409\",\n \"0.48221177\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6422116"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81991,"cells":{"query":{"kind":"string","value":"Delete the remote entity"},"document":{"kind":"string","value":"def delete(self):\n self.call('DELETE', expect=error.NO_CONTENT)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_otoroshi_controllers_adminapi_tcp_service_api_controller_delete_entity_action(self):\n pass","def delete(self, obj):","def delete(self):\n ...","def remove(self):\n instance = self.get_object() \n instance.delete() \n return self.response(status='Successfully Delete')","def delete(self, request, *args, **kwargs):\n self.object = self.get_object()\n self.object.delete()\n return JsonResponse({'status': 'ok'})","def delete(self, _id):","def delete():","def delete(self):\n self.request().delete()","def delete(self):\n pass","def delete(self):\n pass","def delete(self):\n pass","def delete(self):\n pass","def destroy(self, request, pk=None): #delete a specific object\n return Response({'http_method': 'DELETE'})","def delete(self, *args, **kwargs):\n pass","def delete(self, *args, **kwargs):\n pass","def delete_entity(self, device_id):\n url = '{}/ngsi-ld/v1/entities/{}'.format(self.url, device_id)\n r = requests.delete(url, headers=self.headers_ld)\n return r","async def delete(self, delete: TPayload) -> None:","def test_delete_entity(self):\n\n storage = StringIO.StringIO()\n c = pycurl.Curl()\n c.setopt(c.URL,\"http://127.0.0.1:8090/compute/this_is_bilel\")\n c.setopt(c.HTTPHEADER, ['Content-Type: application/occi+json', 'Accept: application/occi+json'])\n c.setopt(c.CUSTOMREQUEST, 'DELETE')\n c.setopt(c.WRITEFUNCTION, storage.write)\n c.perform()\n content = storage.getvalue()\n print \" ===== Body content =====\\n \" + content + \" ==========\\n\"","def test_delete_remote(self):\n # Create source site and remote project\n source_site = self.make_site(\n name=REMOTE_SITE_NAME,\n url=REMOTE_SITE_URL,\n mode=SITE_MODE_SOURCE,\n description=REMOTE_SITE_DESC,\n secret=REMOTE_SITE_SECRET,\n )\n self.make_remote_project(\n project_uuid=self.project.sodar_uuid,\n project=self.project,\n site=source_site,\n level=SODAR_CONSTANTS['REMOTE_LEVEL_READ_ROLES'],\n )\n self.assertEqual(RoleAssignment.objects.count(), 3)\n url = reverse(\n 'projectroles:api_role_destroy',\n kwargs={'roleassignment': self.update_as.sodar_uuid},\n )\n response = self.request_knox(url, method='DELETE')\n self.assertEqual(response.status_code, 400, msg=response.content)\n self.assertEqual(RoleAssignment.objects.count(), 3)","def delete(self, *args, **kwargs):\n self.request(\"delete\", *args, **kwargs)","def delete_entity(self, owner_username, entity_relative_id):\n\t\treturn self._send_command_to_entity_server(us.SERVER_COMMAND_DELETE_ENTITY, owner_username + '|' + str(entity_relative_id))","def _delete(self, *args, **kwargs):\n return self._request('delete', *args, **kwargs)","def delete(self):\n self.method = \"DELETE\"\n self.send()","def delete(self, obj=None):\n pass","def delete(self):\n raise NotImplementedError(\"Deleting not supported for servers\")","def delete(self):\r\n self.domain.delete_item(self)","def delete(self, obj):\n raise NotImplementedError","def delete(self, remote):\n self.target.ttbd_iface_call(\"store\", \"file\", method = \"DELETE\",\n file_path = remote)","def delete(self):\n self._client.delete(self)","def remove(self):\n self._switch.odlclient._request(self._path, method=\"delete\")","def delete(self):\n url = util.join_url(self.path, str(self['id']))\n new_attributes = self.api.delete(url)\n self.error = None\n self.merge(new_attributes)\n return self.success()","def delete(self, obj):\n self.session.delete(obj)","def delete(self):\r\n return http.Request('DELETE', '{0}'.format(\r\n self.get_url())), parsers.parse_json","def delete_model(self, request, instance):\n pass","def delete(self):\n raise NotImplementedError","def delete(self, request , pk=None): \n return Response({'message':'DELETE'})","def delete(self, *args, **kwargs):\n return self.handle_delete_request()","def delete(self, *args, **kwargs) -> Any:\n pass","def delete_object(self, id):\n self.request(id, post_args={\"method\": \"delete\"})","def delete(self, identifier):\n self.get(identifier)\n conn = self.get_connector()\n cursor = conn.cursor()\n\n query = \"delete from {0} where {2}={1}\".format(\n self.ressource_config[\"table\"],\n identifier,\n self.model.pk_field.name)\n try:\n cursor.execute(query)\n except sqlite3.IntegrityError, e:\n message = \"\"\n if \"foreign\" in e.message:\n message = \"\"\"another ressource depends on this\n object. Cloud not delete before all ressources\n depending on it are also deleted\"\"\"\n\n raise BadRequest(message)\n\n conn.commit()\n conn.close()","def delete(self):\n\n raise NotImplementedError()","def destroy(self):\n response = self.request(uri=self.uri, method=\"DELETE\")\n\n return response","def delete(self, instance: BaseModel):\n with rconnect() as conn:\n id = str(instance.id)\n try:\n query = self.q.get(id).delete()\n rv = query.run(conn)\n except Exception as e:\n console.warn(e)\n raise\n else:\n return True","def destroy(self, request, pk=None):\n return Response({'http_method':'DELETE'})","def delete_entity(self, device_id):\n url = '{}/iot/devices/{}'.format(self.url, device_id)\n r = requests.delete(url, headers=self.headers)\n return r","def destroy(self, request, pk=None):\n\n return Response({'http_method': 'DELETE'})","def destroy(self,request,pk = None):\n return Response({'http_method':'DELETE'})","def delete(openstack_resource):\n openstack_resource.delete()","def test_delete_object(self):\n u = self.d.user('example')\n u.delete()\n\n method, url, data, headers = self.d._fetcher.last_request\n self.assertEqual(method, 'DELETE')\n self.assertEqual(url, '/users/example')","def delete(self, data):\r\n pass","def delete(self):\n # pylint: disable=protected-access\n self.manager.session.delete(uri=self.uri, resource=self)\n self.manager._name_uri_cache.delete(\n self.get_properties_local(self.manager._name_prop, None))","def delete(self):\n return self.parent.delete_instance(self.name)","def delete(self):\n raise NotImplementedError()","def delete(self):\n raise NotImplementedError()","def delete(self):\n raise exceptions.NotImplemented","async def delete(self):\r\n try:\r\n data = await self.request.json()\r\n agent_uuid = data.get(\"agent_uuid\")\r\n agent_to_delete = Agent.filter(Agent.uuid == agent_uuid).first()\r\n sys_id = (\r\n System.select().where(System.agent_uuid == agent_to_delete).execute()\r\n )\r\n if sys_id:\r\n logger.error(\"Agent not deleted\")\r\n return web.Response(text=\"Agent not deleted.\")\r\n else:\r\n agent_to_delete.delete_instance()\r\n logger.info(\"Agent deleted successfully\")\r\n return web.Response(text=\"Agent deleted successfully.\")\r\n except Exception as ex:\r\n error_message = str(ex)\r\n logger.error(error_message)\r\n return web.Response(text=error_message, status=500)","def delete(self, *args, **kw):\n kw['method'] = 'DELETE'\n return self.open(*args, **kw)","def delete(self, cls, id):\n pass","def delete(self, *args, **kwargs):\n return 0","def destroy(self, request, pk=None):\n\n return Response({'http_method':'DELETE'})","def delete(self, *args, **kwargs):\n raise NotImplementedError()","def test_delete(self):\n\n self.metadata.create_or_update(data=self.create)\n\n # Find by name\n res_name = self.metadata.get_by_name(\n entity=Dashboard, fqn=self.entity.fullyQualifiedName\n )\n # Then fetch by ID\n res_id = self.metadata.get_by_id(\n entity=Dashboard, entity_id=str(res_name.id.__root__)\n )\n\n # Delete\n self.metadata.delete(\n entity=Dashboard, entity_id=str(res_id.id.__root__), recursive=True\n )\n\n # Then we should not find it\n res = self.metadata.list_entities(entity=Dashboard)\n assert not next(\n iter(\n ent\n for ent in res.entities\n if ent.fullyQualifiedName == self.entity.fullyQualifiedName\n ),\n None,\n )","def delete(self):\n self.manager.delete(self.name)","def delete(self):\n self.manager.delete(self.name)","def obj_delete(self, bundle, **kwargs):\n try:\n obj = self.obj_get(bundle, **kwargs)\n except ObjectDoesNotExist:\n raise NotFound(\"A model instance matching the provided arguments could not be found.\")\n\n self._nids_delete([obj])","def destroy(self, request, pk=None):\n\n return Response({'http_method': 'DELETE'})","def delete(self):\n return self.manager.delete(self)","def delObject(self, obj):\n\n try:\n req = self._delete(obj.selfUrl)\n if req.status_code == requests.codes.ok:\n print('object {0} deleted'.format(obj.id))\n return req.status_code\n else:\n print('not deleted', req.status_code)\n return req.status_code\n\n\n except requests.exceptions.RequestException as err:\n print('del request failed:', err)","def delete(self, request, *args, **kwargs):\r\n self.object = self.get_object()\r\n success_url = self.get_success_url()\r\n self.object.delete()\r\n messages.success(self.request, self.success_message)\r\n return HttpResponseRedirect(success_url)","def do_DELETE(self,):\n self.http_method = 'DELETE'\n self.response()","def delete_object(self, id):\n return self.request(\n \"{0}/{1}\".format(self.version, id), method=\"DELETE\"\n )","def delete(self, name):\n err = C.git_remote_delete(self._repo._repo, to_bytes(name))\n check_error(err)","def __delete__(self, instance):\n self.session.close()","def delete(self):\n if Model.data_connector:\n with Model.data_connector.u_lock:\n Model.data_connector.remove_object(self)","def delete(self):\r\n db.session.delete(self)\r\n db.session.commit()","def delete_remote(self, remote: \"Remote\") -> str:\n return Remote.remove(self, remote)","def do_destroy(self, arg):\n obj = self.verify(arg, 2)\n if obj:\n del storage.all()[obj]\n storage.save()","def test_delete_hyperflex_server_model(self):\n pass","def delete(self):\n import labstep.entities.resource.repository as resourceRepository\n\n return resourceRepository.editResource(self, deleted_at=getTime())","def delete(self):\n try:\n resp = requests.delete('{0}/vnfs/{1}'.format(self._tenor_url,\n self._dummy_id))\n except:\n raise IOError('{0} instance unreachable'.format(self._tenor_url))\n return resp","def delete(self):\n return self.request('', pylastica.request.Request.DELETE)","def delete(self):\r\n if self.__abstract__:\r\n raise ThunderdomeException('cant delete abstract elements')\r\n if self.eid is None:\r\n return self\r\n query = \"\"\"\r\n e = g.e(eid)\r\n if (e != null) {\r\n g.removeEdge(e)\r\n g.stopTransaction(SUCCESS)\r\n }\r\n \"\"\" \r\n results = execute_query(query, {'eid':self.eid})","def delete(self):\n # type: () -> BoundAction\n return self._client.delete(self)","def delete(self):\r\n s = self.get_session()\r\n s.delete(self)\r\n s.commit()","def delete(self, name):\n\n pass","def DeleteModel(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def delete(self):\n self.manager.delete(self)","def delete(self):\n self.id = uuid4()\n DataStore.remove_instance(self)","async def delete_one(self, where):\n\n pass","def delete(self, hostname):\n self.not_supported()","def delete(self, host, file):","def delete(self, request, *args, **kwargs):\n if self.json:\n self.object = self.get_object()\n obj = copy.deepcopy(self.object)\n self.object.delete()\n return self.json_to_response(data=obj)\n else:\n return super().delete(request, *args, **kwargs)","def handle_delete(self, api, command):\n return self._make_request_from_command('DELETE', command)","def delete(self, object_id):\n libplasma.delete(self.conn, object_id)","def DELETE(self):\n ids = self.context.objectIds()\n self.context.manage_delObjects(ids)\n self.context.createTemplate()\n return self.request.response.setStatus(200)","def model_delete(self, db):\n db.session.delete(self)\n db.session.commit()","def delete_entity(self, entity):\n entity_type = entity.lower()\n if 'acl' in entity_type:\n entity_type = 'acl'\n elif 'secret' in entity_type:\n entity_type = 'secret'\n elif 'container' in entity_type:\n entity_type = 'container'\n else:\n entity_type = 'order'\n\n self.created_entities[entity_type].remove(entity)","def DeleteModel(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def _delete(self, url):\n return self._request(url, method=\"DELETE\")","def delete(self):\n\n raise NotImplementedError('Must be implemented by subclasses')"],"string":"[\n \"def test_otoroshi_controllers_adminapi_tcp_service_api_controller_delete_entity_action(self):\\n pass\",\n \"def delete(self, obj):\",\n \"def delete(self):\\n ...\",\n \"def remove(self):\\n instance = self.get_object() \\n instance.delete() \\n return self.response(status='Successfully Delete')\",\n \"def delete(self, request, *args, **kwargs):\\n self.object = self.get_object()\\n self.object.delete()\\n return JsonResponse({'status': 'ok'})\",\n \"def delete(self, _id):\",\n \"def delete():\",\n \"def delete(self):\\n self.request().delete()\",\n \"def delete(self):\\n pass\",\n \"def delete(self):\\n pass\",\n \"def delete(self):\\n pass\",\n \"def delete(self):\\n pass\",\n \"def destroy(self, request, pk=None): #delete a specific object\\n return Response({'http_method': 'DELETE'})\",\n \"def delete(self, *args, **kwargs):\\n pass\",\n \"def delete(self, *args, **kwargs):\\n pass\",\n \"def delete_entity(self, device_id):\\n url = '{}/ngsi-ld/v1/entities/{}'.format(self.url, device_id)\\n r = requests.delete(url, headers=self.headers_ld)\\n return r\",\n \"async def delete(self, delete: TPayload) -> None:\",\n \"def test_delete_entity(self):\\n\\n storage = StringIO.StringIO()\\n c = pycurl.Curl()\\n c.setopt(c.URL,\\\"http://127.0.0.1:8090/compute/this_is_bilel\\\")\\n c.setopt(c.HTTPHEADER, ['Content-Type: application/occi+json', 'Accept: application/occi+json'])\\n c.setopt(c.CUSTOMREQUEST, 'DELETE')\\n c.setopt(c.WRITEFUNCTION, storage.write)\\n c.perform()\\n content = storage.getvalue()\\n print \\\" ===== Body content =====\\\\n \\\" + content + \\\" ==========\\\\n\\\"\",\n \"def test_delete_remote(self):\\n # Create source site and remote project\\n source_site = self.make_site(\\n name=REMOTE_SITE_NAME,\\n url=REMOTE_SITE_URL,\\n mode=SITE_MODE_SOURCE,\\n description=REMOTE_SITE_DESC,\\n secret=REMOTE_SITE_SECRET,\\n )\\n self.make_remote_project(\\n project_uuid=self.project.sodar_uuid,\\n project=self.project,\\n site=source_site,\\n level=SODAR_CONSTANTS['REMOTE_LEVEL_READ_ROLES'],\\n )\\n self.assertEqual(RoleAssignment.objects.count(), 3)\\n url = reverse(\\n 'projectroles:api_role_destroy',\\n kwargs={'roleassignment': self.update_as.sodar_uuid},\\n )\\n response = self.request_knox(url, method='DELETE')\\n self.assertEqual(response.status_code, 400, msg=response.content)\\n self.assertEqual(RoleAssignment.objects.count(), 3)\",\n \"def delete(self, *args, **kwargs):\\n self.request(\\\"delete\\\", *args, **kwargs)\",\n \"def delete_entity(self, owner_username, entity_relative_id):\\n\\t\\treturn self._send_command_to_entity_server(us.SERVER_COMMAND_DELETE_ENTITY, owner_username + '|' + str(entity_relative_id))\",\n \"def _delete(self, *args, **kwargs):\\n return self._request('delete', *args, **kwargs)\",\n \"def delete(self):\\n self.method = \\\"DELETE\\\"\\n self.send()\",\n \"def delete(self, obj=None):\\n pass\",\n \"def delete(self):\\n raise NotImplementedError(\\\"Deleting not supported for servers\\\")\",\n \"def delete(self):\\r\\n self.domain.delete_item(self)\",\n \"def delete(self, obj):\\n raise NotImplementedError\",\n \"def delete(self, remote):\\n self.target.ttbd_iface_call(\\\"store\\\", \\\"file\\\", method = \\\"DELETE\\\",\\n file_path = remote)\",\n \"def delete(self):\\n self._client.delete(self)\",\n \"def remove(self):\\n self._switch.odlclient._request(self._path, method=\\\"delete\\\")\",\n \"def delete(self):\\n url = util.join_url(self.path, str(self['id']))\\n new_attributes = self.api.delete(url)\\n self.error = None\\n self.merge(new_attributes)\\n return self.success()\",\n \"def delete(self, obj):\\n self.session.delete(obj)\",\n \"def delete(self):\\r\\n return http.Request('DELETE', '{0}'.format(\\r\\n self.get_url())), parsers.parse_json\",\n \"def delete_model(self, request, instance):\\n pass\",\n \"def delete(self):\\n raise NotImplementedError\",\n \"def delete(self, request , pk=None): \\n return Response({'message':'DELETE'})\",\n \"def delete(self, *args, **kwargs):\\n return self.handle_delete_request()\",\n \"def delete(self, *args, **kwargs) -> Any:\\n pass\",\n \"def delete_object(self, id):\\n self.request(id, post_args={\\\"method\\\": \\\"delete\\\"})\",\n \"def delete(self, identifier):\\n self.get(identifier)\\n conn = self.get_connector()\\n cursor = conn.cursor()\\n\\n query = \\\"delete from {0} where {2}={1}\\\".format(\\n self.ressource_config[\\\"table\\\"],\\n identifier,\\n self.model.pk_field.name)\\n try:\\n cursor.execute(query)\\n except sqlite3.IntegrityError, e:\\n message = \\\"\\\"\\n if \\\"foreign\\\" in e.message:\\n message = \\\"\\\"\\\"another ressource depends on this\\n object. Cloud not delete before all ressources\\n depending on it are also deleted\\\"\\\"\\\"\\n\\n raise BadRequest(message)\\n\\n conn.commit()\\n conn.close()\",\n \"def delete(self):\\n\\n raise NotImplementedError()\",\n \"def destroy(self):\\n response = self.request(uri=self.uri, method=\\\"DELETE\\\")\\n\\n return response\",\n \"def delete(self, instance: BaseModel):\\n with rconnect() as conn:\\n id = str(instance.id)\\n try:\\n query = self.q.get(id).delete()\\n rv = query.run(conn)\\n except Exception as e:\\n console.warn(e)\\n raise\\n else:\\n return True\",\n \"def destroy(self, request, pk=None):\\n return Response({'http_method':'DELETE'})\",\n \"def delete_entity(self, device_id):\\n url = '{}/iot/devices/{}'.format(self.url, device_id)\\n r = requests.delete(url, headers=self.headers)\\n return r\",\n \"def destroy(self, request, pk=None):\\n\\n return Response({'http_method': 'DELETE'})\",\n \"def destroy(self,request,pk = None):\\n return Response({'http_method':'DELETE'})\",\n \"def delete(openstack_resource):\\n openstack_resource.delete()\",\n \"def test_delete_object(self):\\n u = self.d.user('example')\\n u.delete()\\n\\n method, url, data, headers = self.d._fetcher.last_request\\n self.assertEqual(method, 'DELETE')\\n self.assertEqual(url, '/users/example')\",\n \"def delete(self, data):\\r\\n pass\",\n \"def delete(self):\\n # pylint: disable=protected-access\\n self.manager.session.delete(uri=self.uri, resource=self)\\n self.manager._name_uri_cache.delete(\\n self.get_properties_local(self.manager._name_prop, None))\",\n \"def delete(self):\\n return self.parent.delete_instance(self.name)\",\n \"def delete(self):\\n raise NotImplementedError()\",\n \"def delete(self):\\n raise NotImplementedError()\",\n \"def delete(self):\\n raise exceptions.NotImplemented\",\n \"async def delete(self):\\r\\n try:\\r\\n data = await self.request.json()\\r\\n agent_uuid = data.get(\\\"agent_uuid\\\")\\r\\n agent_to_delete = Agent.filter(Agent.uuid == agent_uuid).first()\\r\\n sys_id = (\\r\\n System.select().where(System.agent_uuid == agent_to_delete).execute()\\r\\n )\\r\\n if sys_id:\\r\\n logger.error(\\\"Agent not deleted\\\")\\r\\n return web.Response(text=\\\"Agent not deleted.\\\")\\r\\n else:\\r\\n agent_to_delete.delete_instance()\\r\\n logger.info(\\\"Agent deleted successfully\\\")\\r\\n return web.Response(text=\\\"Agent deleted successfully.\\\")\\r\\n except Exception as ex:\\r\\n error_message = str(ex)\\r\\n logger.error(error_message)\\r\\n return web.Response(text=error_message, status=500)\",\n \"def delete(self, *args, **kw):\\n kw['method'] = 'DELETE'\\n return self.open(*args, **kw)\",\n \"def delete(self, cls, id):\\n pass\",\n \"def delete(self, *args, **kwargs):\\n return 0\",\n \"def destroy(self, request, pk=None):\\n\\n return Response({'http_method':'DELETE'})\",\n \"def delete(self, *args, **kwargs):\\n raise NotImplementedError()\",\n \"def test_delete(self):\\n\\n self.metadata.create_or_update(data=self.create)\\n\\n # Find by name\\n res_name = self.metadata.get_by_name(\\n entity=Dashboard, fqn=self.entity.fullyQualifiedName\\n )\\n # Then fetch by ID\\n res_id = self.metadata.get_by_id(\\n entity=Dashboard, entity_id=str(res_name.id.__root__)\\n )\\n\\n # Delete\\n self.metadata.delete(\\n entity=Dashboard, entity_id=str(res_id.id.__root__), recursive=True\\n )\\n\\n # Then we should not find it\\n res = self.metadata.list_entities(entity=Dashboard)\\n assert not next(\\n iter(\\n ent\\n for ent in res.entities\\n if ent.fullyQualifiedName == self.entity.fullyQualifiedName\\n ),\\n None,\\n )\",\n \"def delete(self):\\n self.manager.delete(self.name)\",\n \"def delete(self):\\n self.manager.delete(self.name)\",\n \"def obj_delete(self, bundle, **kwargs):\\n try:\\n obj = self.obj_get(bundle, **kwargs)\\n except ObjectDoesNotExist:\\n raise NotFound(\\\"A model instance matching the provided arguments could not be found.\\\")\\n\\n self._nids_delete([obj])\",\n \"def destroy(self, request, pk=None):\\n\\n return Response({'http_method': 'DELETE'})\",\n \"def delete(self):\\n return self.manager.delete(self)\",\n \"def delObject(self, obj):\\n\\n try:\\n req = self._delete(obj.selfUrl)\\n if req.status_code == requests.codes.ok:\\n print('object {0} deleted'.format(obj.id))\\n return req.status_code\\n else:\\n print('not deleted', req.status_code)\\n return req.status_code\\n\\n\\n except requests.exceptions.RequestException as err:\\n print('del request failed:', err)\",\n \"def delete(self, request, *args, **kwargs):\\r\\n self.object = self.get_object()\\r\\n success_url = self.get_success_url()\\r\\n self.object.delete()\\r\\n messages.success(self.request, self.success_message)\\r\\n return HttpResponseRedirect(success_url)\",\n \"def do_DELETE(self,):\\n self.http_method = 'DELETE'\\n self.response()\",\n \"def delete_object(self, id):\\n return self.request(\\n \\\"{0}/{1}\\\".format(self.version, id), method=\\\"DELETE\\\"\\n )\",\n \"def delete(self, name):\\n err = C.git_remote_delete(self._repo._repo, to_bytes(name))\\n check_error(err)\",\n \"def __delete__(self, instance):\\n self.session.close()\",\n \"def delete(self):\\n if Model.data_connector:\\n with Model.data_connector.u_lock:\\n Model.data_connector.remove_object(self)\",\n \"def delete(self):\\r\\n db.session.delete(self)\\r\\n db.session.commit()\",\n \"def delete_remote(self, remote: \\\"Remote\\\") -> str:\\n return Remote.remove(self, remote)\",\n \"def do_destroy(self, arg):\\n obj = self.verify(arg, 2)\\n if obj:\\n del storage.all()[obj]\\n storage.save()\",\n \"def test_delete_hyperflex_server_model(self):\\n pass\",\n \"def delete(self):\\n import labstep.entities.resource.repository as resourceRepository\\n\\n return resourceRepository.editResource(self, deleted_at=getTime())\",\n \"def delete(self):\\n try:\\n resp = requests.delete('{0}/vnfs/{1}'.format(self._tenor_url,\\n self._dummy_id))\\n except:\\n raise IOError('{0} instance unreachable'.format(self._tenor_url))\\n return resp\",\n \"def delete(self):\\n return self.request('', pylastica.request.Request.DELETE)\",\n \"def delete(self):\\r\\n if self.__abstract__:\\r\\n raise ThunderdomeException('cant delete abstract elements')\\r\\n if self.eid is None:\\r\\n return self\\r\\n query = \\\"\\\"\\\"\\r\\n e = g.e(eid)\\r\\n if (e != null) {\\r\\n g.removeEdge(e)\\r\\n g.stopTransaction(SUCCESS)\\r\\n }\\r\\n \\\"\\\"\\\" \\r\\n results = execute_query(query, {'eid':self.eid})\",\n \"def delete(self):\\n # type: () -> BoundAction\\n return self._client.delete(self)\",\n \"def delete(self):\\r\\n s = self.get_session()\\r\\n s.delete(self)\\r\\n s.commit()\",\n \"def delete(self, name):\\n\\n pass\",\n \"def DeleteModel(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 delete(self):\\n self.manager.delete(self)\",\n \"def delete(self):\\n self.id = uuid4()\\n DataStore.remove_instance(self)\",\n \"async def delete_one(self, where):\\n\\n pass\",\n \"def delete(self, hostname):\\n self.not_supported()\",\n \"def delete(self, host, file):\",\n \"def delete(self, request, *args, **kwargs):\\n if self.json:\\n self.object = self.get_object()\\n obj = copy.deepcopy(self.object)\\n self.object.delete()\\n return self.json_to_response(data=obj)\\n else:\\n return super().delete(request, *args, **kwargs)\",\n \"def handle_delete(self, api, command):\\n return self._make_request_from_command('DELETE', command)\",\n \"def delete(self, object_id):\\n libplasma.delete(self.conn, object_id)\",\n \"def DELETE(self):\\n ids = self.context.objectIds()\\n self.context.manage_delObjects(ids)\\n self.context.createTemplate()\\n return self.request.response.setStatus(200)\",\n \"def model_delete(self, db):\\n db.session.delete(self)\\n db.session.commit()\",\n \"def delete_entity(self, entity):\\n entity_type = entity.lower()\\n if 'acl' in entity_type:\\n entity_type = 'acl'\\n elif 'secret' in entity_type:\\n entity_type = 'secret'\\n elif 'container' in entity_type:\\n entity_type = 'container'\\n else:\\n entity_type = 'order'\\n\\n self.created_entities[entity_type].remove(entity)\",\n \"def DeleteModel(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 _delete(self, url):\\n return self._request(url, method=\\\"DELETE\\\")\",\n \"def delete(self):\\n\\n raise NotImplementedError('Must be implemented by subclasses')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7196658","0.70685035","0.7056511","0.7055168","0.7014683","0.69954413","0.6993684","0.6924908","0.6901423","0.6901423","0.6901423","0.6901423","0.6825376","0.681299","0.681299","0.6777683","0.67732435","0.67707646","0.6770634","0.6756004","0.67313147","0.6715537","0.6708717","0.6701217","0.6684052","0.66690814","0.66580284","0.6634052","0.66302747","0.6624207","0.66109884","0.6603117","0.6602919","0.6594277","0.65813786","0.65782267","0.6570356","0.6567949","0.65467024","0.6540286","0.6512955","0.65122014","0.6501977","0.64987856","0.64842516","0.6481213","0.64680403","0.6466725","0.646499","0.6458626","0.64567477","0.64510846","0.64292514","0.64292514","0.6412127","0.64085007","0.6406078","0.6403009","0.6390755","0.63838947","0.63824046","0.63561237","0.63482195","0.63482195","0.6339555","0.633194","0.63264126","0.6319868","0.63110274","0.6307105","0.6302783","0.63010097","0.6290406","0.62767345","0.62740785","0.6266739","0.6263539","0.6263177","0.6262241","0.62598264","0.625945","0.62426144","0.624131","0.62309396","0.62244946","0.6213168","0.62108064","0.62070733","0.6201761","0.6196801","0.61917025","0.61889523","0.618654","0.61845684","0.61822015","0.61782223","0.6175564","0.6167911","0.6167079","0.6161599"],"string":"[\n \"0.7196658\",\n \"0.70685035\",\n \"0.7056511\",\n \"0.7055168\",\n \"0.7014683\",\n \"0.69954413\",\n \"0.6993684\",\n \"0.6924908\",\n \"0.6901423\",\n \"0.6901423\",\n \"0.6901423\",\n \"0.6901423\",\n \"0.6825376\",\n \"0.681299\",\n \"0.681299\",\n \"0.6777683\",\n \"0.67732435\",\n \"0.67707646\",\n \"0.6770634\",\n \"0.6756004\",\n \"0.67313147\",\n \"0.6715537\",\n \"0.6708717\",\n \"0.6701217\",\n \"0.6684052\",\n \"0.66690814\",\n \"0.66580284\",\n \"0.6634052\",\n \"0.66302747\",\n \"0.6624207\",\n \"0.66109884\",\n \"0.6603117\",\n \"0.6602919\",\n \"0.6594277\",\n \"0.65813786\",\n \"0.65782267\",\n \"0.6570356\",\n \"0.6567949\",\n \"0.65467024\",\n \"0.6540286\",\n \"0.6512955\",\n \"0.65122014\",\n \"0.6501977\",\n \"0.64987856\",\n \"0.64842516\",\n \"0.6481213\",\n \"0.64680403\",\n \"0.6466725\",\n \"0.646499\",\n \"0.6458626\",\n \"0.64567477\",\n \"0.64510846\",\n \"0.64292514\",\n \"0.64292514\",\n \"0.6412127\",\n \"0.64085007\",\n \"0.6406078\",\n \"0.6403009\",\n \"0.6390755\",\n \"0.63838947\",\n \"0.63824046\",\n \"0.63561237\",\n \"0.63482195\",\n \"0.63482195\",\n \"0.6339555\",\n \"0.633194\",\n \"0.63264126\",\n \"0.6319868\",\n \"0.63110274\",\n \"0.6307105\",\n \"0.6302783\",\n \"0.63010097\",\n \"0.6290406\",\n \"0.62767345\",\n \"0.62740785\",\n \"0.6266739\",\n \"0.6263539\",\n \"0.6263177\",\n \"0.6262241\",\n \"0.62598264\",\n \"0.625945\",\n \"0.62426144\",\n \"0.624131\",\n \"0.62309396\",\n \"0.62244946\",\n \"0.6213168\",\n \"0.62108064\",\n \"0.62070733\",\n \"0.6201761\",\n \"0.6196801\",\n \"0.61917025\",\n \"0.61889523\",\n \"0.618654\",\n \"0.61845684\",\n \"0.61822015\",\n \"0.61782223\",\n \"0.6175564\",\n \"0.6167911\",\n \"0.6167079\",\n \"0.6161599\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6575764"},"document_rank":{"kind":"string","value":"36"}}},{"rowIdx":81992,"cells":{"query":{"kind":"string","value":"Return a Node connected with the given parameters, see L{connection}"},"document":{"kind":"string","value":"def connect(cls, url=None, router=None, timeout=10, ssl_domain=None, sasl=None, edge_router=None):\n url_ = Url(url) # Convert string to Url class.\n\n if url_.path is not None:\n path = url_.path\n elif router:\n path = '_topo/0/%s/$management' % router\n elif edge_router:\n path = '_edge/%s/$management' % edge_router\n else:\n path = u'$management'\n connection = BlockingConnection(url,\n timeout=timeout,\n ssl_domain=ssl_domain,\n sasl_enabled=bool(ssl_domain or sasl),\n allowed_mechs=str(sasl.mechs) if sasl and sasl.mechs is not None else None,\n user=str(sasl.user) if sasl and sasl.user is not None else None,\n password=str(sasl.password) if sasl and sasl.password is not None else None)\n try:\n return cls(connection, path)\n except Exception:\n # ownership of connection has not been given to a new Node; close the connection\n connection.close()\n raise"},"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_node(conn, name):\n datacenter_id = get_datacenter_id()\n\n for item in conn.list_servers(datacenter_id)[\"items\"]:\n if item[\"properties\"][\"name\"] == name:\n node = {\"id\": item[\"id\"]}\n node.update(item[\"properties\"])\n return node","def connect_node(config, node, gateway):\n try:\n conn = Connection(node, user=config.user, gateway=gateway, connect_kwargs=gateway.connect_kwargs)\n conn.open()\n if conn.is_connected:\n logging.info(f\"Connection to {Fore.CYAN}{node}{Style.RESET_ALL} through {Fore.CYAN}{gateway.host}{Style.RESET_ALL} ESTABLISHED\")\n return conn\n except:\n logging.exception(f\"Connection to {Fore.RED}{node}{Style.RESET_ALL} through {Fore.CYAN}{gateway.host}{Style.RESET_ALL} FAILED\")","def connect_entry_node(config):\n connect_kwargs = _authenticate(config)\n try:\n conn = Connection(config.hostname, user=config.user, connect_kwargs=connect_kwargs)\n conn.open()\n if conn.is_connected:\n logging.info(f\"Connection to {Fore.CYAN}{config.hostname}{Style.RESET_ALL} ESTABLISHED\")\n return conn\n except:\n logging.exception(f\"Connection to {Fore.RED}{config.hostname}{Style.RESET_ALL} FAILED\")","def connectTo( self, node, cls = None ):\n if ( not node ):\n return\n \n con = self.scene().addConnection(cls)\n con.setOutputNode(self)\n con.setInputNode(node)\n \n return con","async def random_node(self) -> AioConnection:\n if self.partition_aware:\n # if partition awareness is used just pick a random connected node\n return await self._get_random_node()\n else:\n # if partition awareness is not used then just return the current\n # node if it's alive or the next usable node if connection with the\n # current is broken\n node = self._nodes[self._current_node]\n if node.alive:\n return node\n\n # close current (supposedly failed) node\n await self._nodes[self._current_node].close()\n\n # advance the node index\n self._current_node += 1\n if self._current_node >= len(self._nodes):\n self._current_node = 0\n\n # prepare the list of node indexes to try to connect to\n for i in chain(range(self._current_node, len(self._nodes)), range(self._current_node)):\n node = self._nodes[i]\n try:\n await node.connect()\n except connection_errors:\n pass\n else:\n return node\n\n # no nodes left\n raise ReconnectError('Can not reconnect: out of nodes.')","def getConnection(parameter):\n try:\n server, group = parameter.split(r\"/\")\n except ValueError:\n g.es(\"Could not decifer server/group from '%s'\" % (parameter,), color=\"red\")\n raise NewsTreeError\n #\n try:\n connection = nntplib.NNTP(server)\n except Exception as err:\n g.es(\"Unable to connect to '%s': %s\" % (server, err), color=\"red\")\n raise NewsTreeError\n #\n try:\n resp, count, first, last, name = connection.group(group)\n except Exception as err:\n g.es(\"Unable to talk to group '%s': %s\" % (group, err), color=\"red\")\n raise NewsTreeError\n #\n return (connection, resp, count, first, last, name)","def _get_connect(self, port, username, password):\n paramiko.util.log_to_file(PARAMIKO_LOG)\n ssh_obj = paramiko.SSHClient()\n ssh_obj.set_missing_host_key_policy(paramiko.AutoAddPolicy())\n\n try:\n ssh_obj.connect(self.host, port, username=username,\n password=password,\n allow_agent=True)\n except Exception as err:\n print \"Can't access node %s, detailed error as %s\" % (\n host,\n six.text_type(err))\n return ssh_obj","def connect_to_node(self, **kwargs):\n # project_name, node_name\n\n try:\n if kwargs['project_name'] in self.data:\n project_name = kwargs['project_name']\n project_id = self.data[project_name]['project_id']\n if kwargs['node_name'] in self.data[project_name]['nodes']:\n node_name = kwargs['node_name']\n console_port = self.data[project_name]['nodes'][node_name]['console_port']\n console_session = Telnet(server_ip=self.IP, device_type='cisco_ios_telnet', console_port=console_port, node_name=node_name)\n self.telnet_threads.append(console_session)\n self.data[project_name]['nodes'][node_name]['console_session'] = console_session\n #console_session.start()\n except:\n traceback_print_exc()","def new_node(self, **kwargs):\n params = self._node_param_resolve(**kwargs)\n return GuidedNode(**params)","def get_connection(self, params):\r\n return Redis(connection_pool=self.get_or_create_connection_pool(params))","def connectnode():\n content = request.get_json()\n \n #Check request method\n if content[\"method\"] == \"GET\":\n res = hl.nodeGet(content[\"url\"])\n elif content[\"method\"] == \"GET\":\n res = hl.nodePost(content[\"url\"], content[\"data\"])\n\n #Error check\n if res:\n if ('result' in res and res['result']) or 'result' not in res:\n try:\n res.pop(\"result\")\n except:\n pass\n \n result = {\"result\" : True, \"data\" : res} \n else:\n result = {\"result\" : False} \n else:\n result = {\"result\" : False} \n \n #Return response\n return(jsonify(result))","def get_conn(self, *args, **kwargs):\n connections = self.__connections_for('get_conn', args=args, kwargs=kwargs)\n\n if len(connections) == 1:\n return connections[0]\n else:\n return connections","def connect(self, params={}):\n self.params = params\n return None","def connect(**connectparams):","def connect(self) -> ContextManager[Connection]:","async def connect(\n cls,\n *,\n client: discord.Client,\n nodes: list[Node],\n spotify: spotify_.SpotifyClient | None = None\n ) -> dict[str, Node]:\n if client.user is None:\n raise RuntimeError('')\n\n for node in nodes:\n\n if spotify:\n node._spotify = spotify\n\n if node.id in cls.__nodes:\n logger.error(f'A Node with the ID \"{node.id}\" already exists on the NodePool. Disregarding.')\n continue\n\n try:\n await node._connect(client)\n except AuthorizationFailed:\n logger.error(f'The Node <{node!r}> failed to authenticate properly. '\n f'Please check your password and try again.')\n else:\n cls.__nodes[node.id] = node\n\n return cls.nodes","async def node(self, node, *, dc=None, watch=None, consistency=None):\n node_id = extract_attr(node, keys=[\"Node\", \"ID\"])\n response = await self._api.get(\"/v1/session/node\", node_id, params={\n \"dc\": dc}, watch=watch, consistency=consistency)\n return consul(response)","def connect(self, *args, **kw):\n\n return self.get_pool(*args, **kw).connect()","def connect(self, *args):\n nodes = self._process_connect_args(*args)\n return _ConnectionContextManager(self, nodes)","def _create_connection(self):\r\n if not self._hosts:\r\n raise CQLConnectionError(\"At least one host required\")\r\n\r\n hosts = copy(self._hosts)\r\n random.shuffle(hosts)\r\n\r\n for host in hosts:\r\n try:\r\n transport = self._create_transport(host)\r\n new_conn = cql.connect(\r\n host.name,\r\n host.port,\r\n user=self._username,\r\n password=self._password,\r\n consistency_level=self._consistency,\r\n transport=transport\r\n )\r\n new_conn.set_cql_version('3.0.0')\r\n return new_conn\r\n except Exception as exc:\r\n logging.debug(\"Could not establish connection to\"\r\n \" {}:{} ({!r})\".format(host.name, host.port, exc))\r\n\r\n raise CQLConnectionError(\"Could not connect to any server in cluster\")","def get_node(cur, id):\n sql = \"\"\"\n SELECT\n *\n FROM\n nodes\n WHERE\n id = %s;\n \"\"\"\n if not isinstance(id, str):\n raise TypeError('ID must be type string (UUID4).')\n\n cur.execute(sql, (id, ))\n result = cur.fetchone()\n\n if result is None:\n raise exceptions.NodeNotFound(id)\n else:\n return NodeData(**result)","def connect(self, **kw_params):\r\n if self.connection_cls:\r\n return self.connection_cls(region=self, **kw_params)","def connect():","def get_node(port, identity: dht.Identity=None, is_bootstrap=False, ipv4:str=\"\", \n ipv6:str=\"\", config:dht.DhtConfig=None, bootstrap_node=None,\n logfile=None):\n log.debug(f\"get_node called for port {port}\")\n global nodes\n if port not in nodes or not nodes[port].isRunning():\n n = dht.DhtRunner()\n if config is not None:\n n.run(id=identity, is_bootstrap=is_bootstrap, port=port, ipv4=ipv4, ipv6=ipv6, config=config)\n else:\n n.run(id=identity, is_bootstrap=is_bootstrap, port=port, ipv4=ipv4, ipv6=ipv6)\n nodes[port] = n\n\n if logfile:\n n.enableFileLogging(logfile)\n\n if bootstrap_node is not None:\n bhost, bport = bootstrap_node.split(':')\n n.bootstrap(bhost, bport)\n\n return nodes[port]","def connect(self, source, target):\r\n connection = (self.coalesce_node(source), self.coalesce_node(target))\r\n self.connections.add(connection)","def select_node(self, *args):\n node = super().select_node(*args)\n self.subscribe_mqtt(self.generate_node_topic(node, '#', type='responses'))\n\n return node","def get_info_by_node(conn, node): \n cur = conn.cursor()\n cur.execute(\"SELECT * FROM Info WHERE NodeID=?\", (node))","def get_new_connection(self, conn_params):\r\n self.__connection_string = conn_params.get('connection_string', '')\r\n conn = Database.connect(**conn_params)\r\n return conn","def connect(self,ip,port):\n return self.network.connect(ip,port)","def connect(host, port = DEFAULT_SERVER_PORT):\n return factory.connect(host, port, SlaveService)","def find_conn(self, v):\n pass","def get_resource(self, graph_db):\n node = neo_resource.get_node(graph_db, self.index)\n return node","def get_connection(self, host, login, passwd, conn):\n # force all string values to unicode\n host = unicode(host)\n login = unicode(login)\n passwd = unicode(passwd) if passwd is not None else None\n\n connection = self._search_connection(host, login, passwd, conn)\n\n if (connection is None):\n self._connections_lock.acquireWrite()\n try:\n # we have to search for the connection again after aquireing the write lock\n # as the thread previously holding the write lock may have already added our connection\n connection = self._search_connection(host, login, passwd, conn)\n if (connection is None):\n # create a new connection if a matching connection does not already exist\n connection = wvmConnection(host, login, passwd, conn)\n\n # add new connection to connection dict\n if host in self._connections:\n self._connections[host].append(connection)\n else:\n self._connections[host] = [connection]\n finally:\n self._connections_lock.release()\n\n elif not connection.connected:\n # try to (re-)connect if connection is closed\n connection.connect()\n\n if connection.connected:\n # return libvirt connection object\n return connection.connection\n else:\n # raise libvirt error\n raise libvirtError(connection.last_error)","def get_node(uuid, **fields):\n try:\n with session_for_read() as session:\n res = session.query(model.Node).filter_by(\n uuid=uuid, **fields).one()\n return model.Node(uuid=res.uuid, version_id=res.version_id,\n state=res.state, started_at=res.started_at,\n finished_at=res.finished_at, error=res.error,\n manage_boot=res.manage_boot)\n except (orm_errors.NoResultFound, orm_errors.StaleDataError):\n raise utils.NodeNotFoundInDBError()","def select_node_by_label(conn, label):\n cur = conn.cursor()\n cur.execute(\"SELECT * FROM Nodes WHERE label=?\", (label,))","def _connection_maker(\n self,\n first_device,\n first_port,\n second_device,\n second_port):\n if first_port is None:\n return self.network.make_connection(\n first_device.id, None,\n second_device.id, second_port.id)\n else:\n return self.network.make_connection(\n first_device.id, first_port.id,\n second_device.id, second_port.id)","def get_node(self, value):\n\t\treturn self.adjacency_list[value]","def warp():\n # Magic to get est # of nodes in graph from restful API\n resp = requests.get(NEODB[:-4] +\n \"manage/server/jmx/domain/org.neo4j/instance%3Dkernel%230%2Cname%3DPrimitive%20count?_=1342719685294\")\n rdict = resp.json()[0]\n for i in range(len(rdict['attributes'])):\n if rdict['attributes'][i]['name'] == \"NumberOfNodeIdsInUse\":\n nodeCount = rdict['attributes'][i]['value']\n \n # try 10 times to get a random node\n for i in range(10):\n r = random.randrange(0,nodeCount)\n query = q.format(\"*\")[:-6] + \" SKIP {0} LIMIT 1;\\n\".format(r)\n neoNodes, metadata = cypher.execute(G, query)\n if len(neoNodes) > 0:\n node = neoNodes[0][0]\n return node._id\n # if we can't find a random node, return node 0\n return 0","def establish_connection(self):\n conninfo = self.client\n for name, default_value in items(self.default_connection_params):\n if not getattr(conninfo, name, None):\n setattr(conninfo, name, default_value)\n if conninfo.hostname == 'localhost':\n conninfo.hostname = '127.0.0.1'\n conn = self.Connection(host=conninfo.host,\n userid=conninfo.userid,\n password=conninfo.password,\n login_method=conninfo.login_method,\n virtual_host=conninfo.virtual_host,\n insist=conninfo.insist,\n ssl=conninfo.ssl,\n connect_timeout=conninfo.connect_timeout)\n conn.client = self.client\n return conn","def initialize_node(db, c):\n\n # have we already called this function?\n if saq.SAQ_NODE_ID is not None:\n return\n\n saq.SAQ_NODE_ID = None\n\n # we always default to a local node so that it doesn't get used by remote nodes automatically\n c.execute(\"SELECT id FROM nodes WHERE name = %s\", (saq.SAQ_NODE,))\n row = c.fetchone()\n if row is not None:\n saq.SAQ_NODE_ID = row[0]\n logging.debug(\"got existing node id {} for {}\".format(saq.SAQ_NODE_ID, saq.SAQ_NODE))\n\n if saq.SAQ_NODE_ID is None:\n execute_with_retry(db, c, \"\"\"INSERT INTO nodes ( name, location, company_id, is_local, last_update ) \n VALUES ( %s, %s, %s, %s, NOW() )\"\"\", \n (saq.SAQ_NODE, saq.API_PREFIX, saq.COMPANY_ID, True),\n commit=True)\n\n c.execute(\"SELECT id FROM nodes WHERE name = %s\", (saq.SAQ_NODE,))\n row = c.fetchone()\n if row is None:\n logging.critical(\"unable to allocate a node_id from the database\")\n sys.exit(1)\n else:\n saq.SAQ_NODE_ID = row[0]\n logging.info(\"allocated node id {} for {}\".format(saq.SAQ_NODE_ID, saq.SAQ_NODE))","def active_connect(self):\n try:\n self.logger.info(\"Trying active connection to %s\" % self.switch)\n soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n soc.connect((self.switch, self.port))\n self.logger.info(\"Connected to \" + self.switch + \" on \" +\n str(self.port))\n soc.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, True)\n self.switch_addr = (self.switch, self.port)\n return soc\n except (StandardError, socket.error) as e:\n self.logger.error(\"Could not connect to %s at %d:: %s\" %\n (self.switch, self.port, str(e)))\n return None","def get_resource(self, graph_db, timestamp):\n node_name = self.hostname + '_' + 'Machine' + '_0'\n index = ('physical_resource', 'physical_name', node_name)\n node = neo_resource.add_node(graph_db, index, timestamp)\n return node","def get_one(self, uuid):\n if self._from_chassis:\n raise exception.OperationNotPermitted\n\n rpc_node = objects.Node.get_by_uuid(pecan.request.context, uuid)\n return Node.convert_with_links(rpc_node)","def __connectNode__(self, numOfNodes, linksPerIteration):\n numOfLinks = 0\n node1 = self.getNode(numOfNodes - 1)\n # add n links per iteration\n while numOfLinks < linksPerIteration:\n #choose second node randomly\n nodeid2 = 0\n r = random.random()\n while nodeid2 < numOfNodes-1:\n node2 = self.getNode(nodeid2)\n #determine probability to choose node\n if self.degreeSum != 0 and node2.degree() != 0:\n pi = float(node2.degree()) / (self.degreeSum - node1.degree())\n else:\n pi = float(1)\n if not node1.hasLinkTo(node2):\n #choose node with probability pi\n if r < pi:\n numOfLinks += 1\n self.degreeSum += 2\n node1.addLinkTo(node2)\n node2.addLinkTo(node1)\n break\n r -= pi\n nodeid2 += 1","def _connect(*args):\n return None, None","def _connect(*args):\n return None, None","def create_node(\n self,\n node: Node,\n parameters: Any\n ) -> str:\n raise NotImplementedError","def connect_to_device(client: virl.ClientLibrary, node: virl_ty.Node) -> netmiko.BaseConnection:\n\tconn = netmiko.ConnectHandler(device_type='terminal_server',\n\t\thost=client.get_host(),\n\t\tusername=client.username,\n\t\tpassword=client.password,\n\t)\n\n\tconn.write_channel('\\r')\n\tconn.write_channel(f'open /{node.lab.id}/{node.id}/0\\r')\n\n\t#conn.write_channel('\\r\\n')\n\tsleep(0.5)\n\n\t#conn.write_channel('\\r\\n')\n\n\t# try to activate the device\n\tfor _ in range(3):\n\t\tconn.write_channel('\\r\\n')\n\t\tsleep(0.4)\n\n\tnode_def = node.node_definition\n\tdevice_type = None\n\tif node_def == 'iosv' or node_def == 'iosvl2':\n\t\tdevice_type = 'cisco_ios'\n\telif node_def == 'asav':\n\t\tdevice_type = 'cisco_asa'\n\telse:\n\t\tprint(f\"Unrecognized node_definition: {repr(node_def)}, defaulting to 'cisco_ios' netmiko device_type\", file=sys.stderr)\n\t\tdevice_type = 'cisco_ios'\n\t\n\t# tell netmiko what our actual device is\n\tnetmiko.redispatch(conn, device_type)\n\n\tconn.write_channel('\\r\\n\\r\\n')\n\t#conn.write_channel('\\r\\n')\n\tsleep(0.5)\n\tconn.write_channel('\\r\\n\\r\\n')\n\n\tconn.find_prompt()\n\n\tconn.disable_paging()\n\n\treturn conn","def __enter__(self) -> \"Connection\":\n\n if (not self.connected):\n self.connect()\n \n return self","def create_connection():\n try:\n with open('connection_string', 'rt') as f:\n connection_string = f.read()\n conn = connect(connection_string)\n print(\"Conn : \", conn)\n return conn\n except Error as e:\n print(e)\n\n return None","def get_neighbouring_nodes(node) :\r\n\r\n connected_nodes = [] #A list of the connected nodes\r\n\r\n #Checking if the node belongs to the 1st row\r\n if(node.coords[0] != 0) :\r\n connected_node = Node((node.coords[0] - 1, node.coords[1]), goal_pos, node.gn_value - 1)\r\n #Checking if the node is an obstacle\r\n if(not connected_node.coords in obstacle_coords) :\r\n connected_nodes.append(connected_node)\r\n\r\n #Checking if the node belongs to the last row\r\n if(node.coords[0] != grid_dims[0] - 1) :\r\n connected_node = Node((node.coords[0] + 1, node.coords[1]), goal_pos, node.gn_value - 1)\r\n #Checking if the node is an obstacle\r\n if(not connected_node.coords in obstacle_coords) :\r\n connected_nodes.append(connected_node)\r\n\r\n #Checking if the node belongs to the 1st column\r\n if(node.coords[1] != 0) :\r\n connected_node = Node((node.coords[0], node.coords[1] - 1), goal_pos, node.gn_value - 1)\r\n #Checking if the node is an obstacle\r\n if(not connected_node.coords in obstacle_coords) :\r\n connected_nodes.append(connected_node)\r\n\r\n #Checking if the node belongs to the 1st column\r\n if(node.coords[1] != grid_dims[1] - 1) :\r\n connected_node = Node((node.coords[0], node.coords[1] + 1), goal_pos, node.gn_value - 1)\r\n #Checking if the node is an obstacle\r\n if(not connected_node.coords in obstacle_coords) :\r\n connected_nodes.append(connected_node)\r\n\r\n return connected_nodes","def ConnectSocket(self) -> Socket:","def get_node(self, _id):\n return self.make_request(\"GET\", \"nodes/\"+_id, {})","def _build_connection(self,\n node,\n source_port: PipelineNodeIO = None,\n target_port: PipelineNodeIO = None,\n filters: entities.Filters = None,\n action: str = None) -> PipelineConnection:\n if source_port is None and self.outputs:\n source_port = self.outputs[0]\n\n if target_port is None and node.inputs:\n target_port = node.inputs[0]\n\n if node.is_root():\n self._pipeline.set_start_node(self)\n\n source_connection = PipelineConnectionPort(node_id=self.node_id, port_id=source_port.port_id)\n target_connection = PipelineConnectionPort(node_id=node.node_id, port_id=target_port.port_id)\n if action is None and source_port.actions is not None and source_port.actions != []:\n action = source_port.actions[0]\n connection = PipelineConnection(source=source_connection, target=target_connection, filters=filters,\n action=action)\n return connection","def currentnode(version, url):\n stm = shared_morphene_instance()\n if mph.rpc is not None:\n mph.rpc.rpcconnect()\n offline = mph.offline\n mph.move_current_node_to_front()\n node = mph.get_default_nodes()\n if version and not offline:\n print(mph.get_blockchain_version())\n return\n elif version and offline:\n print(\"Node is offline\")\n return\n if url and not offline:\n print(mph.rpc.url)\n return\n t = PrettyTable([\"Key\", \"Value\"])\n t.align = \"l\"\n if not offline:\n t.add_row([\"Node-Url\", mph.rpc.url])\n else:\n t.add_row([\"Node-Url\", node[0]])\n if not offline:\n t.add_row([\"Version\", mph.get_blockchain_version()])\n else:\n t.add_row([\"Version\", \"morphenepy is in offline mode...\"])\n print(t)","def openConnection():\n connection = nj.GraphDatabase.driver(\n uri=URI, auth=nj.basic_auth(USER, PASSWORD))\n return connection","def connect(self, host, password, bolt_port, http_port, use_bolt=False,\n timeout=30):\n\n connected = False\n # print(\"testing if we can connect at:\", http_port)\n while timeout > 0:\n try:\n socket.create_connection((host, http_port), 1)\n except socket.error:\n timeout -= 1\n time.sleep(1)\n else:\n connected = True\n break\n if not connected:\n raise socket.timeout('timed out trying to connect to {}'.format(\n host, http_port))\n logging.debug(\n \"connecting graph to http port: {} bolt_port: {} host: {}\".format(\n http_port, bolt_port, host))\n self.bolt_port = bolt_port\n self.http_port = http_port\n sys.stdout.write(\n \"connecting to http port: {} bolt_port: {} host: {} bolt: {}\\n\".\n format(http_port, bolt_port, host, use_bolt))\n time.sleep(5)\n\n graph = Graph('http://{}:{}/db/data/'.format(host, self.http_port),\n 'bolt://{}:{}/'.format(host, self.bolt_port),\n bolt=use_bolt, password=password,\n bolt_port=bolt_port,\n http_port=http_port)\n if self.debug:\n watch(\"neo4j.bolt\")\n logging.debug(\"connected\", graph)\n return graph","def add_node():\n\ttry:\n\t\tif(check_entries()):\n\t\t\tserver_entry = [frame.entries[0].get(), str(frame.entries[1].get()+\".\"+frame.entries[2].get()+\".\"+frame.entries[3].get()+\".\"+frame.entries[4].get())]\n\t\t\tclient_entry = [frame.entries[5].get(), str(frame.entries[6].get()+\".\"+frame.entries[7].get()+\".\"+frame.entries[8].get()+\".\"+frame.entries[9].get())]\n\t\t\tconnection_lifetime = frame.entries[10].get()\n\t\t\tnetwork.add_connection(server_entry, client_entry, connection_lifetime);\n\n\texcept ValueError as err:\n\t\tfeedback.config(text=err)","def create(self, connectionParams) :\n conn = RemoteConnection(connectionParams)\n\n # Generate a unique id by which to refer to this connection in the future\n id = str(uuid.uuid1())\n\n self.remoteConnections[id] = conn\n return id","def connect(self, node):\n self._hostname = node['host']\n node_hash = self._node_hash(node)\n if node_hash in self.__existing_connections:\n self._ssh = self.__existing_connections[node_hash]\n else:\n start = time()\n self._ssh.connect(node['host'], username=node['username'],\n password=node['password'])\n self.__existing_connections[node_hash] = self._ssh\n logger.trace('connect took {} seconds'.format(time() - start))","def get_connection(self):\n mess_start = '[LIDAR] '\n # Wait for connection\n if self.gui_message is not None:\n self.gui_message.message(mess_start + 'Listening on port %i...' % self.port)\n else:\n print(mess_start + 'Listening on port %i...' % self.port)\n self.sock.listen(1)\n\n # Accept connection\n self.conn, self.addr = self.sock.accept()\n if self.gui_message is not None:\n self.gui_message.message(mess_start + 'Got connection from %s' % self.addr[0])\n else:\n print(mess_start + 'Got connection from %s' % self.addr[0])\n self._queue.put(self.conn)","def __create_node(self, from_node_id, to_node_id):\n #ensure from_node_id and start_node_id is not the same\n if from_node_id == to_node_id:\n print(\"Cannot insert same node\")\n return\n \n # 1. declare two variable nodes\n n1 = n2 = None\n \n # 2. check if exist\n for x in self.__node:\n if x.getId()==from_node_id:\n n1 = x\n if x.getId()==to_node_id:\n n2 = x\n\n # 3. if n1 or n2 is None, create from_node_id / to_node_id\n if n1 is None:\n n1 = Node(from_node_id)\n self.__node.append(n1)\n \n if n2 is None:\n n2 = Node(to_node_id)\n self.__node.append(n2)\n\n #return from_node and to_node\n return n1, n2","def get_node_by_server(self, ip, port, is_register=False):\n # print('List of nodes in stream ', self.get_server_address())\n # for node in self.nodes:\n # print(node.get_server_address(), node.is_register)\n node_address = (Node.parse_ip(ip), port)\n for node in self.nodes:\n if node.get_server_address() == node_address and node.is_register == is_register:\n return node\n return None","def get_node(self, name):\n return self.source_net.nodes[name]","def connections(self, src=False, dst=True, params=True): \n conns = []\n if params:\n if src:\n #grab the node params that this node is a src to\n edges = self.parent.graph.out_edges(self, data=True) \n conns.extend([ edge[2][\"dst_param\"] for edge in edges ])\n if dst:\n #grab the node param that this node is a dst to\n edges = self.parent.graph.in_edges(self, data=True) \n conns.extend([ edge[2][\"src_param\"] for edge in edges ])\n else: \n if src:\n conns.extend(self.parent.graph.successors(self))\n if dst:\n conns.extend(self.parent.graph.predecessors(self))\n \n return conns","def __init__(self, node_number, all_nodes):\n self.self_host = 'localhost'\n self.base_port = 5000\n self.self_port = self.base_port + node_number\n self.other_nodes = [(self.self_host, p)\n for p in range(self.base_port + 1, self.base_port + all_nodes + 1)\n if p != self.self_port]\n self.other_nodes_len = all_nodes - 1\n self.current_node = 0","def _bddnode(root, lo, hi):\n\t# print(\"_bddnode\")\n\tif lo is hi:\n\t\tnode = lo\n\telse:\n\t\tkey = (root, lo, hi)\n\t\ttry:\n\t\t\tnode = _NODES[key]\n\t\texcept KeyError:\n\t\t\tnode = _NODES[key] = BDDNode(*key)\n\treturn node","def nodes(topology):\n return topology.nodes()","def connect_node():\n node_address = request.form[\"nodeadress_port\"]\n # post_object = {\n # 'Node address': node_address\n # }\n global CONNECTED_NODE_ADDRESS\n CONNECTED_NODE_ADDRESS = \"http://\"+node_address\n print(connect_node)\n \n return redirect('/transaction')","def node(self):\n return Node(self)","def get_conn(self):\n if self.game_request:\n # Prima cerca di ricavare la connessione ciclando sulle connessioni\n for connection in connections.values():\n if connection.player == self:\n return connection\n\n # Nell'eventualità remota che non ve la faccia prova nell'altro modo\n try:\n session = self.game_request.getSession()\n except error.AlreadyCalled:\n return None\n if session in connections:\n return connections[session]\n\n return None","def make_connection( hostname, port = 4663 ):\n \tconnection = socket.socket();","def get_node(self, name):\n response = self.connection.request(action=\"/v1/containers/%s\" % name, method=\"GET\")\n container = response.parse_body()\n \n try:\n state = self.NODE_STATE_MAP[container['state']]\n except KeyError:\n state = NodeState.UNKNOWN\n \n return Node( id=container['name'],\n name=container['name'],\n state=state,\n public_ips=container['ips'],\n private_ips=[],\n driver=self,\n image=self.list_images()[0])","async def get_best_node(\n self, cache: Union[int, str, 'BaseCache'], key: Any = None, key_hint: 'IgniteDataType' = None\n ) -> 'AioConnection':\n conn = await self.random_node()\n\n if self.partition_aware and key is not None:\n caches = self._caches_to_update_affinity()\n if caches:\n async with self._affinity_query_mux:\n while True:\n caches = self._caches_to_update_affinity()\n if not caches:\n break\n\n try:\n full_affinity = await self._get_affinity(conn, caches)\n self._update_affinity(full_affinity)\n\n asyncio.ensure_future(\n asyncio.gather(\n *[node.reconnect() for node in self._nodes if not node.alive],\n return_exceptions=True\n )\n )\n\n break\n except connection_errors:\n # retry if connection failed\n conn = await self.random_node()\n pass\n except CacheError:\n # server did not create mapping in time\n return conn\n\n c_id = cache.cache_id if isinstance(cache, BaseCache) else cache_id(cache)\n parts = self._cache_partition_mapping(c_id).get('number_of_partitions')\n\n if not parts:\n return conn\n\n key, key_hint = self._get_affinity_key(c_id, key, key_hint)\n\n hashcode = await key_hint.hashcode_async(key, client=self)\n\n best_node = self._get_node_by_hashcode(c_id, hashcode, parts)\n if best_node:\n return best_node\n\n return conn","def get_connected_nodes(node, current_path_len) :\r\n\r\n connected_nodes = [] #A list of the connected nodes\r\n closed_list_coords = get_path_coordinates(closed_list)\r\n\r\n #Checking if the node belongs to the 1st row\r\n if(node.coords[0] != 0) :\r\n connected_node = Node((node.coords[0] - 1, node.coords[1]), goal_pos, current_path_len)\r\n #Checking if the node has already been traversed or is it is an obstacle\r\n if(not connected_node.coords in closed_list_coords and not connected_node.coords in obstacle_coords) :\r\n connected_nodes.append(connected_node)\r\n\r\n #Checking if the node belongs to the last row\r\n if(node.coords[0] != grid_dims[0] - 1) :\r\n connected_node = Node((node.coords[0] + 1, node.coords[1]), goal_pos, current_path_len)\r\n #Checking if the node has already been traversed or is it is an obstacle\r\n if(not connected_node.coords in closed_list_coords and not connected_node.coords in obstacle_coords) :\r\n connected_nodes.append(connected_node)\r\n\r\n #Checking if the node belongs to the 1st column\r\n if(node.coords[1] != 0) :\r\n connected_node = Node((node.coords[0], node.coords[1] - 1), goal_pos, current_path_len)\r\n #Checking if the node has already been traversed or is it is an obstacle\r\n if(not connected_node.coords in closed_list_coords and not connected_node.coords in obstacle_coords) :\r\n connected_nodes.append(connected_node)\r\n\r\n #Checking if the node belongs to the 1st column\r\n if(node.coords[1] != grid_dims[1] - 1) :\r\n connected_node = Node((node.coords[0], node.coords[1] + 1), goal_pos, current_path_len)\r\n #Checking if the node has already been traversed or is it is an obstacle\r\n if(not connected_node.coords in closed_list_coords and not connected_node.coords in obstacle_coords) :\r\n connected_nodes.append(connected_node)\r\n\r\n return connected_nodes","def create_netmiko_connection(self, opt):\n\n key = opt['ip']\n conn_list = ['None', 'None', 'None']\n net_connect_dict = self._netmiko_connection\n auth = (opt['username'], opt['password'])\n if key not in net_connect_dict:\n # case 1: No key create a connection\n try:\n net_connect = self._establish_netmiko_handler(opt, net_connect_dict)\n if net_connect:\n hashed_auth = self._hash_auth_string(auth)\n conn_list[0] = net_connect\n conn_list[1] = hashed_auth\n conn_list[2] = threading.Lock()\n net_connect_dict[key] = conn_list\n except ValueError as err:\n raise\n except Exception as err:\n raise\n\n else:\n existing_hash = net_connect_dict[key][1]\n conn_list = self._get_netmiko_connection(key)\n conn_obj = conn_list[0]\n if self._check_auth_string(existing_hash, auth):\n # case 2: check if connection object is alive\n if conn_obj.is_alive() is True:\n conn_obj.set_base_prompt()\n return\n # case 3: Assume user value is new so delete existing\n # and add new connection object for this\n else:\n #disconnect stale object\n conn_list[2].acquire()\n conn_obj.disconnect()\n conn_list[2].release()\n\n # Existing object is not valid so clear and create new\n # connection\n del net_connect_dict[key]\n try:\n net_connect = self._establish_netmiko_handler(opt, net_connect_dict)\n if net_connect:\n new_hash = self._hash_auth_string(auth)\n conn_list[0] = net_connect\n conn_list[1] = new_hash\n conn_list[2] = threading.Lock()\n net_connect_dict[key] = conn_list\n except ValueError as error:\n raise\n except Exception:\n raise Exception","def c2p_connection(self, u, v):\n qnode = namedtuple('Node', 'asn path_type')\n\n q = list()\n q.append(qnode(u, -1))\n\n visited = defaultdict(int)\n\n while q:\n node = q.pop()\n visited[node.asn] = 1\n\n if self.has_node(node.asn):\n for neighbor in nx.all_neighbors(self, node.asn):\n if visited[neighbor] != 1:\n edge_data = self.get_edge_data(node.asn, neighbor)\n\n # c2p - p2c link\n if edge_data[\"relationship\"] == -1:\n if node.path_type == -1:\n path_type = 0 if node.asn == edge_data[\"as2\"] else 1\n else:\n path_type = node.path_type\n # c2p\n if (node.asn == edge_data[\"as2\"] and path_type == 0)\\\n or (node.asn == edge_data[\"as1\"] and path_type == 1):\n if neighbor == v:\n return True, -1 if path_type == 0 else 1\n q.append(qnode(neighbor, path_type))\n return False, None","def connect(self, host, port, db):\r\n params = self.make_connection_params(host, port, db)\r\n return self.get_connection(params)","def test_good_node():\n node_a = Node({'A':['B','C']})\n assert node_a.name == 'A'\n assert node_a.connections == ['B','C']","def connect_thread():\n return factory.connect_thread(SlaveService, remote_service = SlaveService)","def connect(self, node1, node2):\n self.neighbour1 = node1\n self.neighbour2 = node2","def connection(composition):\n return Connection(BASE_URL, 'http://localhost')","def node(self, ident, time=None):\n if time is not None:\n ident = (ident, time)\n return self._nodes[ident]","def get_connection(hostname, logger):\n return Connection(\n hostname,\n logger=logger,\n sudo=needs_sudo(),\n )","async def get_connection(self, username: str, password: str) -> asyncssh.connect:\n conn = await asyncssh.connect(self.ip, known_hosts=None, username=username, password=password,\n server_host_key_algs=['ssh-rsa'])\n # return created connection\n return conn","def get_connection(ssid,password):\n # First check if there already is any connection:\n if wlan_sta.isconnected():\n return wlan_sta\n\n connected = False\n try:\n # ESP connecting to WiFi takes time, wait a bit and try again:\n time.sleep(3)\n if wlan_sta.isconnected():\n return wlan_sta\n\n # Search WiFis in range\n wlan_sta.active(True)\n connected = do_connect(ssid,password)\n\n except OSError as e:\n print(\"exception\", str(e))\n\n # start web server for connection manager:\n # if not connected:\n # connected = start()\n\n return wlan_sta if connected else None","def get_conn(args):\n\n # connect this thing\n from pyVmomi import vim\n from pyVim.connect import SmartConnect, Disconnect\n import atexit\n try:\n si = SmartConnect(host=args.host, port=args.port, user=args.user, pwd=args.password)\n except Exception as exc:\n if isinstance(exc, vim.fault.HostConnectFault) and '[SSL: CERTIFICATE_VERIFY_FAILED]' in exc.msg:\n try:\n import ssl\n default_context = ssl._create_default_https_context\n ssl._create_default_https_context = ssl._create_unverified_context\n si = SmartConnect(\n host=args.host,\n port=args.port,\n user=args.user,\n pwd=args.password,\n )\n ssl._create_default_https_context = default_context\n except Exception as exc1:\n raise Exception(exc1)\n else:\n import ssl\n context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)\n context.verify_mode = ssl.CERT_NONE\n si = SmartConnect(\n host=args.host,\n port=args.port,\n user=args.user,\n pwd=args.password,\n sslContext=context)\n atexit.register(Disconnect, si)\n return si","def establish_connection(self):\r\n\r\n #creates SSH connection and adds SSH key to .known_hosts\r\n self.ssh_conn = paramiko.SSHClient()\r\n self.ssh_conn.set_missing_host_key_policy(paramiko.AutoAddPolicy())\r\n\r\n try:\r\n self.ssh_conn.connect(**self.conn_parm)\r\n print \"Connected to %s\" % self.conn_parm['hostname']\r\n #testing: self.ssh_conn.close()\r\n except socket.error:\r\n print \"Connection Failed on device %s\" % self.conn_parm['hostname']\r\n\r\n #find prompt\r\n open_session = self.ssh_conn.invoke_shell()\r\n output = open_session.recv(1000)\r\n\r\n #testing: print output\r\n\r\n #go into Enable-Mode if not already in it\r\n if '#' not in output:\r\n open_session.send('enable\\n')\r\n time.sleep(1)\r\n open_session.send(self.password)\r\n open_session.send('\\n')\r\n else:\r\n print \"In Enable-Mode\"\r\n\r\n #turn off paging\r\n open_session.send('terminal length 0\\n')\r\n time.sleep(3)\r\n \r\n return open_session","def create_graph_network(start_node, connections):\n graph = nx.Graph()\n graph.add_node(start_node)\n print(connections.index)\n graph.add_nodes_from(connections.index)\n edge_list = list(zip(itertools.repeat(start_node), connections.index))\n print(\"edge list is \", edge_list)\n graph.add_edges_from(edge_list)\n for i in graph.edges():\n graph[i[0]][i[1]]['weight'] = connections.loc[i[1]]['count']\n # graph[i[0]][i[1]]['proposal_number'] = connections.loc[i[1]]['proposal_number']\n # graph[i[0]][i[1]]['institution'] = connections.loc[i[1]]['institution']\n # graph[i[0]][i[1]]['proposal_title'] = connections.loc[i[1]]['proposal_title']\n # graph[i[0]][i[1]]['project_status'] = connections.loc[i[1]]['project_status']\n\n # Adding random position data to the graph.\n # pos = nx.spring_layout(graph, k=1)\n pos = nx.circular_layout(graph)\n nx.set_node_attributes(graph, 'pos', pos)\n return graph","def build_connection(self, src, tgt) -> NoReturn:\n # If src and tgt are the same node, src not in node_collection or\n # tgt not in node_collection,\n # then skip this edge.\n if src == tgt or src not in self._nodes_collection or tgt not in self._nodes_collection:\n if src.split(':')[0] not in self._nodes_collection:\n warnings.warn(f\"Graph construct a self-loop node {src}. Ignored.\")\n return\n\n if tgt not in self._nodes_collection[src.split(':')[0]].successor_nodes:\n self._nodes_collection[src.split(':')[0]].successor_nodes.append(tgt)\n if src not in self._nodes_collection[tgt].precursor_nodes:\n self._nodes_collection[tgt.split(':')[0]].precursor_nodes.append(src)","def _build_connection(self, address, serverkey=None):\n cn_uuid = self._address_to_uuid.get(address)\n cn = None\n if cn_uuid is not None:\n cn = self._platform_connections.get(cn_uuid)\n if cn is not None and cn.serverkey != serverkey:\n cn.kill()\n del self._platform_connections[cn_uuid]\n cn = None\n\n if cn is None:\n parsed = urlparse(address)\n if parsed.scheme == 'tcp':\n cn = Connection(address=address, serverkey=serverkey,\n publickey=self.core.publickey,\n secretkey=self.core.secretkey,\n peer=VOLTTRON_CENTRAL_PLATFORM)\n else:\n cn = Connection(address=address, peer=VOLTTRON_CENTRAL_PLATFORM)\n\n assert cn.is_connected(), \"Connection unavailable for address {}\"\\\n .format(address)\n if cn_uuid is None:\n cn_uuid = str(uuid.uuid4())\n self._address_to_uuid[address] = cn_uuid\n self._platform_connections[cn_uuid] = cn\n return cn","def get_node(self, name, create=False):\n\n try:\n node = self.find_node(name, create)\n except KeyError:\n node = None\n return node","def GetCreateConnectionPoint(identifier, namespace, klass=Interface, initfunction=None, **parameters):\n assert(issubclass(klass, ConnectionPoint))\n return pynt.xmlns.GetCreateRDFObject(identifier=identifier, namespace=namespace, klass=klass, \n verifyAttributes=False, initfunction=initfunction, **parameters)","def request(self, nodes:NodeAssignment) -> ICommunicationController:\n com_proc = self.__method(nodes)\n com_ctrl = cc(com_proc)\n time.sleep(2)\n return com_ctrl","def get_connection(self, command, args=()):\n # TODO: find a better way to determine if connection is free\n # and not havily used.\n command = command.upper().strip()\n is_pubsub = command in _PUBSUB_COMMANDS\n if is_pubsub and self._pubsub_conn:\n if not self._pubsub_conn.closed:\n return self._pubsub_conn, self._pubsub_conn.address\n self._pubsub_conn = None\n for i in range(self.freesize):\n conn = self._pool[0]\n self._pool.rotate(1)\n if conn.closed: # or conn._waiters: (eg: busy connection)\n continue\n if conn.in_pubsub:\n continue\n if is_pubsub:\n self._pubsub_conn = conn\n self._pool.remove(conn)\n self._used.add(conn)\n return conn, conn.address\n return None, self._address # figure out","def create_node(self, *labels, **props):\n component = Node(*labels, **props)\n self.graph.create(component)\n return component","def get_node(self, key: str) -> Node:","def _get_connection(self, conf):\n return get_session()","def construct_connection(module):\n connection = dict((k, module.params.get(k)) for k in (\n 'id',\n 'name',\n 'description',\n 'speed',\n 'billing_term',\n 'customer_networks',\n 'primary_ocid',\n 'secondary_ocid'\n ))\n connection.update(dict(\n type='ORACLE_FAST_CONNECT',\n high_availability=True,\n location=get_object_link(module, '/locations', 'location_id', 'location_href'),\n cloud_region=get_object_link(module, '/cloudRegions', 'cloud_region_id', 'cloud_region_href'),\n nat=dict(\n enabled=module.params.get('nat_enabled'),\n mappings=[dict(native_cidr=nat_mapping)\n for nat_mapping in module.params.get('nat_mappings')]\n )\n ))\n connection = snake_dict_to_camel_dict(connection)\n # Correct naming\n connection.update(dict(\n peering=dict(\n type='PRIVATE',\n primaryRemoteBgpIP=module.params.get('primary_remote_bgp_ip'),\n primaryPureportBgpIP=module.params.get('primary_pureport_bgp_ip'),\n secondaryRemoteBgpIP=module.params.get('secondary_remote_bgp_ip'),\n secondaryPureportBgpIP=module.params.get('secondary_pureport_bgp_ip'),\n ),\n tags=module.params.get('tags')\n ))\n return connection","def _search_connection(self, host, login, passwd, conn):\n self._connections_lock.acquireRead()\n try:\n if (host in self._connections):\n connections = self._connections[host]\n\n for connection in connections:\n if (connection.login == login and connection.passwd == passwd and connection.type == conn):\n return connection\n finally:\n self._connections_lock.release()\n\n return None"],"string":"[\n \"def get_node(conn, name):\\n datacenter_id = get_datacenter_id()\\n\\n for item in conn.list_servers(datacenter_id)[\\\"items\\\"]:\\n if item[\\\"properties\\\"][\\\"name\\\"] == name:\\n node = {\\\"id\\\": item[\\\"id\\\"]}\\n node.update(item[\\\"properties\\\"])\\n return node\",\n \"def connect_node(config, node, gateway):\\n try:\\n conn = Connection(node, user=config.user, gateway=gateway, connect_kwargs=gateway.connect_kwargs)\\n conn.open()\\n if conn.is_connected:\\n logging.info(f\\\"Connection to {Fore.CYAN}{node}{Style.RESET_ALL} through {Fore.CYAN}{gateway.host}{Style.RESET_ALL} ESTABLISHED\\\")\\n return conn\\n except:\\n logging.exception(f\\\"Connection to {Fore.RED}{node}{Style.RESET_ALL} through {Fore.CYAN}{gateway.host}{Style.RESET_ALL} FAILED\\\")\",\n \"def connect_entry_node(config):\\n connect_kwargs = _authenticate(config)\\n try:\\n conn = Connection(config.hostname, user=config.user, connect_kwargs=connect_kwargs)\\n conn.open()\\n if conn.is_connected:\\n logging.info(f\\\"Connection to {Fore.CYAN}{config.hostname}{Style.RESET_ALL} ESTABLISHED\\\")\\n return conn\\n except:\\n logging.exception(f\\\"Connection to {Fore.RED}{config.hostname}{Style.RESET_ALL} FAILED\\\")\",\n \"def connectTo( self, node, cls = None ):\\n if ( not node ):\\n return\\n \\n con = self.scene().addConnection(cls)\\n con.setOutputNode(self)\\n con.setInputNode(node)\\n \\n return con\",\n \"async def random_node(self) -> AioConnection:\\n if self.partition_aware:\\n # if partition awareness is used just pick a random connected node\\n return await self._get_random_node()\\n else:\\n # if partition awareness is not used then just return the current\\n # node if it's alive or the next usable node if connection with the\\n # current is broken\\n node = self._nodes[self._current_node]\\n if node.alive:\\n return node\\n\\n # close current (supposedly failed) node\\n await self._nodes[self._current_node].close()\\n\\n # advance the node index\\n self._current_node += 1\\n if self._current_node >= len(self._nodes):\\n self._current_node = 0\\n\\n # prepare the list of node indexes to try to connect to\\n for i in chain(range(self._current_node, len(self._nodes)), range(self._current_node)):\\n node = self._nodes[i]\\n try:\\n await node.connect()\\n except connection_errors:\\n pass\\n else:\\n return node\\n\\n # no nodes left\\n raise ReconnectError('Can not reconnect: out of nodes.')\",\n \"def getConnection(parameter):\\n try:\\n server, group = parameter.split(r\\\"/\\\")\\n except ValueError:\\n g.es(\\\"Could not decifer server/group from '%s'\\\" % (parameter,), color=\\\"red\\\")\\n raise NewsTreeError\\n #\\n try:\\n connection = nntplib.NNTP(server)\\n except Exception as err:\\n g.es(\\\"Unable to connect to '%s': %s\\\" % (server, err), color=\\\"red\\\")\\n raise NewsTreeError\\n #\\n try:\\n resp, count, first, last, name = connection.group(group)\\n except Exception as err:\\n g.es(\\\"Unable to talk to group '%s': %s\\\" % (group, err), color=\\\"red\\\")\\n raise NewsTreeError\\n #\\n return (connection, resp, count, first, last, name)\",\n \"def _get_connect(self, port, username, password):\\n paramiko.util.log_to_file(PARAMIKO_LOG)\\n ssh_obj = paramiko.SSHClient()\\n ssh_obj.set_missing_host_key_policy(paramiko.AutoAddPolicy())\\n\\n try:\\n ssh_obj.connect(self.host, port, username=username,\\n password=password,\\n allow_agent=True)\\n except Exception as err:\\n print \\\"Can't access node %s, detailed error as %s\\\" % (\\n host,\\n six.text_type(err))\\n return ssh_obj\",\n \"def connect_to_node(self, **kwargs):\\n # project_name, node_name\\n\\n try:\\n if kwargs['project_name'] in self.data:\\n project_name = kwargs['project_name']\\n project_id = self.data[project_name]['project_id']\\n if kwargs['node_name'] in self.data[project_name]['nodes']:\\n node_name = kwargs['node_name']\\n console_port = self.data[project_name]['nodes'][node_name]['console_port']\\n console_session = Telnet(server_ip=self.IP, device_type='cisco_ios_telnet', console_port=console_port, node_name=node_name)\\n self.telnet_threads.append(console_session)\\n self.data[project_name]['nodes'][node_name]['console_session'] = console_session\\n #console_session.start()\\n except:\\n traceback_print_exc()\",\n \"def new_node(self, **kwargs):\\n params = self._node_param_resolve(**kwargs)\\n return GuidedNode(**params)\",\n \"def get_connection(self, params):\\r\\n return Redis(connection_pool=self.get_or_create_connection_pool(params))\",\n \"def connectnode():\\n content = request.get_json()\\n \\n #Check request method\\n if content[\\\"method\\\"] == \\\"GET\\\":\\n res = hl.nodeGet(content[\\\"url\\\"])\\n elif content[\\\"method\\\"] == \\\"GET\\\":\\n res = hl.nodePost(content[\\\"url\\\"], content[\\\"data\\\"])\\n\\n #Error check\\n if res:\\n if ('result' in res and res['result']) or 'result' not in res:\\n try:\\n res.pop(\\\"result\\\")\\n except:\\n pass\\n \\n result = {\\\"result\\\" : True, \\\"data\\\" : res} \\n else:\\n result = {\\\"result\\\" : False} \\n else:\\n result = {\\\"result\\\" : False} \\n \\n #Return response\\n return(jsonify(result))\",\n \"def get_conn(self, *args, **kwargs):\\n connections = self.__connections_for('get_conn', args=args, kwargs=kwargs)\\n\\n if len(connections) == 1:\\n return connections[0]\\n else:\\n return connections\",\n \"def connect(self, params={}):\\n self.params = params\\n return None\",\n \"def connect(**connectparams):\",\n \"def connect(self) -> ContextManager[Connection]:\",\n \"async def connect(\\n cls,\\n *,\\n client: discord.Client,\\n nodes: list[Node],\\n spotify: spotify_.SpotifyClient | None = None\\n ) -> dict[str, Node]:\\n if client.user is None:\\n raise RuntimeError('')\\n\\n for node in nodes:\\n\\n if spotify:\\n node._spotify = spotify\\n\\n if node.id in cls.__nodes:\\n logger.error(f'A Node with the ID \\\"{node.id}\\\" already exists on the NodePool. Disregarding.')\\n continue\\n\\n try:\\n await node._connect(client)\\n except AuthorizationFailed:\\n logger.error(f'The Node <{node!r}> failed to authenticate properly. '\\n f'Please check your password and try again.')\\n else:\\n cls.__nodes[node.id] = node\\n\\n return cls.nodes\",\n \"async def node(self, node, *, dc=None, watch=None, consistency=None):\\n node_id = extract_attr(node, keys=[\\\"Node\\\", \\\"ID\\\"])\\n response = await self._api.get(\\\"/v1/session/node\\\", node_id, params={\\n \\\"dc\\\": dc}, watch=watch, consistency=consistency)\\n return consul(response)\",\n \"def connect(self, *args, **kw):\\n\\n return self.get_pool(*args, **kw).connect()\",\n \"def connect(self, *args):\\n nodes = self._process_connect_args(*args)\\n return _ConnectionContextManager(self, nodes)\",\n \"def _create_connection(self):\\r\\n if not self._hosts:\\r\\n raise CQLConnectionError(\\\"At least one host required\\\")\\r\\n\\r\\n hosts = copy(self._hosts)\\r\\n random.shuffle(hosts)\\r\\n\\r\\n for host in hosts:\\r\\n try:\\r\\n transport = self._create_transport(host)\\r\\n new_conn = cql.connect(\\r\\n host.name,\\r\\n host.port,\\r\\n user=self._username,\\r\\n password=self._password,\\r\\n consistency_level=self._consistency,\\r\\n transport=transport\\r\\n )\\r\\n new_conn.set_cql_version('3.0.0')\\r\\n return new_conn\\r\\n except Exception as exc:\\r\\n logging.debug(\\\"Could not establish connection to\\\"\\r\\n \\\" {}:{} ({!r})\\\".format(host.name, host.port, exc))\\r\\n\\r\\n raise CQLConnectionError(\\\"Could not connect to any server in cluster\\\")\",\n \"def get_node(cur, id):\\n sql = \\\"\\\"\\\"\\n SELECT\\n *\\n FROM\\n nodes\\n WHERE\\n id = %s;\\n \\\"\\\"\\\"\\n if not isinstance(id, str):\\n raise TypeError('ID must be type string (UUID4).')\\n\\n cur.execute(sql, (id, ))\\n result = cur.fetchone()\\n\\n if result is None:\\n raise exceptions.NodeNotFound(id)\\n else:\\n return NodeData(**result)\",\n \"def connect(self, **kw_params):\\r\\n if self.connection_cls:\\r\\n return self.connection_cls(region=self, **kw_params)\",\n \"def connect():\",\n \"def get_node(port, identity: dht.Identity=None, is_bootstrap=False, ipv4:str=\\\"\\\", \\n ipv6:str=\\\"\\\", config:dht.DhtConfig=None, bootstrap_node=None,\\n logfile=None):\\n log.debug(f\\\"get_node called for port {port}\\\")\\n global nodes\\n if port not in nodes or not nodes[port].isRunning():\\n n = dht.DhtRunner()\\n if config is not None:\\n n.run(id=identity, is_bootstrap=is_bootstrap, port=port, ipv4=ipv4, ipv6=ipv6, config=config)\\n else:\\n n.run(id=identity, is_bootstrap=is_bootstrap, port=port, ipv4=ipv4, ipv6=ipv6)\\n nodes[port] = n\\n\\n if logfile:\\n n.enableFileLogging(logfile)\\n\\n if bootstrap_node is not None:\\n bhost, bport = bootstrap_node.split(':')\\n n.bootstrap(bhost, bport)\\n\\n return nodes[port]\",\n \"def connect(self, source, target):\\r\\n connection = (self.coalesce_node(source), self.coalesce_node(target))\\r\\n self.connections.add(connection)\",\n \"def select_node(self, *args):\\n node = super().select_node(*args)\\n self.subscribe_mqtt(self.generate_node_topic(node, '#', type='responses'))\\n\\n return node\",\n \"def get_info_by_node(conn, node): \\n cur = conn.cursor()\\n cur.execute(\\\"SELECT * FROM Info WHERE NodeID=?\\\", (node))\",\n \"def get_new_connection(self, conn_params):\\r\\n self.__connection_string = conn_params.get('connection_string', '')\\r\\n conn = Database.connect(**conn_params)\\r\\n return conn\",\n \"def connect(self,ip,port):\\n return self.network.connect(ip,port)\",\n \"def connect(host, port = DEFAULT_SERVER_PORT):\\n return factory.connect(host, port, SlaveService)\",\n \"def find_conn(self, v):\\n pass\",\n \"def get_resource(self, graph_db):\\n node = neo_resource.get_node(graph_db, self.index)\\n return node\",\n \"def get_connection(self, host, login, passwd, conn):\\n # force all string values to unicode\\n host = unicode(host)\\n login = unicode(login)\\n passwd = unicode(passwd) if passwd is not None else None\\n\\n connection = self._search_connection(host, login, passwd, conn)\\n\\n if (connection is None):\\n self._connections_lock.acquireWrite()\\n try:\\n # we have to search for the connection again after aquireing the write lock\\n # as the thread previously holding the write lock may have already added our connection\\n connection = self._search_connection(host, login, passwd, conn)\\n if (connection is None):\\n # create a new connection if a matching connection does not already exist\\n connection = wvmConnection(host, login, passwd, conn)\\n\\n # add new connection to connection dict\\n if host in self._connections:\\n self._connections[host].append(connection)\\n else:\\n self._connections[host] = [connection]\\n finally:\\n self._connections_lock.release()\\n\\n elif not connection.connected:\\n # try to (re-)connect if connection is closed\\n connection.connect()\\n\\n if connection.connected:\\n # return libvirt connection object\\n return connection.connection\\n else:\\n # raise libvirt error\\n raise libvirtError(connection.last_error)\",\n \"def get_node(uuid, **fields):\\n try:\\n with session_for_read() as session:\\n res = session.query(model.Node).filter_by(\\n uuid=uuid, **fields).one()\\n return model.Node(uuid=res.uuid, version_id=res.version_id,\\n state=res.state, started_at=res.started_at,\\n finished_at=res.finished_at, error=res.error,\\n manage_boot=res.manage_boot)\\n except (orm_errors.NoResultFound, orm_errors.StaleDataError):\\n raise utils.NodeNotFoundInDBError()\",\n \"def select_node_by_label(conn, label):\\n cur = conn.cursor()\\n cur.execute(\\\"SELECT * FROM Nodes WHERE label=?\\\", (label,))\",\n \"def _connection_maker(\\n self,\\n first_device,\\n first_port,\\n second_device,\\n second_port):\\n if first_port is None:\\n return self.network.make_connection(\\n first_device.id, None,\\n second_device.id, second_port.id)\\n else:\\n return self.network.make_connection(\\n first_device.id, first_port.id,\\n second_device.id, second_port.id)\",\n \"def get_node(self, value):\\n\\t\\treturn self.adjacency_list[value]\",\n \"def warp():\\n # Magic to get est # of nodes in graph from restful API\\n resp = requests.get(NEODB[:-4] +\\n \\\"manage/server/jmx/domain/org.neo4j/instance%3Dkernel%230%2Cname%3DPrimitive%20count?_=1342719685294\\\")\\n rdict = resp.json()[0]\\n for i in range(len(rdict['attributes'])):\\n if rdict['attributes'][i]['name'] == \\\"NumberOfNodeIdsInUse\\\":\\n nodeCount = rdict['attributes'][i]['value']\\n \\n # try 10 times to get a random node\\n for i in range(10):\\n r = random.randrange(0,nodeCount)\\n query = q.format(\\\"*\\\")[:-6] + \\\" SKIP {0} LIMIT 1;\\\\n\\\".format(r)\\n neoNodes, metadata = cypher.execute(G, query)\\n if len(neoNodes) > 0:\\n node = neoNodes[0][0]\\n return node._id\\n # if we can't find a random node, return node 0\\n return 0\",\n \"def establish_connection(self):\\n conninfo = self.client\\n for name, default_value in items(self.default_connection_params):\\n if not getattr(conninfo, name, None):\\n setattr(conninfo, name, default_value)\\n if conninfo.hostname == 'localhost':\\n conninfo.hostname = '127.0.0.1'\\n conn = self.Connection(host=conninfo.host,\\n userid=conninfo.userid,\\n password=conninfo.password,\\n login_method=conninfo.login_method,\\n virtual_host=conninfo.virtual_host,\\n insist=conninfo.insist,\\n ssl=conninfo.ssl,\\n connect_timeout=conninfo.connect_timeout)\\n conn.client = self.client\\n return conn\",\n \"def initialize_node(db, c):\\n\\n # have we already called this function?\\n if saq.SAQ_NODE_ID is not None:\\n return\\n\\n saq.SAQ_NODE_ID = None\\n\\n # we always default to a local node so that it doesn't get used by remote nodes automatically\\n c.execute(\\\"SELECT id FROM nodes WHERE name = %s\\\", (saq.SAQ_NODE,))\\n row = c.fetchone()\\n if row is not None:\\n saq.SAQ_NODE_ID = row[0]\\n logging.debug(\\\"got existing node id {} for {}\\\".format(saq.SAQ_NODE_ID, saq.SAQ_NODE))\\n\\n if saq.SAQ_NODE_ID is None:\\n execute_with_retry(db, c, \\\"\\\"\\\"INSERT INTO nodes ( name, location, company_id, is_local, last_update ) \\n VALUES ( %s, %s, %s, %s, NOW() )\\\"\\\"\\\", \\n (saq.SAQ_NODE, saq.API_PREFIX, saq.COMPANY_ID, True),\\n commit=True)\\n\\n c.execute(\\\"SELECT id FROM nodes WHERE name = %s\\\", (saq.SAQ_NODE,))\\n row = c.fetchone()\\n if row is None:\\n logging.critical(\\\"unable to allocate a node_id from the database\\\")\\n sys.exit(1)\\n else:\\n saq.SAQ_NODE_ID = row[0]\\n logging.info(\\\"allocated node id {} for {}\\\".format(saq.SAQ_NODE_ID, saq.SAQ_NODE))\",\n \"def active_connect(self):\\n try:\\n self.logger.info(\\\"Trying active connection to %s\\\" % self.switch)\\n soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n soc.connect((self.switch, self.port))\\n self.logger.info(\\\"Connected to \\\" + self.switch + \\\" on \\\" +\\n str(self.port))\\n soc.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, True)\\n self.switch_addr = (self.switch, self.port)\\n return soc\\n except (StandardError, socket.error) as e:\\n self.logger.error(\\\"Could not connect to %s at %d:: %s\\\" %\\n (self.switch, self.port, str(e)))\\n return None\",\n \"def get_resource(self, graph_db, timestamp):\\n node_name = self.hostname + '_' + 'Machine' + '_0'\\n index = ('physical_resource', 'physical_name', node_name)\\n node = neo_resource.add_node(graph_db, index, timestamp)\\n return node\",\n \"def get_one(self, uuid):\\n if self._from_chassis:\\n raise exception.OperationNotPermitted\\n\\n rpc_node = objects.Node.get_by_uuid(pecan.request.context, uuid)\\n return Node.convert_with_links(rpc_node)\",\n \"def __connectNode__(self, numOfNodes, linksPerIteration):\\n numOfLinks = 0\\n node1 = self.getNode(numOfNodes - 1)\\n # add n links per iteration\\n while numOfLinks < linksPerIteration:\\n #choose second node randomly\\n nodeid2 = 0\\n r = random.random()\\n while nodeid2 < numOfNodes-1:\\n node2 = self.getNode(nodeid2)\\n #determine probability to choose node\\n if self.degreeSum != 0 and node2.degree() != 0:\\n pi = float(node2.degree()) / (self.degreeSum - node1.degree())\\n else:\\n pi = float(1)\\n if not node1.hasLinkTo(node2):\\n #choose node with probability pi\\n if r < pi:\\n numOfLinks += 1\\n self.degreeSum += 2\\n node1.addLinkTo(node2)\\n node2.addLinkTo(node1)\\n break\\n r -= pi\\n nodeid2 += 1\",\n \"def _connect(*args):\\n return None, None\",\n \"def _connect(*args):\\n return None, None\",\n \"def create_node(\\n self,\\n node: Node,\\n parameters: Any\\n ) -> str:\\n raise NotImplementedError\",\n \"def connect_to_device(client: virl.ClientLibrary, node: virl_ty.Node) -> netmiko.BaseConnection:\\n\\tconn = netmiko.ConnectHandler(device_type='terminal_server',\\n\\t\\thost=client.get_host(),\\n\\t\\tusername=client.username,\\n\\t\\tpassword=client.password,\\n\\t)\\n\\n\\tconn.write_channel('\\\\r')\\n\\tconn.write_channel(f'open /{node.lab.id}/{node.id}/0\\\\r')\\n\\n\\t#conn.write_channel('\\\\r\\\\n')\\n\\tsleep(0.5)\\n\\n\\t#conn.write_channel('\\\\r\\\\n')\\n\\n\\t# try to activate the device\\n\\tfor _ in range(3):\\n\\t\\tconn.write_channel('\\\\r\\\\n')\\n\\t\\tsleep(0.4)\\n\\n\\tnode_def = node.node_definition\\n\\tdevice_type = None\\n\\tif node_def == 'iosv' or node_def == 'iosvl2':\\n\\t\\tdevice_type = 'cisco_ios'\\n\\telif node_def == 'asav':\\n\\t\\tdevice_type = 'cisco_asa'\\n\\telse:\\n\\t\\tprint(f\\\"Unrecognized node_definition: {repr(node_def)}, defaulting to 'cisco_ios' netmiko device_type\\\", file=sys.stderr)\\n\\t\\tdevice_type = 'cisco_ios'\\n\\t\\n\\t# tell netmiko what our actual device is\\n\\tnetmiko.redispatch(conn, device_type)\\n\\n\\tconn.write_channel('\\\\r\\\\n\\\\r\\\\n')\\n\\t#conn.write_channel('\\\\r\\\\n')\\n\\tsleep(0.5)\\n\\tconn.write_channel('\\\\r\\\\n\\\\r\\\\n')\\n\\n\\tconn.find_prompt()\\n\\n\\tconn.disable_paging()\\n\\n\\treturn conn\",\n \"def __enter__(self) -> \\\"Connection\\\":\\n\\n if (not self.connected):\\n self.connect()\\n \\n return self\",\n \"def create_connection():\\n try:\\n with open('connection_string', 'rt') as f:\\n connection_string = f.read()\\n conn = connect(connection_string)\\n print(\\\"Conn : \\\", conn)\\n return conn\\n except Error as e:\\n print(e)\\n\\n return None\",\n \"def get_neighbouring_nodes(node) :\\r\\n\\r\\n connected_nodes = [] #A list of the connected nodes\\r\\n\\r\\n #Checking if the node belongs to the 1st row\\r\\n if(node.coords[0] != 0) :\\r\\n connected_node = Node((node.coords[0] - 1, node.coords[1]), goal_pos, node.gn_value - 1)\\r\\n #Checking if the node is an obstacle\\r\\n if(not connected_node.coords in obstacle_coords) :\\r\\n connected_nodes.append(connected_node)\\r\\n\\r\\n #Checking if the node belongs to the last row\\r\\n if(node.coords[0] != grid_dims[0] - 1) :\\r\\n connected_node = Node((node.coords[0] + 1, node.coords[1]), goal_pos, node.gn_value - 1)\\r\\n #Checking if the node is an obstacle\\r\\n if(not connected_node.coords in obstacle_coords) :\\r\\n connected_nodes.append(connected_node)\\r\\n\\r\\n #Checking if the node belongs to the 1st column\\r\\n if(node.coords[1] != 0) :\\r\\n connected_node = Node((node.coords[0], node.coords[1] - 1), goal_pos, node.gn_value - 1)\\r\\n #Checking if the node is an obstacle\\r\\n if(not connected_node.coords in obstacle_coords) :\\r\\n connected_nodes.append(connected_node)\\r\\n\\r\\n #Checking if the node belongs to the 1st column\\r\\n if(node.coords[1] != grid_dims[1] - 1) :\\r\\n connected_node = Node((node.coords[0], node.coords[1] + 1), goal_pos, node.gn_value - 1)\\r\\n #Checking if the node is an obstacle\\r\\n if(not connected_node.coords in obstacle_coords) :\\r\\n connected_nodes.append(connected_node)\\r\\n\\r\\n return connected_nodes\",\n \"def ConnectSocket(self) -> Socket:\",\n \"def get_node(self, _id):\\n return self.make_request(\\\"GET\\\", \\\"nodes/\\\"+_id, {})\",\n \"def _build_connection(self,\\n node,\\n source_port: PipelineNodeIO = None,\\n target_port: PipelineNodeIO = None,\\n filters: entities.Filters = None,\\n action: str = None) -> PipelineConnection:\\n if source_port is None and self.outputs:\\n source_port = self.outputs[0]\\n\\n if target_port is None and node.inputs:\\n target_port = node.inputs[0]\\n\\n if node.is_root():\\n self._pipeline.set_start_node(self)\\n\\n source_connection = PipelineConnectionPort(node_id=self.node_id, port_id=source_port.port_id)\\n target_connection = PipelineConnectionPort(node_id=node.node_id, port_id=target_port.port_id)\\n if action is None and source_port.actions is not None and source_port.actions != []:\\n action = source_port.actions[0]\\n connection = PipelineConnection(source=source_connection, target=target_connection, filters=filters,\\n action=action)\\n return connection\",\n \"def currentnode(version, url):\\n stm = shared_morphene_instance()\\n if mph.rpc is not None:\\n mph.rpc.rpcconnect()\\n offline = mph.offline\\n mph.move_current_node_to_front()\\n node = mph.get_default_nodes()\\n if version and not offline:\\n print(mph.get_blockchain_version())\\n return\\n elif version and offline:\\n print(\\\"Node is offline\\\")\\n return\\n if url and not offline:\\n print(mph.rpc.url)\\n return\\n t = PrettyTable([\\\"Key\\\", \\\"Value\\\"])\\n t.align = \\\"l\\\"\\n if not offline:\\n t.add_row([\\\"Node-Url\\\", mph.rpc.url])\\n else:\\n t.add_row([\\\"Node-Url\\\", node[0]])\\n if not offline:\\n t.add_row([\\\"Version\\\", mph.get_blockchain_version()])\\n else:\\n t.add_row([\\\"Version\\\", \\\"morphenepy is in offline mode...\\\"])\\n print(t)\",\n \"def openConnection():\\n connection = nj.GraphDatabase.driver(\\n uri=URI, auth=nj.basic_auth(USER, PASSWORD))\\n return connection\",\n \"def connect(self, host, password, bolt_port, http_port, use_bolt=False,\\n timeout=30):\\n\\n connected = False\\n # print(\\\"testing if we can connect at:\\\", http_port)\\n while timeout > 0:\\n try:\\n socket.create_connection((host, http_port), 1)\\n except socket.error:\\n timeout -= 1\\n time.sleep(1)\\n else:\\n connected = True\\n break\\n if not connected:\\n raise socket.timeout('timed out trying to connect to {}'.format(\\n host, http_port))\\n logging.debug(\\n \\\"connecting graph to http port: {} bolt_port: {} host: {}\\\".format(\\n http_port, bolt_port, host))\\n self.bolt_port = bolt_port\\n self.http_port = http_port\\n sys.stdout.write(\\n \\\"connecting to http port: {} bolt_port: {} host: {} bolt: {}\\\\n\\\".\\n format(http_port, bolt_port, host, use_bolt))\\n time.sleep(5)\\n\\n graph = Graph('http://{}:{}/db/data/'.format(host, self.http_port),\\n 'bolt://{}:{}/'.format(host, self.bolt_port),\\n bolt=use_bolt, password=password,\\n bolt_port=bolt_port,\\n http_port=http_port)\\n if self.debug:\\n watch(\\\"neo4j.bolt\\\")\\n logging.debug(\\\"connected\\\", graph)\\n return graph\",\n \"def add_node():\\n\\ttry:\\n\\t\\tif(check_entries()):\\n\\t\\t\\tserver_entry = [frame.entries[0].get(), str(frame.entries[1].get()+\\\".\\\"+frame.entries[2].get()+\\\".\\\"+frame.entries[3].get()+\\\".\\\"+frame.entries[4].get())]\\n\\t\\t\\tclient_entry = [frame.entries[5].get(), str(frame.entries[6].get()+\\\".\\\"+frame.entries[7].get()+\\\".\\\"+frame.entries[8].get()+\\\".\\\"+frame.entries[9].get())]\\n\\t\\t\\tconnection_lifetime = frame.entries[10].get()\\n\\t\\t\\tnetwork.add_connection(server_entry, client_entry, connection_lifetime);\\n\\n\\texcept ValueError as err:\\n\\t\\tfeedback.config(text=err)\",\n \"def create(self, connectionParams) :\\n conn = RemoteConnection(connectionParams)\\n\\n # Generate a unique id by which to refer to this connection in the future\\n id = str(uuid.uuid1())\\n\\n self.remoteConnections[id] = conn\\n return id\",\n \"def connect(self, node):\\n self._hostname = node['host']\\n node_hash = self._node_hash(node)\\n if node_hash in self.__existing_connections:\\n self._ssh = self.__existing_connections[node_hash]\\n else:\\n start = time()\\n self._ssh.connect(node['host'], username=node['username'],\\n password=node['password'])\\n self.__existing_connections[node_hash] = self._ssh\\n logger.trace('connect took {} seconds'.format(time() - start))\",\n \"def get_connection(self):\\n mess_start = '[LIDAR] '\\n # Wait for connection\\n if self.gui_message is not None:\\n self.gui_message.message(mess_start + 'Listening on port %i...' % self.port)\\n else:\\n print(mess_start + 'Listening on port %i...' % self.port)\\n self.sock.listen(1)\\n\\n # Accept connection\\n self.conn, self.addr = self.sock.accept()\\n if self.gui_message is not None:\\n self.gui_message.message(mess_start + 'Got connection from %s' % self.addr[0])\\n else:\\n print(mess_start + 'Got connection from %s' % self.addr[0])\\n self._queue.put(self.conn)\",\n \"def __create_node(self, from_node_id, to_node_id):\\n #ensure from_node_id and start_node_id is not the same\\n if from_node_id == to_node_id:\\n print(\\\"Cannot insert same node\\\")\\n return\\n \\n # 1. declare two variable nodes\\n n1 = n2 = None\\n \\n # 2. check if exist\\n for x in self.__node:\\n if x.getId()==from_node_id:\\n n1 = x\\n if x.getId()==to_node_id:\\n n2 = x\\n\\n # 3. if n1 or n2 is None, create from_node_id / to_node_id\\n if n1 is None:\\n n1 = Node(from_node_id)\\n self.__node.append(n1)\\n \\n if n2 is None:\\n n2 = Node(to_node_id)\\n self.__node.append(n2)\\n\\n #return from_node and to_node\\n return n1, n2\",\n \"def get_node_by_server(self, ip, port, is_register=False):\\n # print('List of nodes in stream ', self.get_server_address())\\n # for node in self.nodes:\\n # print(node.get_server_address(), node.is_register)\\n node_address = (Node.parse_ip(ip), port)\\n for node in self.nodes:\\n if node.get_server_address() == node_address and node.is_register == is_register:\\n return node\\n return None\",\n \"def get_node(self, name):\\n return self.source_net.nodes[name]\",\n \"def connections(self, src=False, dst=True, params=True): \\n conns = []\\n if params:\\n if src:\\n #grab the node params that this node is a src to\\n edges = self.parent.graph.out_edges(self, data=True) \\n conns.extend([ edge[2][\\\"dst_param\\\"] for edge in edges ])\\n if dst:\\n #grab the node param that this node is a dst to\\n edges = self.parent.graph.in_edges(self, data=True) \\n conns.extend([ edge[2][\\\"src_param\\\"] for edge in edges ])\\n else: \\n if src:\\n conns.extend(self.parent.graph.successors(self))\\n if dst:\\n conns.extend(self.parent.graph.predecessors(self))\\n \\n return conns\",\n \"def __init__(self, node_number, all_nodes):\\n self.self_host = 'localhost'\\n self.base_port = 5000\\n self.self_port = self.base_port + node_number\\n self.other_nodes = [(self.self_host, p)\\n for p in range(self.base_port + 1, self.base_port + all_nodes + 1)\\n if p != self.self_port]\\n self.other_nodes_len = all_nodes - 1\\n self.current_node = 0\",\n \"def _bddnode(root, lo, hi):\\n\\t# print(\\\"_bddnode\\\")\\n\\tif lo is hi:\\n\\t\\tnode = lo\\n\\telse:\\n\\t\\tkey = (root, lo, hi)\\n\\t\\ttry:\\n\\t\\t\\tnode = _NODES[key]\\n\\t\\texcept KeyError:\\n\\t\\t\\tnode = _NODES[key] = BDDNode(*key)\\n\\treturn node\",\n \"def nodes(topology):\\n return topology.nodes()\",\n \"def connect_node():\\n node_address = request.form[\\\"nodeadress_port\\\"]\\n # post_object = {\\n # 'Node address': node_address\\n # }\\n global CONNECTED_NODE_ADDRESS\\n CONNECTED_NODE_ADDRESS = \\\"http://\\\"+node_address\\n print(connect_node)\\n \\n return redirect('/transaction')\",\n \"def node(self):\\n return Node(self)\",\n \"def get_conn(self):\\n if self.game_request:\\n # Prima cerca di ricavare la connessione ciclando sulle connessioni\\n for connection in connections.values():\\n if connection.player == self:\\n return connection\\n\\n # Nell'eventualità remota che non ve la faccia prova nell'altro modo\\n try:\\n session = self.game_request.getSession()\\n except error.AlreadyCalled:\\n return None\\n if session in connections:\\n return connections[session]\\n\\n return None\",\n \"def make_connection( hostname, port = 4663 ):\\n \\tconnection = socket.socket();\",\n \"def get_node(self, name):\\n response = self.connection.request(action=\\\"/v1/containers/%s\\\" % name, method=\\\"GET\\\")\\n container = response.parse_body()\\n \\n try:\\n state = self.NODE_STATE_MAP[container['state']]\\n except KeyError:\\n state = NodeState.UNKNOWN\\n \\n return Node( id=container['name'],\\n name=container['name'],\\n state=state,\\n public_ips=container['ips'],\\n private_ips=[],\\n driver=self,\\n image=self.list_images()[0])\",\n \"async def get_best_node(\\n self, cache: Union[int, str, 'BaseCache'], key: Any = None, key_hint: 'IgniteDataType' = None\\n ) -> 'AioConnection':\\n conn = await self.random_node()\\n\\n if self.partition_aware and key is not None:\\n caches = self._caches_to_update_affinity()\\n if caches:\\n async with self._affinity_query_mux:\\n while True:\\n caches = self._caches_to_update_affinity()\\n if not caches:\\n break\\n\\n try:\\n full_affinity = await self._get_affinity(conn, caches)\\n self._update_affinity(full_affinity)\\n\\n asyncio.ensure_future(\\n asyncio.gather(\\n *[node.reconnect() for node in self._nodes if not node.alive],\\n return_exceptions=True\\n )\\n )\\n\\n break\\n except connection_errors:\\n # retry if connection failed\\n conn = await self.random_node()\\n pass\\n except CacheError:\\n # server did not create mapping in time\\n return conn\\n\\n c_id = cache.cache_id if isinstance(cache, BaseCache) else cache_id(cache)\\n parts = self._cache_partition_mapping(c_id).get('number_of_partitions')\\n\\n if not parts:\\n return conn\\n\\n key, key_hint = self._get_affinity_key(c_id, key, key_hint)\\n\\n hashcode = await key_hint.hashcode_async(key, client=self)\\n\\n best_node = self._get_node_by_hashcode(c_id, hashcode, parts)\\n if best_node:\\n return best_node\\n\\n return conn\",\n \"def get_connected_nodes(node, current_path_len) :\\r\\n\\r\\n connected_nodes = [] #A list of the connected nodes\\r\\n closed_list_coords = get_path_coordinates(closed_list)\\r\\n\\r\\n #Checking if the node belongs to the 1st row\\r\\n if(node.coords[0] != 0) :\\r\\n connected_node = Node((node.coords[0] - 1, node.coords[1]), goal_pos, current_path_len)\\r\\n #Checking if the node has already been traversed or is it is an obstacle\\r\\n if(not connected_node.coords in closed_list_coords and not connected_node.coords in obstacle_coords) :\\r\\n connected_nodes.append(connected_node)\\r\\n\\r\\n #Checking if the node belongs to the last row\\r\\n if(node.coords[0] != grid_dims[0] - 1) :\\r\\n connected_node = Node((node.coords[0] + 1, node.coords[1]), goal_pos, current_path_len)\\r\\n #Checking if the node has already been traversed or is it is an obstacle\\r\\n if(not connected_node.coords in closed_list_coords and not connected_node.coords in obstacle_coords) :\\r\\n connected_nodes.append(connected_node)\\r\\n\\r\\n #Checking if the node belongs to the 1st column\\r\\n if(node.coords[1] != 0) :\\r\\n connected_node = Node((node.coords[0], node.coords[1] - 1), goal_pos, current_path_len)\\r\\n #Checking if the node has already been traversed or is it is an obstacle\\r\\n if(not connected_node.coords in closed_list_coords and not connected_node.coords in obstacle_coords) :\\r\\n connected_nodes.append(connected_node)\\r\\n\\r\\n #Checking if the node belongs to the 1st column\\r\\n if(node.coords[1] != grid_dims[1] - 1) :\\r\\n connected_node = Node((node.coords[0], node.coords[1] + 1), goal_pos, current_path_len)\\r\\n #Checking if the node has already been traversed or is it is an obstacle\\r\\n if(not connected_node.coords in closed_list_coords and not connected_node.coords in obstacle_coords) :\\r\\n connected_nodes.append(connected_node)\\r\\n\\r\\n return connected_nodes\",\n \"def create_netmiko_connection(self, opt):\\n\\n key = opt['ip']\\n conn_list = ['None', 'None', 'None']\\n net_connect_dict = self._netmiko_connection\\n auth = (opt['username'], opt['password'])\\n if key not in net_connect_dict:\\n # case 1: No key create a connection\\n try:\\n net_connect = self._establish_netmiko_handler(opt, net_connect_dict)\\n if net_connect:\\n hashed_auth = self._hash_auth_string(auth)\\n conn_list[0] = net_connect\\n conn_list[1] = hashed_auth\\n conn_list[2] = threading.Lock()\\n net_connect_dict[key] = conn_list\\n except ValueError as err:\\n raise\\n except Exception as err:\\n raise\\n\\n else:\\n existing_hash = net_connect_dict[key][1]\\n conn_list = self._get_netmiko_connection(key)\\n conn_obj = conn_list[0]\\n if self._check_auth_string(existing_hash, auth):\\n # case 2: check if connection object is alive\\n if conn_obj.is_alive() is True:\\n conn_obj.set_base_prompt()\\n return\\n # case 3: Assume user value is new so delete existing\\n # and add new connection object for this\\n else:\\n #disconnect stale object\\n conn_list[2].acquire()\\n conn_obj.disconnect()\\n conn_list[2].release()\\n\\n # Existing object is not valid so clear and create new\\n # connection\\n del net_connect_dict[key]\\n try:\\n net_connect = self._establish_netmiko_handler(opt, net_connect_dict)\\n if net_connect:\\n new_hash = self._hash_auth_string(auth)\\n conn_list[0] = net_connect\\n conn_list[1] = new_hash\\n conn_list[2] = threading.Lock()\\n net_connect_dict[key] = conn_list\\n except ValueError as error:\\n raise\\n except Exception:\\n raise Exception\",\n \"def c2p_connection(self, u, v):\\n qnode = namedtuple('Node', 'asn path_type')\\n\\n q = list()\\n q.append(qnode(u, -1))\\n\\n visited = defaultdict(int)\\n\\n while q:\\n node = q.pop()\\n visited[node.asn] = 1\\n\\n if self.has_node(node.asn):\\n for neighbor in nx.all_neighbors(self, node.asn):\\n if visited[neighbor] != 1:\\n edge_data = self.get_edge_data(node.asn, neighbor)\\n\\n # c2p - p2c link\\n if edge_data[\\\"relationship\\\"] == -1:\\n if node.path_type == -1:\\n path_type = 0 if node.asn == edge_data[\\\"as2\\\"] else 1\\n else:\\n path_type = node.path_type\\n # c2p\\n if (node.asn == edge_data[\\\"as2\\\"] and path_type == 0)\\\\\\n or (node.asn == edge_data[\\\"as1\\\"] and path_type == 1):\\n if neighbor == v:\\n return True, -1 if path_type == 0 else 1\\n q.append(qnode(neighbor, path_type))\\n return False, None\",\n \"def connect(self, host, port, db):\\r\\n params = self.make_connection_params(host, port, db)\\r\\n return self.get_connection(params)\",\n \"def test_good_node():\\n node_a = Node({'A':['B','C']})\\n assert node_a.name == 'A'\\n assert node_a.connections == ['B','C']\",\n \"def connect_thread():\\n return factory.connect_thread(SlaveService, remote_service = SlaveService)\",\n \"def connect(self, node1, node2):\\n self.neighbour1 = node1\\n self.neighbour2 = node2\",\n \"def connection(composition):\\n return Connection(BASE_URL, 'http://localhost')\",\n \"def node(self, ident, time=None):\\n if time is not None:\\n ident = (ident, time)\\n return self._nodes[ident]\",\n \"def get_connection(hostname, logger):\\n return Connection(\\n hostname,\\n logger=logger,\\n sudo=needs_sudo(),\\n )\",\n \"async def get_connection(self, username: str, password: str) -> asyncssh.connect:\\n conn = await asyncssh.connect(self.ip, known_hosts=None, username=username, password=password,\\n server_host_key_algs=['ssh-rsa'])\\n # return created connection\\n return conn\",\n \"def get_connection(ssid,password):\\n # First check if there already is any connection:\\n if wlan_sta.isconnected():\\n return wlan_sta\\n\\n connected = False\\n try:\\n # ESP connecting to WiFi takes time, wait a bit and try again:\\n time.sleep(3)\\n if wlan_sta.isconnected():\\n return wlan_sta\\n\\n # Search WiFis in range\\n wlan_sta.active(True)\\n connected = do_connect(ssid,password)\\n\\n except OSError as e:\\n print(\\\"exception\\\", str(e))\\n\\n # start web server for connection manager:\\n # if not connected:\\n # connected = start()\\n\\n return wlan_sta if connected else None\",\n \"def get_conn(args):\\n\\n # connect this thing\\n from pyVmomi import vim\\n from pyVim.connect import SmartConnect, Disconnect\\n import atexit\\n try:\\n si = SmartConnect(host=args.host, port=args.port, user=args.user, pwd=args.password)\\n except Exception as exc:\\n if isinstance(exc, vim.fault.HostConnectFault) and '[SSL: CERTIFICATE_VERIFY_FAILED]' in exc.msg:\\n try:\\n import ssl\\n default_context = ssl._create_default_https_context\\n ssl._create_default_https_context = ssl._create_unverified_context\\n si = SmartConnect(\\n host=args.host,\\n port=args.port,\\n user=args.user,\\n pwd=args.password,\\n )\\n ssl._create_default_https_context = default_context\\n except Exception as exc1:\\n raise Exception(exc1)\\n else:\\n import ssl\\n context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)\\n context.verify_mode = ssl.CERT_NONE\\n si = SmartConnect(\\n host=args.host,\\n port=args.port,\\n user=args.user,\\n pwd=args.password,\\n sslContext=context)\\n atexit.register(Disconnect, si)\\n return si\",\n \"def establish_connection(self):\\r\\n\\r\\n #creates SSH connection and adds SSH key to .known_hosts\\r\\n self.ssh_conn = paramiko.SSHClient()\\r\\n self.ssh_conn.set_missing_host_key_policy(paramiko.AutoAddPolicy())\\r\\n\\r\\n try:\\r\\n self.ssh_conn.connect(**self.conn_parm)\\r\\n print \\\"Connected to %s\\\" % self.conn_parm['hostname']\\r\\n #testing: self.ssh_conn.close()\\r\\n except socket.error:\\r\\n print \\\"Connection Failed on device %s\\\" % self.conn_parm['hostname']\\r\\n\\r\\n #find prompt\\r\\n open_session = self.ssh_conn.invoke_shell()\\r\\n output = open_session.recv(1000)\\r\\n\\r\\n #testing: print output\\r\\n\\r\\n #go into Enable-Mode if not already in it\\r\\n if '#' not in output:\\r\\n open_session.send('enable\\\\n')\\r\\n time.sleep(1)\\r\\n open_session.send(self.password)\\r\\n open_session.send('\\\\n')\\r\\n else:\\r\\n print \\\"In Enable-Mode\\\"\\r\\n\\r\\n #turn off paging\\r\\n open_session.send('terminal length 0\\\\n')\\r\\n time.sleep(3)\\r\\n \\r\\n return open_session\",\n \"def create_graph_network(start_node, connections):\\n graph = nx.Graph()\\n graph.add_node(start_node)\\n print(connections.index)\\n graph.add_nodes_from(connections.index)\\n edge_list = list(zip(itertools.repeat(start_node), connections.index))\\n print(\\\"edge list is \\\", edge_list)\\n graph.add_edges_from(edge_list)\\n for i in graph.edges():\\n graph[i[0]][i[1]]['weight'] = connections.loc[i[1]]['count']\\n # graph[i[0]][i[1]]['proposal_number'] = connections.loc[i[1]]['proposal_number']\\n # graph[i[0]][i[1]]['institution'] = connections.loc[i[1]]['institution']\\n # graph[i[0]][i[1]]['proposal_title'] = connections.loc[i[1]]['proposal_title']\\n # graph[i[0]][i[1]]['project_status'] = connections.loc[i[1]]['project_status']\\n\\n # Adding random position data to the graph.\\n # pos = nx.spring_layout(graph, k=1)\\n pos = nx.circular_layout(graph)\\n nx.set_node_attributes(graph, 'pos', pos)\\n return graph\",\n \"def build_connection(self, src, tgt) -> NoReturn:\\n # If src and tgt are the same node, src not in node_collection or\\n # tgt not in node_collection,\\n # then skip this edge.\\n if src == tgt or src not in self._nodes_collection or tgt not in self._nodes_collection:\\n if src.split(':')[0] not in self._nodes_collection:\\n warnings.warn(f\\\"Graph construct a self-loop node {src}. Ignored.\\\")\\n return\\n\\n if tgt not in self._nodes_collection[src.split(':')[0]].successor_nodes:\\n self._nodes_collection[src.split(':')[0]].successor_nodes.append(tgt)\\n if src not in self._nodes_collection[tgt].precursor_nodes:\\n self._nodes_collection[tgt.split(':')[0]].precursor_nodes.append(src)\",\n \"def _build_connection(self, address, serverkey=None):\\n cn_uuid = self._address_to_uuid.get(address)\\n cn = None\\n if cn_uuid is not None:\\n cn = self._platform_connections.get(cn_uuid)\\n if cn is not None and cn.serverkey != serverkey:\\n cn.kill()\\n del self._platform_connections[cn_uuid]\\n cn = None\\n\\n if cn is None:\\n parsed = urlparse(address)\\n if parsed.scheme == 'tcp':\\n cn = Connection(address=address, serverkey=serverkey,\\n publickey=self.core.publickey,\\n secretkey=self.core.secretkey,\\n peer=VOLTTRON_CENTRAL_PLATFORM)\\n else:\\n cn = Connection(address=address, peer=VOLTTRON_CENTRAL_PLATFORM)\\n\\n assert cn.is_connected(), \\\"Connection unavailable for address {}\\\"\\\\\\n .format(address)\\n if cn_uuid is None:\\n cn_uuid = str(uuid.uuid4())\\n self._address_to_uuid[address] = cn_uuid\\n self._platform_connections[cn_uuid] = cn\\n return cn\",\n \"def get_node(self, name, create=False):\\n\\n try:\\n node = self.find_node(name, create)\\n except KeyError:\\n node = None\\n return node\",\n \"def GetCreateConnectionPoint(identifier, namespace, klass=Interface, initfunction=None, **parameters):\\n assert(issubclass(klass, ConnectionPoint))\\n return pynt.xmlns.GetCreateRDFObject(identifier=identifier, namespace=namespace, klass=klass, \\n verifyAttributes=False, initfunction=initfunction, **parameters)\",\n \"def request(self, nodes:NodeAssignment) -> ICommunicationController:\\n com_proc = self.__method(nodes)\\n com_ctrl = cc(com_proc)\\n time.sleep(2)\\n return com_ctrl\",\n \"def get_connection(self, command, args=()):\\n # TODO: find a better way to determine if connection is free\\n # and not havily used.\\n command = command.upper().strip()\\n is_pubsub = command in _PUBSUB_COMMANDS\\n if is_pubsub and self._pubsub_conn:\\n if not self._pubsub_conn.closed:\\n return self._pubsub_conn, self._pubsub_conn.address\\n self._pubsub_conn = None\\n for i in range(self.freesize):\\n conn = self._pool[0]\\n self._pool.rotate(1)\\n if conn.closed: # or conn._waiters: (eg: busy connection)\\n continue\\n if conn.in_pubsub:\\n continue\\n if is_pubsub:\\n self._pubsub_conn = conn\\n self._pool.remove(conn)\\n self._used.add(conn)\\n return conn, conn.address\\n return None, self._address # figure out\",\n \"def create_node(self, *labels, **props):\\n component = Node(*labels, **props)\\n self.graph.create(component)\\n return component\",\n \"def get_node(self, key: str) -> Node:\",\n \"def _get_connection(self, conf):\\n return get_session()\",\n \"def construct_connection(module):\\n connection = dict((k, module.params.get(k)) for k in (\\n 'id',\\n 'name',\\n 'description',\\n 'speed',\\n 'billing_term',\\n 'customer_networks',\\n 'primary_ocid',\\n 'secondary_ocid'\\n ))\\n connection.update(dict(\\n type='ORACLE_FAST_CONNECT',\\n high_availability=True,\\n location=get_object_link(module, '/locations', 'location_id', 'location_href'),\\n cloud_region=get_object_link(module, '/cloudRegions', 'cloud_region_id', 'cloud_region_href'),\\n nat=dict(\\n enabled=module.params.get('nat_enabled'),\\n mappings=[dict(native_cidr=nat_mapping)\\n for nat_mapping in module.params.get('nat_mappings')]\\n )\\n ))\\n connection = snake_dict_to_camel_dict(connection)\\n # Correct naming\\n connection.update(dict(\\n peering=dict(\\n type='PRIVATE',\\n primaryRemoteBgpIP=module.params.get('primary_remote_bgp_ip'),\\n primaryPureportBgpIP=module.params.get('primary_pureport_bgp_ip'),\\n secondaryRemoteBgpIP=module.params.get('secondary_remote_bgp_ip'),\\n secondaryPureportBgpIP=module.params.get('secondary_pureport_bgp_ip'),\\n ),\\n tags=module.params.get('tags')\\n ))\\n return connection\",\n \"def _search_connection(self, host, login, passwd, conn):\\n self._connections_lock.acquireRead()\\n try:\\n if (host in self._connections):\\n connections = self._connections[host]\\n\\n for connection in connections:\\n if (connection.login == login and connection.passwd == passwd and connection.type == conn):\\n return connection\\n finally:\\n self._connections_lock.release()\\n\\n return None\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.618464","0.61416286","0.6074083","0.60132295","0.6008891","0.59954274","0.5794639","0.57695985","0.5758491","0.5756829","0.5743585","0.56941","0.5691204","0.56248885","0.5612602","0.5611256","0.56028306","0.5598274","0.558752","0.55844176","0.5578297","0.5544518","0.5522329","0.5507401","0.54872817","0.5469061","0.5465461","0.5462967","0.54529774","0.5442289","0.5424502","0.5423858","0.54230034","0.5420269","0.54122484","0.5410896","0.5406346","0.5383115","0.53804904","0.53756964","0.5352793","0.53515166","0.5337642","0.53338647","0.5331584","0.5331584","0.5319213","0.531301","0.5303749","0.52972895","0.52971077","0.5293022","0.5290558","0.52851325","0.5278926","0.5278307","0.52776295","0.5275513","0.52728486","0.52613807","0.5254536","0.5253332","0.52505517","0.52491724","0.5238479","0.52331084","0.52287066","0.5225033","0.52186143","0.52108186","0.52093613","0.52067417","0.5202502","0.5202334","0.51829314","0.51779217","0.51694137","0.5146894","0.51438725","0.51421106","0.5138351","0.513286","0.5124465","0.51218337","0.5118801","0.5109724","0.5108516","0.5105781","0.5100815","0.50975513","0.50959224","0.5092069","0.5088504","0.50878316","0.50875556","0.5085691","0.50856286","0.50855994","0.50829613","0.5081006"],"string":"[\n \"0.618464\",\n \"0.61416286\",\n \"0.6074083\",\n \"0.60132295\",\n \"0.6008891\",\n \"0.59954274\",\n \"0.5794639\",\n \"0.57695985\",\n \"0.5758491\",\n \"0.5756829\",\n \"0.5743585\",\n \"0.56941\",\n \"0.5691204\",\n \"0.56248885\",\n \"0.5612602\",\n \"0.5611256\",\n \"0.56028306\",\n \"0.5598274\",\n \"0.558752\",\n \"0.55844176\",\n \"0.5578297\",\n \"0.5544518\",\n \"0.5522329\",\n \"0.5507401\",\n \"0.54872817\",\n \"0.5469061\",\n \"0.5465461\",\n \"0.5462967\",\n \"0.54529774\",\n \"0.5442289\",\n \"0.5424502\",\n \"0.5423858\",\n \"0.54230034\",\n \"0.5420269\",\n \"0.54122484\",\n \"0.5410896\",\n \"0.5406346\",\n \"0.5383115\",\n \"0.53804904\",\n \"0.53756964\",\n \"0.5352793\",\n \"0.53515166\",\n \"0.5337642\",\n \"0.53338647\",\n \"0.5331584\",\n \"0.5331584\",\n \"0.5319213\",\n \"0.531301\",\n \"0.5303749\",\n \"0.52972895\",\n \"0.52971077\",\n \"0.5293022\",\n \"0.5290558\",\n \"0.52851325\",\n \"0.5278926\",\n \"0.5278307\",\n \"0.52776295\",\n \"0.5275513\",\n \"0.52728486\",\n \"0.52613807\",\n \"0.5254536\",\n \"0.5253332\",\n \"0.52505517\",\n \"0.52491724\",\n \"0.5238479\",\n \"0.52331084\",\n \"0.52287066\",\n \"0.5225033\",\n \"0.52186143\",\n \"0.52108186\",\n \"0.52093613\",\n \"0.52067417\",\n \"0.5202502\",\n \"0.5202334\",\n \"0.51829314\",\n \"0.51779217\",\n \"0.51694137\",\n \"0.5146894\",\n \"0.51438725\",\n \"0.51421106\",\n \"0.5138351\",\n \"0.513286\",\n \"0.5124465\",\n \"0.51218337\",\n \"0.5118801\",\n \"0.5109724\",\n \"0.5108516\",\n \"0.5105781\",\n \"0.5100815\",\n \"0.50975513\",\n \"0.50959224\",\n \"0.5092069\",\n \"0.5088504\",\n \"0.50878316\",\n \"0.50875556\",\n \"0.5085691\",\n \"0.50856286\",\n \"0.50855994\",\n \"0.50829613\",\n \"0.5081006\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.53575635"},"document_rank":{"kind":"string","value":"40"}}},{"rowIdx":81993,"cells":{"query":{"kind":"string","value":"Create a management node proxy using the given connection."},"document":{"kind":"string","value":"def __init__(self, connection, path, locales=None):\n self.name = self.identity = 'self'\n self.type = 'org.amqp.management' # AMQP management node type\n self.locales = locales\n\n self.locales = locales\n self.url = Url(connection.url)\n self.url.path = path\n self.client = SyncRequestResponse(connection, self.url.path)\n self.reply_to = self.client.reply_to\n self.connection = connection"},"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":["async def _create_proxy(self):\n self._proxy = await self._controller.fopen_tcp_proxy(\n Cellular._DRONE_WEB_API_PORT\n )\n\n self._drone_http_url = f\"http://{self._proxy.address}:{self._proxy.port}\"\n\n if self._autoconfigure and self._user_apc_token is None:\n self.logger.info(\"cellular auto pairing and configuration\")\n # generate a new anonymous user APC token and configure the cellular.\n self._fautoconfigure_with_new_token()","def create(addr='127.0.0.1', port=0, options=None):\n if options is None:\n options = {}\n\n backend = MitmProxy(addr, port, options)\n\n t = threading.Thread(name='Selenium Wire Proxy Server', target=backend.serve_forever)\n t.daemon = not options.get('standalone')\n t.start()\n\n addr, port, *_ = backend.address()\n log.info('Created proxy listening on %s:%s', addr, port)\n\n return backend","def repository_create_proxy():\n pass","def create(self, upstream, name, listen=None, enabled=None):\n\n if name in self.proxies():\n raise_with_traceback(ProxyExists(\"This proxy already exists.\"))\n\n # Lets build a dictionary to send the data to the Toxiproxy server\n json = {\n \"upstream\": upstream,\n \"name\": name\n }\n\n if listen is not None:\n json[\"listen\"] = listen\n else:\n json[\"listen\"] = \"127.0.0.1:0\"\n if enabled is not None:\n json[\"enabled\"] = enabled\n\n proxy_info = APIConsumer.post(\"/proxies\", json=json).json()\n proxy_info[\"api_consumer\"] = APIConsumer\n\n # Lets create a Proxy object to hold all its data\n proxy = Proxy(**proxy_info)\n\n return proxy","def CreateProxy(self, request):\n try:\n params = request._serialize()\n headers = request.headers\n body = self.call(\"CreateProxy\", params, headers=headers)\n response = json.loads(body)\n model = models.CreateProxyResponse()\n model._deserialize(response[\"Response\"])\n return model\n except Exception as e:\n if isinstance(e, TencentCloudSDKException):\n raise\n else:\n raise TencentCloudSDKException(type(e).__name__, str(e))","def _create_connection(self):\n if not self.connection:\n log.info(\"{}: Creating connection with address={}\".format(\n self.container_id, self.address.geturl()))\n self.connection = Connection(\n self.address.hostname,\n self.auth,\n container_id=self.container_id,\n properties=self._create_properties(),\n debug=self.debug)","def create_connection(location=None, bandwidth=None, connectionName=None):\n pass","def __init__(self, host, redis_port, ssh_user, use_ssh=True):\n\n if use_ssh:\n forwarder = create_tunnel(host=host, port=redis_port, ssh_user=ssh_user)\n self.connection = redis.StrictRedis(host=forwarder.bind_address, port=forwarder.bind_port, db=0)\n else:\n self.connection = redis.StrictRedis(host=host, port=redis_port, db=0)","def new(configuration: Mapping[str, Any], loop: AbstractEventLoop) \\\n -> ProxyProtocol:\n return SocksProxy(loop)","def init(opts):\n opts[\"multiprocessing\"] = False\n log.debug(\"Opening connection to junos\")\n\n args = {\"host\": opts[\"proxy\"][\"host\"]}\n optional_args = [\n \"user\",\n \"username\",\n \"password\",\n \"passwd\",\n \"port\",\n \"gather_facts\",\n \"mode\",\n \"baud\",\n \"attempts\",\n \"auto_probe\",\n \"ssh_private_key_file\",\n \"ssh_config\",\n \"normalize\",\n \"huge_tree\",\n ]\n\n if \"username\" in opts[\"proxy\"].keys():\n opts[\"proxy\"][\"user\"] = opts[\"proxy\"].pop(\"username\")\n proxy_keys = opts[\"proxy\"].keys()\n for arg in optional_args:\n if arg in proxy_keys:\n args[arg] = opts[\"proxy\"][arg]\n log.debug(\"Args: %s\", args)\n thisproxy[\"conn\"] = jnpr.junos.Device(**args)\n try:\n thisproxy[\"conn\"].open()\n except (\n ProbeError,\n ConnectAuthError,\n ConnectRefusedError,\n ConnectTimeoutError,\n ConnectError,\n ) as ex:\n log.error(\"%s : not able to initiate connection to the device\", ex)\n thisproxy[\"initialized\"] = False\n return\n\n if \"timeout\" in proxy_keys:\n timeout = int(opts[\"proxy\"][\"timeout\"])\n try:\n thisproxy[\"conn\"].timeout = timeout\n except Exception as ex: # pylint: disable=broad-except\n log.error(\"Not able to set timeout due to: %s\", str(ex))\n else:\n log.debug(\"RPC timeout set to %d seconds\", timeout)\n\n try:\n thisproxy[\"conn\"].bind(cu=jnpr.junos.utils.config.Config)\n except Exception as ex: # pylint: disable=broad-except\n log.error(\"Bind failed with Config class due to: %s\", ex)\n\n try:\n thisproxy[\"conn\"].bind(sw=jnpr.junos.utils.sw.SW)\n except Exception as ex: # pylint: disable=broad-except\n log.error(\"Bind failed with SW class due to: %s\", ex)\n thisproxy[\"initialized\"] = True","def openProxy(self):\n self.state = ZenProcessTask.STATE_CONNECTING\n if (self.snmpProxy is None or\n self.snmpProxy.snmpConnInfo != self.snmpConnInfo):\n self.snmpProxy = self.snmpConnInfo.createSession()\n self.snmpProxy.open()","def _NewConnection(self, *args, **kwargs):\n return Connection(*args, dhcp_method=Connection.DHCP_DHCPCD, **kwargs)","def connection_proxmox(config):\n return ProxmoxAPI(\n config[\"host\"],\n user=config[\"user\"],\n password=config[\"password\"],\n verify_ssl=config[\"verify_ssl\"],\n )","def createMachine():\n cd('/')\n machine = create(machineName, 'UnixMachine')\n cd('Machines/'+machineName+'/NodeManager/'+machineName)\n cmo.setName(machineName)\n cmo.setListenAddress(hostname)","def make_connection( hostname, port = 4663 ):\n \tconnection = socket.socket();","def _make_connection(self, callback):\n if isinstance(callback, MethodType):\n connection = _MethodConnection(self, callback)\n else:\n connection = _DirectConnection(self, callback)\n return connection","def nxos_connect(self, nexus_host, nexus_ssh_port, nexus_user,\n nexus_password):\n man = manager.connect(host=nexus_host, port=nexus_ssh_port,\n username=nexus_user, password=nexus_password)\n return man","def __init__(self, connection):\n\t\tself.name = None\n\t\tself.remote_player_proxy = RemotePlayerProxy(connection)","def create_outbound(self, addr, use_new_connection=False):","def new_connection(self, host=None, port=None, timeout=45):\n if self._conn:\n self._conn.close()\n\n if not host:\n host = self._host\n port = self._port\n self._host = host\n self._port = port\n host_display = host + (':%d' % port if port else '')\n\n proxy = self._proxy\n if proxy:\n logger.debug('Connecting to proxy server %s', proxy)\n self._conn = TLS1_2Connection(proxy, timeout=timeout)\n\n logger.debug('Tunneling to host %s' % host_display)\n self._conn.set_tunnel(host, port=port)\n\n try:\n self._conn.connect()\n except Exception as e:\n msg = 'Failed to connect to proxy server %s: %s.' % (proxy, e)\n raise DDGConnectionError(msg)\n else:\n logger.debug('Connecting to new host %s', host_display)\n self._conn = TLS1_2Connection(host, port=port, timeout=timeout)\n try:\n self._conn.connect()\n except Exception as e:\n msg = 'Failed to connect to %s: %s.' % (host_display, e)\n raise DDGConnectionError(msg)","def _NewConnection(self, *args, **kwargs):\n kwargs.setdefault('dhcp_method', Connection.DHCP_DHCPCD)\n\n return Connection(*args, **kwargs)","def createManagedDomain():\n selectCustomTemplate(localTemplate)\n loadTemplates()\n # set the Node Manager listen address and listen port.\n cd('/')\n cd('NMProperties')\n set('ListenAddress', hostname)\n #create the domain\n writeDomain(domainPath)","def create_node(self, node_cfg):\n with self.__connect_node(node_cfg) as conn:\n self._provision_node(conn, node_cfg)\n self._bootup_node(conn)","def create_proxy(proxyname):\n # Running in a software collection?\n enable_scls = []\n scls = os.environ.get('X_SCLS', '')\n for scl in scls.split():\n with open('/etc/scl/conf/{}'.format(scl)) as fin:\n prefix = fin.readline().rstrip()\n enable_scls.append('. {}/{}/enable'.format(prefix, scl))\n if scls:\n enable_scls.append('X_SCLS={}'.format(shlex.quote(scls)))\n enable_scls.append('export X_SCLS')\n else:\n enable_scls.append('# No software collections enabled.')\n enable_scls = '\\n'.join(enable_scls)\n # Running in a virtualenv?\n venv = os.environ.get('VIRTUAL_ENV')\n enable_venv = '. {}/bin/activate'.format(venv) if venv else '# No virtualenv enabled.'\n # Create the ~/bin directory if needed\n bindir = os.path.join(util.get_homedir(), 'bin')\n proxyfile = os.path.join(bindir, proxyname)\n util.create_directory(bindir, 0o755)\n contents = textwrap.dedent(\"\"\"\\\n #!/bin/sh\n {}\n {}\n exec python -mravstack.proxy\n \"\"\").format(enable_scls, enable_venv)\n with open(proxyfile, 'w') as fout:\n fout.write(contents)\n os.chmod(proxyfile, 0o700)\n return proxyfile","def remote_createNode(self, pkg, exe, args, name, namespace):\r\n return Node(self, pkg, exe, args, name, namespace)","def do_create(env):\n keyname = env.config['proxy']['key_name']\n proxyname = env.config['proxy']['proxy_name']\n keyfile = create_ssh_keypair(keyname, proxyname)\n proxyfile = create_proxy(proxyname)\n install_proxy(keyfile + '.pub', proxyfile)\n test_proxy(keyfile)\n print('Private key created as: `~/.ssh/{}`.'.format(keyname))\n print('Proxy created at: `~/bin/{}`.'.format(proxyname))","def __init__(self):\r\n self.isConnected, self.atSchool = getNetStatus()\r\n self._token = None\r\n \r\n if self.atSchool:\r\n #print(\"at school\")\r\n urllib.request.install_opener(urllib.request.build_opener(urllib.request.ProxyHandler({'http': 'http://:@proxy.intranet:8080', 'https': 'http://:@proxy.intranet:8080'})))","def test_settings_proxies_creation() -> None:\n settings = Settings()\n\n settings_proxy = settings.create_proxy() # We have one proxy\n assert len(settings._proxies) == 1\n\n second_proxy = settings.create_proxy() # Now we have two proxies\n assert len(settings._proxies) == 2\n\n # We are creating the third one, but the original `settings_proxy` is dereferenced\n settings_proxy = settings.create_proxy()\n assert len(settings._proxies) == 2\n\n del second_proxy\n assert len(settings._proxies) == 1\n\n del settings_proxy\n assert len(settings._proxies) == 0","def test_create_hyperflex_proxy_setting_policy(self):\n pass","def create(self, connectionParams) :\n conn = RemoteConnection(connectionParams)\n\n # Generate a unique id by which to refer to this connection in the future\n id = str(uuid.uuid1())\n\n self.remoteConnections[id] = conn\n return id","def handle_node(self, request):\n \"\"\"\n @api {ANY} /node/:node/:uri Proxy a request\n @apiName ProxyToNode\n @apiGroup Misc\n @apiVersion 1.0.0\n\n @apiDescription Proxy the request :uri to the node :node, and forward the response.\n\n @apiParam {string} :node Node name.\n @apiParam {string} :uri URI.\n \"\"\"\n\n match = re.match('/node/([^/]+)(/.+)', request.uri_path)\n node = match.group(1)\n uri = match.group(2)\n\n if node not in self.cluster.nodes:\n return HTTPReply(code = 404, headers = { 'Content-Type': 'application/javascript', 'Access-Control-Allow-Origin': '*' }, body = '{ \"message\": \"Node not found\" }')\n\n addr = parse_host_port(self.cluster.nodes[node][\"address\"])\n\n client = HTTPClient(addr)\n return client.request(HTTPRequest(uri = uri, method = request.method, body = request.body))","def __new__(cls, connection):\n return object.__new__(cls)","def create_remote_access(self, info):\n if info:\n response = self._request(\"POST\", [ROUTE_REMOTE_ACCESSES], {\n \"type\": info[\"type\"],\n \"address\": info[\"address\"],\n \"port\": info[\"port\"],\n \"login\": info[\"login\"],\n \"password\": info[\"password\"],\n \"key\": info[\"key\"],\n \"node\": info[\"node\"]\n })\n logging.debug(\"Create connexion remote access::{}\".format(response.text))\n if self.verif_response(response):\n logging.info('remote access successfully created {}'.format(info[\"address\"]))\n return CBWParser().parse_response(CBWRemoteAccess, response)\n\n logging.error(\"Error create connection remote access\")\n return False","def repository_create_proxy_recipe(ctx: click.Context, **kwargs):\n _create_repository(ctx, 'proxy', **kwargs)","def __init__(self, *args, **kvargs):\n self.proxy_host = kvargs.get('proxy_host')\n self.proxy_user = kvargs.get('proxy_user')\n self.proxy_password = kvargs.get('proxy_password')\n self.proxy_port = kvargs.get('proxy_port')\n self.proxy_ssh_key_file = kvargs.get('proxy_ssh_key')\n self.proxy_connection = False\n self.host = kvargs.get('host')\n self.user = kvargs.get('user')\n self.password = kvargs.get('password')\n self.port = kvargs.get('port')\n self.dest_connection = False\n\n try:\n # Add host key policy\n if self.proxy_port is None:\n self.proxy_port = 22\n self.transport = paramiko.Transport((self.proxy_host, self.proxy_port))\n self.transport.start_client()\n if self.proxy_ssh_key_file:\n self.proxy_ssh_key = paramiko.RSAKey.from_private_key_file(self.proxy_ssh_key_file)\n conn_result = self.transport.auth_publickey(username=self.proxy_user, key=self.proxy_ssh_key)\n else:\n conn_result = self.transport.auth_password(username=self.proxy_user, password=self.proxy_password)\n if len(conn_result) == 0:\n self.proxy_connection = True\n else:\n logging.error('Unable to connect to proxy host. Authentication failed.')\n raise TobyException('Unable to connect to proxy host. Authentication failed.')\n except Exception as exp:\n logging.error('Unable to connect to proxy host: %s' % exp)\n raise TobyException('Unable to connect to proxy host: %s' % exp)\n\n try:\n if self.port is None:\n self.port = 22\n self.tunnel = paramiko.Transport(self.transport.open_channel(\n kind='direct-tcpip',\n dest_addr=(self.host, self.port),\n src_addr=('127.0.0.1', 0)))\n self.tunnel.start_client()\n conn_result = self.tunnel.auth_password(username=self.user, password=self.password)\n if len(conn_result) == 0:\n self.dest_connection = True\n else:\n logging.error('Unable to connect to destination host. Authentication failed.')\n raise TobyException('Unable to connect to destination host. Authentication failed.')\n except Exception as exp:\n logging.error('Unable to connect to destination host: %s' % exp)\n raise TobyException('Unable to connect to destination host: %s' % exp)\n\n try:\n self.handle = self.tunnel.open_session(20)\n self.handle.get_pty(width=160, height=0)\n self.handle.invoke_shell()\n self.handle.set_combine_stderr(True)\n self.handle.settimeout(60)\n tnh = self.handle\n got = []\n while True:\n _rd, _wr, _err = select([tnh], [], [], 10)\n if _rd:\n data = tnh.recv(1024)\n data = data.decode(\"utf-8\")\n got.append(data)\n if re.search('> ', data):\n tnh.send(b' start shell\\n')\n data = tnh.recv(1024)\n data = data.decode(\"utf-8\")\n if re.search(r'(\\$|>|#|%)[\\s\\t]?', data):\n break\n except Exception as exp:\n logging.error(\n 'Unable to fetch the prompt on destination host: %s' % exp)\n raise TobyException(\n 'Unable to fetch the prompt on destination host: %s' % exp)","def setup_class(cls):\n cls.cwd = os.getcwd()\n cls.t = tempfile.mkdtemp()\n os.chdir(cls.t)\n\n temp_dir = os.path.join(cls.t, \"temp_dir_node\")\n os.mkdir(temp_dir)\n cls.connection_node = _make_libp2p_connection(data_dir=temp_dir, delegate=True)\n temp_dir_client = os.path.join(cls.t, \"temp_dir_client\")\n os.mkdir(temp_dir_client)\n cls.connection = _make_libp2p_client_connection(\n data_dir=temp_dir_client, peer_public_key=cls.connection_node.node.pub\n )","def repository_create_proxy_yum(ctx: click.Context, **kwargs):\n _create_repository(ctx, 'proxy', **kwargs)","def repository_create_proxy_maven(ctx: click.Context, **kwargs):\n _create_repository(ctx, 'proxy', **kwargs)","def switch_proxy(self, proxy):","def setproxy(self,proxytype=None,addr=None,port=None,rdns=True,username=None,password=None):\r\n self.__proxy = (proxytype,addr,port,rdns,username,password)","def makeConnection(self, transport):\n pass","def new(sock, info=None):\n return ProxyPlayer(sock, info)","def createWrapper():\n\n # read properties file and get MANO name and IP\n config = RawConfigParser()\n config.read(\"../../coreMano/coreMano.properties\")\n name = config.get(\"CoreMano\", \"coreMano.name\")\n host_ip = config.get(\"CoreMano\", \"coreMano.ip\")\n\n # instanciate and return the MANO\n if name == \"osm\":\n mano = OsmWrapper(name, host_ip)\n if name == \"cloudify\":\n mano = CloudifyWrapper(name, host_ip)\n return mano","def create_netmiko_connection(self, opt):\n\n key = opt['ip']\n conn_list = ['None', 'None', 'None']\n net_connect_dict = self._netmiko_connection\n auth = (opt['username'], opt['password'])\n if key not in net_connect_dict:\n # case 1: No key create a connection\n try:\n net_connect = self._establish_netmiko_handler(opt, net_connect_dict)\n if net_connect:\n hashed_auth = self._hash_auth_string(auth)\n conn_list[0] = net_connect\n conn_list[1] = hashed_auth\n conn_list[2] = threading.Lock()\n net_connect_dict[key] = conn_list\n except ValueError as err:\n raise\n except Exception as err:\n raise\n\n else:\n existing_hash = net_connect_dict[key][1]\n conn_list = self._get_netmiko_connection(key)\n conn_obj = conn_list[0]\n if self._check_auth_string(existing_hash, auth):\n # case 2: check if connection object is alive\n if conn_obj.is_alive() is True:\n conn_obj.set_base_prompt()\n return\n # case 3: Assume user value is new so delete existing\n # and add new connection object for this\n else:\n #disconnect stale object\n conn_list[2].acquire()\n conn_obj.disconnect()\n conn_list[2].release()\n\n # Existing object is not valid so clear and create new\n # connection\n del net_connect_dict[key]\n try:\n net_connect = self._establish_netmiko_handler(opt, net_connect_dict)\n if net_connect:\n new_hash = self._hash_auth_string(auth)\n conn_list[0] = net_connect\n conn_list[1] = new_hash\n conn_list[2] = threading.Lock()\n net_connect_dict[key] = conn_list\n except ValueError as error:\n raise\n except Exception:\n raise Exception","def create_connection(address):\n\n sock = socks.socksocket()\n sock.connect(address)\n return sock","def make_connection(self):\n if self._created_connections() >= self.max_connections:\n raise ConnPoolException(\"Too many connections.\")\n connection = self.connection_class(**self.connection_kwargs)\n connection.connect()\n return connection","async def create(cls, host: str, port: Union[int, str]) -> Connection:\n self = cls()\n self.reader, self.writer = await asyncio.open_connection(host, port)\n return self","def setUp(self):\n self.clnt = CvpClient()\n nodes = [\"1.1.1.1\"]\n self.clnt.nodes = nodes\n self.clnt.node_cnt = len(nodes)\n self.clnt.node_pool = cycle(nodes)\n self.api = CvpApi(self.clnt)","def createTunnel(self, name, targetIP):\r\n return self._ref.callRemote('createTunnel', name, targetIP)","def create_connection():\n # REDIS_URL is defined in .env and loaded into the environment by Honcho\n redis_url = os.getenv('REDIS_URL')\n # If it's not defined, use the Redis default\n if not redis_url:\n redis_url = 'redis://localhost:6379'\n urlparse.uses_netloc.append('redis')\n url = urlparse.urlparse(redis_url)\n return redis.StrictRedis(\n host=url.hostname,\n port=url.port,\n db=0,\n password=url.password\n )","def startNode(klass):\n try:\n ws = klass('ws://localhost:8080/ws')\n ws.daemon = False\n ws.connect()\n except:\n ws.close()","def connect(cls, url=None, router=None, timeout=10, ssl_domain=None, sasl=None, edge_router=None):\n url_ = Url(url) # Convert string to Url class.\n\n if url_.path is not None:\n path = url_.path\n elif router:\n path = '_topo/0/%s/$management' % router\n elif edge_router:\n path = '_edge/%s/$management' % edge_router\n else:\n path = u'$management'\n connection = BlockingConnection(url,\n timeout=timeout,\n ssl_domain=ssl_domain,\n sasl_enabled=bool(ssl_domain or sasl),\n allowed_mechs=str(sasl.mechs) if sasl and sasl.mechs is not None else None,\n user=str(sasl.user) if sasl and sasl.user is not None else None,\n password=str(sasl.password) if sasl and sasl.password is not None else None)\n try:\n return cls(connection, path)\n except Exception:\n # ownership of connection has not been given to a new Node; close the connection\n connection.close()\n raise","def _connect_gen(\n cls: Type[ConnectionType],\n conninfo: str = \"\",\n *,\n autocommit: bool = False,\n ) -> PQGenConn[ConnectionType]:\n pgconn = yield from connect(conninfo)\n conn = cls(pgconn)\n conn._autocommit = bool(autocommit)\n return conn","def install_connection(connection):\n global _connection\n _connection = connection","def __init__(self, server, ressource):\n self.server = server\n local_url = \"http://%s:%d/xmlrpc/common\" % (\n server.server_url,\n server.server_port,\n )\n rpc = ServerProxy(local_url)\n self.uid = rpc.login(server.server_db, server.login, server.password)\n local_url = \"http://%s:%d/xmlrpc/object\" % (\n server.server_url,\n server.server_port,\n )\n self.rpc = ServerProxy(local_url)\n self.ressource = ressource","def rpc_create_connection(client, source, dest,crypto=\"btc\",\n rpc_user=BTC_RPC_USER, rpc_password=BTC_RPC_PASSWD, rpc_port=BTC_RPC_PORT):\n try:\n if(crypto==\"btc\"):\n rpc_server = get_ip_by_unknown(client, source)\n dest = get_ip_by_unknown(client, dest)\n else:\n rpc_server = get_ip_by_unknown(client, source,DOCK_NETWORK_NAME_ZCH)\n dest = get_ip_by_unknown(client, dest, DOCK_NETWORK_NAME_ZCH)\n #print rpc_user+\" \"+rpc_password+\" \"+rpc_server+ \" \"+str(rpc_port)\n rpc_connection = AuthServiceProxy(\"http://%s:%s@%s:%s\" % (rpc_user, rpc_password, rpc_server, rpc_port))\n rpc_connection.addnode(dest, \"add\")\n return True\n except JSONRPCException as err:\n print(err)\n return False","def set_proxy(self, host: str, port: int,\n proxy_type=ProxyTypes.Http,\n secret='', # for Mtproto\n username='',\n password='',\n http_only=False, # For HTTP: Pass true, if the proxy supports only HTTP requests and doesn't support\n # transparent TCP connections via HTTP CONNECT method.\n check_proxy=True) -> None:\n self.remove_proxy()\n\n proxy_type_obj = {\n '@type': proxy_type,\n 'secret': secret,\n 'http_only': http_only,\n 'username': username,\n 'password': password,\n }\n\n self.call_method('addProxy', server=host, port=port, enable=True, type=proxy_type_obj)\n\n if check_proxy:\n self.check_proxy()","def create_manager(self, username, tenancy):\n raise NotImplementedError","def connect_multiplexer(multiplexer):","def create_gateway():\n # Start the gateway to connect with py4j\n if 'gateway' not in os.popen('jps').read():\n os.system('java gateway &')\n delay(0.5)\n LOGGER.debug('Started Java gateway')\n # Connect to gateway getting jvm object\n LOGGER.debug('Connecting to gateway from py4j')\n gate = JavaGateway()\n return gate","def make_new_connection(\n self,\n proto_handle,\n own_addr,\n source_addr,\n relay_addr\n ):\n handler = self.handler_factory.make_new_handler(\n own_addr,\n source_addr,\n relay_addr\n )\n connection = Connection(\n proto_handle,\n handler,\n own_addr,\n source_addr,\n relay_addr\n )\n handler.connection = connection\n return connection","def connect(self):\n self.connection = redis.Redis(\n host=self.host,\n port=self.port,\n socket_connect_timeout=self.timeout,\n socket_timeout=self.timeout\n )","def __init__(self, ip, port, automatic = True, control_buf_size = 32, data_buf_size = 128, \\\n m_to = 0.01, socket_to = 0.005):\n self.conn = Connector(ip, port, control_buf_size, data_buf_size, socket_to)\n self.conn.connect()\n self.m_to = m_to\n self.status = Modem.Status.IDLE\n self.node_status = 0\n self.automatic = automatic\n self.interpreter = Interpreter()\n self.mainPID = os.getpid()\n self.error_status = Modem.ErrorDict.NONE\n self.commands_queue = \"\".split(Interpreter.END_COMMAND)\n if automatic:\n thread.start_new_thread(self.run,())","def setup_gateway(self, args):\n if args.preponly:\n return\n\n # edit the gateway properties file and restart the gateway\n # mdm.ip.addresses = <addresses of node0,node1>\n # security.bypass_certificate_check = true\n _config = '/opt/emc/scaleio/gateway/webapps/ROOT/WEB-INF/classes/gatewayUser.properties'\n _commands = []\n #_commands.append(\"sed -i 's|^mdm.ip.addresses.*|mdm.ip.addresses={},{}|' {}\".format(args.IP[0], args.IP[1], _config))\n #_commands.append(\"sed -i 's|^security.bypass_certificate_check.*|security.bypass_certificate_check=true|' {}\".format( _config))\n _commands.append(\"systemctl restart scaleio-gateway\")\n self.node_execute_multiple(args.IP[2], args.USERNAME, args.PASSWORD, _commands)\n return","def repository_create_proxy_docker(ctx: click.Context, **kwargs):\n _create_repository(ctx, 'proxy', **kwargs)","def __call__(self, proxy):\n return LocalProxy(self, proxy)","def __call__(self, proxy):\n return LocalProxy(self, proxy)","def repository_create_proxy_apt(ctx: click.Context, **kwargs):\n _create_repository(ctx, 'proxy', **kwargs)","def test_add_proxy():\n result = False\n\n proxy = {\n \"name\": \"proxy\",\n \"address\": \"proxy.ntnxlab.local\",\n \"port\": \"8080\",\n \"http\": True,\n \"https\": True,\n \"socks\": False,\n \"username\": '',\n \"password\": '',\n }\n\n cluster_obj = prism.Cluster(api_client=_api())\n config_obj = prism.Config(api_client=_api())\n clusters = cluster_obj.get_all_uuids()\n for each_uuid in clusters:\n config_obj.set_proxy(address=proxy['address'], port=proxy['port'], name=proxy['name'], http=proxy['http'], https=proxy['https'],\n username=proxy['username'], password=proxy['password'], socks=proxy['socks'], clusteruuid=each_uuid)\n cluster_proxy = config_obj.get_proxy(clusteruuid=each_uuid)\n\n if proxy['address'] == cluster_proxy[0]['address']:\n result = True\n\n assert result","def expand(self):\n try:\n self.create_connection()\n except Exception as excpt:\n print(excpt)","def _clone_node(self, node):\n spec = node.gateway.spec\n spec.id = None\n self.nodemanager.group.allocate_id(spec)\n node = self.nodemanager.setup_node(spec, self.queue.put)\n self._active_nodes.add(node)\n return node","def _repo_manager(repo_conn):\n util = Utility()\n config = util.CONFIG\n repo_mgr = util.get_plugin(config.PATH_REPO_MGR)\n repo_mgr.connect(repo_conn)\n return repo_mgr","def new_node(self, **kwargs):\n params = self._node_param_resolve(**kwargs)\n return GuidedNode(**params)","def make_tcp_proxy(server_addr, dest_ddr):\n handler = partial(proxy_to, dest_addr)\n proxy_server = StreamServer(server_addr, handler)\n return proxy_server","def createNode(self, pkg, exe, args, name, nspace):\r\n node = Node(self)\r\n self.callRemote('createNode', pkg, exe, args, name,\r\n nspace).chainDeferred(node)\r\n return node","def create_api_gateway(args):\n return create_pool(_create_api_gateway_from_meta, args, 1)","def set_target(self, host, port):\r\n pass","def __make_connection(self):\n return self.euca.make_connection()","def __init__(self, listen_connection, bootstrap_connection = ('router.bittorrent.com', 6881),\n\t\t\tuser_setup = {}, user_router = None):\n\t\tsetup = {'discover_t': 180, 'check_t': 30, 'check_N': 10}\n\t\tsetup.update(user_setup)\n\t\tself._log = logging.getLogger(self.__class__.__name__ + '.%s.%d' % listen_connection)\n\t\tself._log.info('Starting DHT node with bootstrap connection %s:%d' % bootstrap_connection)\n\t\tlisten_connection = (socket.gethostbyname(listen_connection[0]), listen_connection[1])\n\t\t# Generate key for token generation\n\t\tself._token_key = os.urandom(20)\n\t\t# Start KRPC server process and Routing table\n\t\tself._krpc = KRPCPeer(listen_connection, self._handle_query)\n\t\tif not user_router:\n\t\t\tuser_router = DHT_Router('%s.%d' % listen_connection, setup)\n\t\tself._nodes = user_router\n\t\tself._node = DHT_Node(listen_connection, os.urandom(20))\n\t\tself._node_lock = threading.RLock()\n\t\t# Start bootstrap process\n\t\ttry:\n\t\t\ttmp = self.ping(bootstrap_connection, sender_id = self._node.id).get_result(timeout = 1)\n\t\texcept Exception:\n\t\t\traise\n\t\t\ttmp = {b'ip': encode_connection(listen_connection), b'r': {b'id': self._node.id}}\n\t\tself._node.connection = decode_connection(tmp[b'ip'])\n\t\tself._bootstrap_node = self._nodes.register_node(bootstrap_connection, tmp[b'r'][b'id'])\n\t\t# BEP #0042 Enable security extension\n\t\tlocal_id = bytearray(self._node.id)\n\t\tbep42_value = encode_uint32(bep42_prefix(self._node.connection[0], local_id[-1], local_id[0]))\n\t\tself._node.set_id(bep42_value[:3] + self._node.id[3:])\n\t\tassert(valid_id(self._node.id, self._node.connection))\n\t\tself._nodes.protect_nodes([self._node.id])\n\n\t\t# Start maintainance threads\n\t\tself._threads = ThreadManager(self._log.getChild('maintainance'))\n\n\t\t# Periodically ping nodes in the routing table\n\t\tdef _check_nodes(N, last_ping = 15 * 60, timeout = 5):\n\t\t\tdef get_unpinged(n):\n\t\t\t\treturn time.time() - n.last_ping > last_ping\n\t\t\tcheck_nodes = list(self._nodes.get_nodes(N, expression = get_unpinged))\n\t\t\tif not check_nodes:\n\t\t\t\treturn\n\t\t\tself._log.debug('Starting cleanup of known nodes')\n\t\t\tnode_result_list = []\n\t\t\tfor node in check_nodes:\n\t\t\t\tnode.last_ping = time.time()\n\t\t\t\tnode_result_list.append((node, node.id, self.ping(node.connection, self._node.id)))\n\t\t\tt_end = time.time() + timeout\n\t\t\tfor (node, node_id, async_result) in node_result_list:\n\t\t\t\tresult = self._eval_dht_response(node, async_result, timeout = max(0, t_end - time.time()))\n\t\t\t\tif result and (node.id != result.get(b'id')): # remove nodes with changing identities\n\t\t\t\t\tself._nodes.remove_node(node, force = True)\n\t\tself._threads.start_continuous_thread(_check_nodes, thread_interval = setup['check_t'], N = setup['check_N'])\n\n\t\t# Try to discover a random node to populate routing table\n\t\tdef _discover_nodes():\n\t\t\tself._log.debug('Starting discovery of random node')\n\t\t\tfor idx, entry in enumerate(self.dht_find_node(os.urandom(20), timeout = 1)):\n\t\t\t\tif idx > 10:\n\t\t\t\t\tbreak\n\t\tself._threads.start_continuous_thread(_discover_nodes, thread_interval = setup['discover_t'])","def manage(module, **params):\n try:\n return proxies[module]\n except KeyError:\n return proxies.setdefault(module, _DBProxy(module, **params))","def create_node(self, address, service):\n node = create_node(address, service)\n node.id = address + \"_\" + service\n return node","def setupTcp(self):\n \tself.tcpManager = QueuedConnectionManager()\n \tself.tcpReader = QueuedConnectionReader(self.tcpManager, 0)\n \tself.tcpWriter = ConnectionWriter(self.tcpManager, 0)","def new_remotenode(address) -> str:\n return address","async def _mk_http_connection(self) -> ClientSession:\n if self._ssl_context is not None:\n connector = TCPConnector(ssl=self._ssl_context)\n base_url = f'https://{self._netloc}/'\n else:\n connector = TCPConnector()\n base_url = f'http://{self._netloc}/'\n\n return ClientSession(base_url, connector=connector, timeout=ClientTimeout(self._socket_timeout))","def buildProtocol(self, addr):\n m = MyConnection()\n m.addr = addr\n return m","def _connect(self):\n self.connection = RedisConnection(self.host, self.port, self.dbname)","def setUp(self):\n self.manager, self.proxy = tests.utils.setup_xmlrpc()\n self.proxy.provider.register(\n PROVIDER_ID, USERNAME, PASSWORD, URL, TENANT, PROVIDER_TYPE\n )","def connect(self):\n if self._sock is None:\n if not self.proxy_host:\n host = self.host\n port = self.port\n else:\n host = self.proxy_host\n port = self.proxy_port\n \n sock = socket.create_connection((host, port), 5)\n proto = None\n\n if self.secure:\n assert not self.proxy_host, \"Using a proxy with HTTPS not yet supported.\"\n sock, proto = wrap_socket(sock, host, self.ssl_context)\n\n log.debug(\"Selected protocol: %s\", proto)\n sock = BufferedSocket(sock, self.network_buffer_size)\n\n if proto not in ('http/1.1', None):\n raise TLSUpgrade(proto, sock)\n\n self._sock = sock\n\n return","def getConnection(server, port):\n connectionUrl = 'http://%s:%s/' % (server, port)\n\n conn = Connection(connectionUrl, 'v0')\n return conn","def get_connection(hostname, logger):\n return Connection(\n hostname,\n logger=logger,\n sudo=needs_sudo(),\n )","def __new__(cls, urls=None):\n if Proxy.__instance is None:\n Proxy.__instance = object.__new__(cls)\n Proxy.__instance.urls = urls\n\n return Proxy.__instance","def __init__(self, obj):\n obj.Proxy = self","def __init__(self, obj):\n obj.Proxy = self","def connection(composition):\n return Connection(BASE_URL, 'http://localhost')","def __init__(self, proxy_enabled: ConfigNodePropertyBoolean=None, proxy_host: ConfigNodePropertyString=None, proxy_port: ConfigNodePropertyInteger=None, proxy_user: ConfigNodePropertyString=None, proxy_password: ConfigNodePropertyString=None, proxy_exceptions: ConfigNodePropertyArray=None): # noqa: E501\n self.openapi_types = {\n 'proxy_enabled': ConfigNodePropertyBoolean,\n 'proxy_host': ConfigNodePropertyString,\n 'proxy_port': ConfigNodePropertyInteger,\n 'proxy_user': ConfigNodePropertyString,\n 'proxy_password': ConfigNodePropertyString,\n 'proxy_exceptions': ConfigNodePropertyArray\n }\n\n self.attribute_map = {\n 'proxy_enabled': 'proxy.enabled',\n 'proxy_host': 'proxy.host',\n 'proxy_port': 'proxy.port',\n 'proxy_user': 'proxy.user',\n 'proxy_password': 'proxy.password',\n 'proxy_exceptions': 'proxy.exceptions'\n }\n\n self._proxy_enabled = proxy_enabled\n self._proxy_host = proxy_host\n self._proxy_port = proxy_port\n self._proxy_user = proxy_user\n self._proxy_password = proxy_password\n self._proxy_exceptions = proxy_exceptions","def setup_class(cls):\n cls.cwd = os.getcwd()\n cls.t = tempfile.mkdtemp()\n os.chdir(cls.t)\n\n cls.log_files = []\n cls.multiplexers = []\n\n try:\n temp_dir_node_1 = os.path.join(cls.t, \"temp_dir_node_1\")\n os.mkdir(temp_dir_node_1)\n cls.connection_node_1 = _make_libp2p_connection(\n data_dir=temp_dir_node_1,\n port=DEFAULT_PORT + 1,\n delegate_port=DEFAULT_DELEGATE_PORT + 1,\n delegate=True,\n )\n cls.multiplexer_node_1 = Multiplexer(\n [cls.connection_node_1], protocols=[MockDefaultMessageProtocol]\n )\n cls.log_files.append(cls.connection_node_1.node.log_file)\n cls.multiplexer_node_1.connect()\n cls.multiplexers.append(cls.multiplexer_node_1)\n\n entry_peer = cls.connection_node_1.node.multiaddrs[0]\n\n temp_dir_node_2 = os.path.join(cls.t, \"temp_dir_node_2\")\n os.mkdir(temp_dir_node_2)\n cls.connection_node_2 = _make_libp2p_connection(\n data_dir=temp_dir_node_2,\n port=DEFAULT_PORT + 2,\n delegate_port=DEFAULT_DELEGATE_PORT + 2,\n entry_peers=[entry_peer],\n delegate=True,\n )\n cls.multiplexer_node_2 = Multiplexer(\n [cls.connection_node_2], protocols=[MockDefaultMessageProtocol]\n )\n cls.log_files.append(cls.connection_node_2.node.log_file)\n cls.multiplexer_node_2.connect()\n\n cls.multiplexers.append(cls.multiplexer_node_2)\n\n wait_for_condition(lambda: cls.multiplexer_node_1.is_connected, 10)\n wait_for_condition(lambda: cls.multiplexer_node_2.is_connected, 10)\n wait_for_condition(lambda: cls.connection_node_1.is_connected, 10)\n wait_for_condition(lambda: cls.connection_node_2.is_connected, 10)\n cls.connections = [cls.connection_node_1, cls.connection_node_2]\n cls.addresses = [\n cls.connection_node_1.address,\n cls.connection_node_2.address,\n ]\n\n for j in range(DEFAULT_CLIENTS_PER_NODE):\n ports = [DEFAULT_DELEGATE_PORT + 1, DEFAULT_DELEGATE_PORT + 2]\n peers_public_keys = [\n cls.connection_node_1.node.pub,\n cls.connection_node_2.node.pub,\n ]\n for i in range(len(ports)):\n port = ports[i]\n peer_public_key = peers_public_keys[i]\n temp_dir_client = os.path.join(cls.t, f\"temp_dir_client__{j}_{i}\")\n os.mkdir(temp_dir_client)\n conn = _make_libp2p_client_connection(\n data_dir=temp_dir_client,\n peer_public_key=peer_public_key,\n node_port=port,\n )\n mux = Multiplexer([conn], protocols=[MockDefaultMessageProtocol])\n\n cls.connections.append(conn)\n cls.addresses.append(conn.address)\n\n mux.connect()\n wait_for_condition((lambda m: lambda: m.is_connected)(mux), 10)\n wait_for_condition((lambda c: lambda: c.is_connected)(conn), 10)\n cls.multiplexers.append(mux)\n break\n\n except Exception:\n cls.teardown_class()\n raise","def createGridWarpNodeMI():\n return gy()","def setup_node(config, args):\n if args.templates:\n config['templates'].insert(0, args.templates)\n config.templates = config._templates()\n stdin, stderr = args.node.ssh(config.template(\"scripts/node_setup.sh\"))\n if stderr:\n print stderr\n else:\n print u\"Node ready at %s\" % (args.node.hostname)","def set_proxy(self):","def __init__(self, node1, node2, **kwargs):\n # Create links on remote node\n self.node1 = node1\n self.node2 = node2\n self.tunnel = None\n kwargs.setdefault('params1', {})\n kwargs.setdefault('params2', {})\n kwargs.setdefault('cls1', TCIntf)\n kwargs.setdefault('cls2', TCIntf)\n self.cmd = None # satisfy pylint\n Link.__init__(self, node1, node2, **kwargs)"],"string":"[\n \"async def _create_proxy(self):\\n self._proxy = await self._controller.fopen_tcp_proxy(\\n Cellular._DRONE_WEB_API_PORT\\n )\\n\\n self._drone_http_url = f\\\"http://{self._proxy.address}:{self._proxy.port}\\\"\\n\\n if self._autoconfigure and self._user_apc_token is None:\\n self.logger.info(\\\"cellular auto pairing and configuration\\\")\\n # generate a new anonymous user APC token and configure the cellular.\\n self._fautoconfigure_with_new_token()\",\n \"def create(addr='127.0.0.1', port=0, options=None):\\n if options is None:\\n options = {}\\n\\n backend = MitmProxy(addr, port, options)\\n\\n t = threading.Thread(name='Selenium Wire Proxy Server', target=backend.serve_forever)\\n t.daemon = not options.get('standalone')\\n t.start()\\n\\n addr, port, *_ = backend.address()\\n log.info('Created proxy listening on %s:%s', addr, port)\\n\\n return backend\",\n \"def repository_create_proxy():\\n pass\",\n \"def create(self, upstream, name, listen=None, enabled=None):\\n\\n if name in self.proxies():\\n raise_with_traceback(ProxyExists(\\\"This proxy already exists.\\\"))\\n\\n # Lets build a dictionary to send the data to the Toxiproxy server\\n json = {\\n \\\"upstream\\\": upstream,\\n \\\"name\\\": name\\n }\\n\\n if listen is not None:\\n json[\\\"listen\\\"] = listen\\n else:\\n json[\\\"listen\\\"] = \\\"127.0.0.1:0\\\"\\n if enabled is not None:\\n json[\\\"enabled\\\"] = enabled\\n\\n proxy_info = APIConsumer.post(\\\"/proxies\\\", json=json).json()\\n proxy_info[\\\"api_consumer\\\"] = APIConsumer\\n\\n # Lets create a Proxy object to hold all its data\\n proxy = Proxy(**proxy_info)\\n\\n return proxy\",\n \"def CreateProxy(self, request):\\n try:\\n params = request._serialize()\\n headers = request.headers\\n body = self.call(\\\"CreateProxy\\\", params, headers=headers)\\n response = json.loads(body)\\n model = models.CreateProxyResponse()\\n model._deserialize(response[\\\"Response\\\"])\\n return model\\n except Exception as e:\\n if isinstance(e, TencentCloudSDKException):\\n raise\\n else:\\n raise TencentCloudSDKException(type(e).__name__, str(e))\",\n \"def _create_connection(self):\\n if not self.connection:\\n log.info(\\\"{}: Creating connection with address={}\\\".format(\\n self.container_id, self.address.geturl()))\\n self.connection = Connection(\\n self.address.hostname,\\n self.auth,\\n container_id=self.container_id,\\n properties=self._create_properties(),\\n debug=self.debug)\",\n \"def create_connection(location=None, bandwidth=None, connectionName=None):\\n pass\",\n \"def __init__(self, host, redis_port, ssh_user, use_ssh=True):\\n\\n if use_ssh:\\n forwarder = create_tunnel(host=host, port=redis_port, ssh_user=ssh_user)\\n self.connection = redis.StrictRedis(host=forwarder.bind_address, port=forwarder.bind_port, db=0)\\n else:\\n self.connection = redis.StrictRedis(host=host, port=redis_port, db=0)\",\n \"def new(configuration: Mapping[str, Any], loop: AbstractEventLoop) \\\\\\n -> ProxyProtocol:\\n return SocksProxy(loop)\",\n \"def init(opts):\\n opts[\\\"multiprocessing\\\"] = False\\n log.debug(\\\"Opening connection to junos\\\")\\n\\n args = {\\\"host\\\": opts[\\\"proxy\\\"][\\\"host\\\"]}\\n optional_args = [\\n \\\"user\\\",\\n \\\"username\\\",\\n \\\"password\\\",\\n \\\"passwd\\\",\\n \\\"port\\\",\\n \\\"gather_facts\\\",\\n \\\"mode\\\",\\n \\\"baud\\\",\\n \\\"attempts\\\",\\n \\\"auto_probe\\\",\\n \\\"ssh_private_key_file\\\",\\n \\\"ssh_config\\\",\\n \\\"normalize\\\",\\n \\\"huge_tree\\\",\\n ]\\n\\n if \\\"username\\\" in opts[\\\"proxy\\\"].keys():\\n opts[\\\"proxy\\\"][\\\"user\\\"] = opts[\\\"proxy\\\"].pop(\\\"username\\\")\\n proxy_keys = opts[\\\"proxy\\\"].keys()\\n for arg in optional_args:\\n if arg in proxy_keys:\\n args[arg] = opts[\\\"proxy\\\"][arg]\\n log.debug(\\\"Args: %s\\\", args)\\n thisproxy[\\\"conn\\\"] = jnpr.junos.Device(**args)\\n try:\\n thisproxy[\\\"conn\\\"].open()\\n except (\\n ProbeError,\\n ConnectAuthError,\\n ConnectRefusedError,\\n ConnectTimeoutError,\\n ConnectError,\\n ) as ex:\\n log.error(\\\"%s : not able to initiate connection to the device\\\", ex)\\n thisproxy[\\\"initialized\\\"] = False\\n return\\n\\n if \\\"timeout\\\" in proxy_keys:\\n timeout = int(opts[\\\"proxy\\\"][\\\"timeout\\\"])\\n try:\\n thisproxy[\\\"conn\\\"].timeout = timeout\\n except Exception as ex: # pylint: disable=broad-except\\n log.error(\\\"Not able to set timeout due to: %s\\\", str(ex))\\n else:\\n log.debug(\\\"RPC timeout set to %d seconds\\\", timeout)\\n\\n try:\\n thisproxy[\\\"conn\\\"].bind(cu=jnpr.junos.utils.config.Config)\\n except Exception as ex: # pylint: disable=broad-except\\n log.error(\\\"Bind failed with Config class due to: %s\\\", ex)\\n\\n try:\\n thisproxy[\\\"conn\\\"].bind(sw=jnpr.junos.utils.sw.SW)\\n except Exception as ex: # pylint: disable=broad-except\\n log.error(\\\"Bind failed with SW class due to: %s\\\", ex)\\n thisproxy[\\\"initialized\\\"] = True\",\n \"def openProxy(self):\\n self.state = ZenProcessTask.STATE_CONNECTING\\n if (self.snmpProxy is None or\\n self.snmpProxy.snmpConnInfo != self.snmpConnInfo):\\n self.snmpProxy = self.snmpConnInfo.createSession()\\n self.snmpProxy.open()\",\n \"def _NewConnection(self, *args, **kwargs):\\n return Connection(*args, dhcp_method=Connection.DHCP_DHCPCD, **kwargs)\",\n \"def connection_proxmox(config):\\n return ProxmoxAPI(\\n config[\\\"host\\\"],\\n user=config[\\\"user\\\"],\\n password=config[\\\"password\\\"],\\n verify_ssl=config[\\\"verify_ssl\\\"],\\n )\",\n \"def createMachine():\\n cd('/')\\n machine = create(machineName, 'UnixMachine')\\n cd('Machines/'+machineName+'/NodeManager/'+machineName)\\n cmo.setName(machineName)\\n cmo.setListenAddress(hostname)\",\n \"def make_connection( hostname, port = 4663 ):\\n \\tconnection = socket.socket();\",\n \"def _make_connection(self, callback):\\n if isinstance(callback, MethodType):\\n connection = _MethodConnection(self, callback)\\n else:\\n connection = _DirectConnection(self, callback)\\n return connection\",\n \"def nxos_connect(self, nexus_host, nexus_ssh_port, nexus_user,\\n nexus_password):\\n man = manager.connect(host=nexus_host, port=nexus_ssh_port,\\n username=nexus_user, password=nexus_password)\\n return man\",\n \"def __init__(self, connection):\\n\\t\\tself.name = None\\n\\t\\tself.remote_player_proxy = RemotePlayerProxy(connection)\",\n \"def create_outbound(self, addr, use_new_connection=False):\",\n \"def new_connection(self, host=None, port=None, timeout=45):\\n if self._conn:\\n self._conn.close()\\n\\n if not host:\\n host = self._host\\n port = self._port\\n self._host = host\\n self._port = port\\n host_display = host + (':%d' % port if port else '')\\n\\n proxy = self._proxy\\n if proxy:\\n logger.debug('Connecting to proxy server %s', proxy)\\n self._conn = TLS1_2Connection(proxy, timeout=timeout)\\n\\n logger.debug('Tunneling to host %s' % host_display)\\n self._conn.set_tunnel(host, port=port)\\n\\n try:\\n self._conn.connect()\\n except Exception as e:\\n msg = 'Failed to connect to proxy server %s: %s.' % (proxy, e)\\n raise DDGConnectionError(msg)\\n else:\\n logger.debug('Connecting to new host %s', host_display)\\n self._conn = TLS1_2Connection(host, port=port, timeout=timeout)\\n try:\\n self._conn.connect()\\n except Exception as e:\\n msg = 'Failed to connect to %s: %s.' % (host_display, e)\\n raise DDGConnectionError(msg)\",\n \"def _NewConnection(self, *args, **kwargs):\\n kwargs.setdefault('dhcp_method', Connection.DHCP_DHCPCD)\\n\\n return Connection(*args, **kwargs)\",\n \"def createManagedDomain():\\n selectCustomTemplate(localTemplate)\\n loadTemplates()\\n # set the Node Manager listen address and listen port.\\n cd('/')\\n cd('NMProperties')\\n set('ListenAddress', hostname)\\n #create the domain\\n writeDomain(domainPath)\",\n \"def create_node(self, node_cfg):\\n with self.__connect_node(node_cfg) as conn:\\n self._provision_node(conn, node_cfg)\\n self._bootup_node(conn)\",\n \"def create_proxy(proxyname):\\n # Running in a software collection?\\n enable_scls = []\\n scls = os.environ.get('X_SCLS', '')\\n for scl in scls.split():\\n with open('/etc/scl/conf/{}'.format(scl)) as fin:\\n prefix = fin.readline().rstrip()\\n enable_scls.append('. {}/{}/enable'.format(prefix, scl))\\n if scls:\\n enable_scls.append('X_SCLS={}'.format(shlex.quote(scls)))\\n enable_scls.append('export X_SCLS')\\n else:\\n enable_scls.append('# No software collections enabled.')\\n enable_scls = '\\\\n'.join(enable_scls)\\n # Running in a virtualenv?\\n venv = os.environ.get('VIRTUAL_ENV')\\n enable_venv = '. {}/bin/activate'.format(venv) if venv else '# No virtualenv enabled.'\\n # Create the ~/bin directory if needed\\n bindir = os.path.join(util.get_homedir(), 'bin')\\n proxyfile = os.path.join(bindir, proxyname)\\n util.create_directory(bindir, 0o755)\\n contents = textwrap.dedent(\\\"\\\"\\\"\\\\\\n #!/bin/sh\\n {}\\n {}\\n exec python -mravstack.proxy\\n \\\"\\\"\\\").format(enable_scls, enable_venv)\\n with open(proxyfile, 'w') as fout:\\n fout.write(contents)\\n os.chmod(proxyfile, 0o700)\\n return proxyfile\",\n \"def remote_createNode(self, pkg, exe, args, name, namespace):\\r\\n return Node(self, pkg, exe, args, name, namespace)\",\n \"def do_create(env):\\n keyname = env.config['proxy']['key_name']\\n proxyname = env.config['proxy']['proxy_name']\\n keyfile = create_ssh_keypair(keyname, proxyname)\\n proxyfile = create_proxy(proxyname)\\n install_proxy(keyfile + '.pub', proxyfile)\\n test_proxy(keyfile)\\n print('Private key created as: `~/.ssh/{}`.'.format(keyname))\\n print('Proxy created at: `~/bin/{}`.'.format(proxyname))\",\n \"def __init__(self):\\r\\n self.isConnected, self.atSchool = getNetStatus()\\r\\n self._token = None\\r\\n \\r\\n if self.atSchool:\\r\\n #print(\\\"at school\\\")\\r\\n urllib.request.install_opener(urllib.request.build_opener(urllib.request.ProxyHandler({'http': 'http://:@proxy.intranet:8080', 'https': 'http://:@proxy.intranet:8080'})))\",\n \"def test_settings_proxies_creation() -> None:\\n settings = Settings()\\n\\n settings_proxy = settings.create_proxy() # We have one proxy\\n assert len(settings._proxies) == 1\\n\\n second_proxy = settings.create_proxy() # Now we have two proxies\\n assert len(settings._proxies) == 2\\n\\n # We are creating the third one, but the original `settings_proxy` is dereferenced\\n settings_proxy = settings.create_proxy()\\n assert len(settings._proxies) == 2\\n\\n del second_proxy\\n assert len(settings._proxies) == 1\\n\\n del settings_proxy\\n assert len(settings._proxies) == 0\",\n \"def test_create_hyperflex_proxy_setting_policy(self):\\n pass\",\n \"def create(self, connectionParams) :\\n conn = RemoteConnection(connectionParams)\\n\\n # Generate a unique id by which to refer to this connection in the future\\n id = str(uuid.uuid1())\\n\\n self.remoteConnections[id] = conn\\n return id\",\n \"def handle_node(self, request):\\n \\\"\\\"\\\"\\n @api {ANY} /node/:node/:uri Proxy a request\\n @apiName ProxyToNode\\n @apiGroup Misc\\n @apiVersion 1.0.0\\n\\n @apiDescription Proxy the request :uri to the node :node, and forward the response.\\n\\n @apiParam {string} :node Node name.\\n @apiParam {string} :uri URI.\\n \\\"\\\"\\\"\\n\\n match = re.match('/node/([^/]+)(/.+)', request.uri_path)\\n node = match.group(1)\\n uri = match.group(2)\\n\\n if node not in self.cluster.nodes:\\n return HTTPReply(code = 404, headers = { 'Content-Type': 'application/javascript', 'Access-Control-Allow-Origin': '*' }, body = '{ \\\"message\\\": \\\"Node not found\\\" }')\\n\\n addr = parse_host_port(self.cluster.nodes[node][\\\"address\\\"])\\n\\n client = HTTPClient(addr)\\n return client.request(HTTPRequest(uri = uri, method = request.method, body = request.body))\",\n \"def __new__(cls, connection):\\n return object.__new__(cls)\",\n \"def create_remote_access(self, info):\\n if info:\\n response = self._request(\\\"POST\\\", [ROUTE_REMOTE_ACCESSES], {\\n \\\"type\\\": info[\\\"type\\\"],\\n \\\"address\\\": info[\\\"address\\\"],\\n \\\"port\\\": info[\\\"port\\\"],\\n \\\"login\\\": info[\\\"login\\\"],\\n \\\"password\\\": info[\\\"password\\\"],\\n \\\"key\\\": info[\\\"key\\\"],\\n \\\"node\\\": info[\\\"node\\\"]\\n })\\n logging.debug(\\\"Create connexion remote access::{}\\\".format(response.text))\\n if self.verif_response(response):\\n logging.info('remote access successfully created {}'.format(info[\\\"address\\\"]))\\n return CBWParser().parse_response(CBWRemoteAccess, response)\\n\\n logging.error(\\\"Error create connection remote access\\\")\\n return False\",\n \"def repository_create_proxy_recipe(ctx: click.Context, **kwargs):\\n _create_repository(ctx, 'proxy', **kwargs)\",\n \"def __init__(self, *args, **kvargs):\\n self.proxy_host = kvargs.get('proxy_host')\\n self.proxy_user = kvargs.get('proxy_user')\\n self.proxy_password = kvargs.get('proxy_password')\\n self.proxy_port = kvargs.get('proxy_port')\\n self.proxy_ssh_key_file = kvargs.get('proxy_ssh_key')\\n self.proxy_connection = False\\n self.host = kvargs.get('host')\\n self.user = kvargs.get('user')\\n self.password = kvargs.get('password')\\n self.port = kvargs.get('port')\\n self.dest_connection = False\\n\\n try:\\n # Add host key policy\\n if self.proxy_port is None:\\n self.proxy_port = 22\\n self.transport = paramiko.Transport((self.proxy_host, self.proxy_port))\\n self.transport.start_client()\\n if self.proxy_ssh_key_file:\\n self.proxy_ssh_key = paramiko.RSAKey.from_private_key_file(self.proxy_ssh_key_file)\\n conn_result = self.transport.auth_publickey(username=self.proxy_user, key=self.proxy_ssh_key)\\n else:\\n conn_result = self.transport.auth_password(username=self.proxy_user, password=self.proxy_password)\\n if len(conn_result) == 0:\\n self.proxy_connection = True\\n else:\\n logging.error('Unable to connect to proxy host. Authentication failed.')\\n raise TobyException('Unable to connect to proxy host. Authentication failed.')\\n except Exception as exp:\\n logging.error('Unable to connect to proxy host: %s' % exp)\\n raise TobyException('Unable to connect to proxy host: %s' % exp)\\n\\n try:\\n if self.port is None:\\n self.port = 22\\n self.tunnel = paramiko.Transport(self.transport.open_channel(\\n kind='direct-tcpip',\\n dest_addr=(self.host, self.port),\\n src_addr=('127.0.0.1', 0)))\\n self.tunnel.start_client()\\n conn_result = self.tunnel.auth_password(username=self.user, password=self.password)\\n if len(conn_result) == 0:\\n self.dest_connection = True\\n else:\\n logging.error('Unable to connect to destination host. Authentication failed.')\\n raise TobyException('Unable to connect to destination host. Authentication failed.')\\n except Exception as exp:\\n logging.error('Unable to connect to destination host: %s' % exp)\\n raise TobyException('Unable to connect to destination host: %s' % exp)\\n\\n try:\\n self.handle = self.tunnel.open_session(20)\\n self.handle.get_pty(width=160, height=0)\\n self.handle.invoke_shell()\\n self.handle.set_combine_stderr(True)\\n self.handle.settimeout(60)\\n tnh = self.handle\\n got = []\\n while True:\\n _rd, _wr, _err = select([tnh], [], [], 10)\\n if _rd:\\n data = tnh.recv(1024)\\n data = data.decode(\\\"utf-8\\\")\\n got.append(data)\\n if re.search('> ', data):\\n tnh.send(b' start shell\\\\n')\\n data = tnh.recv(1024)\\n data = data.decode(\\\"utf-8\\\")\\n if re.search(r'(\\\\$|>|#|%)[\\\\s\\\\t]?', data):\\n break\\n except Exception as exp:\\n logging.error(\\n 'Unable to fetch the prompt on destination host: %s' % exp)\\n raise TobyException(\\n 'Unable to fetch the prompt on destination host: %s' % exp)\",\n \"def setup_class(cls):\\n cls.cwd = os.getcwd()\\n cls.t = tempfile.mkdtemp()\\n os.chdir(cls.t)\\n\\n temp_dir = os.path.join(cls.t, \\\"temp_dir_node\\\")\\n os.mkdir(temp_dir)\\n cls.connection_node = _make_libp2p_connection(data_dir=temp_dir, delegate=True)\\n temp_dir_client = os.path.join(cls.t, \\\"temp_dir_client\\\")\\n os.mkdir(temp_dir_client)\\n cls.connection = _make_libp2p_client_connection(\\n data_dir=temp_dir_client, peer_public_key=cls.connection_node.node.pub\\n )\",\n \"def repository_create_proxy_yum(ctx: click.Context, **kwargs):\\n _create_repository(ctx, 'proxy', **kwargs)\",\n \"def repository_create_proxy_maven(ctx: click.Context, **kwargs):\\n _create_repository(ctx, 'proxy', **kwargs)\",\n \"def switch_proxy(self, proxy):\",\n \"def setproxy(self,proxytype=None,addr=None,port=None,rdns=True,username=None,password=None):\\r\\n self.__proxy = (proxytype,addr,port,rdns,username,password)\",\n \"def makeConnection(self, transport):\\n pass\",\n \"def new(sock, info=None):\\n return ProxyPlayer(sock, info)\",\n \"def createWrapper():\\n\\n # read properties file and get MANO name and IP\\n config = RawConfigParser()\\n config.read(\\\"../../coreMano/coreMano.properties\\\")\\n name = config.get(\\\"CoreMano\\\", \\\"coreMano.name\\\")\\n host_ip = config.get(\\\"CoreMano\\\", \\\"coreMano.ip\\\")\\n\\n # instanciate and return the MANO\\n if name == \\\"osm\\\":\\n mano = OsmWrapper(name, host_ip)\\n if name == \\\"cloudify\\\":\\n mano = CloudifyWrapper(name, host_ip)\\n return mano\",\n \"def create_netmiko_connection(self, opt):\\n\\n key = opt['ip']\\n conn_list = ['None', 'None', 'None']\\n net_connect_dict = self._netmiko_connection\\n auth = (opt['username'], opt['password'])\\n if key not in net_connect_dict:\\n # case 1: No key create a connection\\n try:\\n net_connect = self._establish_netmiko_handler(opt, net_connect_dict)\\n if net_connect:\\n hashed_auth = self._hash_auth_string(auth)\\n conn_list[0] = net_connect\\n conn_list[1] = hashed_auth\\n conn_list[2] = threading.Lock()\\n net_connect_dict[key] = conn_list\\n except ValueError as err:\\n raise\\n except Exception as err:\\n raise\\n\\n else:\\n existing_hash = net_connect_dict[key][1]\\n conn_list = self._get_netmiko_connection(key)\\n conn_obj = conn_list[0]\\n if self._check_auth_string(existing_hash, auth):\\n # case 2: check if connection object is alive\\n if conn_obj.is_alive() is True:\\n conn_obj.set_base_prompt()\\n return\\n # case 3: Assume user value is new so delete existing\\n # and add new connection object for this\\n else:\\n #disconnect stale object\\n conn_list[2].acquire()\\n conn_obj.disconnect()\\n conn_list[2].release()\\n\\n # Existing object is not valid so clear and create new\\n # connection\\n del net_connect_dict[key]\\n try:\\n net_connect = self._establish_netmiko_handler(opt, net_connect_dict)\\n if net_connect:\\n new_hash = self._hash_auth_string(auth)\\n conn_list[0] = net_connect\\n conn_list[1] = new_hash\\n conn_list[2] = threading.Lock()\\n net_connect_dict[key] = conn_list\\n except ValueError as error:\\n raise\\n except Exception:\\n raise Exception\",\n \"def create_connection(address):\\n\\n sock = socks.socksocket()\\n sock.connect(address)\\n return sock\",\n \"def make_connection(self):\\n if self._created_connections() >= self.max_connections:\\n raise ConnPoolException(\\\"Too many connections.\\\")\\n connection = self.connection_class(**self.connection_kwargs)\\n connection.connect()\\n return connection\",\n \"async def create(cls, host: str, port: Union[int, str]) -> Connection:\\n self = cls()\\n self.reader, self.writer = await asyncio.open_connection(host, port)\\n return self\",\n \"def setUp(self):\\n self.clnt = CvpClient()\\n nodes = [\\\"1.1.1.1\\\"]\\n self.clnt.nodes = nodes\\n self.clnt.node_cnt = len(nodes)\\n self.clnt.node_pool = cycle(nodes)\\n self.api = CvpApi(self.clnt)\",\n \"def createTunnel(self, name, targetIP):\\r\\n return self._ref.callRemote('createTunnel', name, targetIP)\",\n \"def create_connection():\\n # REDIS_URL is defined in .env and loaded into the environment by Honcho\\n redis_url = os.getenv('REDIS_URL')\\n # If it's not defined, use the Redis default\\n if not redis_url:\\n redis_url = 'redis://localhost:6379'\\n urlparse.uses_netloc.append('redis')\\n url = urlparse.urlparse(redis_url)\\n return redis.StrictRedis(\\n host=url.hostname,\\n port=url.port,\\n db=0,\\n password=url.password\\n )\",\n \"def startNode(klass):\\n try:\\n ws = klass('ws://localhost:8080/ws')\\n ws.daemon = False\\n ws.connect()\\n except:\\n ws.close()\",\n \"def connect(cls, url=None, router=None, timeout=10, ssl_domain=None, sasl=None, edge_router=None):\\n url_ = Url(url) # Convert string to Url class.\\n\\n if url_.path is not None:\\n path = url_.path\\n elif router:\\n path = '_topo/0/%s/$management' % router\\n elif edge_router:\\n path = '_edge/%s/$management' % edge_router\\n else:\\n path = u'$management'\\n connection = BlockingConnection(url,\\n timeout=timeout,\\n ssl_domain=ssl_domain,\\n sasl_enabled=bool(ssl_domain or sasl),\\n allowed_mechs=str(sasl.mechs) if sasl and sasl.mechs is not None else None,\\n user=str(sasl.user) if sasl and sasl.user is not None else None,\\n password=str(sasl.password) if sasl and sasl.password is not None else None)\\n try:\\n return cls(connection, path)\\n except Exception:\\n # ownership of connection has not been given to a new Node; close the connection\\n connection.close()\\n raise\",\n \"def _connect_gen(\\n cls: Type[ConnectionType],\\n conninfo: str = \\\"\\\",\\n *,\\n autocommit: bool = False,\\n ) -> PQGenConn[ConnectionType]:\\n pgconn = yield from connect(conninfo)\\n conn = cls(pgconn)\\n conn._autocommit = bool(autocommit)\\n return conn\",\n \"def install_connection(connection):\\n global _connection\\n _connection = connection\",\n \"def __init__(self, server, ressource):\\n self.server = server\\n local_url = \\\"http://%s:%d/xmlrpc/common\\\" % (\\n server.server_url,\\n server.server_port,\\n )\\n rpc = ServerProxy(local_url)\\n self.uid = rpc.login(server.server_db, server.login, server.password)\\n local_url = \\\"http://%s:%d/xmlrpc/object\\\" % (\\n server.server_url,\\n server.server_port,\\n )\\n self.rpc = ServerProxy(local_url)\\n self.ressource = ressource\",\n \"def rpc_create_connection(client, source, dest,crypto=\\\"btc\\\",\\n rpc_user=BTC_RPC_USER, rpc_password=BTC_RPC_PASSWD, rpc_port=BTC_RPC_PORT):\\n try:\\n if(crypto==\\\"btc\\\"):\\n rpc_server = get_ip_by_unknown(client, source)\\n dest = get_ip_by_unknown(client, dest)\\n else:\\n rpc_server = get_ip_by_unknown(client, source,DOCK_NETWORK_NAME_ZCH)\\n dest = get_ip_by_unknown(client, dest, DOCK_NETWORK_NAME_ZCH)\\n #print rpc_user+\\\" \\\"+rpc_password+\\\" \\\"+rpc_server+ \\\" \\\"+str(rpc_port)\\n rpc_connection = AuthServiceProxy(\\\"http://%s:%s@%s:%s\\\" % (rpc_user, rpc_password, rpc_server, rpc_port))\\n rpc_connection.addnode(dest, \\\"add\\\")\\n return True\\n except JSONRPCException as err:\\n print(err)\\n return False\",\n \"def set_proxy(self, host: str, port: int,\\n proxy_type=ProxyTypes.Http,\\n secret='', # for Mtproto\\n username='',\\n password='',\\n http_only=False, # For HTTP: Pass true, if the proxy supports only HTTP requests and doesn't support\\n # transparent TCP connections via HTTP CONNECT method.\\n check_proxy=True) -> None:\\n self.remove_proxy()\\n\\n proxy_type_obj = {\\n '@type': proxy_type,\\n 'secret': secret,\\n 'http_only': http_only,\\n 'username': username,\\n 'password': password,\\n }\\n\\n self.call_method('addProxy', server=host, port=port, enable=True, type=proxy_type_obj)\\n\\n if check_proxy:\\n self.check_proxy()\",\n \"def create_manager(self, username, tenancy):\\n raise NotImplementedError\",\n \"def connect_multiplexer(multiplexer):\",\n \"def create_gateway():\\n # Start the gateway to connect with py4j\\n if 'gateway' not in os.popen('jps').read():\\n os.system('java gateway &')\\n delay(0.5)\\n LOGGER.debug('Started Java gateway')\\n # Connect to gateway getting jvm object\\n LOGGER.debug('Connecting to gateway from py4j')\\n gate = JavaGateway()\\n return gate\",\n \"def make_new_connection(\\n self,\\n proto_handle,\\n own_addr,\\n source_addr,\\n relay_addr\\n ):\\n handler = self.handler_factory.make_new_handler(\\n own_addr,\\n source_addr,\\n relay_addr\\n )\\n connection = Connection(\\n proto_handle,\\n handler,\\n own_addr,\\n source_addr,\\n relay_addr\\n )\\n handler.connection = connection\\n return connection\",\n \"def connect(self):\\n self.connection = redis.Redis(\\n host=self.host,\\n port=self.port,\\n socket_connect_timeout=self.timeout,\\n socket_timeout=self.timeout\\n )\",\n \"def __init__(self, ip, port, automatic = True, control_buf_size = 32, data_buf_size = 128, \\\\\\n m_to = 0.01, socket_to = 0.005):\\n self.conn = Connector(ip, port, control_buf_size, data_buf_size, socket_to)\\n self.conn.connect()\\n self.m_to = m_to\\n self.status = Modem.Status.IDLE\\n self.node_status = 0\\n self.automatic = automatic\\n self.interpreter = Interpreter()\\n self.mainPID = os.getpid()\\n self.error_status = Modem.ErrorDict.NONE\\n self.commands_queue = \\\"\\\".split(Interpreter.END_COMMAND)\\n if automatic:\\n thread.start_new_thread(self.run,())\",\n \"def setup_gateway(self, args):\\n if args.preponly:\\n return\\n\\n # edit the gateway properties file and restart the gateway\\n # mdm.ip.addresses = <addresses of node0,node1>\\n # security.bypass_certificate_check = true\\n _config = '/opt/emc/scaleio/gateway/webapps/ROOT/WEB-INF/classes/gatewayUser.properties'\\n _commands = []\\n #_commands.append(\\\"sed -i 's|^mdm.ip.addresses.*|mdm.ip.addresses={},{}|' {}\\\".format(args.IP[0], args.IP[1], _config))\\n #_commands.append(\\\"sed -i 's|^security.bypass_certificate_check.*|security.bypass_certificate_check=true|' {}\\\".format( _config))\\n _commands.append(\\\"systemctl restart scaleio-gateway\\\")\\n self.node_execute_multiple(args.IP[2], args.USERNAME, args.PASSWORD, _commands)\\n return\",\n \"def repository_create_proxy_docker(ctx: click.Context, **kwargs):\\n _create_repository(ctx, 'proxy', **kwargs)\",\n \"def __call__(self, proxy):\\n return LocalProxy(self, proxy)\",\n \"def __call__(self, proxy):\\n return LocalProxy(self, proxy)\",\n \"def repository_create_proxy_apt(ctx: click.Context, **kwargs):\\n _create_repository(ctx, 'proxy', **kwargs)\",\n \"def test_add_proxy():\\n result = False\\n\\n proxy = {\\n \\\"name\\\": \\\"proxy\\\",\\n \\\"address\\\": \\\"proxy.ntnxlab.local\\\",\\n \\\"port\\\": \\\"8080\\\",\\n \\\"http\\\": True,\\n \\\"https\\\": True,\\n \\\"socks\\\": False,\\n \\\"username\\\": '',\\n \\\"password\\\": '',\\n }\\n\\n cluster_obj = prism.Cluster(api_client=_api())\\n config_obj = prism.Config(api_client=_api())\\n clusters = cluster_obj.get_all_uuids()\\n for each_uuid in clusters:\\n config_obj.set_proxy(address=proxy['address'], port=proxy['port'], name=proxy['name'], http=proxy['http'], https=proxy['https'],\\n username=proxy['username'], password=proxy['password'], socks=proxy['socks'], clusteruuid=each_uuid)\\n cluster_proxy = config_obj.get_proxy(clusteruuid=each_uuid)\\n\\n if proxy['address'] == cluster_proxy[0]['address']:\\n result = True\\n\\n assert result\",\n \"def expand(self):\\n try:\\n self.create_connection()\\n except Exception as excpt:\\n print(excpt)\",\n \"def _clone_node(self, node):\\n spec = node.gateway.spec\\n spec.id = None\\n self.nodemanager.group.allocate_id(spec)\\n node = self.nodemanager.setup_node(spec, self.queue.put)\\n self._active_nodes.add(node)\\n return node\",\n \"def _repo_manager(repo_conn):\\n util = Utility()\\n config = util.CONFIG\\n repo_mgr = util.get_plugin(config.PATH_REPO_MGR)\\n repo_mgr.connect(repo_conn)\\n return repo_mgr\",\n \"def new_node(self, **kwargs):\\n params = self._node_param_resolve(**kwargs)\\n return GuidedNode(**params)\",\n \"def make_tcp_proxy(server_addr, dest_ddr):\\n handler = partial(proxy_to, dest_addr)\\n proxy_server = StreamServer(server_addr, handler)\\n return proxy_server\",\n \"def createNode(self, pkg, exe, args, name, nspace):\\r\\n node = Node(self)\\r\\n self.callRemote('createNode', pkg, exe, args, name,\\r\\n nspace).chainDeferred(node)\\r\\n return node\",\n \"def create_api_gateway(args):\\n return create_pool(_create_api_gateway_from_meta, args, 1)\",\n \"def set_target(self, host, port):\\r\\n pass\",\n \"def __make_connection(self):\\n return self.euca.make_connection()\",\n \"def __init__(self, listen_connection, bootstrap_connection = ('router.bittorrent.com', 6881),\\n\\t\\t\\tuser_setup = {}, user_router = None):\\n\\t\\tsetup = {'discover_t': 180, 'check_t': 30, 'check_N': 10}\\n\\t\\tsetup.update(user_setup)\\n\\t\\tself._log = logging.getLogger(self.__class__.__name__ + '.%s.%d' % listen_connection)\\n\\t\\tself._log.info('Starting DHT node with bootstrap connection %s:%d' % bootstrap_connection)\\n\\t\\tlisten_connection = (socket.gethostbyname(listen_connection[0]), listen_connection[1])\\n\\t\\t# Generate key for token generation\\n\\t\\tself._token_key = os.urandom(20)\\n\\t\\t# Start KRPC server process and Routing table\\n\\t\\tself._krpc = KRPCPeer(listen_connection, self._handle_query)\\n\\t\\tif not user_router:\\n\\t\\t\\tuser_router = DHT_Router('%s.%d' % listen_connection, setup)\\n\\t\\tself._nodes = user_router\\n\\t\\tself._node = DHT_Node(listen_connection, os.urandom(20))\\n\\t\\tself._node_lock = threading.RLock()\\n\\t\\t# Start bootstrap process\\n\\t\\ttry:\\n\\t\\t\\ttmp = self.ping(bootstrap_connection, sender_id = self._node.id).get_result(timeout = 1)\\n\\t\\texcept Exception:\\n\\t\\t\\traise\\n\\t\\t\\ttmp = {b'ip': encode_connection(listen_connection), b'r': {b'id': self._node.id}}\\n\\t\\tself._node.connection = decode_connection(tmp[b'ip'])\\n\\t\\tself._bootstrap_node = self._nodes.register_node(bootstrap_connection, tmp[b'r'][b'id'])\\n\\t\\t# BEP #0042 Enable security extension\\n\\t\\tlocal_id = bytearray(self._node.id)\\n\\t\\tbep42_value = encode_uint32(bep42_prefix(self._node.connection[0], local_id[-1], local_id[0]))\\n\\t\\tself._node.set_id(bep42_value[:3] + self._node.id[3:])\\n\\t\\tassert(valid_id(self._node.id, self._node.connection))\\n\\t\\tself._nodes.protect_nodes([self._node.id])\\n\\n\\t\\t# Start maintainance threads\\n\\t\\tself._threads = ThreadManager(self._log.getChild('maintainance'))\\n\\n\\t\\t# Periodically ping nodes in the routing table\\n\\t\\tdef _check_nodes(N, last_ping = 15 * 60, timeout = 5):\\n\\t\\t\\tdef get_unpinged(n):\\n\\t\\t\\t\\treturn time.time() - n.last_ping > last_ping\\n\\t\\t\\tcheck_nodes = list(self._nodes.get_nodes(N, expression = get_unpinged))\\n\\t\\t\\tif not check_nodes:\\n\\t\\t\\t\\treturn\\n\\t\\t\\tself._log.debug('Starting cleanup of known nodes')\\n\\t\\t\\tnode_result_list = []\\n\\t\\t\\tfor node in check_nodes:\\n\\t\\t\\t\\tnode.last_ping = time.time()\\n\\t\\t\\t\\tnode_result_list.append((node, node.id, self.ping(node.connection, self._node.id)))\\n\\t\\t\\tt_end = time.time() + timeout\\n\\t\\t\\tfor (node, node_id, async_result) in node_result_list:\\n\\t\\t\\t\\tresult = self._eval_dht_response(node, async_result, timeout = max(0, t_end - time.time()))\\n\\t\\t\\t\\tif result and (node.id != result.get(b'id')): # remove nodes with changing identities\\n\\t\\t\\t\\t\\tself._nodes.remove_node(node, force = True)\\n\\t\\tself._threads.start_continuous_thread(_check_nodes, thread_interval = setup['check_t'], N = setup['check_N'])\\n\\n\\t\\t# Try to discover a random node to populate routing table\\n\\t\\tdef _discover_nodes():\\n\\t\\t\\tself._log.debug('Starting discovery of random node')\\n\\t\\t\\tfor idx, entry in enumerate(self.dht_find_node(os.urandom(20), timeout = 1)):\\n\\t\\t\\t\\tif idx > 10:\\n\\t\\t\\t\\t\\tbreak\\n\\t\\tself._threads.start_continuous_thread(_discover_nodes, thread_interval = setup['discover_t'])\",\n \"def manage(module, **params):\\n try:\\n return proxies[module]\\n except KeyError:\\n return proxies.setdefault(module, _DBProxy(module, **params))\",\n \"def create_node(self, address, service):\\n node = create_node(address, service)\\n node.id = address + \\\"_\\\" + service\\n return node\",\n \"def setupTcp(self):\\n \\tself.tcpManager = QueuedConnectionManager()\\n \\tself.tcpReader = QueuedConnectionReader(self.tcpManager, 0)\\n \\tself.tcpWriter = ConnectionWriter(self.tcpManager, 0)\",\n \"def new_remotenode(address) -> str:\\n return address\",\n \"async def _mk_http_connection(self) -> ClientSession:\\n if self._ssl_context is not None:\\n connector = TCPConnector(ssl=self._ssl_context)\\n base_url = f'https://{self._netloc}/'\\n else:\\n connector = TCPConnector()\\n base_url = f'http://{self._netloc}/'\\n\\n return ClientSession(base_url, connector=connector, timeout=ClientTimeout(self._socket_timeout))\",\n \"def buildProtocol(self, addr):\\n m = MyConnection()\\n m.addr = addr\\n return m\",\n \"def _connect(self):\\n self.connection = RedisConnection(self.host, self.port, self.dbname)\",\n \"def setUp(self):\\n self.manager, self.proxy = tests.utils.setup_xmlrpc()\\n self.proxy.provider.register(\\n PROVIDER_ID, USERNAME, PASSWORD, URL, TENANT, PROVIDER_TYPE\\n )\",\n \"def connect(self):\\n if self._sock is None:\\n if not self.proxy_host:\\n host = self.host\\n port = self.port\\n else:\\n host = self.proxy_host\\n port = self.proxy_port\\n \\n sock = socket.create_connection((host, port), 5)\\n proto = None\\n\\n if self.secure:\\n assert not self.proxy_host, \\\"Using a proxy with HTTPS not yet supported.\\\"\\n sock, proto = wrap_socket(sock, host, self.ssl_context)\\n\\n log.debug(\\\"Selected protocol: %s\\\", proto)\\n sock = BufferedSocket(sock, self.network_buffer_size)\\n\\n if proto not in ('http/1.1', None):\\n raise TLSUpgrade(proto, sock)\\n\\n self._sock = sock\\n\\n return\",\n \"def getConnection(server, port):\\n connectionUrl = 'http://%s:%s/' % (server, port)\\n\\n conn = Connection(connectionUrl, 'v0')\\n return conn\",\n \"def get_connection(hostname, logger):\\n return Connection(\\n hostname,\\n logger=logger,\\n sudo=needs_sudo(),\\n )\",\n \"def __new__(cls, urls=None):\\n if Proxy.__instance is None:\\n Proxy.__instance = object.__new__(cls)\\n Proxy.__instance.urls = urls\\n\\n return Proxy.__instance\",\n \"def __init__(self, obj):\\n obj.Proxy = self\",\n \"def __init__(self, obj):\\n obj.Proxy = self\",\n \"def connection(composition):\\n return Connection(BASE_URL, 'http://localhost')\",\n \"def __init__(self, proxy_enabled: ConfigNodePropertyBoolean=None, proxy_host: ConfigNodePropertyString=None, proxy_port: ConfigNodePropertyInteger=None, proxy_user: ConfigNodePropertyString=None, proxy_password: ConfigNodePropertyString=None, proxy_exceptions: ConfigNodePropertyArray=None): # noqa: E501\\n self.openapi_types = {\\n 'proxy_enabled': ConfigNodePropertyBoolean,\\n 'proxy_host': ConfigNodePropertyString,\\n 'proxy_port': ConfigNodePropertyInteger,\\n 'proxy_user': ConfigNodePropertyString,\\n 'proxy_password': ConfigNodePropertyString,\\n 'proxy_exceptions': ConfigNodePropertyArray\\n }\\n\\n self.attribute_map = {\\n 'proxy_enabled': 'proxy.enabled',\\n 'proxy_host': 'proxy.host',\\n 'proxy_port': 'proxy.port',\\n 'proxy_user': 'proxy.user',\\n 'proxy_password': 'proxy.password',\\n 'proxy_exceptions': 'proxy.exceptions'\\n }\\n\\n self._proxy_enabled = proxy_enabled\\n self._proxy_host = proxy_host\\n self._proxy_port = proxy_port\\n self._proxy_user = proxy_user\\n self._proxy_password = proxy_password\\n self._proxy_exceptions = proxy_exceptions\",\n \"def setup_class(cls):\\n cls.cwd = os.getcwd()\\n cls.t = tempfile.mkdtemp()\\n os.chdir(cls.t)\\n\\n cls.log_files = []\\n cls.multiplexers = []\\n\\n try:\\n temp_dir_node_1 = os.path.join(cls.t, \\\"temp_dir_node_1\\\")\\n os.mkdir(temp_dir_node_1)\\n cls.connection_node_1 = _make_libp2p_connection(\\n data_dir=temp_dir_node_1,\\n port=DEFAULT_PORT + 1,\\n delegate_port=DEFAULT_DELEGATE_PORT + 1,\\n delegate=True,\\n )\\n cls.multiplexer_node_1 = Multiplexer(\\n [cls.connection_node_1], protocols=[MockDefaultMessageProtocol]\\n )\\n cls.log_files.append(cls.connection_node_1.node.log_file)\\n cls.multiplexer_node_1.connect()\\n cls.multiplexers.append(cls.multiplexer_node_1)\\n\\n entry_peer = cls.connection_node_1.node.multiaddrs[0]\\n\\n temp_dir_node_2 = os.path.join(cls.t, \\\"temp_dir_node_2\\\")\\n os.mkdir(temp_dir_node_2)\\n cls.connection_node_2 = _make_libp2p_connection(\\n data_dir=temp_dir_node_2,\\n port=DEFAULT_PORT + 2,\\n delegate_port=DEFAULT_DELEGATE_PORT + 2,\\n entry_peers=[entry_peer],\\n delegate=True,\\n )\\n cls.multiplexer_node_2 = Multiplexer(\\n [cls.connection_node_2], protocols=[MockDefaultMessageProtocol]\\n )\\n cls.log_files.append(cls.connection_node_2.node.log_file)\\n cls.multiplexer_node_2.connect()\\n\\n cls.multiplexers.append(cls.multiplexer_node_2)\\n\\n wait_for_condition(lambda: cls.multiplexer_node_1.is_connected, 10)\\n wait_for_condition(lambda: cls.multiplexer_node_2.is_connected, 10)\\n wait_for_condition(lambda: cls.connection_node_1.is_connected, 10)\\n wait_for_condition(lambda: cls.connection_node_2.is_connected, 10)\\n cls.connections = [cls.connection_node_1, cls.connection_node_2]\\n cls.addresses = [\\n cls.connection_node_1.address,\\n cls.connection_node_2.address,\\n ]\\n\\n for j in range(DEFAULT_CLIENTS_PER_NODE):\\n ports = [DEFAULT_DELEGATE_PORT + 1, DEFAULT_DELEGATE_PORT + 2]\\n peers_public_keys = [\\n cls.connection_node_1.node.pub,\\n cls.connection_node_2.node.pub,\\n ]\\n for i in range(len(ports)):\\n port = ports[i]\\n peer_public_key = peers_public_keys[i]\\n temp_dir_client = os.path.join(cls.t, f\\\"temp_dir_client__{j}_{i}\\\")\\n os.mkdir(temp_dir_client)\\n conn = _make_libp2p_client_connection(\\n data_dir=temp_dir_client,\\n peer_public_key=peer_public_key,\\n node_port=port,\\n )\\n mux = Multiplexer([conn], protocols=[MockDefaultMessageProtocol])\\n\\n cls.connections.append(conn)\\n cls.addresses.append(conn.address)\\n\\n mux.connect()\\n wait_for_condition((lambda m: lambda: m.is_connected)(mux), 10)\\n wait_for_condition((lambda c: lambda: c.is_connected)(conn), 10)\\n cls.multiplexers.append(mux)\\n break\\n\\n except Exception:\\n cls.teardown_class()\\n raise\",\n \"def createGridWarpNodeMI():\\n return gy()\",\n \"def setup_node(config, args):\\n if args.templates:\\n config['templates'].insert(0, args.templates)\\n config.templates = config._templates()\\n stdin, stderr = args.node.ssh(config.template(\\\"scripts/node_setup.sh\\\"))\\n if stderr:\\n print stderr\\n else:\\n print u\\\"Node ready at %s\\\" % (args.node.hostname)\",\n \"def set_proxy(self):\",\n \"def __init__(self, node1, node2, **kwargs):\\n # Create links on remote node\\n self.node1 = node1\\n self.node2 = node2\\n self.tunnel = None\\n kwargs.setdefault('params1', {})\\n kwargs.setdefault('params2', {})\\n kwargs.setdefault('cls1', TCIntf)\\n kwargs.setdefault('cls2', TCIntf)\\n self.cmd = None # satisfy pylint\\n Link.__init__(self, node1, node2, **kwargs)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6048795","0.58742714","0.5802584","0.5657759","0.5605936","0.5493677","0.54126096","0.5399687","0.5381373","0.53703874","0.53361976","0.53073025","0.52932906","0.5273362","0.5243213","0.52396035","0.5215712","0.5199959","0.51762295","0.51659554","0.5154082","0.51449317","0.51403785","0.5137221","0.5120202","0.5111127","0.5091579","0.5079476","0.50677305","0.5060609","0.5054933","0.5051231","0.5037422","0.50233984","0.50186116","0.50184697","0.50042254","0.50016314","0.49958307","0.49944827","0.496847","0.49598205","0.49580953","0.49571994","0.49374625","0.4930975","0.49197307","0.49196845","0.49183285","0.49182057","0.49132365","0.4910899","0.49107876","0.4900585","0.48913088","0.48858678","0.48754382","0.4875081","0.48701647","0.48621914","0.48564643","0.4843127","0.48408613","0.48373908","0.48327264","0.4830208","0.4830208","0.48271242","0.4824546","0.4824037","0.48222965","0.48219734","0.4819385","0.48177865","0.4816716","0.4816069","0.48077673","0.48055157","0.48024172","0.47957236","0.47934958","0.4784589","0.47748798","0.4773948","0.4769872","0.47688463","0.47585437","0.47563392","0.47562933","0.4755001","0.47495696","0.47492486","0.47492486","0.4747271","0.47472274","0.4744499","0.4742725","0.47287247","0.47183883","0.4714961"],"string":"[\n \"0.6048795\",\n \"0.58742714\",\n \"0.5802584\",\n \"0.5657759\",\n \"0.5605936\",\n \"0.5493677\",\n \"0.54126096\",\n \"0.5399687\",\n \"0.5381373\",\n \"0.53703874\",\n \"0.53361976\",\n \"0.53073025\",\n \"0.52932906\",\n \"0.5273362\",\n \"0.5243213\",\n \"0.52396035\",\n \"0.5215712\",\n \"0.5199959\",\n \"0.51762295\",\n \"0.51659554\",\n \"0.5154082\",\n \"0.51449317\",\n \"0.51403785\",\n \"0.5137221\",\n \"0.5120202\",\n \"0.5111127\",\n \"0.5091579\",\n \"0.5079476\",\n \"0.50677305\",\n \"0.5060609\",\n \"0.5054933\",\n \"0.5051231\",\n \"0.5037422\",\n \"0.50233984\",\n \"0.50186116\",\n \"0.50184697\",\n \"0.50042254\",\n \"0.50016314\",\n \"0.49958307\",\n \"0.49944827\",\n \"0.496847\",\n \"0.49598205\",\n \"0.49580953\",\n \"0.49571994\",\n \"0.49374625\",\n \"0.4930975\",\n \"0.49197307\",\n \"0.49196845\",\n \"0.49183285\",\n \"0.49182057\",\n \"0.49132365\",\n \"0.4910899\",\n \"0.49107876\",\n \"0.4900585\",\n \"0.48913088\",\n \"0.48858678\",\n \"0.48754382\",\n \"0.4875081\",\n \"0.48701647\",\n \"0.48621914\",\n \"0.48564643\",\n \"0.4843127\",\n \"0.48408613\",\n \"0.48373908\",\n \"0.48327264\",\n \"0.4830208\",\n \"0.4830208\",\n \"0.48271242\",\n \"0.4824546\",\n \"0.4824037\",\n \"0.48222965\",\n \"0.48219734\",\n \"0.4819385\",\n \"0.48177865\",\n \"0.4816716\",\n \"0.4816069\",\n \"0.48077673\",\n \"0.48055157\",\n \"0.48024172\",\n \"0.47957236\",\n \"0.47934958\",\n \"0.4784589\",\n \"0.47748798\",\n \"0.4773948\",\n \"0.4769872\",\n \"0.47688463\",\n \"0.47585437\",\n \"0.47563392\",\n \"0.47562933\",\n \"0.4755001\",\n \"0.47495696\",\n \"0.47492486\",\n \"0.47492486\",\n \"0.4747271\",\n \"0.47472274\",\n \"0.4744499\",\n \"0.4742725\",\n \"0.47287247\",\n \"0.47183883\",\n \"0.4714961\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5361504"},"document_rank":{"kind":"string","value":"10"}}},{"rowIdx":81994,"cells":{"query":{"kind":"string","value":"Shut down the node"},"document":{"kind":"string","value":"def close(self):\n if self.client:\n self.client.connection.close()\n self.client = None"},"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 shutdown(self) -> None:","def shutdown(self) -> None:","def shutdown(self):","def shutdown(self, *args):\n return _SALOMERuntime.PythonNode_shutdown(self, *args)","def shutdown(self):\n ...","def shutdown(self, *args):\n return _SALOMERuntime.SalomeNode_shutdown(self, *args)","def shutdown(self):\n\n pass","def shutdown(self):\n pass","def shutdown(self):\n pass","def shutdown(self):\n pass","def ex_shutdown_node(self, node):\n # NOTE: This method is here for backward compatibility reasons after\n # this method was promoted to be part of the standard compute API in\n # Libcloud v2.7.0\n return self.stop_node(node=node)","def shutdown(self) -> None:\n pass","async def shutdown(self) -> int:","def shutdown(self):\n\n raise NotImplementedError","def shutdown(self):\n self.action('shutdown')","def _shutdown(self):","def shutdown(self):\n\t\tself._log.info('shutting down DHT')\n\t\tself._threads.shutdown() # Trigger shutdown of maintainance threads\n\t\tself._krpc.shutdown() # Stop listening for incoming connections\n\t\tself._nodes.shutdown()\n\t\tself._threads.join() # Trigger shutdown of maintainance threads","async def shutdown(self):","def shutdown(self) -> None:\n self.system.notify('Jarvis::SHUTTING DOWN now')\n sleep(3)\n self.system.power_off()","def shutdown(self):\n if self.alive:\n libplasma.disconnect(self.conn)\n self.alive = False","def shutdown(self):\n print(\"shutting down resource manager\")","def shutdown(self):\n raise NotImplementedError","def shutdown() -> None: # TODO Better place for this code\n # TODO Safe landing\n pass","def destroy_node(self):\n driver = self.driver\n driver.ex_detach_floating_ip_from_node(self.node, self.floating_ip)\n driver.destroy_node(self.node)\n sleep(15)\n for volume in self.volumes:\n driver.destroy_volume(volume)","def shutdown_cluster(self):\n self.cluster.shutdown()","def shutdown(self, *args):\n return _SALOMERuntime.PyFuncNode_shutdown(self, *args)","def shutdown(self) -> None:\n raise NotImplementedError()","def _shutdown_node(self, conn):\n compose_fname = COMPOSE_FNAME\n exec_plan = self.node_exec_plan.copy()\n while len(exec_plan) > 0:\n container_name = exec_plan.pop()\n self.__shutdown_service(conn, compose_fname, container_name)","def __shutdown(self):\n\n pass","def REBshutdown(self):\n pass","def shutdown(self):\n self.req_shutdown = True","def shutdown(self):\n raise NotImplementedError('Abstract Method: shutdown')","async def shutdown_gracefully(self) -> None:","async def shutdown_gracefully(self) -> None:","def Shutdown(self):\n pass","def Shutdown(self):\n pass","def Shutdown(self):\n self.conn.send(False)\n self.process.join()","def shutdown(self):\n self.shutdown_requested = True","def shutdown(self, join=True):\n super(PyrosROS, self).shutdown(join)","def shutdown(self):\n rospy.loginfo(\"Stopping Project\")\n rospy.sleep(1)","def initiate_shutdown(self) -> None:","def shutdown(self):\n self._shutdown(None, None)\n self._running = False","def stopped(self, exitCode):\r\n self._protocol = None\r\n\r\n if self._call:\r\n self._call.cancel()\r\n\r\n if exitCode:\r\n log.msg('Node ({0}) terminated with exit code: '\r\n '{1}'.format(self._name, exitCode))\r\n\r\n if self._owner:\r\n self._owner.unregisterNode(self)\r\n self._owner = None","def __del__(self):\n self.shutdown()","def shutdown(self):\n self.exit_app()","def shutdown_kernel(self, now=False, restart=False):","def shutdown(name):\n ret = {\"name\": name, \"changes\": {}, \"result\": None, \"comment\": \"\"}\n\n if __opts__[\"test\"]:\n ret[\"comment\"] = \"Shutting down local node\"\n return ret\n\n __salt__[\"trafficserver.shutdown\"]()\n\n ret[\"result\"] = True\n ret[\"comment\"] = \"Shutdown local node\"\n return ret","def shutdown_imagenode(self):\n multiprocessing.Process(daemon=True,\n args=((self.pid,)),\n target=self.shutdown_process_by_pid).start()\n sys.exit()","def shutdown():\n\n cmd = dict()\n cmd[\"type_\"] = \"shutdown\"\n cmd[\"name_\"] = \"all\"\n\n ## In case of the shutdown there will be no returned message to\n ## check the success.\n s = comm.send_and_receive_socket(cmd)\n\n s.close()","def shutdown(bot):\n setup(bot)","def shutup(self):\n logging.debug(\"shutup...\")\n self._eng.stop()","def Shutdown(self): # real signature unknown; restored from __doc__\n pass","def shutdown(self):\n try:\n self._request(\"POST /shutdown\")\n time.sleep(0.300)\n except requests.exceptions.ConnectionError:\n pass\n if self._process and self._process.poll() is None:\n self._process.kill()\n if self._session:\n self._session.close()","def shutup():\n try:\n ttsEng.shutup()\n except Exception, e:\n logging.error(e)","def shutdown(self):\n self._send_command('shutdown')\n self.sock.close()\n self.disconnected = True","def ShutDown(self):\n self.stop = True","def close(self):\n self.cluster.shutdown()","def Shutdown(self):\n logger.debug(\"Nodeleader shutting down\")\n\n self.stop_peer_check_loop()\n self.peer_check_loop_deferred = None\n\n self.stop_check_bcr_loop()\n self.check_bcr_loop_deferred = None\n\n self.stop_memcheck_loop()\n self.memcheck_loop_deferred = None\n\n self.stop_blockheight_loop()\n self.blockheight_loop_deferred = None\n\n for p in self.Peers:\n p.Disconnect()","async def shutdown(self):\n if self._unsub_stop:\n self._unsub_stop()\n self._unsub_stop = None\n await self.device.shutdown()","def end(self):\n self.shutdown = True","def shutdown(self) -> None:\n scalesets = Scaleset.search_by_pool(self.name)\n nodes = Node.search(query={\"pool_name\": [self.name]})\n if not scalesets and not nodes:\n logging.info(\"pool stopped, deleting: %s\", self.name)\n\n self.state = PoolState.halt\n self.delete()\n return\n\n for scaleset in scalesets:\n scaleset.state = ScalesetState.shutdown\n scaleset.save()\n\n for node in nodes:\n node.set_shutdown()\n\n self.save()","def __shutdownParallel(self):\n if self._parallelLib == ParallelLibEnum.ray and self._server is not None and not self.rayInstanciatedOutside:\n # we need to ssh and stop each remote node cluster (ray)\n servers = []\n if 'remoteNodes' in self.runInfoDict:\n servers += self.runInfoDict['remoteNodes']\n if 'headNode' in self.runInfoDict:\n servers += [self.runInfoDict['headNode']]\n # get local enviroment\n localEnv = os.environ.copy()\n localEnv[\"PYTHONPATH\"] = os.pathsep.join(sys.path)\n for nodeAddress in servers:\n self.raiseAMessage(\"Shutting down ray at address: \"+ nodeAddress)\n command=\"ray stop\"\n rayTerminate = utils.pickleSafeSubprocessPopen(['ssh',nodeAddress.split(\":\")[0],\"COMMAND='\"+command+\"'\",\"RAVEN_FRAMEWORK_DIR='\"+self.runInfoDict[\"FrameworkDir\"]+\"'\",self.runInfoDict['RemoteRunCommand']],shell=False,env=localEnv)\n rayTerminate.wait()\n if rayTerminate.returncode != 0:\n self.raiseAWarning(\"RAY FAILED TO TERMINATE ON NODE: \"+nodeAddress)\n # shutdown ray API (object storage, plasma, etc.)\n ray.shutdown()\n elif self._parallelLib == ParallelLibEnum.dask and self._server is not None and not self.rayInstanciatedOutside:\n self._server.close()\n if self._daskScheduler is not None:\n self._daskScheduler.terminate()","def power_off_node(self, node):\n msg = 'Node {0} has not become offline after hard shutdown'.format(\n node.name)\n logger.info('Power off node %s', node.name)\n node.destroy()\n logger.info('Wait a %s node offline status', node.name)\n helpers.wait(lambda: not self.fuel_web.get_nailgun_node_by_devops_node(\n node)['online'], timeout=60 * 5, timeout_msg=msg)","def shutdown(self):\n self.running = False\n ev3.Leds.all_off()\n self.left_motor.stop()\n self.right_motor.stop()","def shutdown(self):\n logger.info(\"Shutting down the factory\")\n self.to_shutdown = True","def shutdown(self):\n self.exit_event.set()","def shutdown(self):\n try:\n if self.working and self.exiting.acquire():\n self.bot('shutting down...')\n self.working = False\n self._handleEvent(self.getEvent('EVT_STOP'))\n if self._cron:\n self._cron.stop()\n self.bot('shutting down database connections...')\n self.storage.shutdown()\n except Exception, e:\n self.error(e)","def shutdown(self):\n #=======================================================================\n #\n # TODO: Place any cleanup code here.\n #\n #=======================================================================\n return","def shutdown(self):\n self.connected = False\n self.protocol.send_message(self.sock, '__!shutdown__')\n data = self.protocol.recover_message(self.sock)\n self.sock.close()\n self.sock = None","def shutdown(self):\n\t\trospy.loginfo(\"Stopping the robot...\")\n\t\tself.cmd_vel.publish(Twist())\n\t\trospy.sleep(1)","def _shutdown(self, *args):\n self.server.shutdown()","def shutdown(self):\r\n self.done = True","def shutdown():\n os.kill(os.getpid(), signal.SIGTERM)","def shutdown(self):\n ts.client.transport.close()","def __exit__(self, exc_type, exc_value, traceback): \n self.shutdown()","def terminate(self):\n self.unregister()\n self.zk.stop()\n self.zk.close()","def shutdown(self):\n self.sock.close()","def stop(self):\n shutdown_url = self._env[\"DATASTORE_HOST\"] + \"/shutdown\"\n req = urllib.request.Request(shutdown_url, method=\"POST\")\n urllib.request.urlopen(req)","def stop(self) -> None:\r\n stop_command = \"docker stop %s\" % self.name\r\n self.ip.exec_command(stop_command)\r\n print('node %s of blockchain %s at %s:%s stopped' % (self.node_index, self.blockchain_id,\r\n self.ip.address, self.rpc_port))","def shutdown_plugin(self):\n pass","def __exit__(self, exc_type, exc_val, exc_tb):\n self.server.stop()\n self.driver.quit()","def shutdown_kernel(self, now=False, restart=False):\n pass","def __exit__(self, exc_type, exc_value, traceback):\n nvmlShutdown()","def finish_node(self, node_name):\n del self._execution_pool[node_name]","def shutdown():\n os.system(\"sudo shutdown now\")","def shutdown(self):\n # TODO: Build a certificate chain so we can verify our localhost and remove the verify=False workaround.\n requests.get('{local_server_address}/shutdown'.format(local_server_address=self.local_server_address),\n verify=False)","def stop(self):\n self.__logger__.info(\"Stopping Ozone Cluster\")\n call([Command.docker_compose, \"-f\", self.docker_compose_file, \"down\"])\n Blockade.blockade_destroy()","def shutdown(self):\n print \"Plugin is shutting down.\"","def teardown(self):\n\n\t\tself.shutdown = True\n\t\tself.terminate_process()","def shutdown(self):\n\n if self._pyro_daemon:\n self._pyro_daemon.shutdown()","def shutdown_kernel(self, kernel_id, now=False, restart=False):","def shutdown(self) -> None:\n if self.is_alive():\n self.terminate()\n else:\n logger.warning(\"DHT shutdown has no effect: dht process is already not alive\")","def request_shutdown(self, restart=False):","def __shut_down(self):\n\n for line, buses in self.__bus_dict.items():\n for bus in buses:\n bus.send_to_bus(\"Server Shut Down\")","def Quit(self):\n t = threading.Thread(target=self.server.shutdown)\n t.start()","def shutdown(self) -> None:\n\n raise NotImplementedError(f\"shutdown() not implemented by {self.__class__.__name__}\")","def shutdown(self):\r\n self.socket.close()\r\n # self.socket_video.close()\r\n self.socket_state.close()","def close(self):\n logger.warning('Shutting down')\n self.display.off()\n self.mqtt.disconnect()","def destroy(self):\r\n self._namespace.unregisterNode(self)\r\n self._namespace = None\r\n\r\n super(Node, self).destroy()","def shutdown():\n\n global ALIVE\n if not ALIVE:\n return\n ALIVE = False\n\n LOG.info('shutting down children')\n\n # tell everyone to die\n for col in allLivingCollectors():\n col.shutdown()\n\n LOG.info('exiting')\n sys.exit(1)","def shutdown ( self ):\n # ---- Stop axon ----\n self.axon.stop()"],"string":"[\n \"def shutdown(self) -> None:\",\n \"def shutdown(self) -> None:\",\n \"def shutdown(self):\",\n \"def shutdown(self, *args):\\n return _SALOMERuntime.PythonNode_shutdown(self, *args)\",\n \"def shutdown(self):\\n ...\",\n \"def shutdown(self, *args):\\n return _SALOMERuntime.SalomeNode_shutdown(self, *args)\",\n \"def shutdown(self):\\n\\n pass\",\n \"def shutdown(self):\\n pass\",\n \"def shutdown(self):\\n pass\",\n \"def shutdown(self):\\n pass\",\n \"def ex_shutdown_node(self, node):\\n # NOTE: This method is here for backward compatibility reasons after\\n # this method was promoted to be part of the standard compute API in\\n # Libcloud v2.7.0\\n return self.stop_node(node=node)\",\n \"def shutdown(self) -> None:\\n pass\",\n \"async def shutdown(self) -> int:\",\n \"def shutdown(self):\\n\\n raise NotImplementedError\",\n \"def shutdown(self):\\n self.action('shutdown')\",\n \"def _shutdown(self):\",\n \"def shutdown(self):\\n\\t\\tself._log.info('shutting down DHT')\\n\\t\\tself._threads.shutdown() # Trigger shutdown of maintainance threads\\n\\t\\tself._krpc.shutdown() # Stop listening for incoming connections\\n\\t\\tself._nodes.shutdown()\\n\\t\\tself._threads.join() # Trigger shutdown of maintainance threads\",\n \"async def shutdown(self):\",\n \"def shutdown(self) -> None:\\n self.system.notify('Jarvis::SHUTTING DOWN now')\\n sleep(3)\\n self.system.power_off()\",\n \"def shutdown(self):\\n if self.alive:\\n libplasma.disconnect(self.conn)\\n self.alive = False\",\n \"def shutdown(self):\\n print(\\\"shutting down resource manager\\\")\",\n \"def shutdown(self):\\n raise NotImplementedError\",\n \"def shutdown() -> None: # TODO Better place for this code\\n # TODO Safe landing\\n pass\",\n \"def destroy_node(self):\\n driver = self.driver\\n driver.ex_detach_floating_ip_from_node(self.node, self.floating_ip)\\n driver.destroy_node(self.node)\\n sleep(15)\\n for volume in self.volumes:\\n driver.destroy_volume(volume)\",\n \"def shutdown_cluster(self):\\n self.cluster.shutdown()\",\n \"def shutdown(self, *args):\\n return _SALOMERuntime.PyFuncNode_shutdown(self, *args)\",\n \"def shutdown(self) -> None:\\n raise NotImplementedError()\",\n \"def _shutdown_node(self, conn):\\n compose_fname = COMPOSE_FNAME\\n exec_plan = self.node_exec_plan.copy()\\n while len(exec_plan) > 0:\\n container_name = exec_plan.pop()\\n self.__shutdown_service(conn, compose_fname, container_name)\",\n \"def __shutdown(self):\\n\\n pass\",\n \"def REBshutdown(self):\\n pass\",\n \"def shutdown(self):\\n self.req_shutdown = True\",\n \"def shutdown(self):\\n raise NotImplementedError('Abstract Method: shutdown')\",\n \"async def shutdown_gracefully(self) -> None:\",\n \"async def shutdown_gracefully(self) -> None:\",\n \"def Shutdown(self):\\n pass\",\n \"def Shutdown(self):\\n pass\",\n \"def Shutdown(self):\\n self.conn.send(False)\\n self.process.join()\",\n \"def shutdown(self):\\n self.shutdown_requested = True\",\n \"def shutdown(self, join=True):\\n super(PyrosROS, self).shutdown(join)\",\n \"def shutdown(self):\\n rospy.loginfo(\\\"Stopping Project\\\")\\n rospy.sleep(1)\",\n \"def initiate_shutdown(self) -> None:\",\n \"def shutdown(self):\\n self._shutdown(None, None)\\n self._running = False\",\n \"def stopped(self, exitCode):\\r\\n self._protocol = None\\r\\n\\r\\n if self._call:\\r\\n self._call.cancel()\\r\\n\\r\\n if exitCode:\\r\\n log.msg('Node ({0}) terminated with exit code: '\\r\\n '{1}'.format(self._name, exitCode))\\r\\n\\r\\n if self._owner:\\r\\n self._owner.unregisterNode(self)\\r\\n self._owner = None\",\n \"def __del__(self):\\n self.shutdown()\",\n \"def shutdown(self):\\n self.exit_app()\",\n \"def shutdown_kernel(self, now=False, restart=False):\",\n \"def shutdown(name):\\n ret = {\\\"name\\\": name, \\\"changes\\\": {}, \\\"result\\\": None, \\\"comment\\\": \\\"\\\"}\\n\\n if __opts__[\\\"test\\\"]:\\n ret[\\\"comment\\\"] = \\\"Shutting down local node\\\"\\n return ret\\n\\n __salt__[\\\"trafficserver.shutdown\\\"]()\\n\\n ret[\\\"result\\\"] = True\\n ret[\\\"comment\\\"] = \\\"Shutdown local node\\\"\\n return ret\",\n \"def shutdown_imagenode(self):\\n multiprocessing.Process(daemon=True,\\n args=((self.pid,)),\\n target=self.shutdown_process_by_pid).start()\\n sys.exit()\",\n \"def shutdown():\\n\\n cmd = dict()\\n cmd[\\\"type_\\\"] = \\\"shutdown\\\"\\n cmd[\\\"name_\\\"] = \\\"all\\\"\\n\\n ## In case of the shutdown there will be no returned message to\\n ## check the success.\\n s = comm.send_and_receive_socket(cmd)\\n\\n s.close()\",\n \"def shutdown(bot):\\n setup(bot)\",\n \"def shutup(self):\\n logging.debug(\\\"shutup...\\\")\\n self._eng.stop()\",\n \"def Shutdown(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def shutdown(self):\\n try:\\n self._request(\\\"POST /shutdown\\\")\\n time.sleep(0.300)\\n except requests.exceptions.ConnectionError:\\n pass\\n if self._process and self._process.poll() is None:\\n self._process.kill()\\n if self._session:\\n self._session.close()\",\n \"def shutup():\\n try:\\n ttsEng.shutup()\\n except Exception, e:\\n logging.error(e)\",\n \"def shutdown(self):\\n self._send_command('shutdown')\\n self.sock.close()\\n self.disconnected = True\",\n \"def ShutDown(self):\\n self.stop = True\",\n \"def close(self):\\n self.cluster.shutdown()\",\n \"def Shutdown(self):\\n logger.debug(\\\"Nodeleader shutting down\\\")\\n\\n self.stop_peer_check_loop()\\n self.peer_check_loop_deferred = None\\n\\n self.stop_check_bcr_loop()\\n self.check_bcr_loop_deferred = None\\n\\n self.stop_memcheck_loop()\\n self.memcheck_loop_deferred = None\\n\\n self.stop_blockheight_loop()\\n self.blockheight_loop_deferred = None\\n\\n for p in self.Peers:\\n p.Disconnect()\",\n \"async def shutdown(self):\\n if self._unsub_stop:\\n self._unsub_stop()\\n self._unsub_stop = None\\n await self.device.shutdown()\",\n \"def end(self):\\n self.shutdown = True\",\n \"def shutdown(self) -> None:\\n scalesets = Scaleset.search_by_pool(self.name)\\n nodes = Node.search(query={\\\"pool_name\\\": [self.name]})\\n if not scalesets and not nodes:\\n logging.info(\\\"pool stopped, deleting: %s\\\", self.name)\\n\\n self.state = PoolState.halt\\n self.delete()\\n return\\n\\n for scaleset in scalesets:\\n scaleset.state = ScalesetState.shutdown\\n scaleset.save()\\n\\n for node in nodes:\\n node.set_shutdown()\\n\\n self.save()\",\n \"def __shutdownParallel(self):\\n if self._parallelLib == ParallelLibEnum.ray and self._server is not None and not self.rayInstanciatedOutside:\\n # we need to ssh and stop each remote node cluster (ray)\\n servers = []\\n if 'remoteNodes' in self.runInfoDict:\\n servers += self.runInfoDict['remoteNodes']\\n if 'headNode' in self.runInfoDict:\\n servers += [self.runInfoDict['headNode']]\\n # get local enviroment\\n localEnv = os.environ.copy()\\n localEnv[\\\"PYTHONPATH\\\"] = os.pathsep.join(sys.path)\\n for nodeAddress in servers:\\n self.raiseAMessage(\\\"Shutting down ray at address: \\\"+ nodeAddress)\\n command=\\\"ray stop\\\"\\n rayTerminate = utils.pickleSafeSubprocessPopen(['ssh',nodeAddress.split(\\\":\\\")[0],\\\"COMMAND='\\\"+command+\\\"'\\\",\\\"RAVEN_FRAMEWORK_DIR='\\\"+self.runInfoDict[\\\"FrameworkDir\\\"]+\\\"'\\\",self.runInfoDict['RemoteRunCommand']],shell=False,env=localEnv)\\n rayTerminate.wait()\\n if rayTerminate.returncode != 0:\\n self.raiseAWarning(\\\"RAY FAILED TO TERMINATE ON NODE: \\\"+nodeAddress)\\n # shutdown ray API (object storage, plasma, etc.)\\n ray.shutdown()\\n elif self._parallelLib == ParallelLibEnum.dask and self._server is not None and not self.rayInstanciatedOutside:\\n self._server.close()\\n if self._daskScheduler is not None:\\n self._daskScheduler.terminate()\",\n \"def power_off_node(self, node):\\n msg = 'Node {0} has not become offline after hard shutdown'.format(\\n node.name)\\n logger.info('Power off node %s', node.name)\\n node.destroy()\\n logger.info('Wait a %s node offline status', node.name)\\n helpers.wait(lambda: not self.fuel_web.get_nailgun_node_by_devops_node(\\n node)['online'], timeout=60 * 5, timeout_msg=msg)\",\n \"def shutdown(self):\\n self.running = False\\n ev3.Leds.all_off()\\n self.left_motor.stop()\\n self.right_motor.stop()\",\n \"def shutdown(self):\\n logger.info(\\\"Shutting down the factory\\\")\\n self.to_shutdown = True\",\n \"def shutdown(self):\\n self.exit_event.set()\",\n \"def shutdown(self):\\n try:\\n if self.working and self.exiting.acquire():\\n self.bot('shutting down...')\\n self.working = False\\n self._handleEvent(self.getEvent('EVT_STOP'))\\n if self._cron:\\n self._cron.stop()\\n self.bot('shutting down database connections...')\\n self.storage.shutdown()\\n except Exception, e:\\n self.error(e)\",\n \"def shutdown(self):\\n #=======================================================================\\n #\\n # TODO: Place any cleanup code here.\\n #\\n #=======================================================================\\n return\",\n \"def shutdown(self):\\n self.connected = False\\n self.protocol.send_message(self.sock, '__!shutdown__')\\n data = self.protocol.recover_message(self.sock)\\n self.sock.close()\\n self.sock = None\",\n \"def shutdown(self):\\n\\t\\trospy.loginfo(\\\"Stopping the robot...\\\")\\n\\t\\tself.cmd_vel.publish(Twist())\\n\\t\\trospy.sleep(1)\",\n \"def _shutdown(self, *args):\\n self.server.shutdown()\",\n \"def shutdown(self):\\r\\n self.done = True\",\n \"def shutdown():\\n os.kill(os.getpid(), signal.SIGTERM)\",\n \"def shutdown(self):\\n ts.client.transport.close()\",\n \"def __exit__(self, exc_type, exc_value, traceback): \\n self.shutdown()\",\n \"def terminate(self):\\n self.unregister()\\n self.zk.stop()\\n self.zk.close()\",\n \"def shutdown(self):\\n self.sock.close()\",\n \"def stop(self):\\n shutdown_url = self._env[\\\"DATASTORE_HOST\\\"] + \\\"/shutdown\\\"\\n req = urllib.request.Request(shutdown_url, method=\\\"POST\\\")\\n urllib.request.urlopen(req)\",\n \"def stop(self) -> None:\\r\\n stop_command = \\\"docker stop %s\\\" % self.name\\r\\n self.ip.exec_command(stop_command)\\r\\n print('node %s of blockchain %s at %s:%s stopped' % (self.node_index, self.blockchain_id,\\r\\n self.ip.address, self.rpc_port))\",\n \"def shutdown_plugin(self):\\n pass\",\n \"def __exit__(self, exc_type, exc_val, exc_tb):\\n self.server.stop()\\n self.driver.quit()\",\n \"def shutdown_kernel(self, now=False, restart=False):\\n pass\",\n \"def __exit__(self, exc_type, exc_value, traceback):\\n nvmlShutdown()\",\n \"def finish_node(self, node_name):\\n del self._execution_pool[node_name]\",\n \"def shutdown():\\n os.system(\\\"sudo shutdown now\\\")\",\n \"def shutdown(self):\\n # TODO: Build a certificate chain so we can verify our localhost and remove the verify=False workaround.\\n requests.get('{local_server_address}/shutdown'.format(local_server_address=self.local_server_address),\\n verify=False)\",\n \"def stop(self):\\n self.__logger__.info(\\\"Stopping Ozone Cluster\\\")\\n call([Command.docker_compose, \\\"-f\\\", self.docker_compose_file, \\\"down\\\"])\\n Blockade.blockade_destroy()\",\n \"def shutdown(self):\\n print \\\"Plugin is shutting down.\\\"\",\n \"def teardown(self):\\n\\n\\t\\tself.shutdown = True\\n\\t\\tself.terminate_process()\",\n \"def shutdown(self):\\n\\n if self._pyro_daemon:\\n self._pyro_daemon.shutdown()\",\n \"def shutdown_kernel(self, kernel_id, now=False, restart=False):\",\n \"def shutdown(self) -> None:\\n if self.is_alive():\\n self.terminate()\\n else:\\n logger.warning(\\\"DHT shutdown has no effect: dht process is already not alive\\\")\",\n \"def request_shutdown(self, restart=False):\",\n \"def __shut_down(self):\\n\\n for line, buses in self.__bus_dict.items():\\n for bus in buses:\\n bus.send_to_bus(\\\"Server Shut Down\\\")\",\n \"def Quit(self):\\n t = threading.Thread(target=self.server.shutdown)\\n t.start()\",\n \"def shutdown(self) -> None:\\n\\n raise NotImplementedError(f\\\"shutdown() not implemented by {self.__class__.__name__}\\\")\",\n \"def shutdown(self):\\r\\n self.socket.close()\\r\\n # self.socket_video.close()\\r\\n self.socket_state.close()\",\n \"def close(self):\\n logger.warning('Shutting down')\\n self.display.off()\\n self.mqtt.disconnect()\",\n \"def destroy(self):\\r\\n self._namespace.unregisterNode(self)\\r\\n self._namespace = None\\r\\n\\r\\n super(Node, self).destroy()\",\n \"def shutdown():\\n\\n global ALIVE\\n if not ALIVE:\\n return\\n ALIVE = False\\n\\n LOG.info('shutting down children')\\n\\n # tell everyone to die\\n for col in allLivingCollectors():\\n col.shutdown()\\n\\n LOG.info('exiting')\\n sys.exit(1)\",\n \"def shutdown ( self ):\\n # ---- Stop axon ----\\n self.axon.stop()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75445867","0.75445867","0.7528702","0.7525221","0.74484587","0.7446821","0.7276193","0.72565746","0.72565746","0.72565746","0.7210875","0.71629465","0.71189094","0.7095154","0.70900863","0.7088388","0.7069015","0.7035386","0.6970288","0.69025195","0.6899966","0.68930995","0.688199","0.6841149","0.68382215","0.68218815","0.6792384","0.67824495","0.6757758","0.67551523","0.67378","0.6729971","0.6712011","0.6712011","0.670572","0.670572","0.66982305","0.66885144","0.6687059","0.66692203","0.66614366","0.6658487","0.6641697","0.66343355","0.66340387","0.6625785","0.66158503","0.66087013","0.6604327","0.6600254","0.6585703","0.65808296","0.6566383","0.6566362","0.6554585","0.65522546","0.6546886","0.6543899","0.65358734","0.6521692","0.6521541","0.65034324","0.64969116","0.6479107","0.6459513","0.6456399","0.6439552","0.6435923","0.6435417","0.64147335","0.64065754","0.6404726","0.6404514","0.64013267","0.6400806","0.63897985","0.6382591","0.63801616","0.6379101","0.6371943","0.6358768","0.6349316","0.6341775","0.6339176","0.63366175","0.63331217","0.6321077","0.63091934","0.63089675","0.6304389","0.63019735","0.6294964","0.62933046","0.62703407","0.62685275","0.6268086","0.62680745","0.62636966","0.6262025","0.6256829","0.62564874"],"string":"[\n \"0.75445867\",\n \"0.75445867\",\n \"0.7528702\",\n \"0.7525221\",\n \"0.74484587\",\n \"0.7446821\",\n \"0.7276193\",\n \"0.72565746\",\n \"0.72565746\",\n \"0.72565746\",\n \"0.7210875\",\n \"0.71629465\",\n \"0.71189094\",\n \"0.7095154\",\n \"0.70900863\",\n \"0.7088388\",\n \"0.7069015\",\n \"0.7035386\",\n \"0.6970288\",\n \"0.69025195\",\n \"0.6899966\",\n \"0.68930995\",\n \"0.688199\",\n \"0.6841149\",\n \"0.68382215\",\n \"0.68218815\",\n \"0.6792384\",\n \"0.67824495\",\n \"0.6757758\",\n \"0.67551523\",\n \"0.67378\",\n \"0.6729971\",\n \"0.6712011\",\n \"0.6712011\",\n \"0.670572\",\n \"0.670572\",\n \"0.66982305\",\n \"0.66885144\",\n \"0.6687059\",\n \"0.66692203\",\n \"0.66614366\",\n \"0.6658487\",\n \"0.6641697\",\n \"0.66343355\",\n \"0.66340387\",\n \"0.6625785\",\n \"0.66158503\",\n \"0.66087013\",\n \"0.6604327\",\n \"0.6600254\",\n \"0.6585703\",\n \"0.65808296\",\n \"0.6566383\",\n \"0.6566362\",\n \"0.6554585\",\n \"0.65522546\",\n \"0.6546886\",\n \"0.6543899\",\n \"0.65358734\",\n \"0.6521692\",\n \"0.6521541\",\n \"0.65034324\",\n \"0.64969116\",\n \"0.6479107\",\n \"0.6459513\",\n \"0.6456399\",\n \"0.6439552\",\n \"0.6435923\",\n \"0.6435417\",\n \"0.64147335\",\n \"0.64065754\",\n \"0.6404726\",\n \"0.6404514\",\n \"0.64013267\",\n \"0.6400806\",\n \"0.63897985\",\n \"0.6382591\",\n \"0.63801616\",\n \"0.6379101\",\n \"0.6371943\",\n \"0.6358768\",\n \"0.6349316\",\n \"0.6341775\",\n \"0.6339176\",\n \"0.63366175\",\n \"0.63331217\",\n \"0.6321077\",\n \"0.63091934\",\n \"0.63089675\",\n \"0.6304389\",\n \"0.63019735\",\n \"0.6294964\",\n \"0.62933046\",\n \"0.62703407\",\n \"0.62685275\",\n \"0.6268086\",\n \"0.62680745\",\n \"0.62636966\",\n \"0.6262025\",\n \"0.6256829\",\n \"0.62564874\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":81995,"cells":{"query":{"kind":"string","value":"Check a management response message for errors and correlation ID."},"document":{"kind":"string","value":"def check_response(response, expect=error.OK):\n code = response.properties.get('statusCode')\n if code != expect:\n if 200 <= code <= 299:\n raise ValueError(\"Response was %s(%s) but expected %s(%s): %s\" % (\n code, error.STATUS_TEXT[code], expect, error.STATUS_TEXT[expect],\n response.properties.get('statusDescription')))\n else:\n raise error.ManagementError.create(code, response.properties.get('statusDescription'))"},"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 check_response_errors(self, resp):\n return True","def validate_reply(request, reply):\n assert isinstance(reply, dict) and 'id' in reply\n assert ('result' in reply) != ('error' in reply)\n assert reply['id'] == request['id'] or \\\n reply['id'] == '00' and 'error' in reply","def _error_check(self, command_response):\n error_list = command_response.find(\"./clierror\")\n command_obj = command_response.find(\"./input\")\n if error_list is not None:\n command = command_obj.text if command_obj is not None else \"Unknown command\"\n msg = etree.tostring(error_list).decode()\n raise NXAPICommandError(command, msg)","def has_error(self, response):\n return response.find(' Matched') == -1 and response.find(' Failed') == -1","def _check_response_for_request_errors(self):\r\n if self.response.HighestSeverity == \"ERROR\":\r\n for notification in self.response.Notifications:\r\n if notification.Severity == \"ERROR\":\r\n if \"Invalid tracking number\" in notification.Message:\r\n raise FedexInvalidTrackingNumber(notification.Code,\r\n notification.Message)\r\n else:\r\n raise FedexError(notification.Code,\r\n notification.Message)","def test_broken_odata_details(self, mock_response):\n message = {\n \"error\": {\n \"code\": \"Conflict\",\n \"message\": \"The maximum number of Free ServerFarms allowed in a Subscription is 10.\",\n \"target\": None,\n \"details\": [\n {\"message\": \"The maximum number of Free ServerFarms allowed in a Subscription is 10.\"},\n {\"code\": \"Conflict\"},\n {\n \"errorentity\": {\n \"code\": \"Conflict\",\n \"message\": \"The maximum number of Free ServerFarms allowed in a Subscription is 10.\",\n \"extendedCode\": \"59301\",\n \"messageTemplate\": \"The maximum number of {0} ServerFarms allowed in a Subscription is {1}.\",\n \"parameters\": [\"Free\", \"10\"],\n \"innerErrors\": None,\n }\n },\n ],\n \"innererror\": None,\n }\n }\n exp = HttpResponseError(response=mock_response(json.dumps(message).encode(\"utf-8\")))\n assert exp.error.code == \"Conflict\"","def _check_command(self, resp, prompt):\n for line in resp.split(NEWLINE):\n if line.startswith('?'):\n raise InstrumentProtocolException('error processing command (%r)', resp[1:])\n if line.startswith('*'): # response\n if not valid_response(line):\n raise InstrumentProtocolException('checksum failed (%r)', line)","def validate_response(response: json):\n if \"error\" in response:\n print(\"ERROR: Request returned error\")\n print_request_response(response)\n exit(1)","def _check_response_for_request_errors(self):\r\n if self.response.HighestSeverity == \"ERROR\":\r\n for notification in self.response.Notifications:\r\n if notification.Severity == \"ERROR\":\r\n raise FedexError(notification.Code,\r\n notification.Message)","def validate_response(response):\n assert response.ok\n rpcdict = response.json()\n assert rpcdict['jsonrpc'] == '2.0'\n assert rpcdict['id']\n assert 'error' in rpcdict.keys() or 'result' in rpcdict.keys()","def validate_response(self, response: requests.Response) -> None:\n if 400 <= response.status_code < 500:\n msg = (\n f\"{response.status_code} Client Error: \"\n f\"{response.reason} for path: {self.path}. \"\n f\"Request payload: {response.request.body}\"\n )\n raise FatalAPIError(msg)\n\n elif 500 <= response.status_code < 600:\n msg = (\n f\"{response.status_code} Server Error: \"\n f\"{response.reason} for path: {self.path}\"\n )\n raise RetriableAPIError(msg)","def _get_resp_body_errors(self):\n\n if self._resp_body_errors and len(self._resp_body_errors) > 0:\n return self._resp_body_errors\n\n errors = []\n warnings = []\n resp_codes = []\n\n if self.verb is None:\n return errors\n\n dom = self.response.dom()\n if dom is None:\n return errors\n\n for e in dom.findall('Errors'):\n eSeverity = None\n eClass = None\n eShortMsg = None\n eLongMsg = None\n eCode = None\n\n try:\n eSeverity = e.findall('SeverityCode')[0].text\n except IndexError:\n pass\n\n try:\n eClass = e.findall('ErrorClassification')[0].text\n except IndexError:\n pass\n\n try:\n eCode = e.findall('ErrorCode')[0].text\n except IndexError:\n pass\n\n try:\n eShortMsg = smart_encode(e.findall('ShortMessage')[0].text)\n except IndexError:\n pass\n\n try:\n eLongMsg = smart_encode(e.findall('LongMessage')[0].text)\n except IndexError:\n pass\n\n try:\n eCode = e.findall('ErrorCode')[0].text\n if int(eCode) not in resp_codes:\n resp_codes.append(int(eCode))\n except IndexError:\n pass\n\n msg = str(\"Class: {eClass}, Severity: {severity}, Code: {code}, {shortMsg} {longMsg}\") \\\n .format(eClass=eClass, severity=eSeverity, code=eCode, shortMsg=eShortMsg,\n longMsg=eLongMsg)\n\n # from IPython import embed; embed()\n\n if eSeverity == 'Warning':\n warnings.append(msg)\n else:\n errors.append(msg)\n\n self._resp_body_warnings = warnings\n self._resp_body_errors = errors\n self._resp_codes = resp_codes\n\n if self.config.get('warnings') and len(warnings) > 0:\n log.warn(\"{verb}: {message}\\n\\n\".format(\n verb=self.verb, message=\"\\n\".join(warnings)))\n\n if self.response.reply.Ack == 'Failure':\n if self.config.get('errors'):\n log.error(\"{verb}: {message}\\n\\n\".format(\n verb=self.verb, message=\"\\n\".join(errors)))\n\n return errors\n\n return []","def _check_response(self, res: requests.Response, token: str) -> None:\n return","def validate_response(self, response):\n pass","def validate(self, response):\n return response[\"status_code\"] == 1","def _check_failures(self, response, batch=None):\n if not response.get('Failed'):\n return 0 # nothing to do here\n\n LOGGER.error('The following records failed to put to queue %s', self.queue.url)\n\n for failure in response['Failed']:\n # Pull out the record that matches this ID\n record = self._extract_message_by_id(batch, failure['Id']) if batch else None\n LOGGER.error(self._format_failure_message(failure, record=record))\n\n failed = len(response.get('Failed', []))\n self._log_failed(failed)\n\n # Raise an exception if this is the fault of the sender (us)\n if any(result['SenderFault'] for result in response['Failed']):\n raise SQSClientError('Failed to send records to SQS:\\n{}'.format(response))\n\n return failed","def check_resp(resp, user_id, message):\n event = resp[\"data\"][\"on_chat_message_sent\"][\"event\"]\n assert json.loads(event) == {\n \"user_id\": user_id,\n \"payload\": message,\n }, \"Subscription notification contains wrong data!\"","def _check_response_for_request_errors(self):\r\n if self.response.HighestSeverity == \"ERROR\":\r\n for notification in self.response.Notifications:\r\n if notification.Severity == \"ERROR\":\r\n if \"Postal Code Not Found\" in notification.Message:\r\n raise FedexPostalCodeNotFound(notification.Code,\r\n notification.Message)\r\n\r\n elif \"Invalid Postal Code Format\" in self.response.Notifications:\r\n raise FedexInvalidPostalCodeFormat(notification.Code,\r\n notification.Message)\r\n else:\r\n raise FedexError(notification.Code,\r\n notification.Message)","def _err_response(self, msg):\r\n return {'success': False, 'error': msg}","def check_set_errors(self):\n response = self.read()\n return [] if response == \"\" else [response]","async def _handle_response(response: ClientResponse) -> Dict:\n content = await response.json(encoding='utf-8', loads=loads)\n if response.status != 200:\n for member in JmRpcErrorType:\n if content['message'] != member.value:\n continue\n raise JmRpcError(response.status, content)\n response.raise_for_status()\n return content","def verify_error_message(self, response, error_message):\n self.assertEqual(response.status_code, 400)\n response = json.loads(response.content.decode('utf-8'))\n self.assertIn('error', response)\n self.assertEqual(response['error'], error_message)","def success_message_code(response_obj, check_util=None):\n if check_util:\n success = check_util(response_obj)\n phrase, status = assign_message_code(success)\n else:\n success = True\n phrase, status = response_obj.reason, response_obj.status_code\n return success, phrase, status","def check_error_output(self, output):\n\n # Display info message\n log.info(\"check_error_output\")\n\n # Check if output has some data\n if output:\n\n # Yes\n\n # Display info message\n log.info(\"check_error_output: output has some data\")\n\n # Check all elements in the list of output\n for element in self._send_command_error_in_returned_output:\n\n # Display info message\n log.info(f\"check_error_output: element: {element}\")\n\n # Display info message\n log.info(f\"check_error_output: output[0]: {output[0]}\")\n\n # Check if the output starts with a string with an error message (like \"% Invalid input detected at '^' marker.\")\n\n # Error message?\n if output.startswith(element):\n\n # Yes\n\n # Raise an exception\n raise Exception(output)","def _validate_response(request, response, schema_data, schema_resolver):\n try:\n validate_outgoing_response(\n request,\n response,\n schema_data,\n schema_resolver\n )\n except jsonschema.exceptions.ValidationError as exc:\n # This will alter our stack trace slightly, but Pyramid knows how\n # to render it. And the real value is in the message anyway.\n raise HTTPInternalServerError(str(exc))","def _get_response(self):\n resp = yield from self._responses.get()\n if len(resp) == 1:\n line = resp[0]\n if line.startswith('ACK'):\n i = line.index('@')\n error = line[5:i]\n l = line[i+1:line.index(']')]\n command = line[line.index('{')+1:line.index('}')]\n msg = line[line.index('}')+1:]\n raise MpdCommandException(line, error, l, command, msg)\n return resp","def __CheckResponse(self, response):\n\n status = response.status\n if (status == httplib.OK or status == httplib.CREATED\n or status == httplib.NO_CONTENT):\n return\n elif (status == httplib.UNAUTHORIZED):\n raise BadCredentialsException\n elif (status == httplib.SERVICE_UNAVAILABLE):\n raise ServerBusyException\n elif (status == httplib.BAD_REQUEST\n or status == httplib.UNPROCESSABLE_ENTITY):\n raise BadArgumentsException\n elif (status == httplib.NOT_FOUND):\n raise NotFoundException\n else:\n raise BadOperationException","def checkError(invoke_response, message):\n\n if 'FunctionError' in invoke_response:\n err_message = invoke_response['Payload'].read()\n print(message)\n print(err_message)\n return {\n 'statusCode': 500,\n 'body': json.dumps(str(err_message))\n }\n return None","def _handle_response(response: str) -> Result:\n logger.debug('SoapService - _handle_response(response: {})'.format(response))\n result = Result()\n parsed_response = xmltodict.parse(response)['xmlreply']\n response_result = parsed_response['messages']['result']\n\n if response_result == 'OK':\n refno = parsed_response['apmdata']['prospect']['p.cm']['refno']\n result.data = {'Refno': refno}\n result.status = True\n elif response_result == 'Error':\n errors = parsed_response['messages']['error'] if 'error' in parsed_response['messages'] else None # type: list\n result.status = False\n\n return result","def callback(response):\n error_msg = None\n if response.status_code >= 300 and response.status_code < 500:\n resp = response.json()\n if response.status_code == 401 and resp.get(\"message\") == \"Authentication Error\":\n raise AuthenticationError()\n\n msg = resp.get('messages') or resp.get('message')\n details = resp.get('details')\n error_msg = u\"ReaQta Error: \\n status code: {0}\\n message: {1}\\n details: {2}\".format(\n response.status_code,\n msg,\n details)\n\n return response, error_msg","def get_errors(self, response: response_domain_model.Response, question_code: str) -> Sequence['ValidationError']:\n ...","def verify_message(lines, expected_response):\n position = 0\n if isinstance(expected_response, basestring):\n expected_response = [expected_response]\n if isinstance(expected_response, set):\n expected_response = list(expected_response)\n if not isinstance(expected_response, list):\n raise TypeError(\"verify_message: expectedResponse must be list, set or string\")\n for message in expected_response:\n try:\n found, position, _ = find_next(lines, message, position)\n if not found:\n return False\n position = position + 1\n except TypeError:\n return False\n except LookupError:\n return False\n return True","def _get_error_message(response):\n try:\n return response.json()[\"detail\"]\n except (KeyError, _JSONDecodeError):\n return response.text","def check_response(response):\n for status_code, err_class, err_type in [\n (HTTPStatus.INTERNAL_SERVER_ERROR, ServerError, 'Server'),\n (HTTPStatus.BAD_REQUEST, ClientError, 'Client')\n ]: # highest http status code first\n if response.status_code >= status_code:\n try:\n status = HTTPStatus(response.status_code)\n except ValueError as err:\n m = re.search(r'\\d{3}', err.args[0], flags=re.ASCII)\n if not m:\n raise err\n msg = f'Generic {err_type} Error ({m.group()})'\n else:\n msg = f'({status}) {status.description}'\n\n raise err_class(msg)\n\n if response.status_code == HTTPStatus.OK \\\n and SERVER_DB_ERROR_MSG in response.text:\n raise ServerError('Server cannot access the database')","def validate_get_response(self, response):\n\n self.validate_response(response)\n if response.status_code not in self.model._meta['valid_get_status']:\n raise InvalidStatusError(\n self.model._meta['valid_get_status'], response\n )","def process_error_response(self, resources, resource, api, operation,\n error_response, context):\n pass","def _check_reply(self):\n self._more_packets_available = False\n try:\n if self._reply is None:\n self._status = (3, '{} without reply'.format(\n REPLAY_INFO[unpack_dint(self._message[:2])]))\n return False\n # Get the type of command\n typ = unpack_uint(self._reply[:2])\n\n # Encapsulation status check\n if unpack_dint(self._reply[8:12]) != SUCCESS:\n self._status = (3, \"{0} reply status:{1}\".format(\n REPLAY_INFO[typ],\n SERVICE_STATUS[unpack_dint(self._reply[8:12])]))\n return False\n\n # Command Specific Status check\n if typ == unpack_uint(ENCAPSULATION_COMMAND[\"send_rr_data\"]):\n status = unpack_usint(self._reply[42:43])\n if status != SUCCESS:\n status_msg = \"send_rr_data reply:{0} - Extend status:{1}\"\n self._status = (3, status_msg.format(\n SERVICE_STATUS[status],\n get_extended_status(self._reply, 42)))\n return False\n else:\n return True\n return True\n except Exception as e:\n raise DataError(e)","def identify_result_error(self, record):\n return [\"error\"]","def check_errors(self) -> None:\n # TODO check the manual for error codes & interpert them.\n return self.send(self.cmd.GET_GLOBALSTATUS_CURRENTERROR)","def error(self, message):\n if 'PhysicalResourceId' not in self.response:\n self.response['PhysicalResourceId'] = self.response['LogicalResourceId']\n self.response['Status'] = 'FAILED'\n self.response['Reason'] = message\n self._send_response(self.response)","def check_errors(self, data):\n for entry in data:\n if entry.find('ERROR') != -1:\n return entry\n return False","def response_check(response):\n print(response)\n print(response.text)\n return response.status_code == 201","def _errors_exist(self, doc_type, login, response_payload):\n if \"errors\" in response_payload:\n for _, error in enumerate(response_payload[\"errors\"]):\n message = ':'.join([doc_type, login, str(error)])\n self.logger.error(message)\n return True\n return False","def process_response(response):\n # Print it and exit with 1 if operation wasn't successful\n print(response['message'])\n if response['status'] != 'success':\n sys.exit(1)","def _has_error_code(res):\n\n if res and 'error_code' in res:\n return res['error_code'] > 0\n\n return False","def check(self):\n out = self.LeggiDocumento('000')\n if 'success' in out and 'result' in out:\n out.pop('result')\n else:\n out.pop('request')\n return out","def check_errors(self):\n\n errors = []\n while True:\n err = self.values(\"SYST:ERR?\")\n if int(err[0]) != 0:\n errmsg = \"Agilent 5313xA: {0}: {1}\".format(err[0], err[1])\n log.error(errmsg + '\\n')\n errors.append(errmsg)\n else:\n break\n\n return errors","def check_errors(self) -> None:","def verify_response(self, system_name, expected_api_response,\n expected_response_type, comparison_mode,\n request_id=None, generate_output_diff_file=\"Yes\"):\n arguments = {'system_name': system_name,\n 'expected_api_response': expected_api_response,\n 'expected_response_type': expected_response_type,\n 'comparison_mode': comparison_mode,\n 'request_id': request_id,\n 'generate_output_diff_file': generate_output_diff_file}\n wdesc = \"Verify API response with the expected API response\"\n pNote(wdesc)\n output_file = self.logsdir+\"/difference_output.log\"\n output_file = Utils.file_Utils.addTimeDate(output_file)\n generate_output_diff_file = Utils.rest_Utils.\\\n resolve_value_of_verify(generate_output_diff_file)\n\n try:\n arguments[\"expected_api_response\"] = Utils.rest_Utils.\\\n check_ext_get_abspath(arguments[\"expected_api_response\"],\n self.tc_path)\n\n credentials = Utils.data_Utils.\\\n get_user_specified_tag_values_in_tc(self.datafile, **arguments)\n\n credentials[\"expected_api_response\"] = Utils.rest_Utils.\\\n check_ext_get_abspath(credentials[\"expected_api_response\"],\n os.path.dirname(self.datafile))\n\n if request_id:\n response = Utils.data_Utils.get_object_from_datarepository(\n \"{0}_{1}_api_response_object\".format(system_name,\n credentials['request_id']))\n else:\n response = Utils.data_Utils.get_object_from_datarepository(\n \"{0}_api_response_object\".format(system_name))\n except Exception as exception:\n pNote(exception, \"error\")\n return False\n if any([x in credentials[\"comparison_mode\"] for x in [\"xpath=\", \"jsonpath=\", \"regex=\"]]) \\\n or credentials[\"comparison_mode\"] == \"\":\n status = self.rest_object.cmp_content_response(self.datafile, system_name, response,\n credentials['expected_api_response'],\n credentials['expected_response_type'],\n credentials['comparison_mode'])\n else:\n status = self.rest_object.cmp_response(response,\n credentials['expected_api_response'],\n credentials['expected_response_type'],\n output_file,\n credentials['generate_output_diff_file'])\n return status","def check_response(response):\n status = response.get('status')\n ret = status and status == 'OK'\n if not ret:\n logging.error('Received unexpected failure response from polyswarmd: %s', response)\n return ret","def _check_response_status(response):\n # TODO: Test!\n if response.status == 1:\n raise InvalidLength(f\"{response.info}: Message is too long.\")\n elif response.status == 2:\n raise InvalidXML(f\"{response.info}: Invalid XML content.\")\n elif response.status == 3:\n raise WrongContent(\n f\"{response.info}: Wrong data content. \"\n f\"Ex: too long text in a field.\"\n )\n elif response.status == 4:\n raise NotAuthorized(\n f\"{response.info}: Wrong combination of \"\n f\"transmitter, instance and password\"\n )\n elif response.status == 5:\n # Fail over should kick in.\n raise NotTreatedNotDistributed(\n f\"{response.info}: Error in \"\n f\"processing. It has neither been \"\n f\"treated or distributed\"\n )\n elif response.status == 7:\n raise MandatoryDataMissing(\n f\"{response.info}: Mandatory XML tag \" f\"missing\"\n )\n elif response.status == 9:\n raise ServiceUnavailable(\n (\n f\"{response.info}: Heartbeat is not enabled on the server for \"\n f\"this transmitter or you are not authorized to use it.\"\n )\n )\n elif response.status == 10:\n raise DuplicateAlarm(\n f\"{response.info}: The same alarm was received\" f\" multiple times\"\n )\n elif response.status == 98:\n raise ServerSystemError(f\"{response.info}: General receiver error\")\n elif response.status == 99:\n # Failover should kick in.\n raise OtherError(f\"{response.info}: Unknown receiver error\")\n elif response.status == 100:\n raise XMLHeaderError(f\"{response.info}: Invalid or missing XML \" f\"header\")\n elif response.status == 101:\n raise PingToOften(f\"{response.info}: Heartbeat is sent too often\")","def error_check(self, message):\n matches = ERROR_SYNTAX.match(message)\n if matches:\n error_code = int(matches.group(1))\n error_message = matches.group(2)\n return error_code, error_message\n return None","def _check_errors(self, json_loaded):\n\n content = json_loaded\n try:\n m = content[u'error'][u'message']\n c = content[u'error'][u'code']\n out= \"API Error code: {}\\nError message: {}\".format(c, m)\n raise InvalidQueryException(self.name, out)\n except KeyError:\n pass","def test_error_message_header_role_request_failed_codes(self):\n\n error_type = 11\n error_type_value = Error.ErrorType.OFPET_ROLE_REQUEST_FAILED\n\n error_code = 0\n\n iter_given_code = Error.ErrorType.get_class(error_type_value).__iter__()\n length = Error.ErrorType.get_class(error_type_value).__len__()\n\n while error_code < self.MAX_ROLE_REQUEST_FAILED_CODE_VALUE or length > 0:\n data = UBInt32(random.randint(2, 250)).pack()\n xid = random.randint(2, 250)\n\n test_value = b'\\x05\\x01\\x00\\x10' + UBInt32(xid).pack() + UBInt16(error_type).pack() + \\\n UBInt16(error_code).pack() + data\n\n if error_code < self.MAX_ROLE_REQUEST_FAILED_CODE_VALUE:\n error_code += 1\n length -= 1\n\n test_object_error_messages = Error.ErrorMsg(xid, error_type_value, iter_given_code.__next__(), data).pack()\n\n self.assertEqual(test_value, test_object_error_messages)","def _validate_GetCC_response(self, response, prompt):\n error = self._find_error(response)\n\n if error:\n log.error(\"GetCC command encountered error; type='%s' msg='%s'\", error[0], error[1])\n raise InstrumentProtocolException('GetCC command failure: type=\"%s\" msg=\"%s\"' % (error[0], error[1]))\n\n if not SBE19CalibrationParticle.resp_regex_compiled().search(response):\n log.error('_validate_GetCC_response: GetCC command not recognized: %s.' % response)\n raise InstrumentProtocolException('GetCC command not recognized: %s.' % response)\n\n return response","def check_ocsp_response_status(single_response_map, ocsp_response):\n ret = []\n for hkey, data in single_response_map.items():\n if data['status'] == 'good':\n ret.append(_process_good_status(\n hkey, data, ocsp_response))\n elif data['status'] == 'revoked': # revoked\n _process_revoked_status(hkey, data)\n else: # unknown\n _process_unknown_status(hkey)\n if len(ret) != len(single_response_map):\n raise OperationalError(\n msg=u\"Not all OCSP Response was returned\",\n errno=ER_INVALID_OCSP_RESPONSE,\n )","def check_message(self, msg):\n pass","def _process_unsuccessful_response(\n self,\n response: Response,\n case: Literal['validate_api_key', 'balances', 'trades', 'asset_movements'],\n ) -> Union[\n list,\n tuple[bool, str],\n ExchangeQueryBalances,\n ]:\n try:\n response_list = jsonloads_list(response.text)\n except JSONDecodeError as e:\n msg = f'{self.name} {case} returned an invalid JSON response: {response.text}.'\n log.error(msg)\n\n if case in ('validate_api_key', 'balances'):\n return False, msg\n if case in ('trades', 'asset_movements'):\n self.msg_aggregator.add_error(\n f'Got remote error while querying {self.name} {case}: {msg}',\n )\n return []\n\n raise AssertionError(f'Unexpected {self.name} response_case: {case}') from e\n\n error_data = self._get_error_response_data(response_list)\n if error_data.error_code == API_ERR_AUTH_NONCE_CODE:\n message = API_ERR_AUTH_NONCE_MESSAGE\n # Errors related with the API key return a human readable message\n elif case == 'validate_api_key' and error_data.error_code == API_KEY_ERROR_CODE:\n message = API_KEY_ERROR_MESSAGE\n else:\n # Below any other error not related with the system clock or the API key\n reason = error_data.reason or response.text\n message = (\n f'{self.name} query responded with error status code: {response.status_code} '\n f'and text: {reason}.'\n )\n log.error(message)\n\n if case in ('validate_api_key', 'balances'):\n return False, message\n if case in ('trades', 'asset_movements'):\n self.msg_aggregator.add_error(\n f'Got remote error while querying {self.name} {case}: {message}',\n )\n return []\n\n raise AssertionError(f'Unexpected {self.name} response_case: {case}')","def test_handle_response_wrong_message_type(self):\n lookup = Lookup(FindNode, self.target, self.node, self.event_loop)\n uuid = [uuid for uuid in lookup.pending_requests.keys()][0]\n contact = lookup.shortlist[0]\n msg = OK(uuid, self.node.network_id, self.node.network_id,\n self.reply_port, self.version, self.seal)\n response = asyncio.Future()\n response.set_result(msg)\n lookup._blacklist = mock.MagicMock()\n lookup._handle_error = mock.MagicMock()\n lookup._handle_response(uuid, contact, response)\n lookup._blacklist.assert_called_once_with(contact)\n self.assertEqual(lookup._handle_error.call_count, 1)\n args = lookup._handle_error.call_args[0]\n self.assertEqual(args[0], uuid)\n self.assertEqual(args[1], contact)\n self.assertIsInstance(args[2], TypeError)\n self.assertEqual(args[2].args[0],\n \"Unexpected response type from {}\".format(contact))","def test_process_response(self):\n t = self.create_request_object()\n response_content = u\"\"\" <Response ReferenceNumber=\"82e942b0-48e8-4cf4-b299-51e2b6a89a1b\"\n InboundODMFileOID=\"\"\n IsTransactionSuccessful=\"1\"\n SuccessStatistics=\"Rave objects touched: Subjects=0; Folders=0; Forms=0; Fields=0; LogLines=0\" NewRecords=\"\">\n </Response>\n \"\"\"\n req = mock.Mock(requests.Request, text=response_content)\n response = t.result(req)\n self.assertTrue(isinstance(response, RWSResponse))","def cmd_error_check(self, cmd_out):\n for err in self.err_strings:\n if re.search('\\\\b%s\\\\b' % (err), cmd_out, re.I):\n _log.info(cmd_out)\n _log.info(\n \"Cmd execution failed! with this Return Error: \\n%s\" % (\n cmd_out))\n return 0","def report_transaction_error_messages(self):\n response = self.__get_transaction_response()\n\n # get response data from response object\n response_data = response.json()\n\n # get error messages\n response_error = response_data['Error']\n response_error_messages = response_error['messages']\n\n # add all error messages to the report\n error_messages_to_report = []\n for response_error_message in response_error_messages:\n error_description = response_error_message['description']\n error_messages_to_report.append(error_description)\n\n return error_messages_to_report","def check_response(self, resp):\n\n # For successful API call, response code will be 200 (OK)\n if resp.ok:\n json = resp.json()\n self.response = ResponseHolder()\n self.response.response = json\n\n # Check the code\n if 'status' not in json:\n raise InvalidResponse('No status field')\n\n self.response.status = self.field_to_long(json['status'])\n if self.response.status != EBConsts.STATUS_OK:\n txt_status = self.get_text_status(json)\n raise InvalidStatus('Status is %s (%04X)'\n % (txt_status if txt_status is not None else \"\", self.response.status))\n\n if self.response_checker is not None:\n self.response_checker(self.response)\n\n return self.response\n\n else:\n # If response code is not ok (200), print the resulting http error code with description\n resp.raise_for_status()\n pass","def check_status(result_out, part_msg, log, piid_flag=None):\n passed = '\\033[1;32m...passed\\033[1;0m'\n failed = '\\033[1;31m...failed\\033[1;0m'\n\n if result_out.status_code in [200, 201, 403, 401]:\n if piid_flag == 'data_quality':\n msg = pprint.pformat(result_out.json(), indent=2, width=70)\n else:\n try:\n if 'status' in result_out.json().keys() and result_out.json()['status'] == 'error':\n msg = result_out.json()['message']\n log.error(part_msg + failed)\n log.debug(msg)\n raise RuntimeError\n elif 'success' in result_out.json().keys() and not result_out.json()['success']:\n msg = result_out.json()\n log.error(part_msg + failed)\n log.debug(msg)\n raise RuntimeError\n else:\n if piid_flag == 'organizations':\n msg = 'Number of organizations:\\t' + str(\n len(result_out.json()['organizations'][0]))\n elif piid_flag == 'users':\n msg = 'Number of users:\\t' + str(len(result_out.json()['users'][0]))\n elif piid_flag == 'mappings':\n msg = pprint.pformat(result_out.json()['suggested_column_mappings'],\n indent=2, width=70)\n else:\n msg = pprint.pformat(result_out.json(), indent=2, width=70)\n except BaseException:\n log.error(part_msg + failed)\n log.debug('Unknown error during request results recovery')\n raise RuntimeError\n\n log.info(part_msg + passed)\n log.debug(msg)\n else:\n msg = result_out.reason\n log.error(part_msg + failed)\n log.debug(msg)\n raise RuntimeError\n\n return","def error_details(self) -> pulumi.Output[Sequence['outputs.ErrorDetailResponse']]:\n return pulumi.get(self, \"error_details\")","def check_response(rv):\n if rv != 'OK':\n print \"No message found\"\n return False\n return True","def mora_assert(response):\n assert response.status_code in (200, 201, 400, 404), response.status_code\n if response.status_code == 400:\n # Check actual response\n assert (\n response.text.find(\"not give raise to a new registration\") > 0\n ), response.text\n logger.debug(\"Request had no effect\")\n return None","def check_response(self, xml_str, xml_name):\n\n if \"<ok/>\" not in xml_str:\n self.module.fail_json(msg='Error: %s failed.' % xml_name)","def is_valid_response(self, response):\r\n if response.status_code in VALID_CODES:\r\n return True\r\n return False","def _check_response(response: requests.Response) -> None:\n logger.debug('Received response:\\n%s', response.content)\n try:\n response.raise_for_status()\n if not response.json()['status']:\n _report_failure('your e-mail address appears to be invalid')\n except requests.exceptions.HTTPError:\n _report_failure()\n except (ValueError, KeyError):\n _report_failure('there was a problem with the server response')","def isResp(obxDict):\n readingCode = getReadingCode(obxDict)\n return readingCode == '76270-8'","def _extract_error(self, resp):\n reason = resp.headers.get(\"reason\", None)\n full_response = None\n\n if reason is None:\n try:\n # if response is in json format\n reason = resp.json()[\"error\"][\"msg\"]\n except KeyError:\n # if json response has unexpected structure\n full_response = resp.content\n except ValueError:\n # otherwise we assume it's html\n reason, full_html = self._scrape_response(resp.headers, resp.content)\n full_response = unescape_html(full_html)\n\n msg = \"[Reason: %s]\" % reason\n\n if reason is None:\n msg += \"\\n%s\" % full_response\n\n return msg","def check_result(self, coro_id):\n try:\n status, response = self.coros_result.get(coro_id)\n if status != CoroStatus.Queued:\n self.remove_coro(coro_id)\n return status, response\n except KeyError:\n raise CoroMissingException(\"Coroutine Id {}\"\n \" is not Active\".format(coro_id))","def _validate_response(self, response):\n # Check for unexpected response - all should be JSON dicts that have\n # already been deserialised\n if not isinstance(response, types.DictionaryType):\n self.message(\n \"\\t\\t[!] ERROR - Unexpected value returned from the API: '%s'\" %\n (response))\n return False\n\n # Check for valid errors\n if \"error\" in response and \"msg\" in response:\n self.message(\n \"\\t\\t[!] ERROR - %s (%s)\" %\n (response[\"msg\"], response[\"timestamp\"]))\n return False\n\n # Is this a valid response message\n if \"msg\" in response:\n return True\n\n # Catch all...dictionary returned but does not contain expected keys?\n # Who know's what's going on here?!\n else:\n self.message(\n \"\\t\\t[!] ERROR - Unexpected dictionary response returned from the API: '%s'\" %\n (response))\n return False","def _check_process_resp(self, resp, expected_fields=None):\n\n if resp.status_code != LenovoRestClient.RESP_CODE_OK:\n raise cexc.NOSRestHTTPError(http_code=resp.status_code,\n http_reason=resp.reason, http_op=resp.request.method,\n url=resp.url, http_response=resp.text)\n\n rj = resp.json()\n\n if not expected_fields:\n return rj\n\n for field in expected_fields:\n try:\n val = rj[field]\n except KeyError:\n raise cexc.NOSJsonFieldNotFound(field=field, url=resp.url, json=rj)\n\n return rj","def validate_multi_status(multi_response: List[Dict]):\n if any(response[\"response_code\"] != HTTPStatus.OK for response in multi_response):\n raise RuntimeError(str(multi_response))","def check(self, response, payload):\n # check response body\n if not response.text:\n return False\n\n # check for output\n # uid=user gid=group groups=groups\n regex = r\"(uid=\\d+[\\(\\)\\w\\-]+)(\\s+gid=\\d+[\\(\\)\\w\\-]+)(\\s+groups=\\d+[\\(\\)\\w\\-,]+)?\"\n if re.search(regex, response.text):\n return True\n else:\n return False","def is_error(response: str) -> bool:\n return \"ERROR\" in response","def check_invalid_tab_id_response(self, resp):\r\n\r\n self.assertEqual(resp.status_code, 400)\r\n resp_content = json.loads(resp.content)\r\n self.assertIn(\"error\", resp_content)\r\n self.assertIn(\"invalid_tab_id\", resp_content['error'])","def check(self):\n invalid = []\n\n if not self.route:\n invalid.append(('route', 'missing'))\n elif not self.route[1] in ['GET', 'POST', 'PUT']:\n invalid.append(('route', 'invalid method: %s' % self.route[1]))\n\n has_2xx = False\n for rcode in self.return_codes:\n code = rcode[0]\n if code >= 200 and code < 300:\n has_2xx = True\n break\n if not has_2xx:\n invalid.append(('return_codes', 'Missing succes return code doc'))\n\n if self.client_auth is None:\n invalid.append(\n ('client_auth', 'Please provide client auth requirement'))\n\n if self.user_auth is None:\n invalid.append(\n ('user_auth', 'Please provide user auth requirement'))\n\n if invalid:\n msgs = []\n for error in invalid:\n msgs.append(\"%s: %s\" % error)\n raise ValueError(\n \"APIFunc for %s is invalid: %s\"\n % (self.viewfunc.__name__,\n ', '.join(msgs)))","def __get_response_error(message, response):\n\n rjson = response.json()\n error_description = \"Code %s - %s\" %(str(response.status_code), rjson.get('message'))\n\n return {\n 'app_message': \"%s\" % (message),\n 'error_description': \"[%s] - %s\" % (message, error_description),\n 'code': response.status_code\n }","def test_get_errorCode(self):\n for app_num, servo_type in app_nr.items():\n try:\n par = self.get_parameter(servo_type, app_num, ERROR_CODE_IDX, ERROR_CODE_SUB)\n param_obj = self.__dict__[servo_type]._get_errorCode()\n acs_par, completion = param_obj.get_sync()\n if(completion.code):\n print \"\\nError code found in errorCode...\"\n continue\n self.data_match(acs_par, par)\n except NackEx:\n continue","def test_rpc_response_id_mismatch(self):\n right_id = 5\n wrong_id = 20\n resp = f'{{\"id\": {right_id}, \"result\": 1, \"error\": null, \"callback\": null}}'\n\n with self.assertRaisesRegex(errors.ProtocolError,\n errors.ProtocolError.MISMATCHED_API_ID):\n self.client._decode_response_string_and_validate_format(wrong_id, resp)","def test_error_message_header_bad_request_codes(self):\n error_type = 1\n error_type_value = Error.ErrorType.OFPET_BAD_REQUEST\n\n error_code = 0\n\n iter_given_code = Error.ErrorType.get_class(error_type_value).__iter__()\n length = Error.ErrorType.get_class(error_type_value).__len__()\n\n while error_code < self.MAX_BAD_REQUEST_CODE_VALUE or length > 0:\n\n data = UBInt32(random.randint(2, 250)).pack()\n xid = random.randint(2, 250)\n\n test_value = b'\\x05\\x01\\x00\\x10' + UBInt32(xid).pack() + UBInt16(error_type).pack() + \\\n UBInt16(error_code).pack() + data\n\n if error_code < self.MAX_BAD_REQUEST_CODE_VALUE:\n error_code += 1\n\n length -= 1\n\n test_object_error_messages = Error.ErrorMsg(xid, error_type_value, iter_given_code.__next__(), data).pack()\n\n self.assertEqual(test_value, test_object_error_messages)","def test_model_details_failure(self):\n\n # GIVEN invalid model ID\n model_id = 300\n\n # WHEN model details are retrieved\n response = self.api.dataid(self.app_label, self.model_name2, model_id)\n\n # THEN it should fail\n self.assertTrue(response.error)","def raise_for_response(self, response):\n try:\n code = response.errors[0][0]._code\n\n if code == 'invalidRecipient':\n raise InvalidRecipientException()\n elif code == 'recipientBlocked':\n raise RecipientBlockedException()\n elif code == 'emptyMessageContent':\n raise EmptyMessageContentException()\n elif code == 'other':\n raise OtherMMSOAPException()\n else:\n pass\n\n except AttributeError:\n pass","def handle_validation_error(self, error, bundle_errors):\n \n error_str = six.text_type(error)\n error_msg = self.help.format(error_msg=error_str) if self.help else error_str\n msg = {self.name: error_msg}\n\n if bundle_errors:\n return error, msg\n flask_restful.abort(400, message=msg)","def validate_response(response):\n\n r = response\n try:\n r.raise_for_status()\n except HTTPError as e:\n message = dict(status_code=r.status_code, exception=e)\n\n try:\n response = r.json()\n message['response'] = response\n except JSONDecodeError as e:\n message['response'] = r.content\n\n raise HTTPError(message)","def _check_input_data(self):\n\n n0, n1, corr, pval = np.nan, np.nan, np.nan, np.nan\n\n error_code_test = 0\n error_text_test = 'No error occurred'\n try:\n error_code_test, error_msg = self._check_notnull()\n if error_code_test == 0:\n error_code_test, error_msg, n0, n1 = self._check_group_obs(self.test_min_data)\n if error_code_test == 0:\n error_code_test, error_msg, corr, pval = \\\n self._check_spearman_corr(self.min_corr, self.max_p)\n if error_code_test != 0:\n error_text_test = str(error_msg)\n except:\n error_code_test = 9\n error_text_test = 'Unknown Error'\n\n self.checkstats = {'n0': n0, 'n1': n1, 'frame_spearmanR': corr, 'frame_corrPval': pval}\n\n self.error_code_test = error_code_test\n self.error_text_test = error_text_test\n\n return self.error_code_test, self.error_text_test","def check_message_id(self, user, item_id, message_id):\n try:\n\n err_options = message_id.split(':', 2)\n msg_error_count = int(err_options[1])\n\n # check for token update\n if len(err_options) > 1 and err_options[2] != str(self.get_token(user)):\n self.log.warning(MSG_NEW_TOKEN_.format(item_id, msg_error_count, message_id))\n return 0\n # check update timestamp for message edit\n elif msg_error_count > 1:\n self.log.warning(MSG_FAILED_ALREADY_.format(item_id, message_id))\n return None\n\n elif msg_error_count >= 0:\n self.log.warning(MSG_RETRYING_FAILED_.format(item_id, msg_error_count, message_id))\n return msg_error_count\n\n except:\n self.log.error(MSG_FAILED_TO_PARSE_ID_.format(item_id, message_id, traceback.format_exc()))\n\n return None","def _check_r_res(res, o_exp, g_exp, p_exp):\n print green(\"Checking %s owner, group, permissions. \"\n \"Expected: %s, %s, %s\" % (res, o_exp, g_exp, p_exp))\n if exists(res):\n resp = run('stat -c %%U,%%G,%%a %s' % res)\n o_act, g_act, p_act = map(str.strip, resp.split(','))\n if o_act != o_exp or g_act != g_exp or p_act != p_exp:\n abort(red(\"Resource %s params: %s. Expected: %s\" % (\n res, (o_act, g_act, p_act), (o_exp, g_exp, p_exp))))\n print green(\"Resource %s checking passed\" % res)\n else:\n abort(red(\"Resource %s is not exists\" % res))","def response_check(response):\n print(response)\n print(response.text)\n return response.status_code == 200","def check_auth_interactive_response(self, responses):\n return AUTH_FAILED","def validate_collection_response(self, response):\n\n self.validate_response(response)\n if response.status_code not in self.model._meta['valid_get_status']:\n raise InvalidStatusError(\n self.model._meta['valid_get_status'], response\n )","def handle_response(self, response):\n assert isinstance(response, CommandResponseObject)\n\n # Is there was a protocol error return the error.\n if response.is_protocol_failure():\n raise OffChainProtocolError.make(response.error)\n\n request_cid = response.cid\n\n # If we have already processed the response.\n request = self.committed_commands.try_get(request_cid)\n if request:\n # Check the reponse is the same and log warning otherwise.\n if request.response != response:\n excp = OffChainException(\n 'Got different responses with cid {request_cid}.'\n )\n excp.response1 = request.response\n excp.response2 = response\n raise excp\n # This request may have concurrent modification\n # read db to get latest status\n return self.committed_commands[request_cid].is_success()\n\n request = self.my_pending_requests.try_get(request_cid)\n if not request:\n raise OffChainException(\n f'Response for unknown cid {request_cid} received.'\n )\n\n # Read and write back response into request.\n request.response = response\n\n # Add the next command to the common sequence.\n self.committed_commands[request.cid] = request\n del self.my_pending_requests[request_cid]\n self.register_dependencies(request)\n self.apply_response(request)\n return request.is_success()","def validate_message(self, state_id, msg):\n pass","def api_check_manager_status():\n try:\n ret = AppStatus.check_manager_status()\n if ret is not None:\n return jsonify(ret)\n except Exception as e:\n logger.error(\"Traceback:\\n%s\", traceback.format_exc())\n abort(500, \"failed to send message or invalid manager response\")","def _is_error_call(self, response):\n status = response.get('ResponseMetadata', {}).get('HTTPStatusCode')\n return status != 200","def _assert_existing_user_error(self, response):\n assert response.status_code == 409\n errors = json.loads(response.content.decode('utf-8'))\n for conflict_attribute in [\"username\", \"email\"]:\n assert conflict_attribute in errors\n assert \"belongs to an existing account\" in errors[conflict_attribute][0][\"user_message\"]","def check_error(self, response):\n if type(response) is dict and response.has_key('status_code'):\n if response['status_code'] != 200:\n raise rocket.RocketAPIException(response['status_code'],\n response['status_text'])"],"string":"[\n \"def check_response_errors(self, resp):\\n return True\",\n \"def validate_reply(request, reply):\\n assert isinstance(reply, dict) and 'id' in reply\\n assert ('result' in reply) != ('error' in reply)\\n assert reply['id'] == request['id'] or \\\\\\n reply['id'] == '00' and 'error' in reply\",\n \"def _error_check(self, command_response):\\n error_list = command_response.find(\\\"./clierror\\\")\\n command_obj = command_response.find(\\\"./input\\\")\\n if error_list is not None:\\n command = command_obj.text if command_obj is not None else \\\"Unknown command\\\"\\n msg = etree.tostring(error_list).decode()\\n raise NXAPICommandError(command, msg)\",\n \"def has_error(self, response):\\n return response.find(' Matched') == -1 and response.find(' Failed') == -1\",\n \"def _check_response_for_request_errors(self):\\r\\n if self.response.HighestSeverity == \\\"ERROR\\\":\\r\\n for notification in self.response.Notifications:\\r\\n if notification.Severity == \\\"ERROR\\\":\\r\\n if \\\"Invalid tracking number\\\" in notification.Message:\\r\\n raise FedexInvalidTrackingNumber(notification.Code,\\r\\n notification.Message)\\r\\n else:\\r\\n raise FedexError(notification.Code,\\r\\n notification.Message)\",\n \"def test_broken_odata_details(self, mock_response):\\n message = {\\n \\\"error\\\": {\\n \\\"code\\\": \\\"Conflict\\\",\\n \\\"message\\\": \\\"The maximum number of Free ServerFarms allowed in a Subscription is 10.\\\",\\n \\\"target\\\": None,\\n \\\"details\\\": [\\n {\\\"message\\\": \\\"The maximum number of Free ServerFarms allowed in a Subscription is 10.\\\"},\\n {\\\"code\\\": \\\"Conflict\\\"},\\n {\\n \\\"errorentity\\\": {\\n \\\"code\\\": \\\"Conflict\\\",\\n \\\"message\\\": \\\"The maximum number of Free ServerFarms allowed in a Subscription is 10.\\\",\\n \\\"extendedCode\\\": \\\"59301\\\",\\n \\\"messageTemplate\\\": \\\"The maximum number of {0} ServerFarms allowed in a Subscription is {1}.\\\",\\n \\\"parameters\\\": [\\\"Free\\\", \\\"10\\\"],\\n \\\"innerErrors\\\": None,\\n }\\n },\\n ],\\n \\\"innererror\\\": None,\\n }\\n }\\n exp = HttpResponseError(response=mock_response(json.dumps(message).encode(\\\"utf-8\\\")))\\n assert exp.error.code == \\\"Conflict\\\"\",\n \"def _check_command(self, resp, prompt):\\n for line in resp.split(NEWLINE):\\n if line.startswith('?'):\\n raise InstrumentProtocolException('error processing command (%r)', resp[1:])\\n if line.startswith('*'): # response\\n if not valid_response(line):\\n raise InstrumentProtocolException('checksum failed (%r)', line)\",\n \"def validate_response(response: json):\\n if \\\"error\\\" in response:\\n print(\\\"ERROR: Request returned error\\\")\\n print_request_response(response)\\n exit(1)\",\n \"def _check_response_for_request_errors(self):\\r\\n if self.response.HighestSeverity == \\\"ERROR\\\":\\r\\n for notification in self.response.Notifications:\\r\\n if notification.Severity == \\\"ERROR\\\":\\r\\n raise FedexError(notification.Code,\\r\\n notification.Message)\",\n \"def validate_response(response):\\n assert response.ok\\n rpcdict = response.json()\\n assert rpcdict['jsonrpc'] == '2.0'\\n assert rpcdict['id']\\n assert 'error' in rpcdict.keys() or 'result' in rpcdict.keys()\",\n \"def validate_response(self, response: requests.Response) -> None:\\n if 400 <= response.status_code < 500:\\n msg = (\\n f\\\"{response.status_code} Client Error: \\\"\\n f\\\"{response.reason} for path: {self.path}. \\\"\\n f\\\"Request payload: {response.request.body}\\\"\\n )\\n raise FatalAPIError(msg)\\n\\n elif 500 <= response.status_code < 600:\\n msg = (\\n f\\\"{response.status_code} Server Error: \\\"\\n f\\\"{response.reason} for path: {self.path}\\\"\\n )\\n raise RetriableAPIError(msg)\",\n \"def _get_resp_body_errors(self):\\n\\n if self._resp_body_errors and len(self._resp_body_errors) > 0:\\n return self._resp_body_errors\\n\\n errors = []\\n warnings = []\\n resp_codes = []\\n\\n if self.verb is None:\\n return errors\\n\\n dom = self.response.dom()\\n if dom is None:\\n return errors\\n\\n for e in dom.findall('Errors'):\\n eSeverity = None\\n eClass = None\\n eShortMsg = None\\n eLongMsg = None\\n eCode = None\\n\\n try:\\n eSeverity = e.findall('SeverityCode')[0].text\\n except IndexError:\\n pass\\n\\n try:\\n eClass = e.findall('ErrorClassification')[0].text\\n except IndexError:\\n pass\\n\\n try:\\n eCode = e.findall('ErrorCode')[0].text\\n except IndexError:\\n pass\\n\\n try:\\n eShortMsg = smart_encode(e.findall('ShortMessage')[0].text)\\n except IndexError:\\n pass\\n\\n try:\\n eLongMsg = smart_encode(e.findall('LongMessage')[0].text)\\n except IndexError:\\n pass\\n\\n try:\\n eCode = e.findall('ErrorCode')[0].text\\n if int(eCode) not in resp_codes:\\n resp_codes.append(int(eCode))\\n except IndexError:\\n pass\\n\\n msg = str(\\\"Class: {eClass}, Severity: {severity}, Code: {code}, {shortMsg} {longMsg}\\\") \\\\\\n .format(eClass=eClass, severity=eSeverity, code=eCode, shortMsg=eShortMsg,\\n longMsg=eLongMsg)\\n\\n # from IPython import embed; embed()\\n\\n if eSeverity == 'Warning':\\n warnings.append(msg)\\n else:\\n errors.append(msg)\\n\\n self._resp_body_warnings = warnings\\n self._resp_body_errors = errors\\n self._resp_codes = resp_codes\\n\\n if self.config.get('warnings') and len(warnings) > 0:\\n log.warn(\\\"{verb}: {message}\\\\n\\\\n\\\".format(\\n verb=self.verb, message=\\\"\\\\n\\\".join(warnings)))\\n\\n if self.response.reply.Ack == 'Failure':\\n if self.config.get('errors'):\\n log.error(\\\"{verb}: {message}\\\\n\\\\n\\\".format(\\n verb=self.verb, message=\\\"\\\\n\\\".join(errors)))\\n\\n return errors\\n\\n return []\",\n \"def _check_response(self, res: requests.Response, token: str) -> None:\\n return\",\n \"def validate_response(self, response):\\n pass\",\n \"def validate(self, response):\\n return response[\\\"status_code\\\"] == 1\",\n \"def _check_failures(self, response, batch=None):\\n if not response.get('Failed'):\\n return 0 # nothing to do here\\n\\n LOGGER.error('The following records failed to put to queue %s', self.queue.url)\\n\\n for failure in response['Failed']:\\n # Pull out the record that matches this ID\\n record = self._extract_message_by_id(batch, failure['Id']) if batch else None\\n LOGGER.error(self._format_failure_message(failure, record=record))\\n\\n failed = len(response.get('Failed', []))\\n self._log_failed(failed)\\n\\n # Raise an exception if this is the fault of the sender (us)\\n if any(result['SenderFault'] for result in response['Failed']):\\n raise SQSClientError('Failed to send records to SQS:\\\\n{}'.format(response))\\n\\n return failed\",\n \"def check_resp(resp, user_id, message):\\n event = resp[\\\"data\\\"][\\\"on_chat_message_sent\\\"][\\\"event\\\"]\\n assert json.loads(event) == {\\n \\\"user_id\\\": user_id,\\n \\\"payload\\\": message,\\n }, \\\"Subscription notification contains wrong data!\\\"\",\n \"def _check_response_for_request_errors(self):\\r\\n if self.response.HighestSeverity == \\\"ERROR\\\":\\r\\n for notification in self.response.Notifications:\\r\\n if notification.Severity == \\\"ERROR\\\":\\r\\n if \\\"Postal Code Not Found\\\" in notification.Message:\\r\\n raise FedexPostalCodeNotFound(notification.Code,\\r\\n notification.Message)\\r\\n\\r\\n elif \\\"Invalid Postal Code Format\\\" in self.response.Notifications:\\r\\n raise FedexInvalidPostalCodeFormat(notification.Code,\\r\\n notification.Message)\\r\\n else:\\r\\n raise FedexError(notification.Code,\\r\\n notification.Message)\",\n \"def _err_response(self, msg):\\r\\n return {'success': False, 'error': msg}\",\n \"def check_set_errors(self):\\n response = self.read()\\n return [] if response == \\\"\\\" else [response]\",\n \"async def _handle_response(response: ClientResponse) -> Dict:\\n content = await response.json(encoding='utf-8', loads=loads)\\n if response.status != 200:\\n for member in JmRpcErrorType:\\n if content['message'] != member.value:\\n continue\\n raise JmRpcError(response.status, content)\\n response.raise_for_status()\\n return content\",\n \"def verify_error_message(self, response, error_message):\\n self.assertEqual(response.status_code, 400)\\n response = json.loads(response.content.decode('utf-8'))\\n self.assertIn('error', response)\\n self.assertEqual(response['error'], error_message)\",\n \"def success_message_code(response_obj, check_util=None):\\n if check_util:\\n success = check_util(response_obj)\\n phrase, status = assign_message_code(success)\\n else:\\n success = True\\n phrase, status = response_obj.reason, response_obj.status_code\\n return success, phrase, status\",\n \"def check_error_output(self, output):\\n\\n # Display info message\\n log.info(\\\"check_error_output\\\")\\n\\n # Check if output has some data\\n if output:\\n\\n # Yes\\n\\n # Display info message\\n log.info(\\\"check_error_output: output has some data\\\")\\n\\n # Check all elements in the list of output\\n for element in self._send_command_error_in_returned_output:\\n\\n # Display info message\\n log.info(f\\\"check_error_output: element: {element}\\\")\\n\\n # Display info message\\n log.info(f\\\"check_error_output: output[0]: {output[0]}\\\")\\n\\n # Check if the output starts with a string with an error message (like \\\"% Invalid input detected at '^' marker.\\\")\\n\\n # Error message?\\n if output.startswith(element):\\n\\n # Yes\\n\\n # Raise an exception\\n raise Exception(output)\",\n \"def _validate_response(request, response, schema_data, schema_resolver):\\n try:\\n validate_outgoing_response(\\n request,\\n response,\\n schema_data,\\n schema_resolver\\n )\\n except jsonschema.exceptions.ValidationError as exc:\\n # This will alter our stack trace slightly, but Pyramid knows how\\n # to render it. And the real value is in the message anyway.\\n raise HTTPInternalServerError(str(exc))\",\n \"def _get_response(self):\\n resp = yield from self._responses.get()\\n if len(resp) == 1:\\n line = resp[0]\\n if line.startswith('ACK'):\\n i = line.index('@')\\n error = line[5:i]\\n l = line[i+1:line.index(']')]\\n command = line[line.index('{')+1:line.index('}')]\\n msg = line[line.index('}')+1:]\\n raise MpdCommandException(line, error, l, command, msg)\\n return resp\",\n \"def __CheckResponse(self, response):\\n\\n status = response.status\\n if (status == httplib.OK or status == httplib.CREATED\\n or status == httplib.NO_CONTENT):\\n return\\n elif (status == httplib.UNAUTHORIZED):\\n raise BadCredentialsException\\n elif (status == httplib.SERVICE_UNAVAILABLE):\\n raise ServerBusyException\\n elif (status == httplib.BAD_REQUEST\\n or status == httplib.UNPROCESSABLE_ENTITY):\\n raise BadArgumentsException\\n elif (status == httplib.NOT_FOUND):\\n raise NotFoundException\\n else:\\n raise BadOperationException\",\n \"def checkError(invoke_response, message):\\n\\n if 'FunctionError' in invoke_response:\\n err_message = invoke_response['Payload'].read()\\n print(message)\\n print(err_message)\\n return {\\n 'statusCode': 500,\\n 'body': json.dumps(str(err_message))\\n }\\n return None\",\n \"def _handle_response(response: str) -> Result:\\n logger.debug('SoapService - _handle_response(response: {})'.format(response))\\n result = Result()\\n parsed_response = xmltodict.parse(response)['xmlreply']\\n response_result = parsed_response['messages']['result']\\n\\n if response_result == 'OK':\\n refno = parsed_response['apmdata']['prospect']['p.cm']['refno']\\n result.data = {'Refno': refno}\\n result.status = True\\n elif response_result == 'Error':\\n errors = parsed_response['messages']['error'] if 'error' in parsed_response['messages'] else None # type: list\\n result.status = False\\n\\n return result\",\n \"def callback(response):\\n error_msg = None\\n if response.status_code >= 300 and response.status_code < 500:\\n resp = response.json()\\n if response.status_code == 401 and resp.get(\\\"message\\\") == \\\"Authentication Error\\\":\\n raise AuthenticationError()\\n\\n msg = resp.get('messages') or resp.get('message')\\n details = resp.get('details')\\n error_msg = u\\\"ReaQta Error: \\\\n status code: {0}\\\\n message: {1}\\\\n details: {2}\\\".format(\\n response.status_code,\\n msg,\\n details)\\n\\n return response, error_msg\",\n \"def get_errors(self, response: response_domain_model.Response, question_code: str) -> Sequence['ValidationError']:\\n ...\",\n \"def verify_message(lines, expected_response):\\n position = 0\\n if isinstance(expected_response, basestring):\\n expected_response = [expected_response]\\n if isinstance(expected_response, set):\\n expected_response = list(expected_response)\\n if not isinstance(expected_response, list):\\n raise TypeError(\\\"verify_message: expectedResponse must be list, set or string\\\")\\n for message in expected_response:\\n try:\\n found, position, _ = find_next(lines, message, position)\\n if not found:\\n return False\\n position = position + 1\\n except TypeError:\\n return False\\n except LookupError:\\n return False\\n return True\",\n \"def _get_error_message(response):\\n try:\\n return response.json()[\\\"detail\\\"]\\n except (KeyError, _JSONDecodeError):\\n return response.text\",\n \"def check_response(response):\\n for status_code, err_class, err_type in [\\n (HTTPStatus.INTERNAL_SERVER_ERROR, ServerError, 'Server'),\\n (HTTPStatus.BAD_REQUEST, ClientError, 'Client')\\n ]: # highest http status code first\\n if response.status_code >= status_code:\\n try:\\n status = HTTPStatus(response.status_code)\\n except ValueError as err:\\n m = re.search(r'\\\\d{3}', err.args[0], flags=re.ASCII)\\n if not m:\\n raise err\\n msg = f'Generic {err_type} Error ({m.group()})'\\n else:\\n msg = f'({status}) {status.description}'\\n\\n raise err_class(msg)\\n\\n if response.status_code == HTTPStatus.OK \\\\\\n and SERVER_DB_ERROR_MSG in response.text:\\n raise ServerError('Server cannot access the database')\",\n \"def validate_get_response(self, response):\\n\\n self.validate_response(response)\\n if response.status_code not in self.model._meta['valid_get_status']:\\n raise InvalidStatusError(\\n self.model._meta['valid_get_status'], response\\n )\",\n \"def process_error_response(self, resources, resource, api, operation,\\n error_response, context):\\n pass\",\n \"def _check_reply(self):\\n self._more_packets_available = False\\n try:\\n if self._reply is None:\\n self._status = (3, '{} without reply'.format(\\n REPLAY_INFO[unpack_dint(self._message[:2])]))\\n return False\\n # Get the type of command\\n typ = unpack_uint(self._reply[:2])\\n\\n # Encapsulation status check\\n if unpack_dint(self._reply[8:12]) != SUCCESS:\\n self._status = (3, \\\"{0} reply status:{1}\\\".format(\\n REPLAY_INFO[typ],\\n SERVICE_STATUS[unpack_dint(self._reply[8:12])]))\\n return False\\n\\n # Command Specific Status check\\n if typ == unpack_uint(ENCAPSULATION_COMMAND[\\\"send_rr_data\\\"]):\\n status = unpack_usint(self._reply[42:43])\\n if status != SUCCESS:\\n status_msg = \\\"send_rr_data reply:{0} - Extend status:{1}\\\"\\n self._status = (3, status_msg.format(\\n SERVICE_STATUS[status],\\n get_extended_status(self._reply, 42)))\\n return False\\n else:\\n return True\\n return True\\n except Exception as e:\\n raise DataError(e)\",\n \"def identify_result_error(self, record):\\n return [\\\"error\\\"]\",\n \"def check_errors(self) -> None:\\n # TODO check the manual for error codes & interpert them.\\n return self.send(self.cmd.GET_GLOBALSTATUS_CURRENTERROR)\",\n \"def error(self, message):\\n if 'PhysicalResourceId' not in self.response:\\n self.response['PhysicalResourceId'] = self.response['LogicalResourceId']\\n self.response['Status'] = 'FAILED'\\n self.response['Reason'] = message\\n self._send_response(self.response)\",\n \"def check_errors(self, data):\\n for entry in data:\\n if entry.find('ERROR') != -1:\\n return entry\\n return False\",\n \"def response_check(response):\\n print(response)\\n print(response.text)\\n return response.status_code == 201\",\n \"def _errors_exist(self, doc_type, login, response_payload):\\n if \\\"errors\\\" in response_payload:\\n for _, error in enumerate(response_payload[\\\"errors\\\"]):\\n message = ':'.join([doc_type, login, str(error)])\\n self.logger.error(message)\\n return True\\n return False\",\n \"def process_response(response):\\n # Print it and exit with 1 if operation wasn't successful\\n print(response['message'])\\n if response['status'] != 'success':\\n sys.exit(1)\",\n \"def _has_error_code(res):\\n\\n if res and 'error_code' in res:\\n return res['error_code'] > 0\\n\\n return False\",\n \"def check(self):\\n out = self.LeggiDocumento('000')\\n if 'success' in out and 'result' in out:\\n out.pop('result')\\n else:\\n out.pop('request')\\n return out\",\n \"def check_errors(self):\\n\\n errors = []\\n while True:\\n err = self.values(\\\"SYST:ERR?\\\")\\n if int(err[0]) != 0:\\n errmsg = \\\"Agilent 5313xA: {0}: {1}\\\".format(err[0], err[1])\\n log.error(errmsg + '\\\\n')\\n errors.append(errmsg)\\n else:\\n break\\n\\n return errors\",\n \"def check_errors(self) -> None:\",\n \"def verify_response(self, system_name, expected_api_response,\\n expected_response_type, comparison_mode,\\n request_id=None, generate_output_diff_file=\\\"Yes\\\"):\\n arguments = {'system_name': system_name,\\n 'expected_api_response': expected_api_response,\\n 'expected_response_type': expected_response_type,\\n 'comparison_mode': comparison_mode,\\n 'request_id': request_id,\\n 'generate_output_diff_file': generate_output_diff_file}\\n wdesc = \\\"Verify API response with the expected API response\\\"\\n pNote(wdesc)\\n output_file = self.logsdir+\\\"/difference_output.log\\\"\\n output_file = Utils.file_Utils.addTimeDate(output_file)\\n generate_output_diff_file = Utils.rest_Utils.\\\\\\n resolve_value_of_verify(generate_output_diff_file)\\n\\n try:\\n arguments[\\\"expected_api_response\\\"] = Utils.rest_Utils.\\\\\\n check_ext_get_abspath(arguments[\\\"expected_api_response\\\"],\\n self.tc_path)\\n\\n credentials = Utils.data_Utils.\\\\\\n get_user_specified_tag_values_in_tc(self.datafile, **arguments)\\n\\n credentials[\\\"expected_api_response\\\"] = Utils.rest_Utils.\\\\\\n check_ext_get_abspath(credentials[\\\"expected_api_response\\\"],\\n os.path.dirname(self.datafile))\\n\\n if request_id:\\n response = Utils.data_Utils.get_object_from_datarepository(\\n \\\"{0}_{1}_api_response_object\\\".format(system_name,\\n credentials['request_id']))\\n else:\\n response = Utils.data_Utils.get_object_from_datarepository(\\n \\\"{0}_api_response_object\\\".format(system_name))\\n except Exception as exception:\\n pNote(exception, \\\"error\\\")\\n return False\\n if any([x in credentials[\\\"comparison_mode\\\"] for x in [\\\"xpath=\\\", \\\"jsonpath=\\\", \\\"regex=\\\"]]) \\\\\\n or credentials[\\\"comparison_mode\\\"] == \\\"\\\":\\n status = self.rest_object.cmp_content_response(self.datafile, system_name, response,\\n credentials['expected_api_response'],\\n credentials['expected_response_type'],\\n credentials['comparison_mode'])\\n else:\\n status = self.rest_object.cmp_response(response,\\n credentials['expected_api_response'],\\n credentials['expected_response_type'],\\n output_file,\\n credentials['generate_output_diff_file'])\\n return status\",\n \"def check_response(response):\\n status = response.get('status')\\n ret = status and status == 'OK'\\n if not ret:\\n logging.error('Received unexpected failure response from polyswarmd: %s', response)\\n return ret\",\n \"def _check_response_status(response):\\n # TODO: Test!\\n if response.status == 1:\\n raise InvalidLength(f\\\"{response.info}: Message is too long.\\\")\\n elif response.status == 2:\\n raise InvalidXML(f\\\"{response.info}: Invalid XML content.\\\")\\n elif response.status == 3:\\n raise WrongContent(\\n f\\\"{response.info}: Wrong data content. \\\"\\n f\\\"Ex: too long text in a field.\\\"\\n )\\n elif response.status == 4:\\n raise NotAuthorized(\\n f\\\"{response.info}: Wrong combination of \\\"\\n f\\\"transmitter, instance and password\\\"\\n )\\n elif response.status == 5:\\n # Fail over should kick in.\\n raise NotTreatedNotDistributed(\\n f\\\"{response.info}: Error in \\\"\\n f\\\"processing. It has neither been \\\"\\n f\\\"treated or distributed\\\"\\n )\\n elif response.status == 7:\\n raise MandatoryDataMissing(\\n f\\\"{response.info}: Mandatory XML tag \\\" f\\\"missing\\\"\\n )\\n elif response.status == 9:\\n raise ServiceUnavailable(\\n (\\n f\\\"{response.info}: Heartbeat is not enabled on the server for \\\"\\n f\\\"this transmitter or you are not authorized to use it.\\\"\\n )\\n )\\n elif response.status == 10:\\n raise DuplicateAlarm(\\n f\\\"{response.info}: The same alarm was received\\\" f\\\" multiple times\\\"\\n )\\n elif response.status == 98:\\n raise ServerSystemError(f\\\"{response.info}: General receiver error\\\")\\n elif response.status == 99:\\n # Failover should kick in.\\n raise OtherError(f\\\"{response.info}: Unknown receiver error\\\")\\n elif response.status == 100:\\n raise XMLHeaderError(f\\\"{response.info}: Invalid or missing XML \\\" f\\\"header\\\")\\n elif response.status == 101:\\n raise PingToOften(f\\\"{response.info}: Heartbeat is sent too often\\\")\",\n \"def error_check(self, message):\\n matches = ERROR_SYNTAX.match(message)\\n if matches:\\n error_code = int(matches.group(1))\\n error_message = matches.group(2)\\n return error_code, error_message\\n return None\",\n \"def _check_errors(self, json_loaded):\\n\\n content = json_loaded\\n try:\\n m = content[u'error'][u'message']\\n c = content[u'error'][u'code']\\n out= \\\"API Error code: {}\\\\nError message: {}\\\".format(c, m)\\n raise InvalidQueryException(self.name, out)\\n except KeyError:\\n pass\",\n \"def test_error_message_header_role_request_failed_codes(self):\\n\\n error_type = 11\\n error_type_value = Error.ErrorType.OFPET_ROLE_REQUEST_FAILED\\n\\n error_code = 0\\n\\n iter_given_code = Error.ErrorType.get_class(error_type_value).__iter__()\\n length = Error.ErrorType.get_class(error_type_value).__len__()\\n\\n while error_code < self.MAX_ROLE_REQUEST_FAILED_CODE_VALUE or length > 0:\\n data = UBInt32(random.randint(2, 250)).pack()\\n xid = random.randint(2, 250)\\n\\n test_value = b'\\\\x05\\\\x01\\\\x00\\\\x10' + UBInt32(xid).pack() + UBInt16(error_type).pack() + \\\\\\n UBInt16(error_code).pack() + data\\n\\n if error_code < self.MAX_ROLE_REQUEST_FAILED_CODE_VALUE:\\n error_code += 1\\n length -= 1\\n\\n test_object_error_messages = Error.ErrorMsg(xid, error_type_value, iter_given_code.__next__(), data).pack()\\n\\n self.assertEqual(test_value, test_object_error_messages)\",\n \"def _validate_GetCC_response(self, response, prompt):\\n error = self._find_error(response)\\n\\n if error:\\n log.error(\\\"GetCC command encountered error; type='%s' msg='%s'\\\", error[0], error[1])\\n raise InstrumentProtocolException('GetCC command failure: type=\\\"%s\\\" msg=\\\"%s\\\"' % (error[0], error[1]))\\n\\n if not SBE19CalibrationParticle.resp_regex_compiled().search(response):\\n log.error('_validate_GetCC_response: GetCC command not recognized: %s.' % response)\\n raise InstrumentProtocolException('GetCC command not recognized: %s.' % response)\\n\\n return response\",\n \"def check_ocsp_response_status(single_response_map, ocsp_response):\\n ret = []\\n for hkey, data in single_response_map.items():\\n if data['status'] == 'good':\\n ret.append(_process_good_status(\\n hkey, data, ocsp_response))\\n elif data['status'] == 'revoked': # revoked\\n _process_revoked_status(hkey, data)\\n else: # unknown\\n _process_unknown_status(hkey)\\n if len(ret) != len(single_response_map):\\n raise OperationalError(\\n msg=u\\\"Not all OCSP Response was returned\\\",\\n errno=ER_INVALID_OCSP_RESPONSE,\\n )\",\n \"def check_message(self, msg):\\n pass\",\n \"def _process_unsuccessful_response(\\n self,\\n response: Response,\\n case: Literal['validate_api_key', 'balances', 'trades', 'asset_movements'],\\n ) -> Union[\\n list,\\n tuple[bool, str],\\n ExchangeQueryBalances,\\n ]:\\n try:\\n response_list = jsonloads_list(response.text)\\n except JSONDecodeError as e:\\n msg = f'{self.name} {case} returned an invalid JSON response: {response.text}.'\\n log.error(msg)\\n\\n if case in ('validate_api_key', 'balances'):\\n return False, msg\\n if case in ('trades', 'asset_movements'):\\n self.msg_aggregator.add_error(\\n f'Got remote error while querying {self.name} {case}: {msg}',\\n )\\n return []\\n\\n raise AssertionError(f'Unexpected {self.name} response_case: {case}') from e\\n\\n error_data = self._get_error_response_data(response_list)\\n if error_data.error_code == API_ERR_AUTH_NONCE_CODE:\\n message = API_ERR_AUTH_NONCE_MESSAGE\\n # Errors related with the API key return a human readable message\\n elif case == 'validate_api_key' and error_data.error_code == API_KEY_ERROR_CODE:\\n message = API_KEY_ERROR_MESSAGE\\n else:\\n # Below any other error not related with the system clock or the API key\\n reason = error_data.reason or response.text\\n message = (\\n f'{self.name} query responded with error status code: {response.status_code} '\\n f'and text: {reason}.'\\n )\\n log.error(message)\\n\\n if case in ('validate_api_key', 'balances'):\\n return False, message\\n if case in ('trades', 'asset_movements'):\\n self.msg_aggregator.add_error(\\n f'Got remote error while querying {self.name} {case}: {message}',\\n )\\n return []\\n\\n raise AssertionError(f'Unexpected {self.name} response_case: {case}')\",\n \"def test_handle_response_wrong_message_type(self):\\n lookup = Lookup(FindNode, self.target, self.node, self.event_loop)\\n uuid = [uuid for uuid in lookup.pending_requests.keys()][0]\\n contact = lookup.shortlist[0]\\n msg = OK(uuid, self.node.network_id, self.node.network_id,\\n self.reply_port, self.version, self.seal)\\n response = asyncio.Future()\\n response.set_result(msg)\\n lookup._blacklist = mock.MagicMock()\\n lookup._handle_error = mock.MagicMock()\\n lookup._handle_response(uuid, contact, response)\\n lookup._blacklist.assert_called_once_with(contact)\\n self.assertEqual(lookup._handle_error.call_count, 1)\\n args = lookup._handle_error.call_args[0]\\n self.assertEqual(args[0], uuid)\\n self.assertEqual(args[1], contact)\\n self.assertIsInstance(args[2], TypeError)\\n self.assertEqual(args[2].args[0],\\n \\\"Unexpected response type from {}\\\".format(contact))\",\n \"def test_process_response(self):\\n t = self.create_request_object()\\n response_content = u\\\"\\\"\\\" <Response ReferenceNumber=\\\"82e942b0-48e8-4cf4-b299-51e2b6a89a1b\\\"\\n InboundODMFileOID=\\\"\\\"\\n IsTransactionSuccessful=\\\"1\\\"\\n SuccessStatistics=\\\"Rave objects touched: Subjects=0; Folders=0; Forms=0; Fields=0; LogLines=0\\\" NewRecords=\\\"\\\">\\n </Response>\\n \\\"\\\"\\\"\\n req = mock.Mock(requests.Request, text=response_content)\\n response = t.result(req)\\n self.assertTrue(isinstance(response, RWSResponse))\",\n \"def cmd_error_check(self, cmd_out):\\n for err in self.err_strings:\\n if re.search('\\\\\\\\b%s\\\\\\\\b' % (err), cmd_out, re.I):\\n _log.info(cmd_out)\\n _log.info(\\n \\\"Cmd execution failed! with this Return Error: \\\\n%s\\\" % (\\n cmd_out))\\n return 0\",\n \"def report_transaction_error_messages(self):\\n response = self.__get_transaction_response()\\n\\n # get response data from response object\\n response_data = response.json()\\n\\n # get error messages\\n response_error = response_data['Error']\\n response_error_messages = response_error['messages']\\n\\n # add all error messages to the report\\n error_messages_to_report = []\\n for response_error_message in response_error_messages:\\n error_description = response_error_message['description']\\n error_messages_to_report.append(error_description)\\n\\n return error_messages_to_report\",\n \"def check_response(self, resp):\\n\\n # For successful API call, response code will be 200 (OK)\\n if resp.ok:\\n json = resp.json()\\n self.response = ResponseHolder()\\n self.response.response = json\\n\\n # Check the code\\n if 'status' not in json:\\n raise InvalidResponse('No status field')\\n\\n self.response.status = self.field_to_long(json['status'])\\n if self.response.status != EBConsts.STATUS_OK:\\n txt_status = self.get_text_status(json)\\n raise InvalidStatus('Status is %s (%04X)'\\n % (txt_status if txt_status is not None else \\\"\\\", self.response.status))\\n\\n if self.response_checker is not None:\\n self.response_checker(self.response)\\n\\n return self.response\\n\\n else:\\n # If response code is not ok (200), print the resulting http error code with description\\n resp.raise_for_status()\\n pass\",\n \"def check_status(result_out, part_msg, log, piid_flag=None):\\n passed = '\\\\033[1;32m...passed\\\\033[1;0m'\\n failed = '\\\\033[1;31m...failed\\\\033[1;0m'\\n\\n if result_out.status_code in [200, 201, 403, 401]:\\n if piid_flag == 'data_quality':\\n msg = pprint.pformat(result_out.json(), indent=2, width=70)\\n else:\\n try:\\n if 'status' in result_out.json().keys() and result_out.json()['status'] == 'error':\\n msg = result_out.json()['message']\\n log.error(part_msg + failed)\\n log.debug(msg)\\n raise RuntimeError\\n elif 'success' in result_out.json().keys() and not result_out.json()['success']:\\n msg = result_out.json()\\n log.error(part_msg + failed)\\n log.debug(msg)\\n raise RuntimeError\\n else:\\n if piid_flag == 'organizations':\\n msg = 'Number of organizations:\\\\t' + str(\\n len(result_out.json()['organizations'][0]))\\n elif piid_flag == 'users':\\n msg = 'Number of users:\\\\t' + str(len(result_out.json()['users'][0]))\\n elif piid_flag == 'mappings':\\n msg = pprint.pformat(result_out.json()['suggested_column_mappings'],\\n indent=2, width=70)\\n else:\\n msg = pprint.pformat(result_out.json(), indent=2, width=70)\\n except BaseException:\\n log.error(part_msg + failed)\\n log.debug('Unknown error during request results recovery')\\n raise RuntimeError\\n\\n log.info(part_msg + passed)\\n log.debug(msg)\\n else:\\n msg = result_out.reason\\n log.error(part_msg + failed)\\n log.debug(msg)\\n raise RuntimeError\\n\\n return\",\n \"def error_details(self) -> pulumi.Output[Sequence['outputs.ErrorDetailResponse']]:\\n return pulumi.get(self, \\\"error_details\\\")\",\n \"def check_response(rv):\\n if rv != 'OK':\\n print \\\"No message found\\\"\\n return False\\n return True\",\n \"def mora_assert(response):\\n assert response.status_code in (200, 201, 400, 404), response.status_code\\n if response.status_code == 400:\\n # Check actual response\\n assert (\\n response.text.find(\\\"not give raise to a new registration\\\") > 0\\n ), response.text\\n logger.debug(\\\"Request had no effect\\\")\\n return None\",\n \"def check_response(self, xml_str, xml_name):\\n\\n if \\\"<ok/>\\\" not in xml_str:\\n self.module.fail_json(msg='Error: %s failed.' % xml_name)\",\n \"def is_valid_response(self, response):\\r\\n if response.status_code in VALID_CODES:\\r\\n return True\\r\\n return False\",\n \"def _check_response(response: requests.Response) -> None:\\n logger.debug('Received response:\\\\n%s', response.content)\\n try:\\n response.raise_for_status()\\n if not response.json()['status']:\\n _report_failure('your e-mail address appears to be invalid')\\n except requests.exceptions.HTTPError:\\n _report_failure()\\n except (ValueError, KeyError):\\n _report_failure('there was a problem with the server response')\",\n \"def isResp(obxDict):\\n readingCode = getReadingCode(obxDict)\\n return readingCode == '76270-8'\",\n \"def _extract_error(self, resp):\\n reason = resp.headers.get(\\\"reason\\\", None)\\n full_response = None\\n\\n if reason is None:\\n try:\\n # if response is in json format\\n reason = resp.json()[\\\"error\\\"][\\\"msg\\\"]\\n except KeyError:\\n # if json response has unexpected structure\\n full_response = resp.content\\n except ValueError:\\n # otherwise we assume it's html\\n reason, full_html = self._scrape_response(resp.headers, resp.content)\\n full_response = unescape_html(full_html)\\n\\n msg = \\\"[Reason: %s]\\\" % reason\\n\\n if reason is None:\\n msg += \\\"\\\\n%s\\\" % full_response\\n\\n return msg\",\n \"def check_result(self, coro_id):\\n try:\\n status, response = self.coros_result.get(coro_id)\\n if status != CoroStatus.Queued:\\n self.remove_coro(coro_id)\\n return status, response\\n except KeyError:\\n raise CoroMissingException(\\\"Coroutine Id {}\\\"\\n \\\" is not Active\\\".format(coro_id))\",\n \"def _validate_response(self, response):\\n # Check for unexpected response - all should be JSON dicts that have\\n # already been deserialised\\n if not isinstance(response, types.DictionaryType):\\n self.message(\\n \\\"\\\\t\\\\t[!] ERROR - Unexpected value returned from the API: '%s'\\\" %\\n (response))\\n return False\\n\\n # Check for valid errors\\n if \\\"error\\\" in response and \\\"msg\\\" in response:\\n self.message(\\n \\\"\\\\t\\\\t[!] ERROR - %s (%s)\\\" %\\n (response[\\\"msg\\\"], response[\\\"timestamp\\\"]))\\n return False\\n\\n # Is this a valid response message\\n if \\\"msg\\\" in response:\\n return True\\n\\n # Catch all...dictionary returned but does not contain expected keys?\\n # Who know's what's going on here?!\\n else:\\n self.message(\\n \\\"\\\\t\\\\t[!] ERROR - Unexpected dictionary response returned from the API: '%s'\\\" %\\n (response))\\n return False\",\n \"def _check_process_resp(self, resp, expected_fields=None):\\n\\n if resp.status_code != LenovoRestClient.RESP_CODE_OK:\\n raise cexc.NOSRestHTTPError(http_code=resp.status_code,\\n http_reason=resp.reason, http_op=resp.request.method,\\n url=resp.url, http_response=resp.text)\\n\\n rj = resp.json()\\n\\n if not expected_fields:\\n return rj\\n\\n for field in expected_fields:\\n try:\\n val = rj[field]\\n except KeyError:\\n raise cexc.NOSJsonFieldNotFound(field=field, url=resp.url, json=rj)\\n\\n return rj\",\n \"def validate_multi_status(multi_response: List[Dict]):\\n if any(response[\\\"response_code\\\"] != HTTPStatus.OK for response in multi_response):\\n raise RuntimeError(str(multi_response))\",\n \"def check(self, response, payload):\\n # check response body\\n if not response.text:\\n return False\\n\\n # check for output\\n # uid=user gid=group groups=groups\\n regex = r\\\"(uid=\\\\d+[\\\\(\\\\)\\\\w\\\\-]+)(\\\\s+gid=\\\\d+[\\\\(\\\\)\\\\w\\\\-]+)(\\\\s+groups=\\\\d+[\\\\(\\\\)\\\\w\\\\-,]+)?\\\"\\n if re.search(regex, response.text):\\n return True\\n else:\\n return False\",\n \"def is_error(response: str) -> bool:\\n return \\\"ERROR\\\" in response\",\n \"def check_invalid_tab_id_response(self, resp):\\r\\n\\r\\n self.assertEqual(resp.status_code, 400)\\r\\n resp_content = json.loads(resp.content)\\r\\n self.assertIn(\\\"error\\\", resp_content)\\r\\n self.assertIn(\\\"invalid_tab_id\\\", resp_content['error'])\",\n \"def check(self):\\n invalid = []\\n\\n if not self.route:\\n invalid.append(('route', 'missing'))\\n elif not self.route[1] in ['GET', 'POST', 'PUT']:\\n invalid.append(('route', 'invalid method: %s' % self.route[1]))\\n\\n has_2xx = False\\n for rcode in self.return_codes:\\n code = rcode[0]\\n if code >= 200 and code < 300:\\n has_2xx = True\\n break\\n if not has_2xx:\\n invalid.append(('return_codes', 'Missing succes return code doc'))\\n\\n if self.client_auth is None:\\n invalid.append(\\n ('client_auth', 'Please provide client auth requirement'))\\n\\n if self.user_auth is None:\\n invalid.append(\\n ('user_auth', 'Please provide user auth requirement'))\\n\\n if invalid:\\n msgs = []\\n for error in invalid:\\n msgs.append(\\\"%s: %s\\\" % error)\\n raise ValueError(\\n \\\"APIFunc for %s is invalid: %s\\\"\\n % (self.viewfunc.__name__,\\n ', '.join(msgs)))\",\n \"def __get_response_error(message, response):\\n\\n rjson = response.json()\\n error_description = \\\"Code %s - %s\\\" %(str(response.status_code), rjson.get('message'))\\n\\n return {\\n 'app_message': \\\"%s\\\" % (message),\\n 'error_description': \\\"[%s] - %s\\\" % (message, error_description),\\n 'code': response.status_code\\n }\",\n \"def test_get_errorCode(self):\\n for app_num, servo_type in app_nr.items():\\n try:\\n par = self.get_parameter(servo_type, app_num, ERROR_CODE_IDX, ERROR_CODE_SUB)\\n param_obj = self.__dict__[servo_type]._get_errorCode()\\n acs_par, completion = param_obj.get_sync()\\n if(completion.code):\\n print \\\"\\\\nError code found in errorCode...\\\"\\n continue\\n self.data_match(acs_par, par)\\n except NackEx:\\n continue\",\n \"def test_rpc_response_id_mismatch(self):\\n right_id = 5\\n wrong_id = 20\\n resp = f'{{\\\"id\\\": {right_id}, \\\"result\\\": 1, \\\"error\\\": null, \\\"callback\\\": null}}'\\n\\n with self.assertRaisesRegex(errors.ProtocolError,\\n errors.ProtocolError.MISMATCHED_API_ID):\\n self.client._decode_response_string_and_validate_format(wrong_id, resp)\",\n \"def test_error_message_header_bad_request_codes(self):\\n error_type = 1\\n error_type_value = Error.ErrorType.OFPET_BAD_REQUEST\\n\\n error_code = 0\\n\\n iter_given_code = Error.ErrorType.get_class(error_type_value).__iter__()\\n length = Error.ErrorType.get_class(error_type_value).__len__()\\n\\n while error_code < self.MAX_BAD_REQUEST_CODE_VALUE or length > 0:\\n\\n data = UBInt32(random.randint(2, 250)).pack()\\n xid = random.randint(2, 250)\\n\\n test_value = b'\\\\x05\\\\x01\\\\x00\\\\x10' + UBInt32(xid).pack() + UBInt16(error_type).pack() + \\\\\\n UBInt16(error_code).pack() + data\\n\\n if error_code < self.MAX_BAD_REQUEST_CODE_VALUE:\\n error_code += 1\\n\\n length -= 1\\n\\n test_object_error_messages = Error.ErrorMsg(xid, error_type_value, iter_given_code.__next__(), data).pack()\\n\\n self.assertEqual(test_value, test_object_error_messages)\",\n \"def test_model_details_failure(self):\\n\\n # GIVEN invalid model ID\\n model_id = 300\\n\\n # WHEN model details are retrieved\\n response = self.api.dataid(self.app_label, self.model_name2, model_id)\\n\\n # THEN it should fail\\n self.assertTrue(response.error)\",\n \"def raise_for_response(self, response):\\n try:\\n code = response.errors[0][0]._code\\n\\n if code == 'invalidRecipient':\\n raise InvalidRecipientException()\\n elif code == 'recipientBlocked':\\n raise RecipientBlockedException()\\n elif code == 'emptyMessageContent':\\n raise EmptyMessageContentException()\\n elif code == 'other':\\n raise OtherMMSOAPException()\\n else:\\n pass\\n\\n except AttributeError:\\n pass\",\n \"def handle_validation_error(self, error, bundle_errors):\\n \\n error_str = six.text_type(error)\\n error_msg = self.help.format(error_msg=error_str) if self.help else error_str\\n msg = {self.name: error_msg}\\n\\n if bundle_errors:\\n return error, msg\\n flask_restful.abort(400, message=msg)\",\n \"def validate_response(response):\\n\\n r = response\\n try:\\n r.raise_for_status()\\n except HTTPError as e:\\n message = dict(status_code=r.status_code, exception=e)\\n\\n try:\\n response = r.json()\\n message['response'] = response\\n except JSONDecodeError as e:\\n message['response'] = r.content\\n\\n raise HTTPError(message)\",\n \"def _check_input_data(self):\\n\\n n0, n1, corr, pval = np.nan, np.nan, np.nan, np.nan\\n\\n error_code_test = 0\\n error_text_test = 'No error occurred'\\n try:\\n error_code_test, error_msg = self._check_notnull()\\n if error_code_test == 0:\\n error_code_test, error_msg, n0, n1 = self._check_group_obs(self.test_min_data)\\n if error_code_test == 0:\\n error_code_test, error_msg, corr, pval = \\\\\\n self._check_spearman_corr(self.min_corr, self.max_p)\\n if error_code_test != 0:\\n error_text_test = str(error_msg)\\n except:\\n error_code_test = 9\\n error_text_test = 'Unknown Error'\\n\\n self.checkstats = {'n0': n0, 'n1': n1, 'frame_spearmanR': corr, 'frame_corrPval': pval}\\n\\n self.error_code_test = error_code_test\\n self.error_text_test = error_text_test\\n\\n return self.error_code_test, self.error_text_test\",\n \"def check_message_id(self, user, item_id, message_id):\\n try:\\n\\n err_options = message_id.split(':', 2)\\n msg_error_count = int(err_options[1])\\n\\n # check for token update\\n if len(err_options) > 1 and err_options[2] != str(self.get_token(user)):\\n self.log.warning(MSG_NEW_TOKEN_.format(item_id, msg_error_count, message_id))\\n return 0\\n # check update timestamp for message edit\\n elif msg_error_count > 1:\\n self.log.warning(MSG_FAILED_ALREADY_.format(item_id, message_id))\\n return None\\n\\n elif msg_error_count >= 0:\\n self.log.warning(MSG_RETRYING_FAILED_.format(item_id, msg_error_count, message_id))\\n return msg_error_count\\n\\n except:\\n self.log.error(MSG_FAILED_TO_PARSE_ID_.format(item_id, message_id, traceback.format_exc()))\\n\\n return None\",\n \"def _check_r_res(res, o_exp, g_exp, p_exp):\\n print green(\\\"Checking %s owner, group, permissions. \\\"\\n \\\"Expected: %s, %s, %s\\\" % (res, o_exp, g_exp, p_exp))\\n if exists(res):\\n resp = run('stat -c %%U,%%G,%%a %s' % res)\\n o_act, g_act, p_act = map(str.strip, resp.split(','))\\n if o_act != o_exp or g_act != g_exp or p_act != p_exp:\\n abort(red(\\\"Resource %s params: %s. Expected: %s\\\" % (\\n res, (o_act, g_act, p_act), (o_exp, g_exp, p_exp))))\\n print green(\\\"Resource %s checking passed\\\" % res)\\n else:\\n abort(red(\\\"Resource %s is not exists\\\" % res))\",\n \"def response_check(response):\\n print(response)\\n print(response.text)\\n return response.status_code == 200\",\n \"def check_auth_interactive_response(self, responses):\\n return AUTH_FAILED\",\n \"def validate_collection_response(self, response):\\n\\n self.validate_response(response)\\n if response.status_code not in self.model._meta['valid_get_status']:\\n raise InvalidStatusError(\\n self.model._meta['valid_get_status'], response\\n )\",\n \"def handle_response(self, response):\\n assert isinstance(response, CommandResponseObject)\\n\\n # Is there was a protocol error return the error.\\n if response.is_protocol_failure():\\n raise OffChainProtocolError.make(response.error)\\n\\n request_cid = response.cid\\n\\n # If we have already processed the response.\\n request = self.committed_commands.try_get(request_cid)\\n if request:\\n # Check the reponse is the same and log warning otherwise.\\n if request.response != response:\\n excp = OffChainException(\\n 'Got different responses with cid {request_cid}.'\\n )\\n excp.response1 = request.response\\n excp.response2 = response\\n raise excp\\n # This request may have concurrent modification\\n # read db to get latest status\\n return self.committed_commands[request_cid].is_success()\\n\\n request = self.my_pending_requests.try_get(request_cid)\\n if not request:\\n raise OffChainException(\\n f'Response for unknown cid {request_cid} received.'\\n )\\n\\n # Read and write back response into request.\\n request.response = response\\n\\n # Add the next command to the common sequence.\\n self.committed_commands[request.cid] = request\\n del self.my_pending_requests[request_cid]\\n self.register_dependencies(request)\\n self.apply_response(request)\\n return request.is_success()\",\n \"def validate_message(self, state_id, msg):\\n pass\",\n \"def api_check_manager_status():\\n try:\\n ret = AppStatus.check_manager_status()\\n if ret is not None:\\n return jsonify(ret)\\n except Exception as e:\\n logger.error(\\\"Traceback:\\\\n%s\\\", traceback.format_exc())\\n abort(500, \\\"failed to send message or invalid manager response\\\")\",\n \"def _is_error_call(self, response):\\n status = response.get('ResponseMetadata', {}).get('HTTPStatusCode')\\n return status != 200\",\n \"def _assert_existing_user_error(self, response):\\n assert response.status_code == 409\\n errors = json.loads(response.content.decode('utf-8'))\\n for conflict_attribute in [\\\"username\\\", \\\"email\\\"]:\\n assert conflict_attribute in errors\\n assert \\\"belongs to an existing account\\\" in errors[conflict_attribute][0][\\\"user_message\\\"]\",\n \"def check_error(self, response):\\n if type(response) is dict and response.has_key('status_code'):\\n if response['status_code'] != 200:\\n raise rocket.RocketAPIException(response['status_code'],\\n response['status_text'])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63983744","0.6147145","0.6012438","0.5871563","0.5813378","0.5793791","0.579217","0.5788185","0.5732082","0.5707856","0.5679702","0.5675938","0.5664866","0.5634316","0.5605626","0.56005645","0.5583741","0.5568571","0.55622566","0.55569047","0.55382013","0.552607","0.55216193","0.55210644","0.55180824","0.55101144","0.549671","0.5495152","0.54717946","0.54587567","0.5457671","0.5434249","0.5426033","0.5422725","0.5418832","0.54109156","0.53853124","0.5383511","0.5381236","0.5374442","0.536964","0.5357793","0.5355285","0.5352463","0.5349599","0.53430873","0.53387296","0.5332652","0.53263724","0.5325195","0.5312169","0.5307557","0.5303818","0.530366","0.52817464","0.52813977","0.52805406","0.52732474","0.52709764","0.52578205","0.5253163","0.52381384","0.52358437","0.52319145","0.52202326","0.52201504","0.5214076","0.5211274","0.52024746","0.5196272","0.5194356","0.5193466","0.5192861","0.5184095","0.51679355","0.51674867","0.5163409","0.51592654","0.51528186","0.5150102","0.5138465","0.51369977","0.51225126","0.51224947","0.51180786","0.51072186","0.5099987","0.50955904","0.50860023","0.5077406","0.50764173","0.50744075","0.5069845","0.5069821","0.5069754","0.50695366","0.5063572","0.506237","0.50606334","0.50571084"],"string":"[\n \"0.63983744\",\n \"0.6147145\",\n \"0.6012438\",\n \"0.5871563\",\n \"0.5813378\",\n \"0.5793791\",\n \"0.579217\",\n \"0.5788185\",\n \"0.5732082\",\n \"0.5707856\",\n \"0.5679702\",\n \"0.5675938\",\n \"0.5664866\",\n \"0.5634316\",\n \"0.5605626\",\n \"0.56005645\",\n \"0.5583741\",\n \"0.5568571\",\n \"0.55622566\",\n \"0.55569047\",\n \"0.55382013\",\n \"0.552607\",\n \"0.55216193\",\n \"0.55210644\",\n \"0.55180824\",\n \"0.55101144\",\n \"0.549671\",\n \"0.5495152\",\n \"0.54717946\",\n \"0.54587567\",\n \"0.5457671\",\n \"0.5434249\",\n \"0.5426033\",\n \"0.5422725\",\n \"0.5418832\",\n \"0.54109156\",\n \"0.53853124\",\n \"0.5383511\",\n \"0.5381236\",\n \"0.5374442\",\n \"0.536964\",\n \"0.5357793\",\n \"0.5355285\",\n \"0.5352463\",\n \"0.5349599\",\n \"0.53430873\",\n \"0.53387296\",\n \"0.5332652\",\n \"0.53263724\",\n \"0.5325195\",\n \"0.5312169\",\n \"0.5307557\",\n \"0.5303818\",\n \"0.530366\",\n \"0.52817464\",\n \"0.52813977\",\n \"0.52805406\",\n \"0.52732474\",\n \"0.52709764\",\n \"0.52578205\",\n \"0.5253163\",\n \"0.52381384\",\n \"0.52358437\",\n \"0.52319145\",\n \"0.52202326\",\n \"0.52201504\",\n \"0.5214076\",\n \"0.5211274\",\n \"0.52024746\",\n \"0.5196272\",\n \"0.5194356\",\n \"0.5193466\",\n \"0.5192861\",\n \"0.5184095\",\n \"0.51679355\",\n \"0.51674867\",\n \"0.5163409\",\n \"0.51592654\",\n \"0.51528186\",\n \"0.5150102\",\n \"0.5138465\",\n \"0.51369977\",\n \"0.51225126\",\n \"0.51224947\",\n \"0.51180786\",\n \"0.51072186\",\n \"0.5099987\",\n \"0.50955904\",\n \"0.50860023\",\n \"0.5077406\",\n \"0.50764173\",\n \"0.50744075\",\n \"0.5069845\",\n \"0.5069821\",\n \"0.5069754\",\n \"0.50695366\",\n \"0.5063572\",\n \"0.506237\",\n \"0.50606334\",\n \"0.50571084\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.61792576"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":81996,"cells":{"query":{"kind":"string","value":"Make a L{proton.Message} containining a management request."},"document":{"kind":"string","value":"def request(self, body=None, **properties):\n if self.locales:\n properties.setdefault('locales', self.locales)\n request = proton.Message()\n request.properties = clean_dict(properties)\n request.body = body or {}\n return request"},"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 construct_message(self):\n msg_type = self.msg_type\n if msg_type == \"PUBMSG\":\n msg_type = \"PRIVMSG\"\n ret = \"{} {}\".format(msg_type, self.target)\n if self.content:\n ret += \" :{}\".format(self.content)\n return ret + \"\\r\\n\"","def makeAMQPmsg(self):\n msg = {'msgType' : 'AgentUpdate',\n 'AgentType': 'Bus',\n 'Extnum':self.Extnum,\n 'Vm': self.cv['Vm'],\n 'Va': self.cv['Va'],\n }\n return msg","def Message(self, *args, **kwargs):\n pass","def Message(self, *args, **kwargs):\n return Message(self, *args, **kwargs)","def createMessage( self, *args, **kw ):\n return MailMessage( *args, **kw )","def message(self, *args, **kwargs) -> Message:\n return Message(self.handle, *args, **kwargs)","def _create_msg(self, tr_id, i_triples, i_type, r_triples, r_type, confirm):\n params = SSAP_UPDATE_PARAM_TEMPLATE % (str(i_type).upper(),\n str(i_triples),\n str(r_type).upper(),\n str(r_triples),\n str(confirm).upper())\n tmp = SSAP_MESSAGE_TEMPLATE % (str(self.node_id), str(self.targetSS),\n self.tr_type, str(tr_id), params)\n return tmp","def process_mgmt_msg(self):\n logging.debug('Received message on the management socket')\n \n msg = self.mgmt_socket.recv_json()\n\n logging.debug('Message: %s', msg)\n \n if not isinstance(msg, dict):\n self.mgmt_socket.send_json({ 'success': -1, 'msg': 'Request message should be in JSON format' })\n return\n\n required_attribs = (\n 'cmd',\n )\n \n if not all(k in msg for k in required_attribs):\n return { 'success': -1, 'msg': 'Missing message properties' }\n\n mgmt_cmds = {\n 'manager.status': self.manager_status,\n 'manager.shutdown': self.manager_shutdown,\n }\n\n result = mgmt_cmds[msg['cmd']](msg) if mgmt_cmds.get(msg['cmd']) else { 'success': -1, 'msg': 'Uknown management command requested' }\n\n self.mgmt_socket.send_json(result)","def create_message(self,message_information):\n\n #create the message\n if message_information['service'] == 'whatsapp':\n #The details of the message sent is saved here\n message = self.client.messages.create(\n body='Your order of {food} from the {store_name} store is ready. Additional Information: {addit_info}'.format(**message_information),\n from_='whatsapp:{sender_number}'.format(**self.config),\n to='whatsapp:{mobile}'.format(**message_information)\n )\n #Set the ready state to waiting for collection\n #self.firebase.db.child('orders').child('{store_name}'.format(**message_information)).child('{order_id}'.format(**message_information)).update({\"ready\":\"waiting for collection\"})\n self.firebase.update([\"orders\", STORE_NAME, message_information[\"order_id\"]], {\"ready\": \"waiting for collection\"})","def make_message(self, mto, mbody=None, msubject=None, mtype=None,\n mhtml=None, mfrom=None, mnick=None):\n message = self.Message(sto=mto, stype=mtype, sfrom=mfrom)\n message['body'] = mbody\n message['subject'] = msubject\n if mnick is not None:\n message['nick'] = mnick\n if mhtml is not None:\n message['html']['body'] = mhtml\n return message","def _create_request(self, messages):\n\n msg = ','.join(messages)\n request = '{{\"request\":\"sender data\",\"data\":[{msg}]}}'.format(msg=msg)\n request = request.encode(\"utf-8\")\n logger.debug('Request: %s', request)\n\n return request","def create_request(request, name):\n requestId = hl.createRequest(name, request)\n adminEmails = hl.getAdminEmails()\n #Send email to all admin accounts\n msg = \"\"\"\n Request from {}:\n \n ID: {}\n\n Request: Key Reset\n \n This message is automatically generated, please do not reply as this account is not monitored.\n \n \"\"\".format(name, requestId)\n emailMessage(\"New Request\", adminEmails, msg)\n return redirect(url_for('confirm', confirmed='New Key Request Sent!'))","def _construct_message(self):\n self.message[\"text\"] = \"\"\n if self.from_:\n self.message[\"text\"] += \"From: \" + self.from_ + \"\\n\"\n if self.subject:\n self.message[\"text\"] += \"Subject: \" + self.subject + \"\\n\"\n\n self.message[\"text\"] += self.body\n self._add_attachments()","async def package_request(self, request):\n json_dict = request.get_json_data_dict(JSONFlag.NET)\n\n # Make signature.\n vasp = self.vasp\n my_key = vasp.info_context.get_my_compliance_signature_key(\n self.get_my_address().as_str()\n )\n json_string = await my_key.sign_message(json.dumps(json_dict))\n\n net_message = NetMessage(\n self.myself,\n self.other,\n CommandRequestObject,\n json_string,\n request\n )\n\n return net_message","def horde_message(self, message):","def message(self):\r\n url = '{0}/{1}'.format(self.get_url(), 'message')\r\n return http.Request('GET', url), parsers.parse_json","def makeMessage( name, *structure ):\n return X12Message( name, *structure )","def _create_msg(self, tr_id, triples, type, confirm):\n params = SSAP_REMOVE_PARAM_TEMPLATE % (str(type).upper(),\n str(triples),\n str(confirm).upper())\n tmp = SSAP_MESSAGE_TEMPLATE % (str(self.node_id), str(self.targetSS),\n self.tr_type, str(tr_id), params)\n return tmp","def message():\n # Retrieve JSON parameters data.\n data = request.get_json() or {}\n data.update(dict(request.values))\n msg = data.get(\"msg\")\n if not msg:\n raise abort(400, \"missing 'msg' data\")\n\n # Deffer the message as a task.\n result = tasks.process_message.delay(msg, delta=10)\n task_id = result.task_id\n if not task_id or result.failed():\n raise abort(400, \"task failed\")\n # Then check and return ID.\n return {\n \"task_id\": result.id\n }","def RegMessage(self, request=[], default=None):\n oid, message = request\n wf_message_post(self, [oid], body=message)\n return False","def mailissue(request):\n if not request.issue.edit_allowed:\n if not IS_DEV:\n return HttpTextResponse('Login required', status=401)\n issue = request.issue\n msg = _make_message(request, issue, '', '', True)\n issue.put()\n msg.put()\n\n return HttpTextResponse('OK')","def alloc_request():\n return SentmanRequest(SentmanRequest.ALLOCATE_SENTINEL)","def management(self):\r\n return management.Management(self)","def _create_msg(self, tr_id, payload, confirm, expire_time, encoding):\n tmp = [\"<SSAP_message><transaction_type>INSERT</transaction_type>\",\n \"<message_type>REQUEST</message_type>\"]\n tmp.extend([\"<transaction_id>\", str(tr_id), \"</transaction_id>\"])\n tmp.extend([\"<node_id>\", str(self.node_id), \"</node_id>\"])\n tmp.extend([\"<space_id>\", str(self.targetSS), \"</space_id>\"])\n tmp.extend(['<parameter name=\"insert_graph\" encoding=\"%s\">' % encoding.upper(),\n str(payload), \"</parameter>\"])\n tmp.extend(['<parameter name = \"confirm\">',\n str(confirm).upper(),\n \"</parameter>\",\n \"</SSAP_message>\"])\n return \"\".join(tmp)","def post(self, request):\n # get message from request\n message = request.POST.get('message')\n # create message\n\n ChatMessage.objects.create(\n message=message, _from=request.user, _to=request.user.client.trainer.user)\n # return response\n return HttpResponse('success')","def create_message(self, subject, message, destination, origin = None):\n msg = MIMEText(message)\n if origin is not None:\n msg['From'] = origin\n else:\n msg['From'] = self.origin\n msg['Subject'] = subject\n msg['To'] = destination\n self.messages.append(msg)","def _create_message(self, params):\n # get pending reports\n report_types=params['report_types']\n requestID = params['requestID']\n venID = params['venID']\n content = oadrCreateReport(requestID, report_types, venID)\n return oadrPayload(content)","def _message(self, request_cls, destination=None, message_id=0,\n consent=None, extensions=None, sign=False, sign_prepare=False,\n nsprefix=None, **kwargs):\n if not message_id:\n message_id = sid()\n\n for key, val in self.message_args(message_id).items():\n if key not in kwargs:\n kwargs[key] = val\n\n req = request_cls(**kwargs)\n reqid = req.id\n\n if destination:\n req.destination = destination\n\n if consent:\n req.consent = \"true\"\n\n if extensions:\n req.extensions = extensions\n\n if nsprefix:\n req.register_prefix(nsprefix)\n\n if sign:\n return reqid, self.sign(req, sign_prepare=sign_prepare)\n else:\n logger.info(\"REQUEST: %s\" % req)\n return reqid, req","def make(self):\n return _spacegrant_swig.message_debug_sptr_make(self)","def generate_message(self, mtu):\r\n raise GeneratorExit(\"No more message to send\")","def createMessage( self, *args, **kw ):\n if not kw.has_key('charset'):\n kw['charset'] = self.getOutputCharset()\n kw['to_mail'] = 1\n return MailServerBase.createMessage( self, *args, **kw )","def create(self, data):\n\n\t\tmessage = data\n\t\tmessage[\"id\"] = self.count = self.count + 1\n\t\tself.messages.append(message)\n\n\t\treturn(message)","def test_mesage_model(self):\n msg = Message","def create_next_message(self, **kwargs):\n message = self._builder.create_message(**kwargs)\n return message","def _construct_message(self):\n self.message = {\"token\": self._auth, \"channel\": self.channel}\n super()._construct_message()","async def handle_manager_request(self, msg, recv):\n\n reply = msg.make_reply()\n order = GoMOrder.from_json(msg.body)\n accepted = False\n if self.can_accept_order(order):\n assert self.msg_order is None\n\n self.order = order\n self.msg_order = msg\n reply.set_metadata('performative', 'agree')\n accepted = True\n else:\n reply.set_metadata('performative', 'refuse')\n\n await send(recv, reply)\n if accepted:\n if str(self.jid) == order.location:\n self.add_behaviour(self.WorkBehaviour())\n else:\n msg_tr = Message(to=self.tr_jid, body=msg.body)\n msg_tr.set_metadata('performative', 'request')\n await send(recv, msg_tr)","def register_message():\n global mss_cnt\n\n gmess = Graph()\n\n # Construimos el mensaje de registro\n gmess.bind('foaf', FOAF)\n gmess.bind('dso', DSO)\n reg_obj = agn[InfoAgent.name+'-Register']\n gmess.add((reg_obj, RDF.type, DSO.Register))\n gmess.add((reg_obj, DSO.Uri, InfoAgent.uri))\n gmess.add((reg_obj, FOAF.Name, Literal(InfoAgent.name)))\n gmess.add((reg_obj, DSO.Address, Literal(InfoAgent.address)))\n gmess.add((reg_obj, DSO.AgentType, DSO.TransportAgent))\n\n # Lo metemos en un envoltorio FIPA-ACL y lo enviamos\n gr = send_message(\n build_message(gmess, perf= ACL.request,\n sender= InfoAgent.uri,\n receiver= AgentDirectori.uri,\n content= reg_obj,\n msgcnt= mss_cnt),\n AgentDirectori.address)\n mss_cnt += 1\n\n return gr","def _create_message(self, params):\n # This is an automatic generation, as it will depend on the \"database metadata reports owned\"\n venID = params['venID']\n from project_customization.base_customization import project_configuration\n requestID, reportRequestID, reports = project_configuration.on_OadrRegisterReport_send(venID)\n content = oadrRegisterReport(requestID, requestID, venID, reports)\n return oadrPayload(content)","def comsume_msg(self, msg_type):","def submit_message_from_message(message,body,by=None):\n if not by:\n by = Person.objects.get(name=\"(System)\")\n msg = Message.objects.create(\n by = by,\n subject = message.get('subject',''),\n frm = message.get('from',''),\n to = message.get('to',''),\n cc = message.get('cc',''),\n bcc = message.get('bcc',''),\n reply_to = message.get('reply_to',''),\n body = body,\n time = utc_from_string(message.get('date', ''))\n )\n return msg","def __getmessage__():\n\tmsg = \\\n\t\t 'M-SEARCH * HTTP/1.1\\r\\n' \\\n\t\t 'HOST:239.255.255.250:1900\\r\\n' \\\n\t\t 'ST:upnp:rootdevice\\r\\n' \\\n\t\t 'MX:2\\r\\n' \\\n\t\t 'MAN:\"ssdp:discover\"\\r\\n' \\\n\t\t '\\r\\n'\n\n\treturn msg","async def create_status_message(self, event):\n try:\n channel = await self.client.channel_private_create(event.user)\n except ConnectionError:\n return False\n \n embed, components = self.get_status_embed_and_components()\n \n try:\n message = await self.client.message_create(channel, embed = embed, components = components)\n except ConnectionError:\n return False\n \n except DiscordException as err:\n if err.code == ERROR_CODES.cannot_message_user:\n return False\n \n raise\n \n # We sent an empty message -> should not happen.\n if message is None:\n return False\n \n self.status_message = message\n return True","def sms():\n\n\t# initialize response\n\tresp = MessagingResponse()\n\n\t# add a message\n\tresp.message(\"Thank you for your response! We are confirming your message.\")\n\n\treturn str(resp)","def new_message(self, room, mess):\n pass","def createMessage( self, *args, **kw ):\n if not kw.has_key('charset'):\n kw['charset'] = self.getInputCharset()\n return MailServerBase.createMessage( self, *args, **kw )","def _create_add_message_from_order(order):\n message = {}\n message.update({\"message-type\": \"A\"})\n message.update({\"instrument\": order.instrument})\n message.update({\"order-id\": order.order_id})\n message.update({\"price\": int(order.price)})\n message.update({\"quantity\": int(order.quantity)})\n message.update({\"side\": side_to_str(order.side)})\n message.update({\"timestamp\": order.timestamp})\n message.update({\"snapshot\": 1})\n return message","def new_message(self, body=''):\r\n m = self.message_class(self, body)\r\n m.queue = self\r\n return m","def request_message(self) -> Optional[str]:\n return pulumi.get(self, \"request_message\")","def __init__(self, request):\n self.request = request\n self.fields = Message(request.namespace)","async def prepare_message(self, **args):\n await self.set_args(**args)\n await self.validate()\n return await self.dict()","def getMessage():\n return message","async def mod_check(request: Request) -> Message:\n return Message(message=\"Hello fellow moderator!\")","def _create_message(self, msg):\n head = msg[\"head\"]\n body = msg[\"body\"]\n body = body.format(**self.data)\n length = len(body)\n head = head.format(length=length, **self.data)\n return head + body","def new_message(self):\n msg = {}\n msg['data'] = []\n msg['type'] = self.plugin_type\n msg['source'] = self.name\n msg['ts'] = (datetime.datetime.utcnow() - datetime.datetime(1970, 1, 1)).total_seconds()\n return msg","def _mgmt_request_response(\n self,\n mgmt_operation: bytes,\n message: Any,\n callback: Callable,\n keep_alive_associated_link: bool = True,\n timeout: Optional[float] = None,\n **kwargs: Any\n ) -> \"pyamqp_Message\":\n self._open()\n application_properties = {}\n\n # Some mgmt calls do not support an associated link name (such as list_sessions). Most do, so on by default.\n if keep_alive_associated_link:\n try:\n application_properties = {\n ASSOCIATEDLINKPROPERTYNAME: self._amqp_transport.get_handler_link_name(self._handler)\n }\n except AttributeError:\n pass\n\n mgmt_msg = self._amqp_transport.create_mgmt_msg(\n message=message,\n application_properties=application_properties,\n config=self._config,\n reply_to=self._mgmt_target,\n **kwargs\n )\n\n try:\n return self._amqp_transport.mgmt_client_request(\n self._handler,\n mgmt_msg,\n operation=mgmt_operation,\n operation_type=MGMT_REQUEST_OP_TYPE_ENTITY_MGMT,\n node=self._mgmt_target.encode(self._config.encoding),\n timeout=timeout,\n callback=callback\n )\n except Exception as exp: # pylint: disable=broad-except\n if isinstance(exp, self._amqp_transport.TIMEOUT_ERROR):\n raise OperationTimeoutError(error=exp) from exp\n raise","def build_message():\n outgoing_mail = Mail()\n outgoing_mail.from_email = Email(email_from_address, email_from_name)\n outgoing_mail.subject = subject\n personalization = Personalization()\n for recipient in email_to_addresses:\n personalization.add_to(Email(recipient))\n outgoing_mail.add_personalization(personalization)\n outgoing_mail.add_content(Content(\"text/plain\", str.join('\\n', _log)))\n outgoing_mail.add_content(Content(\"text/html\", \"<html><body> {} </body></html>\".format(str.join(' <br /> ', _log))))\n return outgoing_mail.get()","def Message(title, msg):\r\n return _hiew.HiewGate_Message(title, msg)","def createMessage(self, sender: str, to: str, subject: str, message_text: str):\n message = MIMEText(message_text)\n message['to'] = to\n message['from'] = sender\n message['subject'] = subject\n raw_message = {'raw': base64.urlsafe_b64encode(message.as_bytes())}\n raw_message['raw']=raw_message['raw'].decode('utf-8')\n return raw_message","def msg(self, target, message):\n self.server.message_queue.put(('tests!tests@tes.t', target, message))","def resource_type(self):\n return 'message'","def message_new(self, cr, uid, msg, custom_values=None, context=None):\n if custom_values is None: custom_values = {}\n\n desc = html2plaintext(msg.get('body')) if msg.get('body') else ''\n custom_values.update({\n 'name': msg.get('subject') or _(\"No Subject\"),\n 'description': desc,\n 'email_from': msg.get('from'),\n 'email_cc': msg.get('cc'),\n 'user_id': False,\n })\n if msg.get('priority') in dict(crm.AVAILABLE_PRIORITIES):\n custom_values['priority'] = msg.get('priority')\n return super(crm_lead, self).message_new(cr, uid, msg, custom_values=custom_values, context=context)","def message(self):\n self.add_file_string('Message file')\n self.make_dangerous('Message file')","def register_message():\n global mss_cnt\n\n gmess = Graph()\n\n # Construimos el mensaje de registro\n gmess.bind('foaf', FOAF)\n gmess.bind('dso', DSO)\n reg_obj = agn[InfoAgent.name+'-Register']\n gmess.add((reg_obj, RDF.type, DSO.Register))\n gmess.add((reg_obj, DSO.Uri, InfoAgent.uri))\n gmess.add((reg_obj, FOAF.Name, Literal(InfoAgent.name)))\n gmess.add((reg_obj, DSO.Address, Literal(InfoAgent.address)))\n gmess.add((reg_obj, DSO.AgentType, DSO.HotelsAgent))\n\n # Lo metemos en un envoltorio FIPA-ACL y lo enviamos\n gr = send_message(\n build_message(gmess, perf= ACL.request,\n sender= InfoAgent.uri,\n receiver= AgentDirectori.uri,\n content= reg_obj,\n msgcnt= mss_cnt),\n AgentDirectori.address)\n mss_cnt += 1\n\n return gr","def create_action_msg(self, action):\n raise NotImplementedError(\"Don't know how to translate the action to a msg\")","def _ConvertToMessage(info, status=None):\n message = mtt_messages.Convert(info, mtt_messages.ConfigSetInfo)\n message.status = status\n return message","def newMCRequest(self, request):\n raise NotImplementedError","def make_request_message(request):\n url = urlparse(request.url)\n request_headers = dict(request.headers)\n if 'Host' not in request_headers:\n request_headers['Host'] = url.netloc\n return HTTPMessage(\n line='{method} {path} HTTP/1.1'.format(\n method=request.method,\n path=url.path or '/'),\n headers=NEW_LINE.join(str('%s: %s') % (name, value)\n for name, value\n in request_headers.items()),\n body=request._enc_data,\n content_type=request_headers.get('Content-Type')\n )","def loan_message_creator_factory():\n return partial(\n message_factory, current_app.config[\"ILS_CIRCULATION_MAIL_MSG_CREATOR\"]\n )","def test_get_message_new(self):\n message = mommy.make(\n 'connectmessages.Message', thread=self.thread, sender=self.sender)\n thread = Thread.public.by_user(user=self.user)[0]\n messages = thread.messages_for_user(self.user)\n self.assertEqual(messages[0], message)\n self.assertFalse(messages[0].read)","def status_message(message):\n return StatusMessage(message)","def new_message(self,\n intent=\"\",\n message=\"\",\n type=None,\n not_handled=False,\n time_stamp=None):\n self.messages.append(Message(api_key=self.api_key,\n platform=self.platform,\n version=self.version,\n user_id=self.user_id,\n intent=intent,\n message=message,\n type=type,\n not_handled=not_handled,\n time_stamp=time_stamp))\n return self.messages[-1]","def send_created_email(self):\n if settings.NOTIFY_NEW_REG:\n to = settings.NOTIFY_NEW_REG\n message = \"\"\"\\\nGreetings,<br><br>\n\nA new vehicle registration has been submitted by %s.<br><br>\n\nGo here to view or edit the request: <br>\n<a href=\"%s\">%s</a>\n<br><br>\nSincerely,<br><br>\nThe Janelia Parking Permit Program\n \"\"\" % (self.user_display_name(), self.get_edit_url(True), self.get_edit_url(True))\n subject = 'A new parking permit request has been entered'\n from_email = 'parkingpermit-donotreply@janelia.hhmi.org'\n text_content = re.sub(r'<[^>]+>','',message)\n html_content = message\n msg = EmailMultiAlternatives(subject, text_content, from_email, to)\n msg.attach_alternative(html_content, \"text/html\")\n msg.send()","def generate_message(self, mtu):\r\n raise SystemExit(self.sm.__exit_msg__)","def __message_content__(self) -> MessageContent:","def message(cls, user, message, context):\r\n q.enqueue(new_message_worker, args=(user, message, context), result_ttl=0)\r\n pass","def cmd(self, message):\n pass","def _create_job_message(self):\n #TODO: Final check of source file, add xml settings, allow for user\n # to set priority, verify all job data is correct format\n\n if not hasattr(self.required_files, '_get_message'):\n self.add_file_collection()\n\n if self.pool and hasattr(self.pool, 'id'):\n pool_options = {'poolId': self.pool.id}\n\n elif self.pool:\n pool_options = {'poolId': str(self.pool)}\n\n else:\n size = max(int(self.instances), 1)\n pool_options = {'autoPoolSpecification': self._auto_pool(size)}\n\n job_message = {\n 'Name': str(self.name),\n 'Type': self._api.jobtype(),\n 'RequiredFiles': self.required_files._get_message(\"submit\"),\n 'Parameters': list(self._filter_params()),\n 'JobFile': str(self.source),\n 'Settings': str(self.settings),\n 'Priority': 'Medium'\n }\n job_message.update(pool_options)\n\n self._log.debug(\"Job message: {0}\".format(job_message))\n return job_message","def get_message(self, **kwargs):\n message = dovesoft.Sms()\n\n for key in kwargs.keys():\n if key not in kwargs.get(\"ignore\", smsconf.IGNORE_KEYS):\n fun = getattr(message, \"set_{key}\".format(key=key))\n fun(kwargs.get(key, \"\"))\n\n return message","def build_notification():\n username = post_param('username', '')\n message = post_param('message', '')\n light = post_param('light', 1)\n sound = post_param('sound', 1)\n notification = Notification(username, message, datetime.now(), light, sound)\n \n if not notification.is_valid():\n raise HTTPResponse(body=\"Notification invalid\", status=400)\n \n return notification","def create_user_message(self, *args, **kwargs) -> UserMessage:\n \n raise NotImplementedError()","def _build_common_message(msg_title,msg_text,msg_type):\n data = {\n 'message': {\n \"topic\" : '',\n 'data': {\n 'title': '',\n 'message': '',\n 'type' : ''\n }\n }\n }\n data['message']['topic'] = FCM_TOPIC\n data['message']['data']['title'] = msg_title\n data['message']['data']['message'] = datetime.datetime.now().strftime(\"%H:%M:%S\") + \" \" + msg_text\n data['message']['data']['type'] = msg_type\n return data","def _build_common_message(msg_title,msg_text,msg_type):\n data = {\n 'message': {\n \"topic\" : '',\n 'data': {\n 'title': '',\n 'message': '',\n 'type' : ''\n }\n }\n }\n data['message']['topic'] = FCM_TOPIC\n data['message']['data']['title'] = msg_title\n data['message']['data']['message'] = datetime.datetime.now().strftime(\"%H:%M:%S\") + \" \" + msg_text\n data['message']['data']['type'] = msg_type\n return data","def get_message(self):\n return super().get_message()","def CreateMessageClass(self):\n class ComplexMessage(messages.Message):\n a3 = messages.IntegerField(3)\n b1 = messages.StringField(1)\n c2 = messages.StringField(2)\n\n return ComplexMessage","async def request(self, ctx: commands.Context, *, feature):\n msg = \"Request from {}:\\n\".format(ctx.author.mention) + feature\n await ctx.bot.pm_owner(content=msg)\n await ctx.message.add_reaction(\"✅\")","def message(self, value: str):\n self._properties[\"message\"] = value","async def _cmdf_pmdemo(self, substr, msg, privilege_level):\n pm_target = msg.author\n buf = self._get_pm_greeting(pm_target)\n await self._client.send_msg(pm_target, buf)\n\n await self._client.send_msg(msg, \"<@{}>, check your inbox!\".format(msg.author.id))\n return","def create_message(message):\n return {\n \"id\": message.id,\n \"from\": message.sender,\n \"preview\": create_preview(message),\n \"subject\": message.subject,\n \"date\": message.date_created,\n }","def create_messages(application, action, remedy):\n\n messages = [] \n messages.append(\"\"\"Your Resources: </br><pre style=\"margin-left: 40px\">\"\"\" + application + \"</br></pre>\" + action + \"\"\" in AWS. <strong style=\"font-family: 'Helvetica Neue',Helvetica,Arial,sans-serif; box-sizing: border-box; font-size: 14px; margin: 0;\">\"\"\" + remedy +\"\"\"</strong>\n </td>\n </tr><tr style=\"font-family: 'Helvetica Neue',Helvetica,Arial,sans-serif; box-sizing: border-box; font-size: 14px; margin: 0;\"><td class=\"content-block\" style=\"font-family: 'Helvetica Neue',Helvetica,Arial,sans-serif; box-sizing: border-box; font-size: 14px; vertical-align: top; margin: 0; padding: 0 0 20px;\" valign=\"top\">\n This message was sent to inform you of changes happening to your resources.\n <ul>\n <li>New instances are auto-tagged with an expiration date, an NT ID, and a patch group if invalid.</li>\n <li>Instances without the necessary tags are notified through email and Slack.</li>\n </ul>\n If you have any further questions, please reply to this email.\"\"\")\n \n messages.append(\"Your Resources:\\n\\n\" + application + \"\\n\\n\" + action + \" in AWS. \" + remedy + \"\\n\" + \n (\"\\nThis message was sent to inform you of changes happening to your resources.\\n\"\n \"\\nNew instances are auto-tagged with an expiration date, an NT ID, and a patch group if invalid.\"\n \"Instances without Owner Mail and Owner Team tags are notified through email and slack.\\n\"\n \"\\nIf you have any further questions, please reply to this email.\")) \n\n return messages","def message(self, sid):\r\n return Message(self, sid)","def create_command_from_request(request: RequestInterface):","def send_owner_message(): \n data = order_obj.send_owner_message(request.forms)\n return data","def sms_reply():\n # Fetch the message\n msg = request.form.get('Body')\n\n # Create reply\n resp = MessagingResponse()\n resp.message(\"You said: {} \\n *Kayra Dev* \".format(msg))\n \n account_sid = 'AC195cf76c0d725909794c30f9b0c32961' \n auth_token = '70531f5d14ec79c14254cf7fdfb40bad' \n client = Client(account_sid, auth_token) \n \n message = client.messages.create( \n from_='whatsapp:+14155238886', \n body=msg, \n to='whatsapp:+237696527034' \n ) \n \n print(message.sid)\n return str(resp)","def create_request(v1):\n #get entered data\n data = request.get_json()\n\n #picking the request attributes\n req_title = data.get(\"request_title\")\n req_desc = data.get(\"request_description\")\n requester_name = \"Gideon\"\n req_id = len(all_requests) +1 # + random.randint(1, 3000)\n\n #validation\n if not req_title:\n return jsonify({\"message\": \"Request has no title\"}), 400\n if not req_desc:\n return jsonify({\"message\": \"Request has no description\"}), 400\n if not requester_name:\n return jsonify({\"message\": \"Request must be issued by a user\"}), 400\n if not req_id:\n return jsonify({\"message\": \"Request has no id\"}), 400\n\n #storing entered request\n new_request = MaintenanceRequest(req_title, req_desc, requester_name, req_id)\n all_requests.append(new_request)\n # new_number_of_requests = len(all_requests)\n\n return jsonify({\n \"message\":\"sucessfully created request\",\n 'request_title':new_request.title,\n \"request_description\":new_request.description,\n \"requester_name\" : new_request.requester_name,\n \"request_id\" : new_request.request_id\n })","def send(self, msg):\n self.message('Me', msg)","async def post(self):\n await self.handle_request(self.messages_new_api, 1)","def massage_addinfo(self) -> str:\n self.message_str = f'{self.time}\\n{self.sent_by}\\n'\n return self.message_str","def _set_message(self):\n\n type_to_message = {\n MESSAGE_TYPES['join'] : (\n u\"User '%s' has joined the chat.\" % \n self.author\n ),\n MESSAGE_TYPES['leave'] : (\n u\"User '%s' has left the chat.\" % \n self.author\n ),\n }\n\n message = self.message\n if type_to_message.has_key(self.type):\n message = type_to_message[self.type]\n self.message = message","def generate_msg(props, alert=False, user_pref=None, past=False):\n\t\tmessage = emojize(\":rocket:\", use_aliases=True)\n\t\tif past:\n\t\t\tmessage += ' Launch was held on: ' + props['when'].format('YYYY-MM-DD HH:mm:ss ZZ') + '.\\n'\n\t\t\tif props['holdreason']:\n\t\t\t\tmessage += 'The launch has been *held*. Reason: ' + props['holdreason'] + '\\n'\n\t\t\tif props['failreason']:\n\t\t\t\tmessage += 'Unfortunately, the launch *failed*. Reason: ' + props['failreason'] + '\\n'\n\t\telse:\n\t\t\tif alert:\n\t\t\t\tmessage += ' *Launch is going to happen in some minutes!* '\n\t\tmessage += ' *' + props['name'] + '*' + '\\n'\n\n\t\tif not alert and not past:\n\t\t\tmessage += 'A launch will happen _' + props['when'].humanize() + '_! \\n'\n\t\t\tmessage += 'I mean ' + props['when'].format('YYYY-MM-DD HH:mm:ss ZZ') + '\\n'\n\n\t\tif past:\n\t\t\tmessage += 'Taken from *'\n\t\telse:\n\t\t\tmessage += 'Taking from *'\n\n\t\tmessage += props['location'] + '*.\\n'\n\t\tdescr = Interface.generate_description(props['missions'])\n\t\tmessage += '*Mission description*\\n' + descr + '\\n' if descr else ''\n\t\tmessage += '\\n'\n\n\t\tif props['urls']:\n\t\t\tmessage += 'Watch it here: \\n' if not past else 'You could have watched it here: \\n'\n\t\t\tfor url in props['urls']:\n\t\t\t\tmessage += ' • [' + url + '](' + url +')\\n'\n\t\telse:\n\t\t\tmessage += 'Unfortunately there '\n\t\t\tmessage += 'are' if not past else 'were'\n\t\t\tmessage += ' no reported webcasts ' \\\n\t\t\t\t\t + emojize(':disappointed_relieved:', use_aliases=True)\n\n\t\treturn message","def get_message(self):\n\n if self.gotten: return\n self.get_recipients()\n self.get_text()\n self.get_price()\n self.get_files()\n self.set_text()\n if Settings.get_performer_category() or self.hasPerformers:\n self.get_performers()\n else:\n self.performers = \"unset\"\n self.gotten = True"],"string":"[\n \"def construct_message(self):\\n msg_type = self.msg_type\\n if msg_type == \\\"PUBMSG\\\":\\n msg_type = \\\"PRIVMSG\\\"\\n ret = \\\"{} {}\\\".format(msg_type, self.target)\\n if self.content:\\n ret += \\\" :{}\\\".format(self.content)\\n return ret + \\\"\\\\r\\\\n\\\"\",\n \"def makeAMQPmsg(self):\\n msg = {'msgType' : 'AgentUpdate',\\n 'AgentType': 'Bus',\\n 'Extnum':self.Extnum,\\n 'Vm': self.cv['Vm'],\\n 'Va': self.cv['Va'],\\n }\\n return msg\",\n \"def Message(self, *args, **kwargs):\\n pass\",\n \"def Message(self, *args, **kwargs):\\n return Message(self, *args, **kwargs)\",\n \"def createMessage( self, *args, **kw ):\\n return MailMessage( *args, **kw )\",\n \"def message(self, *args, **kwargs) -> Message:\\n return Message(self.handle, *args, **kwargs)\",\n \"def _create_msg(self, tr_id, i_triples, i_type, r_triples, r_type, confirm):\\n params = SSAP_UPDATE_PARAM_TEMPLATE % (str(i_type).upper(),\\n str(i_triples),\\n str(r_type).upper(),\\n str(r_triples),\\n str(confirm).upper())\\n tmp = SSAP_MESSAGE_TEMPLATE % (str(self.node_id), str(self.targetSS),\\n self.tr_type, str(tr_id), params)\\n return tmp\",\n \"def process_mgmt_msg(self):\\n logging.debug('Received message on the management socket')\\n \\n msg = self.mgmt_socket.recv_json()\\n\\n logging.debug('Message: %s', msg)\\n \\n if not isinstance(msg, dict):\\n self.mgmt_socket.send_json({ 'success': -1, 'msg': 'Request message should be in JSON format' })\\n return\\n\\n required_attribs = (\\n 'cmd',\\n )\\n \\n if not all(k in msg for k in required_attribs):\\n return { 'success': -1, 'msg': 'Missing message properties' }\\n\\n mgmt_cmds = {\\n 'manager.status': self.manager_status,\\n 'manager.shutdown': self.manager_shutdown,\\n }\\n\\n result = mgmt_cmds[msg['cmd']](msg) if mgmt_cmds.get(msg['cmd']) else { 'success': -1, 'msg': 'Uknown management command requested' }\\n\\n self.mgmt_socket.send_json(result)\",\n \"def create_message(self,message_information):\\n\\n #create the message\\n if message_information['service'] == 'whatsapp':\\n #The details of the message sent is saved here\\n message = self.client.messages.create(\\n body='Your order of {food} from the {store_name} store is ready. Additional Information: {addit_info}'.format(**message_information),\\n from_='whatsapp:{sender_number}'.format(**self.config),\\n to='whatsapp:{mobile}'.format(**message_information)\\n )\\n #Set the ready state to waiting for collection\\n #self.firebase.db.child('orders').child('{store_name}'.format(**message_information)).child('{order_id}'.format(**message_information)).update({\\\"ready\\\":\\\"waiting for collection\\\"})\\n self.firebase.update([\\\"orders\\\", STORE_NAME, message_information[\\\"order_id\\\"]], {\\\"ready\\\": \\\"waiting for collection\\\"})\",\n \"def make_message(self, mto, mbody=None, msubject=None, mtype=None,\\n mhtml=None, mfrom=None, mnick=None):\\n message = self.Message(sto=mto, stype=mtype, sfrom=mfrom)\\n message['body'] = mbody\\n message['subject'] = msubject\\n if mnick is not None:\\n message['nick'] = mnick\\n if mhtml is not None:\\n message['html']['body'] = mhtml\\n return message\",\n \"def _create_request(self, messages):\\n\\n msg = ','.join(messages)\\n request = '{{\\\"request\\\":\\\"sender data\\\",\\\"data\\\":[{msg}]}}'.format(msg=msg)\\n request = request.encode(\\\"utf-8\\\")\\n logger.debug('Request: %s', request)\\n\\n return request\",\n \"def create_request(request, name):\\n requestId = hl.createRequest(name, request)\\n adminEmails = hl.getAdminEmails()\\n #Send email to all admin accounts\\n msg = \\\"\\\"\\\"\\n Request from {}:\\n \\n ID: {}\\n\\n Request: Key Reset\\n \\n This message is automatically generated, please do not reply as this account is not monitored.\\n \\n \\\"\\\"\\\".format(name, requestId)\\n emailMessage(\\\"New Request\\\", adminEmails, msg)\\n return redirect(url_for('confirm', confirmed='New Key Request Sent!'))\",\n \"def _construct_message(self):\\n self.message[\\\"text\\\"] = \\\"\\\"\\n if self.from_:\\n self.message[\\\"text\\\"] += \\\"From: \\\" + self.from_ + \\\"\\\\n\\\"\\n if self.subject:\\n self.message[\\\"text\\\"] += \\\"Subject: \\\" + self.subject + \\\"\\\\n\\\"\\n\\n self.message[\\\"text\\\"] += self.body\\n self._add_attachments()\",\n \"async def package_request(self, request):\\n json_dict = request.get_json_data_dict(JSONFlag.NET)\\n\\n # Make signature.\\n vasp = self.vasp\\n my_key = vasp.info_context.get_my_compliance_signature_key(\\n self.get_my_address().as_str()\\n )\\n json_string = await my_key.sign_message(json.dumps(json_dict))\\n\\n net_message = NetMessage(\\n self.myself,\\n self.other,\\n CommandRequestObject,\\n json_string,\\n request\\n )\\n\\n return net_message\",\n \"def horde_message(self, message):\",\n \"def message(self):\\r\\n url = '{0}/{1}'.format(self.get_url(), 'message')\\r\\n return http.Request('GET', url), parsers.parse_json\",\n \"def makeMessage( name, *structure ):\\n return X12Message( name, *structure )\",\n \"def _create_msg(self, tr_id, triples, type, confirm):\\n params = SSAP_REMOVE_PARAM_TEMPLATE % (str(type).upper(),\\n str(triples),\\n str(confirm).upper())\\n tmp = SSAP_MESSAGE_TEMPLATE % (str(self.node_id), str(self.targetSS),\\n self.tr_type, str(tr_id), params)\\n return tmp\",\n \"def message():\\n # Retrieve JSON parameters data.\\n data = request.get_json() or {}\\n data.update(dict(request.values))\\n msg = data.get(\\\"msg\\\")\\n if not msg:\\n raise abort(400, \\\"missing 'msg' data\\\")\\n\\n # Deffer the message as a task.\\n result = tasks.process_message.delay(msg, delta=10)\\n task_id = result.task_id\\n if not task_id or result.failed():\\n raise abort(400, \\\"task failed\\\")\\n # Then check and return ID.\\n return {\\n \\\"task_id\\\": result.id\\n }\",\n \"def RegMessage(self, request=[], default=None):\\n oid, message = request\\n wf_message_post(self, [oid], body=message)\\n return False\",\n \"def mailissue(request):\\n if not request.issue.edit_allowed:\\n if not IS_DEV:\\n return HttpTextResponse('Login required', status=401)\\n issue = request.issue\\n msg = _make_message(request, issue, '', '', True)\\n issue.put()\\n msg.put()\\n\\n return HttpTextResponse('OK')\",\n \"def alloc_request():\\n return SentmanRequest(SentmanRequest.ALLOCATE_SENTINEL)\",\n \"def management(self):\\r\\n return management.Management(self)\",\n \"def _create_msg(self, tr_id, payload, confirm, expire_time, encoding):\\n tmp = [\\\"<SSAP_message><transaction_type>INSERT</transaction_type>\\\",\\n \\\"<message_type>REQUEST</message_type>\\\"]\\n tmp.extend([\\\"<transaction_id>\\\", str(tr_id), \\\"</transaction_id>\\\"])\\n tmp.extend([\\\"<node_id>\\\", str(self.node_id), \\\"</node_id>\\\"])\\n tmp.extend([\\\"<space_id>\\\", str(self.targetSS), \\\"</space_id>\\\"])\\n tmp.extend(['<parameter name=\\\"insert_graph\\\" encoding=\\\"%s\\\">' % encoding.upper(),\\n str(payload), \\\"</parameter>\\\"])\\n tmp.extend(['<parameter name = \\\"confirm\\\">',\\n str(confirm).upper(),\\n \\\"</parameter>\\\",\\n \\\"</SSAP_message>\\\"])\\n return \\\"\\\".join(tmp)\",\n \"def post(self, request):\\n # get message from request\\n message = request.POST.get('message')\\n # create message\\n\\n ChatMessage.objects.create(\\n message=message, _from=request.user, _to=request.user.client.trainer.user)\\n # return response\\n return HttpResponse('success')\",\n \"def create_message(self, subject, message, destination, origin = None):\\n msg = MIMEText(message)\\n if origin is not None:\\n msg['From'] = origin\\n else:\\n msg['From'] = self.origin\\n msg['Subject'] = subject\\n msg['To'] = destination\\n self.messages.append(msg)\",\n \"def _create_message(self, params):\\n # get pending reports\\n report_types=params['report_types']\\n requestID = params['requestID']\\n venID = params['venID']\\n content = oadrCreateReport(requestID, report_types, venID)\\n return oadrPayload(content)\",\n \"def _message(self, request_cls, destination=None, message_id=0,\\n consent=None, extensions=None, sign=False, sign_prepare=False,\\n nsprefix=None, **kwargs):\\n if not message_id:\\n message_id = sid()\\n\\n for key, val in self.message_args(message_id).items():\\n if key not in kwargs:\\n kwargs[key] = val\\n\\n req = request_cls(**kwargs)\\n reqid = req.id\\n\\n if destination:\\n req.destination = destination\\n\\n if consent:\\n req.consent = \\\"true\\\"\\n\\n if extensions:\\n req.extensions = extensions\\n\\n if nsprefix:\\n req.register_prefix(nsprefix)\\n\\n if sign:\\n return reqid, self.sign(req, sign_prepare=sign_prepare)\\n else:\\n logger.info(\\\"REQUEST: %s\\\" % req)\\n return reqid, req\",\n \"def make(self):\\n return _spacegrant_swig.message_debug_sptr_make(self)\",\n \"def generate_message(self, mtu):\\r\\n raise GeneratorExit(\\\"No more message to send\\\")\",\n \"def createMessage( self, *args, **kw ):\\n if not kw.has_key('charset'):\\n kw['charset'] = self.getOutputCharset()\\n kw['to_mail'] = 1\\n return MailServerBase.createMessage( self, *args, **kw )\",\n \"def create(self, data):\\n\\n\\t\\tmessage = data\\n\\t\\tmessage[\\\"id\\\"] = self.count = self.count + 1\\n\\t\\tself.messages.append(message)\\n\\n\\t\\treturn(message)\",\n \"def test_mesage_model(self):\\n msg = Message\",\n \"def create_next_message(self, **kwargs):\\n message = self._builder.create_message(**kwargs)\\n return message\",\n \"def _construct_message(self):\\n self.message = {\\\"token\\\": self._auth, \\\"channel\\\": self.channel}\\n super()._construct_message()\",\n \"async def handle_manager_request(self, msg, recv):\\n\\n reply = msg.make_reply()\\n order = GoMOrder.from_json(msg.body)\\n accepted = False\\n if self.can_accept_order(order):\\n assert self.msg_order is None\\n\\n self.order = order\\n self.msg_order = msg\\n reply.set_metadata('performative', 'agree')\\n accepted = True\\n else:\\n reply.set_metadata('performative', 'refuse')\\n\\n await send(recv, reply)\\n if accepted:\\n if str(self.jid) == order.location:\\n self.add_behaviour(self.WorkBehaviour())\\n else:\\n msg_tr = Message(to=self.tr_jid, body=msg.body)\\n msg_tr.set_metadata('performative', 'request')\\n await send(recv, msg_tr)\",\n \"def register_message():\\n global mss_cnt\\n\\n gmess = Graph()\\n\\n # Construimos el mensaje de registro\\n gmess.bind('foaf', FOAF)\\n gmess.bind('dso', DSO)\\n reg_obj = agn[InfoAgent.name+'-Register']\\n gmess.add((reg_obj, RDF.type, DSO.Register))\\n gmess.add((reg_obj, DSO.Uri, InfoAgent.uri))\\n gmess.add((reg_obj, FOAF.Name, Literal(InfoAgent.name)))\\n gmess.add((reg_obj, DSO.Address, Literal(InfoAgent.address)))\\n gmess.add((reg_obj, DSO.AgentType, DSO.TransportAgent))\\n\\n # Lo metemos en un envoltorio FIPA-ACL y lo enviamos\\n gr = send_message(\\n build_message(gmess, perf= ACL.request,\\n sender= InfoAgent.uri,\\n receiver= AgentDirectori.uri,\\n content= reg_obj,\\n msgcnt= mss_cnt),\\n AgentDirectori.address)\\n mss_cnt += 1\\n\\n return gr\",\n \"def _create_message(self, params):\\n # This is an automatic generation, as it will depend on the \\\"database metadata reports owned\\\"\\n venID = params['venID']\\n from project_customization.base_customization import project_configuration\\n requestID, reportRequestID, reports = project_configuration.on_OadrRegisterReport_send(venID)\\n content = oadrRegisterReport(requestID, requestID, venID, reports)\\n return oadrPayload(content)\",\n \"def comsume_msg(self, msg_type):\",\n \"def submit_message_from_message(message,body,by=None):\\n if not by:\\n by = Person.objects.get(name=\\\"(System)\\\")\\n msg = Message.objects.create(\\n by = by,\\n subject = message.get('subject',''),\\n frm = message.get('from',''),\\n to = message.get('to',''),\\n cc = message.get('cc',''),\\n bcc = message.get('bcc',''),\\n reply_to = message.get('reply_to',''),\\n body = body,\\n time = utc_from_string(message.get('date', ''))\\n )\\n return msg\",\n \"def __getmessage__():\\n\\tmsg = \\\\\\n\\t\\t 'M-SEARCH * HTTP/1.1\\\\r\\\\n' \\\\\\n\\t\\t 'HOST:239.255.255.250:1900\\\\r\\\\n' \\\\\\n\\t\\t 'ST:upnp:rootdevice\\\\r\\\\n' \\\\\\n\\t\\t 'MX:2\\\\r\\\\n' \\\\\\n\\t\\t 'MAN:\\\"ssdp:discover\\\"\\\\r\\\\n' \\\\\\n\\t\\t '\\\\r\\\\n'\\n\\n\\treturn msg\",\n \"async def create_status_message(self, event):\\n try:\\n channel = await self.client.channel_private_create(event.user)\\n except ConnectionError:\\n return False\\n \\n embed, components = self.get_status_embed_and_components()\\n \\n try:\\n message = await self.client.message_create(channel, embed = embed, components = components)\\n except ConnectionError:\\n return False\\n \\n except DiscordException as err:\\n if err.code == ERROR_CODES.cannot_message_user:\\n return False\\n \\n raise\\n \\n # We sent an empty message -> should not happen.\\n if message is None:\\n return False\\n \\n self.status_message = message\\n return True\",\n \"def sms():\\n\\n\\t# initialize response\\n\\tresp = MessagingResponse()\\n\\n\\t# add a message\\n\\tresp.message(\\\"Thank you for your response! We are confirming your message.\\\")\\n\\n\\treturn str(resp)\",\n \"def new_message(self, room, mess):\\n pass\",\n \"def createMessage( self, *args, **kw ):\\n if not kw.has_key('charset'):\\n kw['charset'] = self.getInputCharset()\\n return MailServerBase.createMessage( self, *args, **kw )\",\n \"def _create_add_message_from_order(order):\\n message = {}\\n message.update({\\\"message-type\\\": \\\"A\\\"})\\n message.update({\\\"instrument\\\": order.instrument})\\n message.update({\\\"order-id\\\": order.order_id})\\n message.update({\\\"price\\\": int(order.price)})\\n message.update({\\\"quantity\\\": int(order.quantity)})\\n message.update({\\\"side\\\": side_to_str(order.side)})\\n message.update({\\\"timestamp\\\": order.timestamp})\\n message.update({\\\"snapshot\\\": 1})\\n return message\",\n \"def new_message(self, body=''):\\r\\n m = self.message_class(self, body)\\r\\n m.queue = self\\r\\n return m\",\n \"def request_message(self) -> Optional[str]:\\n return pulumi.get(self, \\\"request_message\\\")\",\n \"def __init__(self, request):\\n self.request = request\\n self.fields = Message(request.namespace)\",\n \"async def prepare_message(self, **args):\\n await self.set_args(**args)\\n await self.validate()\\n return await self.dict()\",\n \"def getMessage():\\n return message\",\n \"async def mod_check(request: Request) -> Message:\\n return Message(message=\\\"Hello fellow moderator!\\\")\",\n \"def _create_message(self, msg):\\n head = msg[\\\"head\\\"]\\n body = msg[\\\"body\\\"]\\n body = body.format(**self.data)\\n length = len(body)\\n head = head.format(length=length, **self.data)\\n return head + body\",\n \"def new_message(self):\\n msg = {}\\n msg['data'] = []\\n msg['type'] = self.plugin_type\\n msg['source'] = self.name\\n msg['ts'] = (datetime.datetime.utcnow() - datetime.datetime(1970, 1, 1)).total_seconds()\\n return msg\",\n \"def _mgmt_request_response(\\n self,\\n mgmt_operation: bytes,\\n message: Any,\\n callback: Callable,\\n keep_alive_associated_link: bool = True,\\n timeout: Optional[float] = None,\\n **kwargs: Any\\n ) -> \\\"pyamqp_Message\\\":\\n self._open()\\n application_properties = {}\\n\\n # Some mgmt calls do not support an associated link name (such as list_sessions). Most do, so on by default.\\n if keep_alive_associated_link:\\n try:\\n application_properties = {\\n ASSOCIATEDLINKPROPERTYNAME: self._amqp_transport.get_handler_link_name(self._handler)\\n }\\n except AttributeError:\\n pass\\n\\n mgmt_msg = self._amqp_transport.create_mgmt_msg(\\n message=message,\\n application_properties=application_properties,\\n config=self._config,\\n reply_to=self._mgmt_target,\\n **kwargs\\n )\\n\\n try:\\n return self._amqp_transport.mgmt_client_request(\\n self._handler,\\n mgmt_msg,\\n operation=mgmt_operation,\\n operation_type=MGMT_REQUEST_OP_TYPE_ENTITY_MGMT,\\n node=self._mgmt_target.encode(self._config.encoding),\\n timeout=timeout,\\n callback=callback\\n )\\n except Exception as exp: # pylint: disable=broad-except\\n if isinstance(exp, self._amqp_transport.TIMEOUT_ERROR):\\n raise OperationTimeoutError(error=exp) from exp\\n raise\",\n \"def build_message():\\n outgoing_mail = Mail()\\n outgoing_mail.from_email = Email(email_from_address, email_from_name)\\n outgoing_mail.subject = subject\\n personalization = Personalization()\\n for recipient in email_to_addresses:\\n personalization.add_to(Email(recipient))\\n outgoing_mail.add_personalization(personalization)\\n outgoing_mail.add_content(Content(\\\"text/plain\\\", str.join('\\\\n', _log)))\\n outgoing_mail.add_content(Content(\\\"text/html\\\", \\\"<html><body> {} </body></html>\\\".format(str.join(' <br /> ', _log))))\\n return outgoing_mail.get()\",\n \"def Message(title, msg):\\r\\n return _hiew.HiewGate_Message(title, msg)\",\n \"def createMessage(self, sender: str, to: str, subject: str, message_text: str):\\n message = MIMEText(message_text)\\n message['to'] = to\\n message['from'] = sender\\n message['subject'] = subject\\n raw_message = {'raw': base64.urlsafe_b64encode(message.as_bytes())}\\n raw_message['raw']=raw_message['raw'].decode('utf-8')\\n return raw_message\",\n \"def msg(self, target, message):\\n self.server.message_queue.put(('tests!tests@tes.t', target, message))\",\n \"def resource_type(self):\\n return 'message'\",\n \"def message_new(self, cr, uid, msg, custom_values=None, context=None):\\n if custom_values is None: custom_values = {}\\n\\n desc = html2plaintext(msg.get('body')) if msg.get('body') else ''\\n custom_values.update({\\n 'name': msg.get('subject') or _(\\\"No Subject\\\"),\\n 'description': desc,\\n 'email_from': msg.get('from'),\\n 'email_cc': msg.get('cc'),\\n 'user_id': False,\\n })\\n if msg.get('priority') in dict(crm.AVAILABLE_PRIORITIES):\\n custom_values['priority'] = msg.get('priority')\\n return super(crm_lead, self).message_new(cr, uid, msg, custom_values=custom_values, context=context)\",\n \"def message(self):\\n self.add_file_string('Message file')\\n self.make_dangerous('Message file')\",\n \"def register_message():\\n global mss_cnt\\n\\n gmess = Graph()\\n\\n # Construimos el mensaje de registro\\n gmess.bind('foaf', FOAF)\\n gmess.bind('dso', DSO)\\n reg_obj = agn[InfoAgent.name+'-Register']\\n gmess.add((reg_obj, RDF.type, DSO.Register))\\n gmess.add((reg_obj, DSO.Uri, InfoAgent.uri))\\n gmess.add((reg_obj, FOAF.Name, Literal(InfoAgent.name)))\\n gmess.add((reg_obj, DSO.Address, Literal(InfoAgent.address)))\\n gmess.add((reg_obj, DSO.AgentType, DSO.HotelsAgent))\\n\\n # Lo metemos en un envoltorio FIPA-ACL y lo enviamos\\n gr = send_message(\\n build_message(gmess, perf= ACL.request,\\n sender= InfoAgent.uri,\\n receiver= AgentDirectori.uri,\\n content= reg_obj,\\n msgcnt= mss_cnt),\\n AgentDirectori.address)\\n mss_cnt += 1\\n\\n return gr\",\n \"def create_action_msg(self, action):\\n raise NotImplementedError(\\\"Don't know how to translate the action to a msg\\\")\",\n \"def _ConvertToMessage(info, status=None):\\n message = mtt_messages.Convert(info, mtt_messages.ConfigSetInfo)\\n message.status = status\\n return message\",\n \"def newMCRequest(self, request):\\n raise NotImplementedError\",\n \"def make_request_message(request):\\n url = urlparse(request.url)\\n request_headers = dict(request.headers)\\n if 'Host' not in request_headers:\\n request_headers['Host'] = url.netloc\\n return HTTPMessage(\\n line='{method} {path} HTTP/1.1'.format(\\n method=request.method,\\n path=url.path or '/'),\\n headers=NEW_LINE.join(str('%s: %s') % (name, value)\\n for name, value\\n in request_headers.items()),\\n body=request._enc_data,\\n content_type=request_headers.get('Content-Type')\\n )\",\n \"def loan_message_creator_factory():\\n return partial(\\n message_factory, current_app.config[\\\"ILS_CIRCULATION_MAIL_MSG_CREATOR\\\"]\\n )\",\n \"def test_get_message_new(self):\\n message = mommy.make(\\n 'connectmessages.Message', thread=self.thread, sender=self.sender)\\n thread = Thread.public.by_user(user=self.user)[0]\\n messages = thread.messages_for_user(self.user)\\n self.assertEqual(messages[0], message)\\n self.assertFalse(messages[0].read)\",\n \"def status_message(message):\\n return StatusMessage(message)\",\n \"def new_message(self,\\n intent=\\\"\\\",\\n message=\\\"\\\",\\n type=None,\\n not_handled=False,\\n time_stamp=None):\\n self.messages.append(Message(api_key=self.api_key,\\n platform=self.platform,\\n version=self.version,\\n user_id=self.user_id,\\n intent=intent,\\n message=message,\\n type=type,\\n not_handled=not_handled,\\n time_stamp=time_stamp))\\n return self.messages[-1]\",\n \"def send_created_email(self):\\n if settings.NOTIFY_NEW_REG:\\n to = settings.NOTIFY_NEW_REG\\n message = \\\"\\\"\\\"\\\\\\nGreetings,<br><br>\\n\\nA new vehicle registration has been submitted by %s.<br><br>\\n\\nGo here to view or edit the request: <br>\\n<a href=\\\"%s\\\">%s</a>\\n<br><br>\\nSincerely,<br><br>\\nThe Janelia Parking Permit Program\\n \\\"\\\"\\\" % (self.user_display_name(), self.get_edit_url(True), self.get_edit_url(True))\\n subject = 'A new parking permit request has been entered'\\n from_email = 'parkingpermit-donotreply@janelia.hhmi.org'\\n text_content = re.sub(r'<[^>]+>','',message)\\n html_content = message\\n msg = EmailMultiAlternatives(subject, text_content, from_email, to)\\n msg.attach_alternative(html_content, \\\"text/html\\\")\\n msg.send()\",\n \"def generate_message(self, mtu):\\r\\n raise SystemExit(self.sm.__exit_msg__)\",\n \"def __message_content__(self) -> MessageContent:\",\n \"def message(cls, user, message, context):\\r\\n q.enqueue(new_message_worker, args=(user, message, context), result_ttl=0)\\r\\n pass\",\n \"def cmd(self, message):\\n pass\",\n \"def _create_job_message(self):\\n #TODO: Final check of source file, add xml settings, allow for user\\n # to set priority, verify all job data is correct format\\n\\n if not hasattr(self.required_files, '_get_message'):\\n self.add_file_collection()\\n\\n if self.pool and hasattr(self.pool, 'id'):\\n pool_options = {'poolId': self.pool.id}\\n\\n elif self.pool:\\n pool_options = {'poolId': str(self.pool)}\\n\\n else:\\n size = max(int(self.instances), 1)\\n pool_options = {'autoPoolSpecification': self._auto_pool(size)}\\n\\n job_message = {\\n 'Name': str(self.name),\\n 'Type': self._api.jobtype(),\\n 'RequiredFiles': self.required_files._get_message(\\\"submit\\\"),\\n 'Parameters': list(self._filter_params()),\\n 'JobFile': str(self.source),\\n 'Settings': str(self.settings),\\n 'Priority': 'Medium'\\n }\\n job_message.update(pool_options)\\n\\n self._log.debug(\\\"Job message: {0}\\\".format(job_message))\\n return job_message\",\n \"def get_message(self, **kwargs):\\n message = dovesoft.Sms()\\n\\n for key in kwargs.keys():\\n if key not in kwargs.get(\\\"ignore\\\", smsconf.IGNORE_KEYS):\\n fun = getattr(message, \\\"set_{key}\\\".format(key=key))\\n fun(kwargs.get(key, \\\"\\\"))\\n\\n return message\",\n \"def build_notification():\\n username = post_param('username', '')\\n message = post_param('message', '')\\n light = post_param('light', 1)\\n sound = post_param('sound', 1)\\n notification = Notification(username, message, datetime.now(), light, sound)\\n \\n if not notification.is_valid():\\n raise HTTPResponse(body=\\\"Notification invalid\\\", status=400)\\n \\n return notification\",\n \"def create_user_message(self, *args, **kwargs) -> UserMessage:\\n \\n raise NotImplementedError()\",\n \"def _build_common_message(msg_title,msg_text,msg_type):\\n data = {\\n 'message': {\\n \\\"topic\\\" : '',\\n 'data': {\\n 'title': '',\\n 'message': '',\\n 'type' : ''\\n }\\n }\\n }\\n data['message']['topic'] = FCM_TOPIC\\n data['message']['data']['title'] = msg_title\\n data['message']['data']['message'] = datetime.datetime.now().strftime(\\\"%H:%M:%S\\\") + \\\" \\\" + msg_text\\n data['message']['data']['type'] = msg_type\\n return data\",\n \"def _build_common_message(msg_title,msg_text,msg_type):\\n data = {\\n 'message': {\\n \\\"topic\\\" : '',\\n 'data': {\\n 'title': '',\\n 'message': '',\\n 'type' : ''\\n }\\n }\\n }\\n data['message']['topic'] = FCM_TOPIC\\n data['message']['data']['title'] = msg_title\\n data['message']['data']['message'] = datetime.datetime.now().strftime(\\\"%H:%M:%S\\\") + \\\" \\\" + msg_text\\n data['message']['data']['type'] = msg_type\\n return data\",\n \"def get_message(self):\\n return super().get_message()\",\n \"def CreateMessageClass(self):\\n class ComplexMessage(messages.Message):\\n a3 = messages.IntegerField(3)\\n b1 = messages.StringField(1)\\n c2 = messages.StringField(2)\\n\\n return ComplexMessage\",\n \"async def request(self, ctx: commands.Context, *, feature):\\n msg = \\\"Request from {}:\\\\n\\\".format(ctx.author.mention) + feature\\n await ctx.bot.pm_owner(content=msg)\\n await ctx.message.add_reaction(\\\"✅\\\")\",\n \"def message(self, value: str):\\n self._properties[\\\"message\\\"] = value\",\n \"async def _cmdf_pmdemo(self, substr, msg, privilege_level):\\n pm_target = msg.author\\n buf = self._get_pm_greeting(pm_target)\\n await self._client.send_msg(pm_target, buf)\\n\\n await self._client.send_msg(msg, \\\"<@{}>, check your inbox!\\\".format(msg.author.id))\\n return\",\n \"def create_message(message):\\n return {\\n \\\"id\\\": message.id,\\n \\\"from\\\": message.sender,\\n \\\"preview\\\": create_preview(message),\\n \\\"subject\\\": message.subject,\\n \\\"date\\\": message.date_created,\\n }\",\n \"def create_messages(application, action, remedy):\\n\\n messages = [] \\n messages.append(\\\"\\\"\\\"Your Resources: </br><pre style=\\\"margin-left: 40px\\\">\\\"\\\"\\\" + application + \\\"</br></pre>\\\" + action + \\\"\\\"\\\" in AWS. <strong style=\\\"font-family: 'Helvetica Neue',Helvetica,Arial,sans-serif; box-sizing: border-box; font-size: 14px; margin: 0;\\\">\\\"\\\"\\\" + remedy +\\\"\\\"\\\"</strong>\\n </td>\\n </tr><tr style=\\\"font-family: 'Helvetica Neue',Helvetica,Arial,sans-serif; box-sizing: border-box; font-size: 14px; margin: 0;\\\"><td class=\\\"content-block\\\" style=\\\"font-family: 'Helvetica Neue',Helvetica,Arial,sans-serif; box-sizing: border-box; font-size: 14px; vertical-align: top; margin: 0; padding: 0 0 20px;\\\" valign=\\\"top\\\">\\n This message was sent to inform you of changes happening to your resources.\\n <ul>\\n <li>New instances are auto-tagged with an expiration date, an NT ID, and a patch group if invalid.</li>\\n <li>Instances without the necessary tags are notified through email and Slack.</li>\\n </ul>\\n If you have any further questions, please reply to this email.\\\"\\\"\\\")\\n \\n messages.append(\\\"Your Resources:\\\\n\\\\n\\\" + application + \\\"\\\\n\\\\n\\\" + action + \\\" in AWS. \\\" + remedy + \\\"\\\\n\\\" + \\n (\\\"\\\\nThis message was sent to inform you of changes happening to your resources.\\\\n\\\"\\n \\\"\\\\nNew instances are auto-tagged with an expiration date, an NT ID, and a patch group if invalid.\\\"\\n \\\"Instances without Owner Mail and Owner Team tags are notified through email and slack.\\\\n\\\"\\n \\\"\\\\nIf you have any further questions, please reply to this email.\\\")) \\n\\n return messages\",\n \"def message(self, sid):\\r\\n return Message(self, sid)\",\n \"def create_command_from_request(request: RequestInterface):\",\n \"def send_owner_message(): \\n data = order_obj.send_owner_message(request.forms)\\n return data\",\n \"def sms_reply():\\n # Fetch the message\\n msg = request.form.get('Body')\\n\\n # Create reply\\n resp = MessagingResponse()\\n resp.message(\\\"You said: {} \\\\n *Kayra Dev* \\\".format(msg))\\n \\n account_sid = 'AC195cf76c0d725909794c30f9b0c32961' \\n auth_token = '70531f5d14ec79c14254cf7fdfb40bad' \\n client = Client(account_sid, auth_token) \\n \\n message = client.messages.create( \\n from_='whatsapp:+14155238886', \\n body=msg, \\n to='whatsapp:+237696527034' \\n ) \\n \\n print(message.sid)\\n return str(resp)\",\n \"def create_request(v1):\\n #get entered data\\n data = request.get_json()\\n\\n #picking the request attributes\\n req_title = data.get(\\\"request_title\\\")\\n req_desc = data.get(\\\"request_description\\\")\\n requester_name = \\\"Gideon\\\"\\n req_id = len(all_requests) +1 # + random.randint(1, 3000)\\n\\n #validation\\n if not req_title:\\n return jsonify({\\\"message\\\": \\\"Request has no title\\\"}), 400\\n if not req_desc:\\n return jsonify({\\\"message\\\": \\\"Request has no description\\\"}), 400\\n if not requester_name:\\n return jsonify({\\\"message\\\": \\\"Request must be issued by a user\\\"}), 400\\n if not req_id:\\n return jsonify({\\\"message\\\": \\\"Request has no id\\\"}), 400\\n\\n #storing entered request\\n new_request = MaintenanceRequest(req_title, req_desc, requester_name, req_id)\\n all_requests.append(new_request)\\n # new_number_of_requests = len(all_requests)\\n\\n return jsonify({\\n \\\"message\\\":\\\"sucessfully created request\\\",\\n 'request_title':new_request.title,\\n \\\"request_description\\\":new_request.description,\\n \\\"requester_name\\\" : new_request.requester_name,\\n \\\"request_id\\\" : new_request.request_id\\n })\",\n \"def send(self, msg):\\n self.message('Me', msg)\",\n \"async def post(self):\\n await self.handle_request(self.messages_new_api, 1)\",\n \"def massage_addinfo(self) -> str:\\n self.message_str = f'{self.time}\\\\n{self.sent_by}\\\\n'\\n return self.message_str\",\n \"def _set_message(self):\\n\\n type_to_message = {\\n MESSAGE_TYPES['join'] : (\\n u\\\"User '%s' has joined the chat.\\\" % \\n self.author\\n ),\\n MESSAGE_TYPES['leave'] : (\\n u\\\"User '%s' has left the chat.\\\" % \\n self.author\\n ),\\n }\\n\\n message = self.message\\n if type_to_message.has_key(self.type):\\n message = type_to_message[self.type]\\n self.message = message\",\n \"def generate_msg(props, alert=False, user_pref=None, past=False):\\n\\t\\tmessage = emojize(\\\":rocket:\\\", use_aliases=True)\\n\\t\\tif past:\\n\\t\\t\\tmessage += ' Launch was held on: ' + props['when'].format('YYYY-MM-DD HH:mm:ss ZZ') + '.\\\\n'\\n\\t\\t\\tif props['holdreason']:\\n\\t\\t\\t\\tmessage += 'The launch has been *held*. Reason: ' + props['holdreason'] + '\\\\n'\\n\\t\\t\\tif props['failreason']:\\n\\t\\t\\t\\tmessage += 'Unfortunately, the launch *failed*. Reason: ' + props['failreason'] + '\\\\n'\\n\\t\\telse:\\n\\t\\t\\tif alert:\\n\\t\\t\\t\\tmessage += ' *Launch is going to happen in some minutes!* '\\n\\t\\tmessage += ' *' + props['name'] + '*' + '\\\\n'\\n\\n\\t\\tif not alert and not past:\\n\\t\\t\\tmessage += 'A launch will happen _' + props['when'].humanize() + '_! \\\\n'\\n\\t\\t\\tmessage += 'I mean ' + props['when'].format('YYYY-MM-DD HH:mm:ss ZZ') + '\\\\n'\\n\\n\\t\\tif past:\\n\\t\\t\\tmessage += 'Taken from *'\\n\\t\\telse:\\n\\t\\t\\tmessage += 'Taking from *'\\n\\n\\t\\tmessage += props['location'] + '*.\\\\n'\\n\\t\\tdescr = Interface.generate_description(props['missions'])\\n\\t\\tmessage += '*Mission description*\\\\n' + descr + '\\\\n' if descr else ''\\n\\t\\tmessage += '\\\\n'\\n\\n\\t\\tif props['urls']:\\n\\t\\t\\tmessage += 'Watch it here: \\\\n' if not past else 'You could have watched it here: \\\\n'\\n\\t\\t\\tfor url in props['urls']:\\n\\t\\t\\t\\tmessage += ' • [' + url + '](' + url +')\\\\n'\\n\\t\\telse:\\n\\t\\t\\tmessage += 'Unfortunately there '\\n\\t\\t\\tmessage += 'are' if not past else 'were'\\n\\t\\t\\tmessage += ' no reported webcasts ' \\\\\\n\\t\\t\\t\\t\\t + emojize(':disappointed_relieved:', use_aliases=True)\\n\\n\\t\\treturn message\",\n \"def get_message(self):\\n\\n if self.gotten: return\\n self.get_recipients()\\n self.get_text()\\n self.get_price()\\n self.get_files()\\n self.set_text()\\n if Settings.get_performer_category() or self.hasPerformers:\\n self.get_performers()\\n else:\\n self.performers = \\\"unset\\\"\\n self.gotten = True\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62443095","0.5764357","0.5720762","0.5711052","0.56360126","0.5537137","0.552277","0.5499183","0.5487821","0.545782","0.54448134","0.5425465","0.54167366","0.54080194","0.54045284","0.5402524","0.53995603","0.5392736","0.5373429","0.53681254","0.5349975","0.5347422","0.53389376","0.5335544","0.5315828","0.52952605","0.5293682","0.5284676","0.528371","0.52794194","0.5248652","0.5235257","0.52331984","0.5227256","0.5226532","0.522573","0.521813","0.5218055","0.52134323","0.5212321","0.5208317","0.5202118","0.51885533","0.51787394","0.51705724","0.51611906","0.51560867","0.51499933","0.51492673","0.5138465","0.5136726","0.5132373","0.5132348","0.51300055","0.5129246","0.5121289","0.51204896","0.5115124","0.5095842","0.5093103","0.50910336","0.5089643","0.50842613","0.50811225","0.5075364","0.5062605","0.50596166","0.5058697","0.5049088","0.50473005","0.50466835","0.50388575","0.503757","0.50348914","0.5024355","0.5022299","0.50145084","0.501048","0.50085026","0.5004837","0.50039434","0.50039434","0.50021607","0.49999872","0.49968007","0.49926874","0.49924973","0.49899212","0.49890786","0.49890772","0.49782032","0.4977471","0.4976477","0.4970879","0.4969736","0.49690822","0.49669728","0.4966772","0.49661806","0.49651825"],"string":"[\n \"0.62443095\",\n \"0.5764357\",\n \"0.5720762\",\n \"0.5711052\",\n \"0.56360126\",\n \"0.5537137\",\n \"0.552277\",\n \"0.5499183\",\n \"0.5487821\",\n \"0.545782\",\n \"0.54448134\",\n \"0.5425465\",\n \"0.54167366\",\n \"0.54080194\",\n \"0.54045284\",\n \"0.5402524\",\n \"0.53995603\",\n \"0.5392736\",\n \"0.5373429\",\n \"0.53681254\",\n \"0.5349975\",\n \"0.5347422\",\n \"0.53389376\",\n \"0.5335544\",\n \"0.5315828\",\n \"0.52952605\",\n \"0.5293682\",\n \"0.5284676\",\n \"0.528371\",\n \"0.52794194\",\n \"0.5248652\",\n \"0.5235257\",\n \"0.52331984\",\n \"0.5227256\",\n \"0.5226532\",\n \"0.522573\",\n \"0.521813\",\n \"0.5218055\",\n \"0.52134323\",\n \"0.5212321\",\n \"0.5208317\",\n \"0.5202118\",\n \"0.51885533\",\n \"0.51787394\",\n \"0.51705724\",\n \"0.51611906\",\n \"0.51560867\",\n \"0.51499933\",\n \"0.51492673\",\n \"0.5138465\",\n \"0.5136726\",\n \"0.5132373\",\n \"0.5132348\",\n \"0.51300055\",\n \"0.5129246\",\n \"0.5121289\",\n \"0.51204896\",\n \"0.5115124\",\n \"0.5095842\",\n \"0.5093103\",\n \"0.50910336\",\n \"0.5089643\",\n \"0.50842613\",\n \"0.50811225\",\n \"0.5075364\",\n \"0.5062605\",\n \"0.50596166\",\n \"0.5058697\",\n \"0.5049088\",\n \"0.50473005\",\n \"0.50466835\",\n \"0.50388575\",\n \"0.503757\",\n \"0.50348914\",\n \"0.5024355\",\n \"0.5022299\",\n \"0.50145084\",\n \"0.501048\",\n \"0.50085026\",\n \"0.5004837\",\n \"0.50039434\",\n \"0.50039434\",\n \"0.50021607\",\n \"0.49999872\",\n \"0.49968007\",\n \"0.49926874\",\n \"0.49924973\",\n \"0.49899212\",\n \"0.49890786\",\n \"0.49890772\",\n \"0.49782032\",\n \"0.4977471\",\n \"0.4976477\",\n \"0.4970879\",\n \"0.4969736\",\n \"0.49690822\",\n \"0.49669728\",\n \"0.4966772\",\n \"0.49661806\",\n \"0.49651825\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5406406"},"document_rank":{"kind":"string","value":"14"}}},{"rowIdx":81997,"cells":{"query":{"kind":"string","value":"Construct a request for the managment node itself"},"document":{"kind":"string","value":"def node_request(self, body=None, **properties):\n return self.request(body, name=self.name, type=self.type, **properties)"},"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 newRequest(self):\n return Request( )","def newMCRequest(self, request):\n raise NotImplementedError","def createRequest(self):\n self.get_bmc_website()\n self.__createChangeRequest = Create(self.browser)\n self.__createChangeRequest.createNCR()","def req():\n return Request()","def alloc_request():\n return SentmanRequest(SentmanRequest.ALLOCATE_SENTINEL)","def createRequest(self, **kwargs):\n for k,v in kwargs.items():\n self.request[\"content\"][k] = v\n \n return self.request","def __init__(self, requestor):\n self.requestor = requestor","def create_command_from_request(request: RequestInterface):","def __init__(self) -> None:\n self.reqparser = reqparse.RequestParser()\n self.reqparser.add_argument('name', required=False, store_missing=False, type=str, location=['form', 'json'])\n self.reqparser.add_argument('id', required=False, store_missing=False, type=str, location=['form', 'json'])","def _create_borrow_node(self):\n\n request_type = int(self.request.arguments['request_type'])\n if request_type not in [BorrowHandler.BORROW, BorrowHandler.LEND]:\n raise InvalidRequestTypeError(request_type)\n return {\n 'title': self.get_arg('title', required=True),\n 'user_id': self.get_arg('user_id', required=True),\n 'description': self.get_arg('description', required=False),\n 'distance': self.get_arg('distance', required=True),\n 'duration': self.get_arg('duration', required=True),\n 'request_type': request_type\n }","def __init__( request ):","def req():\n\n if not current.auth.s3_logged_in():\n return None\n\n ADMIN = current.session.s3.system_roles.ADMIN\n settings = current.deployment_settings\n types = settings.get_req_req_type()\n\n get_vars = {}\n if len(types) == 1:\n t = types[0]\n if t == \"Stock\":\n get_vars = {\"type\": \"1\"}\n elif t == \"People\":\n get_vars = {\"type\": \"2\"}\n create_menu = M(\"Create\", m=\"create\", vars=get_vars)\n\n recurring = lambda i: settings.get_req_recurring()\n use_commit = lambda i: settings.get_req_use_commit()\n req_items = lambda i: \"Stock\" in types\n req_skills = lambda i: \"People\" in types\n\n return M(c=\"req\")(\n M(\"Current Needs\", f=\"organisation_needs\")(\n M(\"Create\", m=\"create\"),\n M(\"Import\", m=\"import\", restrict=[ADMIN]),\n ),\n M(\"Needs at Facilities\", f=\"site_needs\", m=\"summary\")(\n M(\"Create\", m=\"create\"),\n ),\n M(\"Requests\", f=\"req\", vars=get_vars)(\n create_menu,\n M(\"List Recurring Requests\", f=\"req_template\", check=recurring),\n M(\"Map\", m=\"map\"),\n M(\"Report\", m=\"report\"),\n M(\"Search All Requested Items\", f=\"req_item\",\n check=req_items),\n M(\"Search All Requested Skills\", f=\"req_skill\",\n check=req_skills),\n ),\n M(\"Commitments\", f=\"commit\", check=use_commit)(\n ),\n M(\"Items\", c=\"supply\", f=\"item\")(\n M(\"Create\", m=\"create\"),\n M(\"Report\", m=\"report\"),\n M(\"Import\", m=\"import\", p=\"create\"),\n ),\n # Catalog Items moved to be next to the Item Categories\n #M(\"Catalog Items\", c=\"supply\", f=\"catalog_item\")(\n #M(\"Create\", m=\"create\"),\n #),\n M(\"Catalogs\", c=\"supply\", f=\"catalog\")(\n M(\"Create\", m=\"create\"),\n ),\n M(\"Item Categories\", c=\"supply\", f=\"item_category\",\n restrict=[ADMIN])(\n M(\"Create\", m=\"create\"),\n ),\n )","def setup_request_commandline():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"mode\",\n choices=(\"pokemon\", \"ability\", \"move\"))\n\n input_group = parser.add_mutually_exclusive_group(required=True)\n input_group.required = True\n input_group.add_argument(\"--inputfile\")\n input_group.add_argument(\"--inputdata\")\n\n parser.add_argument(\"--expanded\",\n action=\"store_true\")\n\n parser.add_argument(\"--output\")\n\n try:\n args = parser.parse_args()\n request = Request()\n request.mode = args.mode\n request.is_input_file = True if args.inputdata is None else False\n request.input_content = args.inputfile if args.inputdata is None else args.inputdata\n request.expanded = args.expanded\n request.output = args.output\n return request\n except Exception as e:\n print(f\"Error! Could not read arguments.\\n{e}\")\n quit()","def build_request(self):\n self.build_header_2_40()\n self.build_fullprops()\n data_compressed = mcafee_crypto.mcafee_compress(self.agent_pubkey_epo_format + self.fullprops_xml)\n data_len = struct.pack('<I', len(data_compressed))\n final_header_len = struct.pack('<I', len(self.build_header_1()) + len(self.build_header_2_40()))\n self.build_header_1(final_header_len, data_len)\n final_header_1 = mcafee_crypto.xor_c(self.header_1)\n request_signature = mcafee_crypto.dsa_sign(self.regkey, self.header_1 + self.header_2 + data_compressed)\n data_encrypted = mcafee_crypto.mcafee_3des_encrypt(self.header_2 + data_compressed + request_signature)\n post_data = mcafee_crypto.xor_c(final_header_1) + data_encrypted\n return post_data","def form_request(self, request_instance, pack, instance_number, class_member_detail):\n\n pass","def get_request(self, post=None, request_method=\"GET\"):\n if post is None:\n post = {\"csrf_token\": \"irrelevant but required\"}\n request = testing.DummyRequest(post)\n request.client_addr = \"127.0.0.1\"\n request.session = Mock()\n request.method = request_method\n request.repo = self.repo\n request.kerno = self.kerno\n return request","def build_request(input_id, method, params=None):\n request = {\"method\": method, \"id\": input_id}\n if params is not None:\n request[\"params\"] = params\n return request","def buildReq(cmd, target, sequence, fieldList):\n return buildCmd(\"REQ\", cmd, target, sequence, fieldList)","def __init__(self) -> None:\n self.reqparser = reqparse.RequestParser()\n self.reqparser.add_argument('symbol', required=False, type=str, location=['form', 'json'])\n self.reqparser.add_argument('description', required=False, type=str, location=['form', 'json'])","def _get_request(self):\n\n # service shall be WPS\n service = _get_get_param(self.http_request, 'service')\n if service:\n if str(service).lower() != 'wps':\n raise InvalidParameterValue(\n 'parameter SERVICE [%s] not supported' % service, 'service')\n else:\n raise MissingParameterValue('service', 'service')\n\n operation = _get_get_param(self.http_request, 'request')\n\n request_parser = self._get_request_parser(operation)\n request_parser(self.http_request)","def _createPostRequest(self, postBody: dict) -> object:\n request = HttpRequest()\n request.method = \"POST\"\n for name,value in postBody.items():\n request.POST[name]= value\n return request","def request_factory(self) -> 'JSONRPCRequest':\n return JSONRPCRequest()","def create_request(v1):\n #get entered data\n data = request.get_json()\n\n #picking the request attributes\n req_title = data.get(\"request_title\")\n req_desc = data.get(\"request_description\")\n requester_name = \"Gideon\"\n req_id = len(all_requests) +1 # + random.randint(1, 3000)\n\n #validation\n if not req_title:\n return jsonify({\"message\": \"Request has no title\"}), 400\n if not req_desc:\n return jsonify({\"message\": \"Request has no description\"}), 400\n if not requester_name:\n return jsonify({\"message\": \"Request must be issued by a user\"}), 400\n if not req_id:\n return jsonify({\"message\": \"Request has no id\"}), 400\n\n #storing entered request\n new_request = MaintenanceRequest(req_title, req_desc, requester_name, req_id)\n all_requests.append(new_request)\n # new_number_of_requests = len(all_requests)\n\n return jsonify({\n \"message\":\"sucessfully created request\",\n 'request_title':new_request.title,\n \"request_description\":new_request.description,\n \"requester_name\" : new_request.requester_name,\n \"request_id\" : new_request.request_id\n })","def real_obj(self):\n return Request(xml_data=etree.tostring(self))","def create(self):\r\n self.require_collection()\r\n request = http.Request('POST', self.get_url(), self.wrap_object({}))\r\n\r\n return request, parsers.parse_json","def create_request(self, config):\n self.logger.info(\"Injecting request args:\\n%s ...\", config.request_args[\"createRequest\"])\n json_args = json.dumps(config.request_args[\"createRequest\"])\n urn = self.urn_prefix + \"/request\"\n status, data = self.http_request(\"POST\", urn, data=json_args,\n headers=self.headersBody)\n if status > 216:\n self.logger.error(\"Failed to create request with status: %s, data: %s\", status, data)\n sys.exit(1)\n data = json.loads(data)\n self.logger.info(data)\n request_name = data[\"result\"][0][\"request\"]\n self.approve_request(request_name)\n self.logger.info(\"Create request '%s' succeeded.\", request_name)\n\n config.request_names = request_name\n\n return request_name","def createRequest(self, method, *params):\n # this method update interface contract in order to be compatible with\n # methods defined by connection handlers\n return super(MsgpackDatagramProtocol, self).createRequest(method, params)","def __init__(self) -> None:\n self.reqparser = reqparse.RequestParser()\n self.reqparser.add_argument('id', required=False, type=int,\n store_missing=False)\n self.reqparser.add_argument('user_id', required=False, type=int,\n store_missing=False)\n self.reqparser.add_argument('attribute_id', required=False, type=str,\n store_missing=False)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def Create(self, request, global_params=None):\n config = self.GetMethodConfig('Create')\n return self._RunMethod(\n config, request, global_params=global_params)","def _get_request_parser(self, operation):\n\n wpsrequest = self\n\n def parse_get_getcapabilities(http_request):\n \"\"\"Parse GET GetCapabilities request\n \"\"\"\n\n acceptedversions = _get_get_param(http_request, 'acceptversions')\n wpsrequest.check_accepted_versions(acceptedversions)\n\n def parse_get_describeprocess(http_request):\n \"\"\"Parse GET DescribeProcess request\n \"\"\"\n version = _get_get_param(http_request, 'version')\n wpsrequest.check_and_set_version(version)\n\n language = _get_get_param(http_request, 'language')\n wpsrequest.check_and_set_language(language)\n\n wpsrequest.identifiers = _get_get_param(\n http_request, 'identifier', aslist=True)\n\n def parse_get_execute(http_request):\n \"\"\"Parse GET Execute request\n \"\"\"\n version = _get_get_param(http_request, 'version')\n wpsrequest.check_and_set_version(version)\n\n language = _get_get_param(http_request, 'language')\n wpsrequest.check_and_set_language(language)\n\n wpsrequest.identifier = _get_get_param(http_request, 'identifier')\n wpsrequest.store_execute = _get_get_param(\n http_request, 'storeExecuteResponse', 'false')\n wpsrequest.status = _get_get_param(http_request, 'status', 'false')\n wpsrequest.lineage = _get_get_param(\n http_request, 'lineage', 'false')\n wpsrequest.inputs = get_data_from_kvp(\n _get_get_param(http_request, 'DataInputs'), 'DataInputs')\n wpsrequest.outputs = {}\n\n # take responseDocument preferably\n resp_outputs = get_data_from_kvp(\n _get_get_param(http_request, 'ResponseDocument'))\n raw_outputs = get_data_from_kvp(\n _get_get_param(http_request, 'RawDataOutput'))\n wpsrequest.raw = False\n if resp_outputs:\n wpsrequest.outputs = resp_outputs\n elif raw_outputs:\n wpsrequest.outputs = raw_outputs\n wpsrequest.raw = True\n # executeResponse XML will not be stored and no updating of\n # status\n wpsrequest.store_execute = 'false'\n wpsrequest.status = 'false'\n\n if not operation:\n raise MissingParameterValue('Missing request value', 'request')\n else:\n self.operation = operation.lower()\n\n if self.operation == 'getcapabilities':\n return parse_get_getcapabilities\n elif self.operation == 'describeprocess':\n return parse_get_describeprocess\n elif self.operation == 'execute':\n return parse_get_execute\n else:\n raise OperationNotSupported(\n 'Unknown request %r' % self.operation, operation)","def _prepare_create_request(instance):\n parent_name = ('projects/' + instance._client.project)\n message = messages_v2_pb2.CreateInstanceRequest(\n parent=parent_name,\n instance_id=instance.instance_id,\n instance=data_v2_pb2.Instance(\n display_name=instance.display_name,\n ),\n )\n cluster = message.clusters[instance.instance_id]\n cluster.name = instance.name + '/clusters/' + instance.instance_id\n cluster.location = (\n parent_name + '/locations/' + instance._cluster_location_id)\n cluster.serve_nodes = instance._cluster_serve_nodes\n return message","def _req(self):\n self.seq_num += 1\n req = struct.pack(HEADER_FMT, REQUEST_TYPE, self.seq_num)\n return req","def create_request(params={}, path='/', method='POST'):\n request = DummyRequest(path)\n request.method = method\n request.args = params\n return request","def create_policy_request():\n return {\n 'public_key':\n r'BBLewg4VqLR38b38daE7Fj\\/uhr543uGrEpyoPFgmFZK6EZ9g2XdK\\/i65RrSJ6sJ96aXD3DJHY3Me2GJQO9\\/ifjE=',\n 'label':\n 'Integration Test Policy',\n 'operations': [{\n 'sensor_id': 10,\n 'action': 'SHARE',\n }, {\n 'sensor_id': 53,\n 'action': 'BIN',\n 'bins': [30.0, 60.0, 90.0]\n }, {\n 'sensor_id': 55,\n 'action': 'MOVING_AVG',\n 'interval': 300\n }]\n }","def __init__(self, request):\n \n self.request = request","def __init__(self, proknow, requestor):\n self._proknow = proknow\n self._requestor = requestor","def newOrderRequest(self, quantity=1, extraParams={}):\n import labstep.entities.orderRequest.repository as orderRequestRepository\n\n return orderRequestRepository.newOrderRequest(\n self.__user__,\n resource_id=self.id,\n quantity=quantity,\n extraParams=extraParams,\n )","def __init__(self, *args, **kwds):\n if args or kwds:\n super(PlanMovementRequest, self).__init__(*args, **kwds)\n #message fields cannot be None, assign default values for those that are\n if self.group is None:\n self.group = ''\n if self.rand_start is None:\n self.rand_start = False\n if self.current_start is None:\n self.current_start = False\n if self.start_pos is None:\n self.start_pos = []\n if self.rand_target is None:\n self.rand_target = False\n if self.target_pos is None:\n self.target_pos = []\n if self.execute is None:\n self.execute = False\n if self.wait is None:\n self.wait = False\n if self.ret_plan is None:\n self.ret_plan = False\n if self.ret_fps is None:\n self.ret_fps = 0\n else:\n self.group = ''\n self.rand_start = False\n self.current_start = False\n self.start_pos = []\n self.rand_target = False\n self.target_pos = []\n self.execute = False\n self.wait = False\n self.ret_plan = False\n self.ret_fps = 0","def request(self, params=None):\n\t\trequest = APIRequest(self.api)\n\t\tfor attr in APIRequest.attrs:\n\t\t\tval = getattr(self, attr)\n\t\t\t# Copy Mappings (e.g. headers)\n\t\t\tval = dict(val) if isinstance(val, collections.abc.Mapping) else val\n\t\t\tsetattr(request, attr, val)\n\t\t# Update GET parameters\n\t\tif params:\n\t\t\trequest.params.update(params)\n\t\treturn request","def __call__(self, **parameters):\n request = self._build_request(**parameters)\n\n return self.requestor.request(**request)"],"string":"[\n \"def newRequest(self):\\n return Request( )\",\n \"def newMCRequest(self, request):\\n raise NotImplementedError\",\n \"def createRequest(self):\\n self.get_bmc_website()\\n self.__createChangeRequest = Create(self.browser)\\n self.__createChangeRequest.createNCR()\",\n \"def req():\\n return Request()\",\n \"def alloc_request():\\n return SentmanRequest(SentmanRequest.ALLOCATE_SENTINEL)\",\n \"def createRequest(self, **kwargs):\\n for k,v in kwargs.items():\\n self.request[\\\"content\\\"][k] = v\\n \\n return self.request\",\n \"def __init__(self, requestor):\\n self.requestor = requestor\",\n \"def create_command_from_request(request: RequestInterface):\",\n \"def __init__(self) -> None:\\n self.reqparser = reqparse.RequestParser()\\n self.reqparser.add_argument('name', required=False, store_missing=False, type=str, location=['form', 'json'])\\n self.reqparser.add_argument('id', required=False, store_missing=False, type=str, location=['form', 'json'])\",\n \"def _create_borrow_node(self):\\n\\n request_type = int(self.request.arguments['request_type'])\\n if request_type not in [BorrowHandler.BORROW, BorrowHandler.LEND]:\\n raise InvalidRequestTypeError(request_type)\\n return {\\n 'title': self.get_arg('title', required=True),\\n 'user_id': self.get_arg('user_id', required=True),\\n 'description': self.get_arg('description', required=False),\\n 'distance': self.get_arg('distance', required=True),\\n 'duration': self.get_arg('duration', required=True),\\n 'request_type': request_type\\n }\",\n \"def __init__( request ):\",\n \"def req():\\n\\n if not current.auth.s3_logged_in():\\n return None\\n\\n ADMIN = current.session.s3.system_roles.ADMIN\\n settings = current.deployment_settings\\n types = settings.get_req_req_type()\\n\\n get_vars = {}\\n if len(types) == 1:\\n t = types[0]\\n if t == \\\"Stock\\\":\\n get_vars = {\\\"type\\\": \\\"1\\\"}\\n elif t == \\\"People\\\":\\n get_vars = {\\\"type\\\": \\\"2\\\"}\\n create_menu = M(\\\"Create\\\", m=\\\"create\\\", vars=get_vars)\\n\\n recurring = lambda i: settings.get_req_recurring()\\n use_commit = lambda i: settings.get_req_use_commit()\\n req_items = lambda i: \\\"Stock\\\" in types\\n req_skills = lambda i: \\\"People\\\" in types\\n\\n return M(c=\\\"req\\\")(\\n M(\\\"Current Needs\\\", f=\\\"organisation_needs\\\")(\\n M(\\\"Create\\\", m=\\\"create\\\"),\\n M(\\\"Import\\\", m=\\\"import\\\", restrict=[ADMIN]),\\n ),\\n M(\\\"Needs at Facilities\\\", f=\\\"site_needs\\\", m=\\\"summary\\\")(\\n M(\\\"Create\\\", m=\\\"create\\\"),\\n ),\\n M(\\\"Requests\\\", f=\\\"req\\\", vars=get_vars)(\\n create_menu,\\n M(\\\"List Recurring Requests\\\", f=\\\"req_template\\\", check=recurring),\\n M(\\\"Map\\\", m=\\\"map\\\"),\\n M(\\\"Report\\\", m=\\\"report\\\"),\\n M(\\\"Search All Requested Items\\\", f=\\\"req_item\\\",\\n check=req_items),\\n M(\\\"Search All Requested Skills\\\", f=\\\"req_skill\\\",\\n check=req_skills),\\n ),\\n M(\\\"Commitments\\\", f=\\\"commit\\\", check=use_commit)(\\n ),\\n M(\\\"Items\\\", c=\\\"supply\\\", f=\\\"item\\\")(\\n M(\\\"Create\\\", m=\\\"create\\\"),\\n M(\\\"Report\\\", m=\\\"report\\\"),\\n M(\\\"Import\\\", m=\\\"import\\\", p=\\\"create\\\"),\\n ),\\n # Catalog Items moved to be next to the Item Categories\\n #M(\\\"Catalog Items\\\", c=\\\"supply\\\", f=\\\"catalog_item\\\")(\\n #M(\\\"Create\\\", m=\\\"create\\\"),\\n #),\\n M(\\\"Catalogs\\\", c=\\\"supply\\\", f=\\\"catalog\\\")(\\n M(\\\"Create\\\", m=\\\"create\\\"),\\n ),\\n M(\\\"Item Categories\\\", c=\\\"supply\\\", f=\\\"item_category\\\",\\n restrict=[ADMIN])(\\n M(\\\"Create\\\", m=\\\"create\\\"),\\n ),\\n )\",\n \"def setup_request_commandline():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"mode\\\",\\n choices=(\\\"pokemon\\\", \\\"ability\\\", \\\"move\\\"))\\n\\n input_group = parser.add_mutually_exclusive_group(required=True)\\n input_group.required = True\\n input_group.add_argument(\\\"--inputfile\\\")\\n input_group.add_argument(\\\"--inputdata\\\")\\n\\n parser.add_argument(\\\"--expanded\\\",\\n action=\\\"store_true\\\")\\n\\n parser.add_argument(\\\"--output\\\")\\n\\n try:\\n args = parser.parse_args()\\n request = Request()\\n request.mode = args.mode\\n request.is_input_file = True if args.inputdata is None else False\\n request.input_content = args.inputfile if args.inputdata is None else args.inputdata\\n request.expanded = args.expanded\\n request.output = args.output\\n return request\\n except Exception as e:\\n print(f\\\"Error! Could not read arguments.\\\\n{e}\\\")\\n quit()\",\n \"def build_request(self):\\n self.build_header_2_40()\\n self.build_fullprops()\\n data_compressed = mcafee_crypto.mcafee_compress(self.agent_pubkey_epo_format + self.fullprops_xml)\\n data_len = struct.pack('<I', len(data_compressed))\\n final_header_len = struct.pack('<I', len(self.build_header_1()) + len(self.build_header_2_40()))\\n self.build_header_1(final_header_len, data_len)\\n final_header_1 = mcafee_crypto.xor_c(self.header_1)\\n request_signature = mcafee_crypto.dsa_sign(self.regkey, self.header_1 + self.header_2 + data_compressed)\\n data_encrypted = mcafee_crypto.mcafee_3des_encrypt(self.header_2 + data_compressed + request_signature)\\n post_data = mcafee_crypto.xor_c(final_header_1) + data_encrypted\\n return post_data\",\n \"def form_request(self, request_instance, pack, instance_number, class_member_detail):\\n\\n pass\",\n \"def get_request(self, post=None, request_method=\\\"GET\\\"):\\n if post is None:\\n post = {\\\"csrf_token\\\": \\\"irrelevant but required\\\"}\\n request = testing.DummyRequest(post)\\n request.client_addr = \\\"127.0.0.1\\\"\\n request.session = Mock()\\n request.method = request_method\\n request.repo = self.repo\\n request.kerno = self.kerno\\n return request\",\n \"def build_request(input_id, method, params=None):\\n request = {\\\"method\\\": method, \\\"id\\\": input_id}\\n if params is not None:\\n request[\\\"params\\\"] = params\\n return request\",\n \"def buildReq(cmd, target, sequence, fieldList):\\n return buildCmd(\\\"REQ\\\", cmd, target, sequence, fieldList)\",\n \"def __init__(self) -> None:\\n self.reqparser = reqparse.RequestParser()\\n self.reqparser.add_argument('symbol', required=False, type=str, location=['form', 'json'])\\n self.reqparser.add_argument('description', required=False, type=str, location=['form', 'json'])\",\n \"def _get_request(self):\\n\\n # service shall be WPS\\n service = _get_get_param(self.http_request, 'service')\\n if service:\\n if str(service).lower() != 'wps':\\n raise InvalidParameterValue(\\n 'parameter SERVICE [%s] not supported' % service, 'service')\\n else:\\n raise MissingParameterValue('service', 'service')\\n\\n operation = _get_get_param(self.http_request, 'request')\\n\\n request_parser = self._get_request_parser(operation)\\n request_parser(self.http_request)\",\n \"def _createPostRequest(self, postBody: dict) -> object:\\n request = HttpRequest()\\n request.method = \\\"POST\\\"\\n for name,value in postBody.items():\\n request.POST[name]= value\\n return request\",\n \"def request_factory(self) -> 'JSONRPCRequest':\\n return JSONRPCRequest()\",\n \"def create_request(v1):\\n #get entered data\\n data = request.get_json()\\n\\n #picking the request attributes\\n req_title = data.get(\\\"request_title\\\")\\n req_desc = data.get(\\\"request_description\\\")\\n requester_name = \\\"Gideon\\\"\\n req_id = len(all_requests) +1 # + random.randint(1, 3000)\\n\\n #validation\\n if not req_title:\\n return jsonify({\\\"message\\\": \\\"Request has no title\\\"}), 400\\n if not req_desc:\\n return jsonify({\\\"message\\\": \\\"Request has no description\\\"}), 400\\n if not requester_name:\\n return jsonify({\\\"message\\\": \\\"Request must be issued by a user\\\"}), 400\\n if not req_id:\\n return jsonify({\\\"message\\\": \\\"Request has no id\\\"}), 400\\n\\n #storing entered request\\n new_request = MaintenanceRequest(req_title, req_desc, requester_name, req_id)\\n all_requests.append(new_request)\\n # new_number_of_requests = len(all_requests)\\n\\n return jsonify({\\n \\\"message\\\":\\\"sucessfully created request\\\",\\n 'request_title':new_request.title,\\n \\\"request_description\\\":new_request.description,\\n \\\"requester_name\\\" : new_request.requester_name,\\n \\\"request_id\\\" : new_request.request_id\\n })\",\n \"def real_obj(self):\\n return Request(xml_data=etree.tostring(self))\",\n \"def create(self):\\r\\n self.require_collection()\\r\\n request = http.Request('POST', self.get_url(), self.wrap_object({}))\\r\\n\\r\\n return request, parsers.parse_json\",\n \"def create_request(self, config):\\n self.logger.info(\\\"Injecting request args:\\\\n%s ...\\\", config.request_args[\\\"createRequest\\\"])\\n json_args = json.dumps(config.request_args[\\\"createRequest\\\"])\\n urn = self.urn_prefix + \\\"/request\\\"\\n status, data = self.http_request(\\\"POST\\\", urn, data=json_args,\\n headers=self.headersBody)\\n if status > 216:\\n self.logger.error(\\\"Failed to create request with status: %s, data: %s\\\", status, data)\\n sys.exit(1)\\n data = json.loads(data)\\n self.logger.info(data)\\n request_name = data[\\\"result\\\"][0][\\\"request\\\"]\\n self.approve_request(request_name)\\n self.logger.info(\\\"Create request '%s' succeeded.\\\", request_name)\\n\\n config.request_names = request_name\\n\\n return request_name\",\n \"def createRequest(self, method, *params):\\n # this method update interface contract in order to be compatible with\\n # methods defined by connection handlers\\n return super(MsgpackDatagramProtocol, self).createRequest(method, params)\",\n \"def __init__(self) -> None:\\n self.reqparser = reqparse.RequestParser()\\n self.reqparser.add_argument('id', required=False, type=int,\\n store_missing=False)\\n self.reqparser.add_argument('user_id', required=False, type=int,\\n store_missing=False)\\n self.reqparser.add_argument('attribute_id', required=False, type=str,\\n store_missing=False)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Create(self, request, global_params=None):\\n config = self.GetMethodConfig('Create')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def _get_request_parser(self, operation):\\n\\n wpsrequest = self\\n\\n def parse_get_getcapabilities(http_request):\\n \\\"\\\"\\\"Parse GET GetCapabilities request\\n \\\"\\\"\\\"\\n\\n acceptedversions = _get_get_param(http_request, 'acceptversions')\\n wpsrequest.check_accepted_versions(acceptedversions)\\n\\n def parse_get_describeprocess(http_request):\\n \\\"\\\"\\\"Parse GET DescribeProcess request\\n \\\"\\\"\\\"\\n version = _get_get_param(http_request, 'version')\\n wpsrequest.check_and_set_version(version)\\n\\n language = _get_get_param(http_request, 'language')\\n wpsrequest.check_and_set_language(language)\\n\\n wpsrequest.identifiers = _get_get_param(\\n http_request, 'identifier', aslist=True)\\n\\n def parse_get_execute(http_request):\\n \\\"\\\"\\\"Parse GET Execute request\\n \\\"\\\"\\\"\\n version = _get_get_param(http_request, 'version')\\n wpsrequest.check_and_set_version(version)\\n\\n language = _get_get_param(http_request, 'language')\\n wpsrequest.check_and_set_language(language)\\n\\n wpsrequest.identifier = _get_get_param(http_request, 'identifier')\\n wpsrequest.store_execute = _get_get_param(\\n http_request, 'storeExecuteResponse', 'false')\\n wpsrequest.status = _get_get_param(http_request, 'status', 'false')\\n wpsrequest.lineage = _get_get_param(\\n http_request, 'lineage', 'false')\\n wpsrequest.inputs = get_data_from_kvp(\\n _get_get_param(http_request, 'DataInputs'), 'DataInputs')\\n wpsrequest.outputs = {}\\n\\n # take responseDocument preferably\\n resp_outputs = get_data_from_kvp(\\n _get_get_param(http_request, 'ResponseDocument'))\\n raw_outputs = get_data_from_kvp(\\n _get_get_param(http_request, 'RawDataOutput'))\\n wpsrequest.raw = False\\n if resp_outputs:\\n wpsrequest.outputs = resp_outputs\\n elif raw_outputs:\\n wpsrequest.outputs = raw_outputs\\n wpsrequest.raw = True\\n # executeResponse XML will not be stored and no updating of\\n # status\\n wpsrequest.store_execute = 'false'\\n wpsrequest.status = 'false'\\n\\n if not operation:\\n raise MissingParameterValue('Missing request value', 'request')\\n else:\\n self.operation = operation.lower()\\n\\n if self.operation == 'getcapabilities':\\n return parse_get_getcapabilities\\n elif self.operation == 'describeprocess':\\n return parse_get_describeprocess\\n elif self.operation == 'execute':\\n return parse_get_execute\\n else:\\n raise OperationNotSupported(\\n 'Unknown request %r' % self.operation, operation)\",\n \"def _prepare_create_request(instance):\\n parent_name = ('projects/' + instance._client.project)\\n message = messages_v2_pb2.CreateInstanceRequest(\\n parent=parent_name,\\n instance_id=instance.instance_id,\\n instance=data_v2_pb2.Instance(\\n display_name=instance.display_name,\\n ),\\n )\\n cluster = message.clusters[instance.instance_id]\\n cluster.name = instance.name + '/clusters/' + instance.instance_id\\n cluster.location = (\\n parent_name + '/locations/' + instance._cluster_location_id)\\n cluster.serve_nodes = instance._cluster_serve_nodes\\n return message\",\n \"def _req(self):\\n self.seq_num += 1\\n req = struct.pack(HEADER_FMT, REQUEST_TYPE, self.seq_num)\\n return req\",\n \"def create_request(params={}, path='/', method='POST'):\\n request = DummyRequest(path)\\n request.method = method\\n request.args = params\\n return request\",\n \"def create_policy_request():\\n return {\\n 'public_key':\\n r'BBLewg4VqLR38b38daE7Fj\\\\/uhr543uGrEpyoPFgmFZK6EZ9g2XdK\\\\/i65RrSJ6sJ96aXD3DJHY3Me2GJQO9\\\\/ifjE=',\\n 'label':\\n 'Integration Test Policy',\\n 'operations': [{\\n 'sensor_id': 10,\\n 'action': 'SHARE',\\n }, {\\n 'sensor_id': 53,\\n 'action': 'BIN',\\n 'bins': [30.0, 60.0, 90.0]\\n }, {\\n 'sensor_id': 55,\\n 'action': 'MOVING_AVG',\\n 'interval': 300\\n }]\\n }\",\n \"def __init__(self, request):\\n \\n self.request = request\",\n \"def __init__(self, proknow, requestor):\\n self._proknow = proknow\\n self._requestor = requestor\",\n \"def newOrderRequest(self, quantity=1, extraParams={}):\\n import labstep.entities.orderRequest.repository as orderRequestRepository\\n\\n return orderRequestRepository.newOrderRequest(\\n self.__user__,\\n resource_id=self.id,\\n quantity=quantity,\\n extraParams=extraParams,\\n )\",\n \"def __init__(self, *args, **kwds):\\n if args or kwds:\\n super(PlanMovementRequest, self).__init__(*args, **kwds)\\n #message fields cannot be None, assign default values for those that are\\n if self.group is None:\\n self.group = ''\\n if self.rand_start is None:\\n self.rand_start = False\\n if self.current_start is None:\\n self.current_start = False\\n if self.start_pos is None:\\n self.start_pos = []\\n if self.rand_target is None:\\n self.rand_target = False\\n if self.target_pos is None:\\n self.target_pos = []\\n if self.execute is None:\\n self.execute = False\\n if self.wait is None:\\n self.wait = False\\n if self.ret_plan is None:\\n self.ret_plan = False\\n if self.ret_fps is None:\\n self.ret_fps = 0\\n else:\\n self.group = ''\\n self.rand_start = False\\n self.current_start = False\\n self.start_pos = []\\n self.rand_target = False\\n self.target_pos = []\\n self.execute = False\\n self.wait = False\\n self.ret_plan = False\\n self.ret_fps = 0\",\n \"def request(self, params=None):\\n\\t\\trequest = APIRequest(self.api)\\n\\t\\tfor attr in APIRequest.attrs:\\n\\t\\t\\tval = getattr(self, attr)\\n\\t\\t\\t# Copy Mappings (e.g. headers)\\n\\t\\t\\tval = dict(val) if isinstance(val, collections.abc.Mapping) else val\\n\\t\\t\\tsetattr(request, attr, val)\\n\\t\\t# Update GET parameters\\n\\t\\tif params:\\n\\t\\t\\trequest.params.update(params)\\n\\t\\treturn request\",\n \"def __call__(self, **parameters):\\n request = self._build_request(**parameters)\\n\\n return self.requestor.request(**request)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6537257","0.6405457","0.6351566","0.6287773","0.61076057","0.6059556","0.6055695","0.6024805","0.59167784","0.5776078","0.57564014","0.57313454","0.57100374","0.56927186","0.5671444","0.5669032","0.5644252","0.5641237","0.5638615","0.5605619","0.5604527","0.5598424","0.55758846","0.55201554","0.5514555","0.54927456","0.54911995","0.5489943","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5467882","0.5449749","0.5432004","0.5429519","0.54077977","0.5397378","0.53903824","0.5379591","0.53715336","0.53572327","0.5349099","0.53294843"],"string":"[\n \"0.6537257\",\n \"0.6405457\",\n \"0.6351566\",\n \"0.6287773\",\n \"0.61076057\",\n \"0.6059556\",\n \"0.6055695\",\n \"0.6024805\",\n \"0.59167784\",\n \"0.5776078\",\n \"0.57564014\",\n \"0.57313454\",\n \"0.57100374\",\n \"0.56927186\",\n \"0.5671444\",\n \"0.5669032\",\n \"0.5644252\",\n \"0.5641237\",\n \"0.5638615\",\n \"0.5605619\",\n \"0.5604527\",\n \"0.5598424\",\n \"0.55758846\",\n \"0.55201554\",\n \"0.5514555\",\n \"0.54927456\",\n \"0.54911995\",\n \"0.5489943\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5467882\",\n \"0.5449749\",\n \"0.5432004\",\n \"0.5429519\",\n \"0.54077977\",\n \"0.5397378\",\n \"0.53903824\",\n \"0.5379591\",\n \"0.53715336\",\n \"0.53572327\",\n \"0.5349099\",\n \"0.53294843\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.58303213"},"document_rank":{"kind":"string","value":"9"}}},{"rowIdx":81998,"cells":{"query":{"kind":"string","value":"Send a management request message, wait for a response."},"document":{"kind":"string","value":"def call(self, request, expect=error.OK):\n response = self.client.call(request)\n self.check_response(response, expect=expect)\n return response"},"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":["async def _send_request(self, command, waitResponse=False):\n # Make sure we're connected.\n await self._perform_connect()\n \n while self._timeout > 0:\n self.logger.debug('waiting for previous command response')\n await asyncio.sleep(1)\n \n self.logger.debug(\"Sending command: %s\", command)\n await self._websocket.send(command)\n if waitResponse and self.connected:\n while (int(self._received_sequence) < int(self._sequence)) and self._timeout < 5:\n self._timeout += 1\n self.logger.debug('waiting for response sequence: %s, current sequence: %s' % (self._sequence,self._received_sequence))\n await asyncio.sleep(1)\n self._timeout = 0","async def handle_manager_request(self, msg, recv):\n\n reply = msg.make_reply()\n order = GoMOrder.from_json(msg.body)\n accepted = False\n if self.can_accept_order(order):\n assert self.msg_order is None\n\n self.order = order\n self.msg_order = msg\n reply.set_metadata('performative', 'agree')\n accepted = True\n else:\n reply.set_metadata('performative', 'refuse')\n\n await send(recv, reply)\n if accepted:\n if str(self.jid) == order.location:\n self.add_behaviour(self.WorkBehaviour())\n else:\n msg_tr = Message(to=self.tr_jid, body=msg.body)\n msg_tr.set_metadata('performative', 'request')\n await send(recv, msg_tr)","def send(self, response):\n self.mh.send_message(response)","def call(self, request):\n if not self.address and not request.address:\n raise ValueError(\"Request message has no address: %s\" % request)\n request.reply_to = self.reply_to\n request.correlation_id = correlation_id = self.correlation_id.next()\n self.sender.send(request)\n def wakeup():\n return self.response and (self.response.correlation_id == correlation_id)\n self.connection.wait(wakeup, msg=\"Waiting for response\")\n response = self.response\n self.response = None # Ready for next response.\n self.receiver.flow(1) # Set up credit for the next response.\n return response","def _execute(self):\n LOG.info(\"Waiting for a message...\")","async def request(self):\n # TODO: validate the state\n message = Message(self.name_path)\n await self.issue_command(Command(message))","def _mgmt_request_response(\n self,\n mgmt_operation: bytes,\n message: Any,\n callback: Callable,\n keep_alive_associated_link: bool = True,\n timeout: Optional[float] = None,\n **kwargs: Any\n ) -> \"pyamqp_Message\":\n self._open()\n application_properties = {}\n\n # Some mgmt calls do not support an associated link name (such as list_sessions). Most do, so on by default.\n if keep_alive_associated_link:\n try:\n application_properties = {\n ASSOCIATEDLINKPROPERTYNAME: self._amqp_transport.get_handler_link_name(self._handler)\n }\n except AttributeError:\n pass\n\n mgmt_msg = self._amqp_transport.create_mgmt_msg(\n message=message,\n application_properties=application_properties,\n config=self._config,\n reply_to=self._mgmt_target,\n **kwargs\n )\n\n try:\n return self._amqp_transport.mgmt_client_request(\n self._handler,\n mgmt_msg,\n operation=mgmt_operation,\n operation_type=MGMT_REQUEST_OP_TYPE_ENTITY_MGMT,\n node=self._mgmt_target.encode(self._config.encoding),\n timeout=timeout,\n callback=callback\n )\n except Exception as exp: # pylint: disable=broad-except\n if isinstance(exp, self._amqp_transport.TIMEOUT_ERROR):\n raise OperationTimeoutError(error=exp) from exp\n raise","def request(self, msg):\n\t\tif msg.command in ('AUTH', 'EXIT', 'GET', 'SET', 'VERSION', 'COMMAND', 'UPLOAD'):\n\t\t\tmethod = 'handle_request_%s' % (msg.command.lower(),)\n\t\telse:\n\t\t\tmethod = 'handle_request_unknown'\n\n\t\tself.execute(method, msg)","def _send_immediate_response(self, success, message=\"\"):\r\n\r\n # Send the response indicating success/failure\r\n response_str = json.dumps(\r\n {'return_code': 0 if success else 1, 'content': message}\r\n )\r\n\r\n if self._is_grade_request():\r\n self.send_response(\r\n 200, content=response_str, headers={'Content-type': 'text/plain'}\r\n )\r\n self.log_message(\"XQueue: sent response {0}\".format(response_str))\r\n\r\n else:\r\n self.send_response(500)","def send_manage_message(endpoint: str, action: dict, timeout: int = 5):\n context = zmq.Context()\n socket = context.socket(zmq.REQ)\n socket.setsockopt(zmq.LINGER, 0)\n socket.connect(f\"tcp://{endpoint}\")\n socket.send_json(action)\n poller = zmq.Poller()\n poller.register(socket, zmq.POLLIN)\n\n reply = None\n if poller.poll(timeout * 1000):\n reply = socket.recv_json()\n socket.close()\n context.term()\n return reply","def _send_and_response(self, addr, msg):\n self._namefixer(msg)\n return send_and_receive(addr, msg, 30) # manual timeout !!!!! fix it!","def make_work_request(self):\n request = StoreRequest()\n self.bb_client.read_wait(request, self.handle_request)","def __call__(self):\n hub.sleep(random.randint(1, self.interval))\n while True:\n self.send_req()\n self.reply_pending = True\n hub.sleep(self.interval)\n if self.reply_pending:\n self.no_response()","def wait_for_response(self, message: str = None, delay_time: int = 0):\n self._num_rounds += 1\n logging.info(\n f'{self._world_name} waiting for response at round {self._num_rounds}'\n )\n if delay_time > 0:\n time.sleep(delay_time)\n self.agent.observe(\n {'id': constants.ONBOARDING_AGENT, 'text': message, 'episode_done': False}\n )\n self.messages.append(self.agent.act(timeout=self.turn_timeout))","def test_send(self):\n msg_flag = self.instance.send(self.msg_short)\n assert(msg_flag)\n msg_flag, msg_recv = self.driver.recv(self.timeout)\n assert(msg_flag)\n nt.assert_equal(msg_recv, self.msg_short)","def process_mgmt_msg(self):\n logging.debug('Received message on the management socket')\n \n msg = self.mgmt_socket.recv_json()\n\n logging.debug('Message: %s', msg)\n \n if not isinstance(msg, dict):\n self.mgmt_socket.send_json({ 'success': -1, 'msg': 'Request message should be in JSON format' })\n return\n\n required_attribs = (\n 'cmd',\n )\n \n if not all(k in msg for k in required_attribs):\n return { 'success': -1, 'msg': 'Missing message properties' }\n\n mgmt_cmds = {\n 'manager.status': self.manager_status,\n 'manager.shutdown': self.manager_shutdown,\n }\n\n result = mgmt_cmds[msg['cmd']](msg) if mgmt_cmds.get(msg['cmd']) else { 'success': -1, 'msg': 'Uknown management command requested' }\n\n self.mgmt_socket.send_json(result)","async def _async_status_request(self) -> None:\n try:\n # status_response = await self._hass.async_add_executor_job(\n # self._mc_status.status, self._MAX_RETRIES_STATUS\n # )\n if self.access_token:\n if (time.time() - self.last_request) > 1800:\n phantom = await self._hass.async_add_executor_job(\n self._phantom_load\n )\n if phantom.status_code == HTTP_OK:\n self.phantom_load = round(phantom.json().get(\"power\") / 1000, 3)\n else:\n _LOGGER.warning(phantom.content)\n\n # Got answer to request, update properties.\n live = await self._hass.async_add_executor_job(self._live_data)\n\n if live.status_code == HTTP_OK:\n self.power_usage = round(abs(live.json().get(\"power\")) / 1000, 3)\n else:\n _LOGGER.warning(live.content)\n\n self.last_request = time.time()\n self._last_status_request_failed = False\n except OSError as error:\n # No answer to request, set all properties to unknown.\n self.power_usage = None\n self.phantom_load = None\n\n # Inform user once about failed update if necessary.\n if not self._last_status_request_failed:\n _LOGGER.warning(\n \"Updating the properties of '%s' failed - OSError: %s\",\n self.unique_id,\n error,\n )\n self._last_status_request_failed = True","def wait_response(self, address, request, timeout=None):\n request_class = type(request)\n request_class.response_count = 1\n with request_class.cv:\n self.send_service(address, request)\n return_value = request_class.cv.wait(timeout)\n if not return_value:\n raise Timeout()\n if isinstance(request_class.response, StuCanPublicError):\n raise request_class.response\n return request_class.response","def Wait(self, request, global_params=None):\n config = self.GetMethodConfig('Wait')\n return self._RunMethod(\n config, request, global_params=global_params)","def Wait(self, request, global_params=None):\n config = self.GetMethodConfig('Wait')\n return self._RunMethod(\n config, request, global_params=global_params)","def Wait(self, request, global_params=None):\n config = self.GetMethodConfig('Wait')\n return self._RunMethod(\n config, request, global_params=global_params)","def Wait(self, request, global_params=None):\n config = self.GetMethodConfig('Wait')\n return self._RunMethod(\n config, request, global_params=global_params)","def Wait(self, request, global_params=None):\n config = self.GetMethodConfig('Wait')\n return self._RunMethod(\n config, request, global_params=global_params)","def Wait(self, request, global_params=None):\n config = self.GetMethodConfig('Wait')\n return self._RunMethod(\n config, request, global_params=global_params)","def Wait(self, request, global_params=None):\n config = self.GetMethodConfig('Wait')\n return self._RunMethod(\n config, request, global_params=global_params)","def Wait(self, request, global_params=None):\n config = self.GetMethodConfig('Wait')\n return self._RunMethod(\n config, request, global_params=global_params)","def Wait(self, request, global_params=None):\n config = self.GetMethodConfig('Wait')\n return self._RunMethod(\n config, request, global_params=global_params)","def Wait(self, request, global_params=None):\n config = self.GetMethodConfig('Wait')\n return self._RunMethod(\n config, request, global_params=global_params)","def Wait(self, request, global_params=None):\n config = self.GetMethodConfig('Wait')\n return self._RunMethod(\n config, request, global_params=global_params)","def Wait(self, request, global_params=None):\n config = self.GetMethodConfig('Wait')\n return self._RunMethod(\n config, request, global_params=global_params)","def Wait(self, request, global_params=None):\n config = self.GetMethodConfig('Wait')\n return self._RunMethod(\n config, request, global_params=global_params)","def Wait(self, request, global_params=None):\n config = self.GetMethodConfig('Wait')\n return self._RunMethod(\n config, request, global_params=global_params)","def Wait(self, request, global_params=None):\n config = self.GetMethodConfig('Wait')\n return self._RunMethod(\n config, request, global_params=global_params)","def Wait(self, request, global_params=None):\n config = self.GetMethodConfig('Wait')\n return self._RunMethod(\n config, request, global_params=global_params)","def Wait(self, request, global_params=None):\n config = self.GetMethodConfig('Wait')\n return self._RunMethod(\n config, request, global_params=global_params)","def Wait(self, request, global_params=None):\n config = self.GetMethodConfig('Wait')\n return self._RunMethod(\n config, request, global_params=global_params)","def Wait(self, request, global_params=None):\n config = self.GetMethodConfig('Wait')\n return self._RunMethod(\n config, request, global_params=global_params)","def Wait(self, request, global_params=None):\n config = self.GetMethodConfig('Wait')\n return self._RunMethod(\n config, request, global_params=global_params)","def Wait(self, request, global_params=None):\n config = self.GetMethodConfig('Wait')\n return self._RunMethod(\n config, request, global_params=global_params)","def Wait(self, request, global_params=None):\n config = self.GetMethodConfig('Wait')\n return self._RunMethod(\n config, request, global_params=global_params)","def Wait(self, request, global_params=None):\n config = self.GetMethodConfig('Wait')\n return self._RunMethod(\n config, request, global_params=global_params)","def Wait(self, request, global_params=None):\n config = self.GetMethodConfig('Wait')\n return self._RunMethod(\n config, request, global_params=global_params)","def Wait(self, request, global_params=None):\n config = self.GetMethodConfig('Wait')\n return self._RunMethod(\n config, request, global_params=global_params)","def Wait(self, request, global_params=None):\n config = self.GetMethodConfig('Wait')\n return self._RunMethod(\n config, request, global_params=global_params)","def Wait(self, request, global_params=None):\n config = self.GetMethodConfig('Wait')\n return self._RunMethod(\n config, request, global_params=global_params)","def Wait(self, request, global_params=None):\n config = self.GetMethodConfig('Wait')\n return self._RunMethod(\n config, request, global_params=global_params)","async def send(self):","def serve(self):\r\n self.channel.wait()\r\n handler, seq, obj = self._recv()\r\n if handler == \"result\":\r\n self.dispatch_result(seq, obj)\r\n elif handler == \"exception\":\r\n self.dispatch_exception(seq, obj)\r\n else:\r\n self.dispatch_request(handler, seq, obj)","def respond(cmd,t,p):\n\tt.write(cmd)\n\treturn wait(t,p)","def send_request_and_get_response(self, request):\n try:\n node_id = self.get_controller()\n except Exception:\n self.module.fail_json(\n msg='Cannot determine a controller for your current Kafka '\n 'server. Is your Kafka server running and available on '\n '\\'%s\\' with security protocol \\'%s\\'?' % (\n self.client.config['bootstrap_servers'],\n self.client.config['security_protocol']\n )\n )\n\n if self.connection_check(node_id):\n future = self.client.send(node_id, request)\n self.client.poll(future=future)\n if future.succeeded():\n return future.value\n else:\n self.close()\n self.module.fail_json(\n msg='Error while sending request %s to Kafka server: %s.'\n % (request, future.exception)\n )\n else:\n self.close()\n self.module.fail_json(\n msg='Connection is not ready, please check your client '\n 'and server configurations.'\n )","def _wait_what(self, expected):\r\n \r\n self._msg_server(cb.WAITWHATSERVER % (expected))","async def handle_gom_request(self, msg, recv):\n\n assert self.msg_order is None\n assert self.order is None\n\n self.msg_order = msg\n self.order = GoMOrder.from_json(msg.body)\n reply = self.msg_order.make_reply()\n reply.set_metadata('performative', 'agree')\n await send(recv, reply)","async def wait(self) -> str:\n # pylint: disable=protected-access\n await self._event.wait()\n await self.cancel_tasks() # cancel any remaining QoS or expire tasks\n await self._connection._expected_responses.cancel_expected_response(\n self._command\n )\n return self._response","def wait(self):\n try:\n self._handler.wait()\n except Exception as e:\n raise EventHubError(\"Send failed: {}\".format(e))","def _send_request(self):\n url = self.config['url']\n agent = Agent(reactor)\n response = (yield agent.request(\n 'GET',\n url.encode(\"ASCII\"),\n ))\n\n d = defer.Deferred()\n response.deliverBody(ReceiveBody(d))\n defer.returnValue((yield d))","def testQueueMsg(self):\n self.mgr.isGoproBusy = True\n self.mgr.lastRequestSent = monotonic.monotonic()\n self.mgr.queueMsg(4)\n self.assertFalse( self.mgr.msgQueue.empty() )\n self.assertTrue(self.mgr.isGoproBusy)","async def async_send(self, **kwargs):\n ack_response = await super().async_send(address=self._address, **kwargs)\n if ack_response == ResponseStatus.SUCCESS:\n try:\n async with async_timeout.timeout(TIMEOUT + 0.1):\n return await self._message_response.get()\n except asyncio.TimeoutError:\n pass\n return ResponseStatus.FAILURE","async def send(self, message):","def _send_and_wait_block(self, raiden, recipient, transfer, expiration_block):\n raiden.send_async(recipient, transfer)\n\n current_block = raiden.get_block_number()\n while current_block < expiration_block:\n try:\n response = self.response_queue.get(\n timeout=DEFAULT_EVENTS_POLL_TIMEOUT\n )\n except Empty:\n pass\n else:\n if response:\n yield response\n\n current_block = raiden.get_block_number()\n\n if log.isEnabledFor(logging.DEBUG):\n log.debug(\n 'TIMED OUT ON BLOCK %s %s %s',\n current_block,\n self.__class__,\n pex(transfer),\n )\n\n yield TIMEOUT","def test_rpcSendRecv(self):\n cli_send = self.client_msg\n srv_send = self.server_msg\n # Send message to driver\n flag = self.client_comm.send(cli_send)\n assert(flag)\n flag, msg_recv = self.server_comm.recv(timeout=self.timeout)\n assert(flag)\n nt.assert_equal(msg_recv, srv_send)\n # Send response back to instance\n flag = self.server_comm.send(srv_send)\n assert(flag)\n # self.driver.sleep(1)\n flag, msg_recv = self.client_comm.recv(timeout=self.timeout)\n assert(flag)\n nt.assert_equal(msg_recv, cli_send)","def do_command(command):\n send_command(command)\n # time.sleep(0.1) # may be required on slow machines\n response = get_response()\n print(\"Rcvd: <<< \" + response)\n return response","def handle(self):\n data = self.request.recv(1024)\n self.request.send(data)","def on_message(self, event):\n self.response = event.message\n self.connection.container.yield_() # Wake up the wait() loop to handle the message.","def send(\n self, request: Request\n ) -> Union[Response, Coroutine[None, None, Response]]:\n return self.sender.send(request)","def testSendNextMessage(self):\n self.mgr.isGoproBusy = True\n self.mgr.lastRequestSent = monotonic.monotonic()\n self.mgr.queueMsg(3)\n self.mgr.queueMsg(2)\n self.mgr.queueMsg(1)\n self.mgr.processMsgQueue()\n self.v.send_mavlink.assert_called_with(3)\n self.assertEqual( self.mgr.msgQueue.qsize(), 2)","def emulate_request(self, user):\n message = {\n 'action': 'emulate_request',\n 'user_id': user.id,\n 'command_ids': self.ids,\n }\n self.env['telegram.bus'].sendone(message)\n return True","def handle(self):\r\n # self.request is the TCP socket connected to the client\r\n # read the incoming command\r\n request = self.request.recv(1024).strip()\r\n # write to the queue waiting to be processed by the server\r\n INPUT_QUEUE.put(request)\r\n # wait for the server answer in the output queue\r\n response = OUTPUT_QUEUE.get(timeout=5.0)\r\n # send back the answer\r\n self.request.send(response)","async def ask(self, context):\n await self.send_message(context, await self.ask_msg_packed(context))","def _send_and_wait_time(self, raiden, recipient, transfer, timeout):\n\n current_time = time.time()\n limit_time = current_time + timeout\n\n raiden.send_async(recipient, transfer)\n\n while current_time <= limit_time:\n # wait for a response message (not the Ack for the transfer)\n try:\n response = self.response_queue.get(\n timeout=limit_time - current_time,\n )\n except Empty:\n yield TIMEOUT\n return\n\n yield response\n\n current_time = time.time()\n\n if log.isEnabledFor(logging.DEBUG):\n log.debug(\n 'TIMED OUT %s %s',\n self.__class__,\n pex(transfer),\n )","def test_recv(self):\n self.driver.sched_task(0.01, self.driver.send,\n args=[self.msg_short])\n msg_flag, msg_recv = self.instance.recv(self.timeout)\n assert(msg_flag)\n nt.assert_equal(msg_recv, self.msg_short)","def wait(self):\n\t\twhile True:\n\t\t\tr1 = self.zaberSend(self.translation[\"hor\"], self.cmd[\"returnStatus\"], data=0)\n\t\t\tr2 = self.zaberSend(self.translation[\"ver\"], self.cmd[\"returnStatus\"], data=0)\n\t\t\tif r1[2] == 0 and r2[2] == 0:\n\t\t\t\tbreak\n\t\t\telse:\n\t\t\t\ttime.sleep(.01)","def sendAndReceive(self, request):\n count = 0\n while count < 100: # 5 seconds\n try:\n count += 1\n self.sock.sendto(request, self.server_addr)\n reply, _ = self.sock.recvfrom(1024)\n return reply\n except:\n pass","def test_wait(self):\n skill = create_skill()\n\n expected_response = 'Yes I do, very much'\n\n converser = Thread(target=create_converse_responder(expected_response,\n skill))\n converser.start()\n validator = mock.Mock()\n validator.return_value = True\n is_cancel = mock.Mock()\n is_cancel.return_value = False\n on_fail = mock.Mock()\n\n response = skill._wait_response(is_cancel, validator, on_fail, 1)\n self.assertEqual(response, expected_response)\n converser.join()","def _send_request(self):\n route_chosen = self.comboBox_route_list.currentText()\n route_id = route_chosen.split(',')[0] #to get the id of the route\n trip_headsign_chosen = self.comboBox_trip_headsign_list.currentText()\n stop_chosen = self.comboBox_stop_list.currentText()\n self.request(route_id, trip_headsign_chosen, stop_chosen)","def ready(self, all_ok, message):\r\n assert self.status == WAIT_PROCESS\r\n if not all_ok:\r\n self.close()\r\n self.wake_up()\r\n return\r\n self.len = ''\r\n if len(message) == 0:\r\n # it was a oneway request, do not write answer\r\n self.message = ''\r\n self.status = WAIT_LEN\r\n else:\r\n self.message = struct.pack('!i', len(message)) + message\r\n self.status = SEND_ANSWER\r\n self.wake_up()","def wait(self):\n return self.bot_client.send_command(_Command.Wait)","def request() -> None:\n\t_flag.set()","def manage_client(request, conn):\n try:\n response_msg = assemble_response(request)\n except RequestError as ex:\n response_msg = response_error(*ex.args)\n except IOError:\n response_msg = response_error(404, \"File Not Found\")\n except OSError:\n response_msg = response_error(404, \"File Not Found\")\n finally:\n try:\n conn.sendall(response_msg)\n except NameError:\n pass","def wait_till_read_out():\n\n\trespond = send_command('waitreadout')","def wait_for_response(self, request_id):\n url = \"{}/{}/{}\".format(self.url, self.url_dir, request_id)\n while True:\n response = requests.get(url)\n if response.text == \"done\\n\":\n return","def _sendingCommand(self): \n\n while True:\n self.tello.send_command('command') \n time.sleep(5)","def handle(self, name, request, response):\n self._acquire() # prevent other calls to protect data structs\n try:\n pool, requests, ready = self._lists\n # queue request\n requests.append((name, request, response))\n if ready:\n # If any threads are ready and waiting for work\n # then remove one of the locks from the ready pool\n # and release it, letting the waiting thread go forward\n # and consume the request\n ready.pop().release()\n\n finally:\n self._release()","def handle(self) -> None:\r\n\r\n if self.data.get(\"message-id\") != None:\r\n if self.data[\"status\"] == \"error\":\r\n print(self.data[\"error\"])\r\n return\r\n else:\r\n requestData = self.obs.pendingResponses.pop(self.data[\"message-id\"])\r\n request = requestData[\"request-type\"]\r\n #Requests as of version 4.8.0\r\n\r\n #General\r\n if request == \"GetVersion\":\r\n pass\r\n\r\n elif request == \"GetAuthRequired\":\r\n if self.data[\"authRequired\"]:\r\n secret_string: str = self.obs.password + self.data[\"salt\"]\r\n secret_hash: sha256 = sha256(secret_string.encode(\"utf-8\"))\r\n secret: bytes = b64encode(secret_hash.digest())\r\n\r\n response_string: str = secret.decode(\"utf-8\") + self.data[\"challenge\"]\r\n response_hash: sha256 = sha256(response_string.encode(\"utf-8\"))\r\n response: bytes = b64encode(response_hash.digest())\r\n\r\n self.obs.requests.append({\r\n \"type\": \"Authenticate\",\r\n \"auth\": response.decode(\"utf-8\")})\r\n\r\n else:\r\n self.obs.requests.append({\"type\": \"GetSceneList\"})\r\n\r\n elif request == \"Authenticate\":\r\n self.obs.requests.append({\"type\": \"GetSceneList\"})\r\n\r\n elif request == \"SetHeartbeat\":\r\n #To be removed in 5.0.0\r\n pass\r\n\r\n elif request == \"SetFilenameFormatting\":\r\n pass\r\n\r\n elif request == \"GetFilenameFormatting\":\r\n pass\r\n\r\n elif request == \"GetStats\":\r\n pass\r\n\r\n elif request == \"BroadcastCustomMessage\":\r\n pass\r\n\r\n elif request == \"GetVideoInfo\":\r\n pass\r\n\r\n elif request == \"OpenProjector\":\r\n pass\r\n\r\n elif request == \"TriggerHotkeyByName\":\r\n #Unreleased\r\n pass\r\n\r\n elif request == \"TriggerHotkeyBySequence\":\r\n #Unreleased\r\n pass\r\n\r\n #Media Control\r\n elif request == \"PlayPauseMedia\":\r\n #Unreleased\r\n pass\r\n\r\n elif request == \"RestartMedia\":\r\n #Unreleased\r\n pass\r\n\r\n elif request == \"StopMedia\":\r\n #Unreleased\r\n pass\r\n\r\n elif request == \"NextMedia\":\r\n #Unreleased\r\n pass\r\n\r\n elif request == \"PreviousMedia\":\r\n #Unreleased\r\n pass\r\n\r\n elif request == \"GetMediaDuration\":\r\n #Unreleased\r\n pass\r\n\r\n elif request == \"GetMediaTime\":\r\n #Unreleased\r\n pass\r\n\r\n elif request == \"SetMediaTime\":\r\n #Unreleased\r\n pass\r\n\r\n elif request == \"ScrubMedia\":\r\n #Unreleased\r\n pass\r\n\r\n elif request == \"GetMediaState\":\r\n #Unreleased\r\n pass\r\n\r\n #Sources\r\n\r\n elif request == \"GetMediaSourcesList\":\r\n #Unreleased\r\n pass\r\n\r\n elif request == \"GetSourcesList\":\r\n pass\r\n\r\n elif request == \"GetSourceTypesList\":\r\n pass\r\n\r\n elif request == \"GetVolume\":\r\n pass\r\n\r\n elif request == \"SetVolume\":\r\n pass\r\n\r\n elif request == \"GetMute\":\r\n pass\r\n\r\n elif request == \"SetMute\":\r\n pass\r\n\r\n elif request == \"ToggleMute\":\r\n pass\r\n\r\n elif request == \"GetAudioActive\":\r\n pass\r\n\r\n elif request == \"SetSourceName\":\r\n pass\r\n\r\n elif request == \"SetSyncOffset\":\r\n pass\r\n\r\n elif request == \"GetSyncOffset\":\r\n pass\r\n\r\n elif request == \"GetSourceSettings\":\r\n pass\r\n\r\n elif request == \"SetSourceSettings\":\r\n pass\r\n\r\n elif request == \"GetTextGDIPlusProperties\":\r\n pass\r\n\r\n elif request == \"SetTextGDIPlusProperties\":\r\n pass\r\n\r\n elif request == \"GetTextFreetype2Properties\":\r\n pass\r\n\r\n elif request == \"SetTextFreetype2Properties\":\r\n pass\r\n\r\n elif request == \"GetBrowserSourceProperties\":\r\n pass\r\n\r\n elif request == \"SetBrowserSourceProperties\":\r\n pass\r\n\r\n elif request == \"GetSpecialSources\":\r\n pass\r\n\r\n elif request == \"GetSourceFilters\":\r\n source = self.obs.getSource(requestData[\"sourceName\"])\r\n if source != None:\r\n for _filter in self.data[\"filters\"]:\r\n source.addFilter(_filter) #type: ignore\r\n\r\n elif request == \"GetSourceFilterInfo\":\r\n pass\r\n\r\n elif request == \"AddFilterToSource\":\r\n pass\r\n\r\n elif request == \"RemoveFilterFromSource\":\r\n pass\r\n\r\n elif request == \"ReorderSourceFilter\":\r\n pass\r\n\r\n elif request == \"MoveSourceFilter\":\r\n pass\r\n\r\n elif request == \"SetSourceFilterSettings\":\r\n pass\r\n\r\n elif request == \"SetSourceFilterVisibility\":\r\n pass\r\n \r\n elif request == \"GetAudioMonitorType\":\r\n pass\r\n\r\n elif request == \"SetAudioMonitorType\":\r\n pass\r\n\r\n elif request == \"TakeSourceScreenshot\":\r\n pass\r\n\r\n #Outpute\r\n elif request == \"ListOutputs\":\r\n pass\r\n\r\n elif request == \"GetOutputInfo\":\r\n pass\r\n\r\n elif request == \"StartOutput\":\r\n pass\r\n\r\n elif request == \"StopOutput\":\r\n pass\r\n\r\n #Profiles\r\n elif request == \"SetCurrentProfile\":\r\n pass\r\n\r\n elif request == \"GetCurrentProfile\":\r\n pass\r\n\r\n elif request == \"ListProfiles\":\r\n pass\r\n\r\n #Recording\r\n elif request == \"GetRecordingStatus\":\r\n #Unreleased\r\n pass\r\n\r\n elif request == \"StartStopRecording\":\r\n pass\r\n\r\n elif request == \"StartRecording\":\r\n pass\r\n\r\n elif request == \"StopRecording\":\r\n pass\r\n\r\n elif request == \"PauseRecording\":\r\n pass\r\n\r\n elif request == \"ResumeRecording\":\r\n pass\r\n\r\n elif request == \"SetRecordingFolder\":\r\n pass\r\n\r\n elif request == \"GetRecordingFolder\":\r\n pass\r\n\r\n #Replay Buffer\r\n elif request == \"GetReplayBufferStatus\":\r\n #Unreleased\r\n pass\r\n\r\n elif request == \"StartStopReplayBuffer\":\r\n pass\r\n\r\n elif request == \"StartReplayBuffer\":\r\n pass\r\n\r\n elif request == \"StopReplayBuffer\":\r\n pass\r\n\r\n elif request == \"SaveReplayBuffer\":\r\n pass\r\n\r\n #Scene Collections\r\n elif request == \"SetCurrentSceneCollection\":\r\n pass\r\n\r\n elif request == \"GetCurrentSceneCollection\":\r\n pass\r\n\r\n elif request == \"ListSceneCollections\":\r\n pass\r\n\r\n #Scene Items\r\n elif request == \"GetSceneItemList\":\r\n #Unreleased\r\n pass\r\n\r\n elif request == \"GetSceneItemProperties\":\r\n pass\r\n\r\n elif request == \"SetSceneItemProperties\":\r\n pass\r\n\r\n elif request == \"ResetSceneItem\":\r\n pass\r\n\r\n elif request == \"SetSceneItemRender\":\r\n pass\r\n\r\n elif request == \"SetSceneItemPosition\":\r\n pass\r\n\r\n elif request == \"SetSceneItemTransform\":\r\n pass\r\n\r\n elif request == \"SetSceneItemCrop\":\r\n pass\r\n\r\n elif request == \"DeleteSceneItem\":\r\n pass\r\n\r\n elif request == \"AddSceneItem\":\r\n #Unreleased\r\n pass\r\n\r\n elif request == \"DuplicateSceneItem\":\r\n pass\r\n\r\n #Scenes\r\n elif request == \"SetCurrentScene\":\r\n pass\r\n\r\n elif request == \"GetCurrentScene\":\r\n self.obs.setCurrentScene(self.data[\"name\"])\r\n\r\n elif request == \"GetSceneList\":\r\n for scene in self.data[\"scenes\"]:\r\n self.obs.addScene(scene)\r\n self.obs.setCurrentScene(self.data[\"current-scene\"])\r\n\r\n elif request == \"CreateScene\":\r\n pass\r\n\r\n elif request == \"ReorderSceneItems\":\r\n pass\r\n\r\n elif request == \"SetSceneTransitionOverride\":\r\n pass\r\n\r\n elif request == \"RemoveSceneTransitionOverride\":\r\n pass\r\n\r\n elif request == \"GetSceneTransitionOverride\":\r\n pass\r\n\r\n #Streaming\r\n elif request == \"GetStreamingStatus\":\r\n pass\r\n\r\n elif request == \"StartStopStreaming\":\r\n pass\r\n\r\n elif request == \"StartStreaming\":\r\n pass\r\n\r\n elif request == \"StopStreaming\":\r\n pass\r\n\r\n elif request == \"SetStreamSettings\":\r\n pass\r\n\r\n elif request == \"GetStreamSettings\":\r\n pass\r\n\r\n elif request == \"SaveStreamSettings\":\r\n pass\r\n\r\n elif request == \"SendCaptions\":\r\n pass\r\n\r\n #Studio Mode\r\n elif request == \"GetStudioModeStatus\":\r\n pass\r\n\r\n elif request == \"GetPreviewScene\":\r\n pass\r\n\r\n elif request == \"SetPreviewScene\":\r\n pass\r\n\r\n elif request == \"TransitionToProgram\":\r\n pass\r\n\r\n elif request == \"EnableStudioMode\":\r\n pass\r\n\r\n elif request == \"DisableStudioMode\":\r\n pass\r\n\r\n elif request == \"ToggleStudioMode\":\r\n pass\r\n\r\n #Transitions\r\n elif request == \"GetTransitionList\":\r\n pass\r\n\r\n elif request == \"GetCurrentTransition\":\r\n pass\r\n\r\n elif request == \"SetCurrentTransition\":\r\n pass\r\n\r\n elif request == \"SetTransitionDuration\":\r\n pass\r\n\r\n elif request == \"GetTransitionDuration\":\r\n pass\r\n\r\n elif request == \"GetTransitionPosition\":\r\n pass\r\n\r\n else:\r\n print(f\"Unhandled response of type {request} and data {self.data}.\")\r\n\r\n \r\n\r\n else:\r\n event: str = self.data[\"update-type\"]\r\n #Events as of 4.8.0\r\n\r\n #Scenes\r\n if event == \"SwitchScenes\":\r\n self.obs.setCurrentScene(self.data[\"scene-name\"])\r\n\r\n elif event == \"ScenesChanged\":\r\n #self.obs.purgeScenes()\r\n pass\r\n\r\n elif event == \"SceneCollectionChanged\":\r\n pass\r\n\r\n elif event == \"SceneCollectionListChanged\":\r\n pass\r\n\r\n #Transitions\r\n elif event == \"SwitchTransition\":\r\n pass\r\n\r\n elif event == \"TransitionListChanged\":\r\n pass\r\n\r\n elif event == \"TransitionDurationChanged\":\r\n pass\r\n\r\n elif event == \"TransitionBegin\":\r\n pass\r\n\r\n elif event == \"TransitionEnd\":\r\n pass\r\n\r\n elif event == \"TransitionVideoEnd\":\r\n pass\r\n\r\n #Profiles\r\n elif event == \"ProfileChanged\":\r\n pass\r\n\r\n elif event == \"ProfileListChanged\":\r\n pass\r\n\r\n #Streaming\r\n elif event == \"StreamStarting\":\r\n pass\r\n\r\n elif event == \"StreamStarted\":\r\n pass\r\n\r\n elif event == \"StreamStopping\":\r\n pass\r\n\r\n elif event == \"StreamStopped\":\r\n pass\r\n\r\n elif event == \"StreamStatus\":\r\n pass\r\n\r\n #Recording\r\n elif event == \"RecordingStarting\":\r\n pass\r\n\r\n elif event == \"RecordingStarted\":\r\n pass\r\n\r\n elif event == \"RecordingStopping\":\r\n pass\r\n\r\n elif event == \"RecordingStopped\":\r\n pass\r\n\r\n elif event == \"RecordingPaused\":\r\n pass\r\n\r\n elif event == \"RecordingResumed\":\r\n pass\r\n\r\n #Replay Buffer\r\n elif event == \"ReplayStarting\":\r\n pass\r\n\r\n elif event == \"ReplayStarted\":\r\n pass\r\n\r\n elif event == \"ReplayStopping\":\r\n pass\r\n\r\n elif event == \"ReplayStopped\":\r\n pass\r\n\r\n #Other\r\n elif event == \"Exiting\":\r\n pass\r\n\r\n #General\r\n elif event == \"Heartbeat\":\r\n pass\r\n\r\n elif event == \"BroadcastCustomMessage\":\r\n pass\r\n\r\n #Sources\r\n elif event == \"SourceCreated\":\r\n pass\r\n\r\n elif event == \"SourceDestroyed\":\r\n pass\r\n\r\n elif event == \"SourceVolumeChanged\":\r\n pass\r\n\r\n elif event == \"SourceMuteStateChanged\":\r\n pass\r\n\r\n elif event == \"SourceAudioDeactivated\":\r\n #Unreleased\r\n pass\r\n\r\n elif event == \"SourceAudioActivated\":\r\n #Unreleased\r\n pass\r\n\r\n elif event == \"SourceAudioSyncOffsetChanged\":\r\n pass\r\n\r\n elif event == \"SourceAudioMixersChanged\":\r\n pass\r\n\r\n elif event == \"SourceRenamed\":\r\n pass\r\n\r\n elif event == \"SourceFilterAdded\":\r\n pass\r\n\r\n elif event == \"SourceFilterRemoved\":\r\n pass\r\n\r\n elif event == \"SourceFilterVisibilityChanged\":\r\n source = self.obs.getSource(self.data[\"sourceName\"])\r\n if source != None:\r\n _filter = source.getFilter(self.data[\"filterName\"]) #type: ignore\r\n if _filter != None:\r\n _filter.setVisible(self.data[\"filterEnabled\"]) #type: ignore\r\n\r\n elif event == \"SourceFiltersReordered\":\r\n pass\r\n\r\n #Media\r\n elif event == \"MediaPlaying\":\r\n #Unreleased\r\n pass\r\n\r\n elif event == \"MediaPaused\":\r\n #Unreleased\r\n pass\r\n\r\n elif event == \"MediaRestarted\":\r\n #Unreleased\r\n pass\r\n\r\n elif event == \"MediaStopped\":\r\n #Unreleased\r\n pass\r\n\r\n elif event == \"MediaNext\":\r\n #Unreleased\r\n pass\r\n\r\n elif event == \"MediaPrevious\":\r\n #Unreleased\r\n pass\r\n\r\n elif event == \"MediaStarted\":\r\n #Unreleased\r\n pass\r\n\r\n elif event == \"MediaEnded\":\r\n #Unreleased\r\n pass\r\n\r\n #Scene Items\r\n elif event == \"SceneItemOrderChanged\":\r\n pass\r\n\r\n elif event == \"SceneItemAdded\":\r\n pass\r\n\r\n elif event == \"SceneItemRemoved\":\r\n pass\r\n\r\n elif event == \"SceneItemVisibilityChanged\":\r\n scene = self.obs.getScene(self.data[\"scene-name\"])\r\n if scene != None:\r\n source = scene.getSource(self.data[\"item-name\"]) #type: ignore\r\n if source != None:\r\n source.setVisible(self.data[\"item-visible\"]) #type: ignore\r\n \r\n\r\n elif event == \"SceneItemLockChanged\":\r\n pass\r\n\r\n elif event == \"SceneItemTransformChanged\":\r\n pass\r\n\r\n elif event == \"SceneItemSelected\":\r\n pass\r\n\r\n elif event == \"SceneItemDeselected\":\r\n pass\r\n\r\n #Studio Mode\r\n elif event == \"PreviewSceneChanged\":\r\n pass\r\n\r\n elif event == \"StudioModeSwitched\":\r\n pass\r\n\r\n #Unhandled Events\r\n else:\r\n print(\"Unhandled event with data: \" + str(self.data))","def run(self):\n # client -> server\n self.client.send_message(\n new_order_message(self.client,\n symbol='abc',\n side='0',\n order_type='1',\n extra_tags=[(38, 100), # orderQty\n (44, 10), ])) # price\n\n # server <- client\n message = self.server.wait_for_message('waiting for new order')\n assert_is_not_none(message)\n\n # server -> client\n self.server.send_message(\n execution_report(self.server,\n message,\n exec_trans_type='0',\n exec_type='0',\n ord_status='0',\n symbol='abc',\n side='0',\n leaves_qty='100',\n cum_qty='0',\n avg_px='0'))\n\n # client <- server\n message = self.client.wait_for_message('waiting for new order ack')\n assert_is_not_none(message)","def _run(self):\n\n self.sendStatus(C.MSG_PROBE, 'Detecting Management Interface')\n\n data = self.getData()\n host = data.p.host\n for params in data.p.interfacesList:\n port = params['port']\n interfaceHref = params['interfaceHref']\n self.sendStatus(C.MSG_PROBE, 'Checking %s:%s' % (host, port))\n if self._queryService(host, port):\n self._sendResponse(data, interfaceHref, port)\n self.sendStatus(C.OK, 'Found management interface on %s:%s'\n % (host, port))\n return\n\n self._sendResponse(data)\n self.sendStatus(C.OK_1, 'No management interface discovered')","def _request(self, *args):\n self._silent_request(*args)\n return self._get_response()","def process_request(t):\n time.sleep(t)","def process_request(t):\n time.sleep(t)","def process_request(t):\n time.sleep(t)","def send_command(self, cmd):\n\n\t\tself.eyetribe._connection.request(cmd)","def send_request_if_needed(self, request, relations):\n if self.is_request_sent(request, relations):\n logging.debug('Request already sent, not sending new request')\n else:\n for relation in relations:\n logging.debug('Sending request {}'.format(request.request_id))\n relation.data[self.this_unit]['broker_req'] = request.request","def _response_success(self, msg, msgID):\r\n if not self._status:\r\n # Can not help it if the response takes some time and in the mean\r\n # time the interface is disabled; therefore, don't raise an error\r\n # instead just skip sending the response\r\n return\r\n\r\n self._conn.sendMessage(self._iTag, self._clsName, msg, msgID)","def answer_waiting_call(self) -> None:","def testSetRequest(self):\n self.mgr.sendGoProCommand = Mock()\n value = struct.pack('<HH', 8, 22)\n self.mgr.handlePacket(app_packet.GOPRO_SET_REQUEST, value)\n self.mgr.sendGoProCommand.assert_called_with( 8, (22, 0, 0, 0) )","def _send_command(self, cmd, wait_msg=None):\n try:\n if not (self.sock_thr and self.sock_thr.is_active()):\n if cmd not in (TSMessage.STOP, TSMessage.SHUTDOWN):\n self._createThread()\n else:\n return\n # Waiting message if need\n log.d('>> \"{0}\"'.format(cmd))\n if wait_msg:\n with self.waiting.lock:\n log.d('wait message: {0}'.format(wait_msg))\n try:\n self.waiting.msg = wait_msg\n self.waiting.event.clear()\n self.waiting.abort.clear()\n self.sock.send(to_bytes(cmd + '\\r\\n'))\n for t in range(AcePlayer.TIMEOUT_FREEZE * 3): # @UnusedVariable\n log.d(\"waiting message {msg} ({t})\".format(msg=wait_msg, t=t))\n if not self.waiting.msg or self.sock_thr.error or defines.isCancel():\n raise ValueError('Abort waiting message: \"{0}\"'.format(wait_msg))\n if self.waiting.wait(1):\n return self.waiting.msg\n\n self.parent.showStatus(\"Ошибка ожидания. Операция прервана\")\n raise ValueError('AceEngine is freeze')\n\n except Exception as e:\n log.e('_wait_message error: {0}'.format(uni(e)))\n self.waiting.msg = None\n if not Flags.manual_stopped.is_set():\n self.autoStop()\n return\n\n else:\n self.sock.send(to_bytes(cmd + '\\r\\n'))\n return True\n\n except Exception as e:\n log.e('_send_command error: \"{0}\" cmd: \"{1}\"'.format(uni(e), cmd))\n\n if self.sock_thr and self.sock_thr.is_active():\n self.sock_thr.end()","def wait(t):\n message = \"WAIT:\" + str(t) + '\\n'\n sock.sendall(message)\n time.sleep(t)\n return","def send_message(self, sender, to, text, callback=None):\n url = self.assamble_url(sender, to, text)\n logging.debug('Requesting Nexmo service: ' + url)\n request = HTTPRequest(url=url, method='GET')\n\n # Define response callback.\n def handle_request(response):\n if response.error:\n logging.warning(\"Request failed: \" + str(response.error))\n if callback:\n callback(False)\n return\n\n try:\n json_response = json.loads(response.body)\n except ValueError as exc:\n logging.error(\"response was not json\", exc_info=1)\n callback(False)\n return\n\n message_was_send = []\n try:\n for message in json_response['messages']:\n if message['status'] != \"0\":\n message_was_send.append(False)\n else:\n message_was_send.append(True)\n\n if len(message_was_send) > 1:\n logging.warn(\"message was sent as multipart in {} parts\".format(len(message_was_send)))\n\n if not all(message_was_send):\n logging.error(\"sending of {} messages failed. Error message: {}\".format(len(filter(lambda x: x is False, message_was_send)), json_response))\n callback(False)\n return\n\n except ValueError:\n logging.error(\"response is unexpected\", exc_info=True)\n callback(False)\n return\n callback(True)\n\n if self.development_mode:\n # in development mode no requests are send everything is a (huge) success\n callback(True)\n else:\n self.http_client.fetch(request, handle_request)","def _run(self):\n self.running = True\n\n while self.running:\n try:\n print \"Response monitor running...\"\n\n # Get the message count\n messageCount = self.scHandle.amazonSQSManager.getQueueCount(self.scHandle.amazonSQSManager.responsesQueue)\n\n print '%i messages in queue...' % messageCount\n\n # Read a response\n response = self.scHandle.responseManager.getResponseFromResponsesQueue()\n\n # TODO: Do something with the response\n if response:\n print(response)\n\n except Exception, responseMonitorException:\n print \"Response monitor failed with exception %s.\" % str(responseMonitorException)\n\n finally:\n # Wait for a bit\n sleep(self.PAUSE_TIME)","def __call__(self, get_response, request):\n response = self._behaviour(get_response, request)\n sleep(self._seconds)\n return response","def handle_response(self, response):\n with self.lock:\n req_id, status, message = response\n if req_id in self.pending_requests: # request may have timed out\n self.pending_requests[req_id].set((status, message))","def send(msg):\n r = \"No response\"\n try:\n r = requests.post(\"http://127.0.0.1:8000\", data=msg)\n except:\n pass\n #print(r.status_code, r.reason)\n print(r.text[:300] + '...')"],"string":"[\n \"async def _send_request(self, command, waitResponse=False):\\n # Make sure we're connected.\\n await self._perform_connect()\\n \\n while self._timeout > 0:\\n self.logger.debug('waiting for previous command response')\\n await asyncio.sleep(1)\\n \\n self.logger.debug(\\\"Sending command: %s\\\", command)\\n await self._websocket.send(command)\\n if waitResponse and self.connected:\\n while (int(self._received_sequence) < int(self._sequence)) and self._timeout < 5:\\n self._timeout += 1\\n self.logger.debug('waiting for response sequence: %s, current sequence: %s' % (self._sequence,self._received_sequence))\\n await asyncio.sleep(1)\\n self._timeout = 0\",\n \"async def handle_manager_request(self, msg, recv):\\n\\n reply = msg.make_reply()\\n order = GoMOrder.from_json(msg.body)\\n accepted = False\\n if self.can_accept_order(order):\\n assert self.msg_order is None\\n\\n self.order = order\\n self.msg_order = msg\\n reply.set_metadata('performative', 'agree')\\n accepted = True\\n else:\\n reply.set_metadata('performative', 'refuse')\\n\\n await send(recv, reply)\\n if accepted:\\n if str(self.jid) == order.location:\\n self.add_behaviour(self.WorkBehaviour())\\n else:\\n msg_tr = Message(to=self.tr_jid, body=msg.body)\\n msg_tr.set_metadata('performative', 'request')\\n await send(recv, msg_tr)\",\n \"def send(self, response):\\n self.mh.send_message(response)\",\n \"def call(self, request):\\n if not self.address and not request.address:\\n raise ValueError(\\\"Request message has no address: %s\\\" % request)\\n request.reply_to = self.reply_to\\n request.correlation_id = correlation_id = self.correlation_id.next()\\n self.sender.send(request)\\n def wakeup():\\n return self.response and (self.response.correlation_id == correlation_id)\\n self.connection.wait(wakeup, msg=\\\"Waiting for response\\\")\\n response = self.response\\n self.response = None # Ready for next response.\\n self.receiver.flow(1) # Set up credit for the next response.\\n return response\",\n \"def _execute(self):\\n LOG.info(\\\"Waiting for a message...\\\")\",\n \"async def request(self):\\n # TODO: validate the state\\n message = Message(self.name_path)\\n await self.issue_command(Command(message))\",\n \"def _mgmt_request_response(\\n self,\\n mgmt_operation: bytes,\\n message: Any,\\n callback: Callable,\\n keep_alive_associated_link: bool = True,\\n timeout: Optional[float] = None,\\n **kwargs: Any\\n ) -> \\\"pyamqp_Message\\\":\\n self._open()\\n application_properties = {}\\n\\n # Some mgmt calls do not support an associated link name (such as list_sessions). Most do, so on by default.\\n if keep_alive_associated_link:\\n try:\\n application_properties = {\\n ASSOCIATEDLINKPROPERTYNAME: self._amqp_transport.get_handler_link_name(self._handler)\\n }\\n except AttributeError:\\n pass\\n\\n mgmt_msg = self._amqp_transport.create_mgmt_msg(\\n message=message,\\n application_properties=application_properties,\\n config=self._config,\\n reply_to=self._mgmt_target,\\n **kwargs\\n )\\n\\n try:\\n return self._amqp_transport.mgmt_client_request(\\n self._handler,\\n mgmt_msg,\\n operation=mgmt_operation,\\n operation_type=MGMT_REQUEST_OP_TYPE_ENTITY_MGMT,\\n node=self._mgmt_target.encode(self._config.encoding),\\n timeout=timeout,\\n callback=callback\\n )\\n except Exception as exp: # pylint: disable=broad-except\\n if isinstance(exp, self._amqp_transport.TIMEOUT_ERROR):\\n raise OperationTimeoutError(error=exp) from exp\\n raise\",\n \"def request(self, msg):\\n\\t\\tif msg.command in ('AUTH', 'EXIT', 'GET', 'SET', 'VERSION', 'COMMAND', 'UPLOAD'):\\n\\t\\t\\tmethod = 'handle_request_%s' % (msg.command.lower(),)\\n\\t\\telse:\\n\\t\\t\\tmethod = 'handle_request_unknown'\\n\\n\\t\\tself.execute(method, msg)\",\n \"def _send_immediate_response(self, success, message=\\\"\\\"):\\r\\n\\r\\n # Send the response indicating success/failure\\r\\n response_str = json.dumps(\\r\\n {'return_code': 0 if success else 1, 'content': message}\\r\\n )\\r\\n\\r\\n if self._is_grade_request():\\r\\n self.send_response(\\r\\n 200, content=response_str, headers={'Content-type': 'text/plain'}\\r\\n )\\r\\n self.log_message(\\\"XQueue: sent response {0}\\\".format(response_str))\\r\\n\\r\\n else:\\r\\n self.send_response(500)\",\n \"def send_manage_message(endpoint: str, action: dict, timeout: int = 5):\\n context = zmq.Context()\\n socket = context.socket(zmq.REQ)\\n socket.setsockopt(zmq.LINGER, 0)\\n socket.connect(f\\\"tcp://{endpoint}\\\")\\n socket.send_json(action)\\n poller = zmq.Poller()\\n poller.register(socket, zmq.POLLIN)\\n\\n reply = None\\n if poller.poll(timeout * 1000):\\n reply = socket.recv_json()\\n socket.close()\\n context.term()\\n return reply\",\n \"def _send_and_response(self, addr, msg):\\n self._namefixer(msg)\\n return send_and_receive(addr, msg, 30) # manual timeout !!!!! fix it!\",\n \"def make_work_request(self):\\n request = StoreRequest()\\n self.bb_client.read_wait(request, self.handle_request)\",\n \"def __call__(self):\\n hub.sleep(random.randint(1, self.interval))\\n while True:\\n self.send_req()\\n self.reply_pending = True\\n hub.sleep(self.interval)\\n if self.reply_pending:\\n self.no_response()\",\n \"def wait_for_response(self, message: str = None, delay_time: int = 0):\\n self._num_rounds += 1\\n logging.info(\\n f'{self._world_name} waiting for response at round {self._num_rounds}'\\n )\\n if delay_time > 0:\\n time.sleep(delay_time)\\n self.agent.observe(\\n {'id': constants.ONBOARDING_AGENT, 'text': message, 'episode_done': False}\\n )\\n self.messages.append(self.agent.act(timeout=self.turn_timeout))\",\n \"def test_send(self):\\n msg_flag = self.instance.send(self.msg_short)\\n assert(msg_flag)\\n msg_flag, msg_recv = self.driver.recv(self.timeout)\\n assert(msg_flag)\\n nt.assert_equal(msg_recv, self.msg_short)\",\n \"def process_mgmt_msg(self):\\n logging.debug('Received message on the management socket')\\n \\n msg = self.mgmt_socket.recv_json()\\n\\n logging.debug('Message: %s', msg)\\n \\n if not isinstance(msg, dict):\\n self.mgmt_socket.send_json({ 'success': -1, 'msg': 'Request message should be in JSON format' })\\n return\\n\\n required_attribs = (\\n 'cmd',\\n )\\n \\n if not all(k in msg for k in required_attribs):\\n return { 'success': -1, 'msg': 'Missing message properties' }\\n\\n mgmt_cmds = {\\n 'manager.status': self.manager_status,\\n 'manager.shutdown': self.manager_shutdown,\\n }\\n\\n result = mgmt_cmds[msg['cmd']](msg) if mgmt_cmds.get(msg['cmd']) else { 'success': -1, 'msg': 'Uknown management command requested' }\\n\\n self.mgmt_socket.send_json(result)\",\n \"async def _async_status_request(self) -> None:\\n try:\\n # status_response = await self._hass.async_add_executor_job(\\n # self._mc_status.status, self._MAX_RETRIES_STATUS\\n # )\\n if self.access_token:\\n if (time.time() - self.last_request) > 1800:\\n phantom = await self._hass.async_add_executor_job(\\n self._phantom_load\\n )\\n if phantom.status_code == HTTP_OK:\\n self.phantom_load = round(phantom.json().get(\\\"power\\\") / 1000, 3)\\n else:\\n _LOGGER.warning(phantom.content)\\n\\n # Got answer to request, update properties.\\n live = await self._hass.async_add_executor_job(self._live_data)\\n\\n if live.status_code == HTTP_OK:\\n self.power_usage = round(abs(live.json().get(\\\"power\\\")) / 1000, 3)\\n else:\\n _LOGGER.warning(live.content)\\n\\n self.last_request = time.time()\\n self._last_status_request_failed = False\\n except OSError as error:\\n # No answer to request, set all properties to unknown.\\n self.power_usage = None\\n self.phantom_load = None\\n\\n # Inform user once about failed update if necessary.\\n if not self._last_status_request_failed:\\n _LOGGER.warning(\\n \\\"Updating the properties of '%s' failed - OSError: %s\\\",\\n self.unique_id,\\n error,\\n )\\n self._last_status_request_failed = True\",\n \"def wait_response(self, address, request, timeout=None):\\n request_class = type(request)\\n request_class.response_count = 1\\n with request_class.cv:\\n self.send_service(address, request)\\n return_value = request_class.cv.wait(timeout)\\n if not return_value:\\n raise Timeout()\\n if isinstance(request_class.response, StuCanPublicError):\\n raise request_class.response\\n return request_class.response\",\n \"def Wait(self, request, global_params=None):\\n config = self.GetMethodConfig('Wait')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Wait(self, request, global_params=None):\\n config = self.GetMethodConfig('Wait')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Wait(self, request, global_params=None):\\n config = self.GetMethodConfig('Wait')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Wait(self, request, global_params=None):\\n config = self.GetMethodConfig('Wait')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Wait(self, request, global_params=None):\\n config = self.GetMethodConfig('Wait')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Wait(self, request, global_params=None):\\n config = self.GetMethodConfig('Wait')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Wait(self, request, global_params=None):\\n config = self.GetMethodConfig('Wait')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Wait(self, request, global_params=None):\\n config = self.GetMethodConfig('Wait')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Wait(self, request, global_params=None):\\n config = self.GetMethodConfig('Wait')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Wait(self, request, global_params=None):\\n config = self.GetMethodConfig('Wait')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Wait(self, request, global_params=None):\\n config = self.GetMethodConfig('Wait')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Wait(self, request, global_params=None):\\n config = self.GetMethodConfig('Wait')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Wait(self, request, global_params=None):\\n config = self.GetMethodConfig('Wait')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Wait(self, request, global_params=None):\\n config = self.GetMethodConfig('Wait')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Wait(self, request, global_params=None):\\n config = self.GetMethodConfig('Wait')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Wait(self, request, global_params=None):\\n config = self.GetMethodConfig('Wait')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Wait(self, request, global_params=None):\\n config = self.GetMethodConfig('Wait')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Wait(self, request, global_params=None):\\n config = self.GetMethodConfig('Wait')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Wait(self, request, global_params=None):\\n config = self.GetMethodConfig('Wait')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Wait(self, request, global_params=None):\\n config = self.GetMethodConfig('Wait')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Wait(self, request, global_params=None):\\n config = self.GetMethodConfig('Wait')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Wait(self, request, global_params=None):\\n config = self.GetMethodConfig('Wait')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Wait(self, request, global_params=None):\\n config = self.GetMethodConfig('Wait')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Wait(self, request, global_params=None):\\n config = self.GetMethodConfig('Wait')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Wait(self, request, global_params=None):\\n config = self.GetMethodConfig('Wait')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Wait(self, request, global_params=None):\\n config = self.GetMethodConfig('Wait')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Wait(self, request, global_params=None):\\n config = self.GetMethodConfig('Wait')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def Wait(self, request, global_params=None):\\n config = self.GetMethodConfig('Wait')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"async def send(self):\",\n \"def serve(self):\\r\\n self.channel.wait()\\r\\n handler, seq, obj = self._recv()\\r\\n if handler == \\\"result\\\":\\r\\n self.dispatch_result(seq, obj)\\r\\n elif handler == \\\"exception\\\":\\r\\n self.dispatch_exception(seq, obj)\\r\\n else:\\r\\n self.dispatch_request(handler, seq, obj)\",\n \"def respond(cmd,t,p):\\n\\tt.write(cmd)\\n\\treturn wait(t,p)\",\n \"def send_request_and_get_response(self, request):\\n try:\\n node_id = self.get_controller()\\n except Exception:\\n self.module.fail_json(\\n msg='Cannot determine a controller for your current Kafka '\\n 'server. Is your Kafka server running and available on '\\n '\\\\'%s\\\\' with security protocol \\\\'%s\\\\'?' % (\\n self.client.config['bootstrap_servers'],\\n self.client.config['security_protocol']\\n )\\n )\\n\\n if self.connection_check(node_id):\\n future = self.client.send(node_id, request)\\n self.client.poll(future=future)\\n if future.succeeded():\\n return future.value\\n else:\\n self.close()\\n self.module.fail_json(\\n msg='Error while sending request %s to Kafka server: %s.'\\n % (request, future.exception)\\n )\\n else:\\n self.close()\\n self.module.fail_json(\\n msg='Connection is not ready, please check your client '\\n 'and server configurations.'\\n )\",\n \"def _wait_what(self, expected):\\r\\n \\r\\n self._msg_server(cb.WAITWHATSERVER % (expected))\",\n \"async def handle_gom_request(self, msg, recv):\\n\\n assert self.msg_order is None\\n assert self.order is None\\n\\n self.msg_order = msg\\n self.order = GoMOrder.from_json(msg.body)\\n reply = self.msg_order.make_reply()\\n reply.set_metadata('performative', 'agree')\\n await send(recv, reply)\",\n \"async def wait(self) -> str:\\n # pylint: disable=protected-access\\n await self._event.wait()\\n await self.cancel_tasks() # cancel any remaining QoS or expire tasks\\n await self._connection._expected_responses.cancel_expected_response(\\n self._command\\n )\\n return self._response\",\n \"def wait(self):\\n try:\\n self._handler.wait()\\n except Exception as e:\\n raise EventHubError(\\\"Send failed: {}\\\".format(e))\",\n \"def _send_request(self):\\n url = self.config['url']\\n agent = Agent(reactor)\\n response = (yield agent.request(\\n 'GET',\\n url.encode(\\\"ASCII\\\"),\\n ))\\n\\n d = defer.Deferred()\\n response.deliverBody(ReceiveBody(d))\\n defer.returnValue((yield d))\",\n \"def testQueueMsg(self):\\n self.mgr.isGoproBusy = True\\n self.mgr.lastRequestSent = monotonic.monotonic()\\n self.mgr.queueMsg(4)\\n self.assertFalse( self.mgr.msgQueue.empty() )\\n self.assertTrue(self.mgr.isGoproBusy)\",\n \"async def async_send(self, **kwargs):\\n ack_response = await super().async_send(address=self._address, **kwargs)\\n if ack_response == ResponseStatus.SUCCESS:\\n try:\\n async with async_timeout.timeout(TIMEOUT + 0.1):\\n return await self._message_response.get()\\n except asyncio.TimeoutError:\\n pass\\n return ResponseStatus.FAILURE\",\n \"async def send(self, message):\",\n \"def _send_and_wait_block(self, raiden, recipient, transfer, expiration_block):\\n raiden.send_async(recipient, transfer)\\n\\n current_block = raiden.get_block_number()\\n while current_block < expiration_block:\\n try:\\n response = self.response_queue.get(\\n timeout=DEFAULT_EVENTS_POLL_TIMEOUT\\n )\\n except Empty:\\n pass\\n else:\\n if response:\\n yield response\\n\\n current_block = raiden.get_block_number()\\n\\n if log.isEnabledFor(logging.DEBUG):\\n log.debug(\\n 'TIMED OUT ON BLOCK %s %s %s',\\n current_block,\\n self.__class__,\\n pex(transfer),\\n )\\n\\n yield TIMEOUT\",\n \"def test_rpcSendRecv(self):\\n cli_send = self.client_msg\\n srv_send = self.server_msg\\n # Send message to driver\\n flag = self.client_comm.send(cli_send)\\n assert(flag)\\n flag, msg_recv = self.server_comm.recv(timeout=self.timeout)\\n assert(flag)\\n nt.assert_equal(msg_recv, srv_send)\\n # Send response back to instance\\n flag = self.server_comm.send(srv_send)\\n assert(flag)\\n # self.driver.sleep(1)\\n flag, msg_recv = self.client_comm.recv(timeout=self.timeout)\\n assert(flag)\\n nt.assert_equal(msg_recv, cli_send)\",\n \"def do_command(command):\\n send_command(command)\\n # time.sleep(0.1) # may be required on slow machines\\n response = get_response()\\n print(\\\"Rcvd: <<< \\\" + response)\\n return response\",\n \"def handle(self):\\n data = self.request.recv(1024)\\n self.request.send(data)\",\n \"def on_message(self, event):\\n self.response = event.message\\n self.connection.container.yield_() # Wake up the wait() loop to handle the message.\",\n \"def send(\\n self, request: Request\\n ) -> Union[Response, Coroutine[None, None, Response]]:\\n return self.sender.send(request)\",\n \"def testSendNextMessage(self):\\n self.mgr.isGoproBusy = True\\n self.mgr.lastRequestSent = monotonic.monotonic()\\n self.mgr.queueMsg(3)\\n self.mgr.queueMsg(2)\\n self.mgr.queueMsg(1)\\n self.mgr.processMsgQueue()\\n self.v.send_mavlink.assert_called_with(3)\\n self.assertEqual( self.mgr.msgQueue.qsize(), 2)\",\n \"def emulate_request(self, user):\\n message = {\\n 'action': 'emulate_request',\\n 'user_id': user.id,\\n 'command_ids': self.ids,\\n }\\n self.env['telegram.bus'].sendone(message)\\n return True\",\n \"def handle(self):\\r\\n # self.request is the TCP socket connected to the client\\r\\n # read the incoming command\\r\\n request = self.request.recv(1024).strip()\\r\\n # write to the queue waiting to be processed by the server\\r\\n INPUT_QUEUE.put(request)\\r\\n # wait for the server answer in the output queue\\r\\n response = OUTPUT_QUEUE.get(timeout=5.0)\\r\\n # send back the answer\\r\\n self.request.send(response)\",\n \"async def ask(self, context):\\n await self.send_message(context, await self.ask_msg_packed(context))\",\n \"def _send_and_wait_time(self, raiden, recipient, transfer, timeout):\\n\\n current_time = time.time()\\n limit_time = current_time + timeout\\n\\n raiden.send_async(recipient, transfer)\\n\\n while current_time <= limit_time:\\n # wait for a response message (not the Ack for the transfer)\\n try:\\n response = self.response_queue.get(\\n timeout=limit_time - current_time,\\n )\\n except Empty:\\n yield TIMEOUT\\n return\\n\\n yield response\\n\\n current_time = time.time()\\n\\n if log.isEnabledFor(logging.DEBUG):\\n log.debug(\\n 'TIMED OUT %s %s',\\n self.__class__,\\n pex(transfer),\\n )\",\n \"def test_recv(self):\\n self.driver.sched_task(0.01, self.driver.send,\\n args=[self.msg_short])\\n msg_flag, msg_recv = self.instance.recv(self.timeout)\\n assert(msg_flag)\\n nt.assert_equal(msg_recv, self.msg_short)\",\n \"def wait(self):\\n\\t\\twhile True:\\n\\t\\t\\tr1 = self.zaberSend(self.translation[\\\"hor\\\"], self.cmd[\\\"returnStatus\\\"], data=0)\\n\\t\\t\\tr2 = self.zaberSend(self.translation[\\\"ver\\\"], self.cmd[\\\"returnStatus\\\"], data=0)\\n\\t\\t\\tif r1[2] == 0 and r2[2] == 0:\\n\\t\\t\\t\\tbreak\\n\\t\\t\\telse:\\n\\t\\t\\t\\ttime.sleep(.01)\",\n \"def sendAndReceive(self, request):\\n count = 0\\n while count < 100: # 5 seconds\\n try:\\n count += 1\\n self.sock.sendto(request, self.server_addr)\\n reply, _ = self.sock.recvfrom(1024)\\n return reply\\n except:\\n pass\",\n \"def test_wait(self):\\n skill = create_skill()\\n\\n expected_response = 'Yes I do, very much'\\n\\n converser = Thread(target=create_converse_responder(expected_response,\\n skill))\\n converser.start()\\n validator = mock.Mock()\\n validator.return_value = True\\n is_cancel = mock.Mock()\\n is_cancel.return_value = False\\n on_fail = mock.Mock()\\n\\n response = skill._wait_response(is_cancel, validator, on_fail, 1)\\n self.assertEqual(response, expected_response)\\n converser.join()\",\n \"def _send_request(self):\\n route_chosen = self.comboBox_route_list.currentText()\\n route_id = route_chosen.split(',')[0] #to get the id of the route\\n trip_headsign_chosen = self.comboBox_trip_headsign_list.currentText()\\n stop_chosen = self.comboBox_stop_list.currentText()\\n self.request(route_id, trip_headsign_chosen, stop_chosen)\",\n \"def ready(self, all_ok, message):\\r\\n assert self.status == WAIT_PROCESS\\r\\n if not all_ok:\\r\\n self.close()\\r\\n self.wake_up()\\r\\n return\\r\\n self.len = ''\\r\\n if len(message) == 0:\\r\\n # it was a oneway request, do not write answer\\r\\n self.message = ''\\r\\n self.status = WAIT_LEN\\r\\n else:\\r\\n self.message = struct.pack('!i', len(message)) + message\\r\\n self.status = SEND_ANSWER\\r\\n self.wake_up()\",\n \"def wait(self):\\n return self.bot_client.send_command(_Command.Wait)\",\n \"def request() -> None:\\n\\t_flag.set()\",\n \"def manage_client(request, conn):\\n try:\\n response_msg = assemble_response(request)\\n except RequestError as ex:\\n response_msg = response_error(*ex.args)\\n except IOError:\\n response_msg = response_error(404, \\\"File Not Found\\\")\\n except OSError:\\n response_msg = response_error(404, \\\"File Not Found\\\")\\n finally:\\n try:\\n conn.sendall(response_msg)\\n except NameError:\\n pass\",\n \"def wait_till_read_out():\\n\\n\\trespond = send_command('waitreadout')\",\n \"def wait_for_response(self, request_id):\\n url = \\\"{}/{}/{}\\\".format(self.url, self.url_dir, request_id)\\n while True:\\n response = requests.get(url)\\n if response.text == \\\"done\\\\n\\\":\\n return\",\n \"def _sendingCommand(self): \\n\\n while True:\\n self.tello.send_command('command') \\n time.sleep(5)\",\n \"def handle(self, name, request, response):\\n self._acquire() # prevent other calls to protect data structs\\n try:\\n pool, requests, ready = self._lists\\n # queue request\\n requests.append((name, request, response))\\n if ready:\\n # If any threads are ready and waiting for work\\n # then remove one of the locks from the ready pool\\n # and release it, letting the waiting thread go forward\\n # and consume the request\\n ready.pop().release()\\n\\n finally:\\n self._release()\",\n \"def handle(self) -> None:\\r\\n\\r\\n if self.data.get(\\\"message-id\\\") != None:\\r\\n if self.data[\\\"status\\\"] == \\\"error\\\":\\r\\n print(self.data[\\\"error\\\"])\\r\\n return\\r\\n else:\\r\\n requestData = self.obs.pendingResponses.pop(self.data[\\\"message-id\\\"])\\r\\n request = requestData[\\\"request-type\\\"]\\r\\n #Requests as of version 4.8.0\\r\\n\\r\\n #General\\r\\n if request == \\\"GetVersion\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetAuthRequired\\\":\\r\\n if self.data[\\\"authRequired\\\"]:\\r\\n secret_string: str = self.obs.password + self.data[\\\"salt\\\"]\\r\\n secret_hash: sha256 = sha256(secret_string.encode(\\\"utf-8\\\"))\\r\\n secret: bytes = b64encode(secret_hash.digest())\\r\\n\\r\\n response_string: str = secret.decode(\\\"utf-8\\\") + self.data[\\\"challenge\\\"]\\r\\n response_hash: sha256 = sha256(response_string.encode(\\\"utf-8\\\"))\\r\\n response: bytes = b64encode(response_hash.digest())\\r\\n\\r\\n self.obs.requests.append({\\r\\n \\\"type\\\": \\\"Authenticate\\\",\\r\\n \\\"auth\\\": response.decode(\\\"utf-8\\\")})\\r\\n\\r\\n else:\\r\\n self.obs.requests.append({\\\"type\\\": \\\"GetSceneList\\\"})\\r\\n\\r\\n elif request == \\\"Authenticate\\\":\\r\\n self.obs.requests.append({\\\"type\\\": \\\"GetSceneList\\\"})\\r\\n\\r\\n elif request == \\\"SetHeartbeat\\\":\\r\\n #To be removed in 5.0.0\\r\\n pass\\r\\n\\r\\n elif request == \\\"SetFilenameFormatting\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetFilenameFormatting\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetStats\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"BroadcastCustomMessage\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetVideoInfo\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"OpenProjector\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"TriggerHotkeyByName\\\":\\r\\n #Unreleased\\r\\n pass\\r\\n\\r\\n elif request == \\\"TriggerHotkeyBySequence\\\":\\r\\n #Unreleased\\r\\n pass\\r\\n\\r\\n #Media Control\\r\\n elif request == \\\"PlayPauseMedia\\\":\\r\\n #Unreleased\\r\\n pass\\r\\n\\r\\n elif request == \\\"RestartMedia\\\":\\r\\n #Unreleased\\r\\n pass\\r\\n\\r\\n elif request == \\\"StopMedia\\\":\\r\\n #Unreleased\\r\\n pass\\r\\n\\r\\n elif request == \\\"NextMedia\\\":\\r\\n #Unreleased\\r\\n pass\\r\\n\\r\\n elif request == \\\"PreviousMedia\\\":\\r\\n #Unreleased\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetMediaDuration\\\":\\r\\n #Unreleased\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetMediaTime\\\":\\r\\n #Unreleased\\r\\n pass\\r\\n\\r\\n elif request == \\\"SetMediaTime\\\":\\r\\n #Unreleased\\r\\n pass\\r\\n\\r\\n elif request == \\\"ScrubMedia\\\":\\r\\n #Unreleased\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetMediaState\\\":\\r\\n #Unreleased\\r\\n pass\\r\\n\\r\\n #Sources\\r\\n\\r\\n elif request == \\\"GetMediaSourcesList\\\":\\r\\n #Unreleased\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetSourcesList\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetSourceTypesList\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetVolume\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"SetVolume\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetMute\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"SetMute\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"ToggleMute\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetAudioActive\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"SetSourceName\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"SetSyncOffset\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetSyncOffset\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetSourceSettings\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"SetSourceSettings\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetTextGDIPlusProperties\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"SetTextGDIPlusProperties\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetTextFreetype2Properties\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"SetTextFreetype2Properties\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetBrowserSourceProperties\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"SetBrowserSourceProperties\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetSpecialSources\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetSourceFilters\\\":\\r\\n source = self.obs.getSource(requestData[\\\"sourceName\\\"])\\r\\n if source != None:\\r\\n for _filter in self.data[\\\"filters\\\"]:\\r\\n source.addFilter(_filter) #type: ignore\\r\\n\\r\\n elif request == \\\"GetSourceFilterInfo\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"AddFilterToSource\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"RemoveFilterFromSource\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"ReorderSourceFilter\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"MoveSourceFilter\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"SetSourceFilterSettings\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"SetSourceFilterVisibility\\\":\\r\\n pass\\r\\n \\r\\n elif request == \\\"GetAudioMonitorType\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"SetAudioMonitorType\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"TakeSourceScreenshot\\\":\\r\\n pass\\r\\n\\r\\n #Outpute\\r\\n elif request == \\\"ListOutputs\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetOutputInfo\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"StartOutput\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"StopOutput\\\":\\r\\n pass\\r\\n\\r\\n #Profiles\\r\\n elif request == \\\"SetCurrentProfile\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetCurrentProfile\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"ListProfiles\\\":\\r\\n pass\\r\\n\\r\\n #Recording\\r\\n elif request == \\\"GetRecordingStatus\\\":\\r\\n #Unreleased\\r\\n pass\\r\\n\\r\\n elif request == \\\"StartStopRecording\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"StartRecording\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"StopRecording\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"PauseRecording\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"ResumeRecording\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"SetRecordingFolder\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetRecordingFolder\\\":\\r\\n pass\\r\\n\\r\\n #Replay Buffer\\r\\n elif request == \\\"GetReplayBufferStatus\\\":\\r\\n #Unreleased\\r\\n pass\\r\\n\\r\\n elif request == \\\"StartStopReplayBuffer\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"StartReplayBuffer\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"StopReplayBuffer\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"SaveReplayBuffer\\\":\\r\\n pass\\r\\n\\r\\n #Scene Collections\\r\\n elif request == \\\"SetCurrentSceneCollection\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetCurrentSceneCollection\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"ListSceneCollections\\\":\\r\\n pass\\r\\n\\r\\n #Scene Items\\r\\n elif request == \\\"GetSceneItemList\\\":\\r\\n #Unreleased\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetSceneItemProperties\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"SetSceneItemProperties\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"ResetSceneItem\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"SetSceneItemRender\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"SetSceneItemPosition\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"SetSceneItemTransform\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"SetSceneItemCrop\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"DeleteSceneItem\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"AddSceneItem\\\":\\r\\n #Unreleased\\r\\n pass\\r\\n\\r\\n elif request == \\\"DuplicateSceneItem\\\":\\r\\n pass\\r\\n\\r\\n #Scenes\\r\\n elif request == \\\"SetCurrentScene\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetCurrentScene\\\":\\r\\n self.obs.setCurrentScene(self.data[\\\"name\\\"])\\r\\n\\r\\n elif request == \\\"GetSceneList\\\":\\r\\n for scene in self.data[\\\"scenes\\\"]:\\r\\n self.obs.addScene(scene)\\r\\n self.obs.setCurrentScene(self.data[\\\"current-scene\\\"])\\r\\n\\r\\n elif request == \\\"CreateScene\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"ReorderSceneItems\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"SetSceneTransitionOverride\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"RemoveSceneTransitionOverride\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetSceneTransitionOverride\\\":\\r\\n pass\\r\\n\\r\\n #Streaming\\r\\n elif request == \\\"GetStreamingStatus\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"StartStopStreaming\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"StartStreaming\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"StopStreaming\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"SetStreamSettings\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetStreamSettings\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"SaveStreamSettings\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"SendCaptions\\\":\\r\\n pass\\r\\n\\r\\n #Studio Mode\\r\\n elif request == \\\"GetStudioModeStatus\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetPreviewScene\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"SetPreviewScene\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"TransitionToProgram\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"EnableStudioMode\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"DisableStudioMode\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"ToggleStudioMode\\\":\\r\\n pass\\r\\n\\r\\n #Transitions\\r\\n elif request == \\\"GetTransitionList\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetCurrentTransition\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"SetCurrentTransition\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"SetTransitionDuration\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetTransitionDuration\\\":\\r\\n pass\\r\\n\\r\\n elif request == \\\"GetTransitionPosition\\\":\\r\\n pass\\r\\n\\r\\n else:\\r\\n print(f\\\"Unhandled response of type {request} and data {self.data}.\\\")\\r\\n\\r\\n \\r\\n\\r\\n else:\\r\\n event: str = self.data[\\\"update-type\\\"]\\r\\n #Events as of 4.8.0\\r\\n\\r\\n #Scenes\\r\\n if event == \\\"SwitchScenes\\\":\\r\\n self.obs.setCurrentScene(self.data[\\\"scene-name\\\"])\\r\\n\\r\\n elif event == \\\"ScenesChanged\\\":\\r\\n #self.obs.purgeScenes()\\r\\n pass\\r\\n\\r\\n elif event == \\\"SceneCollectionChanged\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"SceneCollectionListChanged\\\":\\r\\n pass\\r\\n\\r\\n #Transitions\\r\\n elif event == \\\"SwitchTransition\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"TransitionListChanged\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"TransitionDurationChanged\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"TransitionBegin\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"TransitionEnd\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"TransitionVideoEnd\\\":\\r\\n pass\\r\\n\\r\\n #Profiles\\r\\n elif event == \\\"ProfileChanged\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"ProfileListChanged\\\":\\r\\n pass\\r\\n\\r\\n #Streaming\\r\\n elif event == \\\"StreamStarting\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"StreamStarted\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"StreamStopping\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"StreamStopped\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"StreamStatus\\\":\\r\\n pass\\r\\n\\r\\n #Recording\\r\\n elif event == \\\"RecordingStarting\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"RecordingStarted\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"RecordingStopping\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"RecordingStopped\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"RecordingPaused\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"RecordingResumed\\\":\\r\\n pass\\r\\n\\r\\n #Replay Buffer\\r\\n elif event == \\\"ReplayStarting\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"ReplayStarted\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"ReplayStopping\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"ReplayStopped\\\":\\r\\n pass\\r\\n\\r\\n #Other\\r\\n elif event == \\\"Exiting\\\":\\r\\n pass\\r\\n\\r\\n #General\\r\\n elif event == \\\"Heartbeat\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"BroadcastCustomMessage\\\":\\r\\n pass\\r\\n\\r\\n #Sources\\r\\n elif event == \\\"SourceCreated\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"SourceDestroyed\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"SourceVolumeChanged\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"SourceMuteStateChanged\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"SourceAudioDeactivated\\\":\\r\\n #Unreleased\\r\\n pass\\r\\n\\r\\n elif event == \\\"SourceAudioActivated\\\":\\r\\n #Unreleased\\r\\n pass\\r\\n\\r\\n elif event == \\\"SourceAudioSyncOffsetChanged\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"SourceAudioMixersChanged\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"SourceRenamed\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"SourceFilterAdded\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"SourceFilterRemoved\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"SourceFilterVisibilityChanged\\\":\\r\\n source = self.obs.getSource(self.data[\\\"sourceName\\\"])\\r\\n if source != None:\\r\\n _filter = source.getFilter(self.data[\\\"filterName\\\"]) #type: ignore\\r\\n if _filter != None:\\r\\n _filter.setVisible(self.data[\\\"filterEnabled\\\"]) #type: ignore\\r\\n\\r\\n elif event == \\\"SourceFiltersReordered\\\":\\r\\n pass\\r\\n\\r\\n #Media\\r\\n elif event == \\\"MediaPlaying\\\":\\r\\n #Unreleased\\r\\n pass\\r\\n\\r\\n elif event == \\\"MediaPaused\\\":\\r\\n #Unreleased\\r\\n pass\\r\\n\\r\\n elif event == \\\"MediaRestarted\\\":\\r\\n #Unreleased\\r\\n pass\\r\\n\\r\\n elif event == \\\"MediaStopped\\\":\\r\\n #Unreleased\\r\\n pass\\r\\n\\r\\n elif event == \\\"MediaNext\\\":\\r\\n #Unreleased\\r\\n pass\\r\\n\\r\\n elif event == \\\"MediaPrevious\\\":\\r\\n #Unreleased\\r\\n pass\\r\\n\\r\\n elif event == \\\"MediaStarted\\\":\\r\\n #Unreleased\\r\\n pass\\r\\n\\r\\n elif event == \\\"MediaEnded\\\":\\r\\n #Unreleased\\r\\n pass\\r\\n\\r\\n #Scene Items\\r\\n elif event == \\\"SceneItemOrderChanged\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"SceneItemAdded\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"SceneItemRemoved\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"SceneItemVisibilityChanged\\\":\\r\\n scene = self.obs.getScene(self.data[\\\"scene-name\\\"])\\r\\n if scene != None:\\r\\n source = scene.getSource(self.data[\\\"item-name\\\"]) #type: ignore\\r\\n if source != None:\\r\\n source.setVisible(self.data[\\\"item-visible\\\"]) #type: ignore\\r\\n \\r\\n\\r\\n elif event == \\\"SceneItemLockChanged\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"SceneItemTransformChanged\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"SceneItemSelected\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"SceneItemDeselected\\\":\\r\\n pass\\r\\n\\r\\n #Studio Mode\\r\\n elif event == \\\"PreviewSceneChanged\\\":\\r\\n pass\\r\\n\\r\\n elif event == \\\"StudioModeSwitched\\\":\\r\\n pass\\r\\n\\r\\n #Unhandled Events\\r\\n else:\\r\\n print(\\\"Unhandled event with data: \\\" + str(self.data))\",\n \"def run(self):\\n # client -> server\\n self.client.send_message(\\n new_order_message(self.client,\\n symbol='abc',\\n side='0',\\n order_type='1',\\n extra_tags=[(38, 100), # orderQty\\n (44, 10), ])) # price\\n\\n # server <- client\\n message = self.server.wait_for_message('waiting for new order')\\n assert_is_not_none(message)\\n\\n # server -> client\\n self.server.send_message(\\n execution_report(self.server,\\n message,\\n exec_trans_type='0',\\n exec_type='0',\\n ord_status='0',\\n symbol='abc',\\n side='0',\\n leaves_qty='100',\\n cum_qty='0',\\n avg_px='0'))\\n\\n # client <- server\\n message = self.client.wait_for_message('waiting for new order ack')\\n assert_is_not_none(message)\",\n \"def _run(self):\\n\\n self.sendStatus(C.MSG_PROBE, 'Detecting Management Interface')\\n\\n data = self.getData()\\n host = data.p.host\\n for params in data.p.interfacesList:\\n port = params['port']\\n interfaceHref = params['interfaceHref']\\n self.sendStatus(C.MSG_PROBE, 'Checking %s:%s' % (host, port))\\n if self._queryService(host, port):\\n self._sendResponse(data, interfaceHref, port)\\n self.sendStatus(C.OK, 'Found management interface on %s:%s'\\n % (host, port))\\n return\\n\\n self._sendResponse(data)\\n self.sendStatus(C.OK_1, 'No management interface discovered')\",\n \"def _request(self, *args):\\n self._silent_request(*args)\\n return self._get_response()\",\n \"def process_request(t):\\n time.sleep(t)\",\n \"def process_request(t):\\n time.sleep(t)\",\n \"def process_request(t):\\n time.sleep(t)\",\n \"def send_command(self, cmd):\\n\\n\\t\\tself.eyetribe._connection.request(cmd)\",\n \"def send_request_if_needed(self, request, relations):\\n if self.is_request_sent(request, relations):\\n logging.debug('Request already sent, not sending new request')\\n else:\\n for relation in relations:\\n logging.debug('Sending request {}'.format(request.request_id))\\n relation.data[self.this_unit]['broker_req'] = request.request\",\n \"def _response_success(self, msg, msgID):\\r\\n if not self._status:\\r\\n # Can not help it if the response takes some time and in the mean\\r\\n # time the interface is disabled; therefore, don't raise an error\\r\\n # instead just skip sending the response\\r\\n return\\r\\n\\r\\n self._conn.sendMessage(self._iTag, self._clsName, msg, msgID)\",\n \"def answer_waiting_call(self) -> None:\",\n \"def testSetRequest(self):\\n self.mgr.sendGoProCommand = Mock()\\n value = struct.pack('<HH', 8, 22)\\n self.mgr.handlePacket(app_packet.GOPRO_SET_REQUEST, value)\\n self.mgr.sendGoProCommand.assert_called_with( 8, (22, 0, 0, 0) )\",\n \"def _send_command(self, cmd, wait_msg=None):\\n try:\\n if not (self.sock_thr and self.sock_thr.is_active()):\\n if cmd not in (TSMessage.STOP, TSMessage.SHUTDOWN):\\n self._createThread()\\n else:\\n return\\n # Waiting message if need\\n log.d('>> \\\"{0}\\\"'.format(cmd))\\n if wait_msg:\\n with self.waiting.lock:\\n log.d('wait message: {0}'.format(wait_msg))\\n try:\\n self.waiting.msg = wait_msg\\n self.waiting.event.clear()\\n self.waiting.abort.clear()\\n self.sock.send(to_bytes(cmd + '\\\\r\\\\n'))\\n for t in range(AcePlayer.TIMEOUT_FREEZE * 3): # @UnusedVariable\\n log.d(\\\"waiting message {msg} ({t})\\\".format(msg=wait_msg, t=t))\\n if not self.waiting.msg or self.sock_thr.error or defines.isCancel():\\n raise ValueError('Abort waiting message: \\\"{0}\\\"'.format(wait_msg))\\n if self.waiting.wait(1):\\n return self.waiting.msg\\n\\n self.parent.showStatus(\\\"Ошибка ожидания. Операция прервана\\\")\\n raise ValueError('AceEngine is freeze')\\n\\n except Exception as e:\\n log.e('_wait_message error: {0}'.format(uni(e)))\\n self.waiting.msg = None\\n if not Flags.manual_stopped.is_set():\\n self.autoStop()\\n return\\n\\n else:\\n self.sock.send(to_bytes(cmd + '\\\\r\\\\n'))\\n return True\\n\\n except Exception as e:\\n log.e('_send_command error: \\\"{0}\\\" cmd: \\\"{1}\\\"'.format(uni(e), cmd))\\n\\n if self.sock_thr and self.sock_thr.is_active():\\n self.sock_thr.end()\",\n \"def wait(t):\\n message = \\\"WAIT:\\\" + str(t) + '\\\\n'\\n sock.sendall(message)\\n time.sleep(t)\\n return\",\n \"def send_message(self, sender, to, text, callback=None):\\n url = self.assamble_url(sender, to, text)\\n logging.debug('Requesting Nexmo service: ' + url)\\n request = HTTPRequest(url=url, method='GET')\\n\\n # Define response callback.\\n def handle_request(response):\\n if response.error:\\n logging.warning(\\\"Request failed: \\\" + str(response.error))\\n if callback:\\n callback(False)\\n return\\n\\n try:\\n json_response = json.loads(response.body)\\n except ValueError as exc:\\n logging.error(\\\"response was not json\\\", exc_info=1)\\n callback(False)\\n return\\n\\n message_was_send = []\\n try:\\n for message in json_response['messages']:\\n if message['status'] != \\\"0\\\":\\n message_was_send.append(False)\\n else:\\n message_was_send.append(True)\\n\\n if len(message_was_send) > 1:\\n logging.warn(\\\"message was sent as multipart in {} parts\\\".format(len(message_was_send)))\\n\\n if not all(message_was_send):\\n logging.error(\\\"sending of {} messages failed. Error message: {}\\\".format(len(filter(lambda x: x is False, message_was_send)), json_response))\\n callback(False)\\n return\\n\\n except ValueError:\\n logging.error(\\\"response is unexpected\\\", exc_info=True)\\n callback(False)\\n return\\n callback(True)\\n\\n if self.development_mode:\\n # in development mode no requests are send everything is a (huge) success\\n callback(True)\\n else:\\n self.http_client.fetch(request, handle_request)\",\n \"def _run(self):\\n self.running = True\\n\\n while self.running:\\n try:\\n print \\\"Response monitor running...\\\"\\n\\n # Get the message count\\n messageCount = self.scHandle.amazonSQSManager.getQueueCount(self.scHandle.amazonSQSManager.responsesQueue)\\n\\n print '%i messages in queue...' % messageCount\\n\\n # Read a response\\n response = self.scHandle.responseManager.getResponseFromResponsesQueue()\\n\\n # TODO: Do something with the response\\n if response:\\n print(response)\\n\\n except Exception, responseMonitorException:\\n print \\\"Response monitor failed with exception %s.\\\" % str(responseMonitorException)\\n\\n finally:\\n # Wait for a bit\\n sleep(self.PAUSE_TIME)\",\n \"def __call__(self, get_response, request):\\n response = self._behaviour(get_response, request)\\n sleep(self._seconds)\\n return response\",\n \"def handle_response(self, response):\\n with self.lock:\\n req_id, status, message = response\\n if req_id in self.pending_requests: # request may have timed out\\n self.pending_requests[req_id].set((status, message))\",\n \"def send(msg):\\n r = \\\"No response\\\"\\n try:\\n r = requests.post(\\\"http://127.0.0.1:8000\\\", data=msg)\\n except:\\n pass\\n #print(r.status_code, r.reason)\\n print(r.text[:300] + '...')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6157053","0.611986","0.59369206","0.5933973","0.5905822","0.5852787","0.58384734","0.5809734","0.5773247","0.5763428","0.5689041","0.5659244","0.5653349","0.5627476","0.559565","0.5584633","0.5567643","0.55364376","0.55341464","0.55341464","0.55341464","0.55341464","0.55341464","0.55341464","0.55341464","0.55341464","0.55341464","0.55341464","0.55341464","0.55341464","0.55341464","0.55341464","0.55341464","0.55341464","0.55341464","0.55341464","0.55341464","0.55341464","0.55341464","0.55341464","0.55341464","0.55341464","0.55341464","0.55341464","0.55341464","0.55341464","0.54958874","0.54627806","0.54370064","0.54338825","0.54331553","0.5431339","0.54274833","0.5417148","0.54137754","0.54112816","0.54073495","0.53913385","0.5382631","0.5368228","0.5367012","0.5365171","0.5360565","0.536019","0.5350302","0.53430593","0.5342551","0.5324677","0.5322136","0.5303355","0.5299925","0.529474","0.52904326","0.5261028","0.52538633","0.5247732","0.5246453","0.52432245","0.5237633","0.5237184","0.5223592","0.5222753","0.5215861","0.5214341","0.52069056","0.5196541","0.5194461","0.5194461","0.5194461","0.51797134","0.51732635","0.5167654","0.51566356","0.5156425","0.5153519","0.5150078","0.51467806","0.51400757","0.51399696","0.51344126","0.51328677"],"string":"[\n \"0.6157053\",\n \"0.611986\",\n \"0.59369206\",\n \"0.5933973\",\n \"0.5905822\",\n \"0.5852787\",\n \"0.58384734\",\n \"0.5809734\",\n \"0.5773247\",\n \"0.5763428\",\n \"0.5689041\",\n \"0.5659244\",\n \"0.5653349\",\n \"0.5627476\",\n \"0.559565\",\n \"0.5584633\",\n \"0.5567643\",\n \"0.55364376\",\n \"0.55341464\",\n \"0.55341464\",\n \"0.55341464\",\n \"0.55341464\",\n \"0.55341464\",\n \"0.55341464\",\n \"0.55341464\",\n \"0.55341464\",\n \"0.55341464\",\n \"0.55341464\",\n \"0.55341464\",\n \"0.55341464\",\n \"0.55341464\",\n \"0.55341464\",\n \"0.55341464\",\n \"0.55341464\",\n \"0.55341464\",\n \"0.55341464\",\n \"0.55341464\",\n \"0.55341464\",\n \"0.55341464\",\n \"0.55341464\",\n \"0.55341464\",\n \"0.55341464\",\n \"0.55341464\",\n \"0.55341464\",\n \"0.55341464\",\n \"0.55341464\",\n \"0.54958874\",\n \"0.54627806\",\n \"0.54370064\",\n \"0.54338825\",\n \"0.54331553\",\n \"0.5431339\",\n \"0.54274833\",\n \"0.5417148\",\n \"0.54137754\",\n \"0.54112816\",\n \"0.54073495\",\n \"0.53913385\",\n \"0.5382631\",\n \"0.5368228\",\n \"0.5367012\",\n \"0.5365171\",\n \"0.5360565\",\n \"0.536019\",\n \"0.5350302\",\n \"0.53430593\",\n \"0.5342551\",\n \"0.5324677\",\n \"0.5322136\",\n \"0.5303355\",\n \"0.5299925\",\n \"0.529474\",\n \"0.52904326\",\n \"0.5261028\",\n \"0.52538633\",\n \"0.5247732\",\n \"0.5246453\",\n \"0.52432245\",\n \"0.5237633\",\n \"0.5237184\",\n \"0.5223592\",\n \"0.5222753\",\n \"0.5215861\",\n \"0.5214341\",\n \"0.52069056\",\n \"0.5196541\",\n \"0.5194461\",\n \"0.5194461\",\n \"0.5194461\",\n \"0.51797134\",\n \"0.51732635\",\n \"0.5167654\",\n \"0.51566356\",\n \"0.5156425\",\n \"0.5153519\",\n \"0.5150078\",\n \"0.51467806\",\n \"0.51400757\",\n \"0.51399696\",\n \"0.51344126\",\n \"0.51328677\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":81999,"cells":{"query":{"kind":"string","value":"Return an iterator that yields a dictionary for each result."},"document":{"kind":"string","value":"def iter_dicts(self, clean=False):\n for r in self.results:\n if clean:\n yield clean_dict(zip(self.attribute_names, r))\n else:\n yield dict(zip(self.attribute_names, r))"},"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 iter_dict(self):\n\n itr = iter(self)\n\n headers = next(itr)\n\n for row in itr:\n yield dict(zip(headers, row))","def __iter__(self) -> iter:\n return iter(self._dict)","def __iter__(self):\n for key, value in self.read():\n yield key, value","def process_response(self, response: Dict) -> Iterator[dict]:","def __iter__(self):\n for value in self.__dict__.values():\n yield value","def iterresults(self, essid):\n for key in self.iterkeys(essid):\n yield self[essid, key]","def __iter__(self):\n\n for each in list(self.keys()):\n yield each","def __iter__(self):\n return iter({})","def __iter__(self):\n\n # For each key in set of keys\n for key in self.keys_set:\n\n # Yield that key and associated value\n yield key, self.__getitem__(key)","def __iter__(self):\n for instresult in self.instresults:\n yield instresult","def iteritems(self):\n return DictItemsIterator(self)","def __iter__(self):\n # Return an iterator for the keys in the underlying dictionary.\n return iter(self.data)","def iteritems(self):\n def make_iter(self=self):\n keys = self.iterkeys()\n while True:\n key = keys.next()\n yield (key, self[key])\n return make_iter()","def __iter__(self):\n self._fetch_all()\n return iter(self._result_cache)","def __iter__(self):\r\n for item in self._data:\r\n yield item # yield the KEY\r","def itervalues(self):\n return DictValuesIterator(self)","def iterator(self):\n yield","def __iter__(self) -> Generator:\n for k in self.raw.keys():\n yield k","def iterentries(self):\n for key in self.iterkeys():\n yield self.get(key)","def __iter__(self):\n for acronym in self.keys:\n yield acronym, self.dict[acronym]","def __iter__(self):\n yield from chain.from_iterable(self.data.values())","def __iter__(self):\n key = list(self.keys())[0]\n length = len(self[key])\n for i in range(length):\n res = {}\n for key, feature in self.items():\n res[key] = feature.data[feature.name][i]\n yield res","def itervalues(self):\n def make_iter(self=self):\n keys = self.iterkeys()\n while True:\n yield self[keys.next()]\n return make_iter()","def __iter__(self):\n return iter(self.keys())","def iteritems(self):\n for key in self:\n yield key, self[key]","def __iter__(self):\n\n return iter([key for key in self._data.keys()])","def iteritems(self):\r\n for wr, value in self.data.iteritems():\r\n key = wr()\r\n if key is not None:\r\n yield key, value","def iteritems(self):\r\n for wr, value in self.data.iteritems():\r\n key = wr()\r\n if key is not None:\r\n yield key, value","def __iter__(self):\n for mapping in self._mappings.values():\n yield mapping","def __iter__(self):\n for v in self._items:\n yield v","def itervalues(self):\n for key in self:\n yield self[key]","def __iter__(self):\n cursor=0\n while cursor<len(self):\n yield self._item[cursor].key\n cursor+=1","def iteritems(self):\n for key in self:\n yield (key, self[key])","def __iter__(self):\n prefix = len(META_NS) + 2\n for key, value in self.stats.items():\n yield (key[prefix:-6], int(value))","def __iter__(self):\n return self._data_dict.__iter__()","def iteritems(self):\n return iter((kvp.key, kvp.value) for kvp in self.keyvaluepair_set.all())","def __iter__(self, *args, **kwargs):\n for key in self.keys(*args, **kwargs):\n yield key","def __iter__(self):\n for value in dict.__iter__(self):\n for count in range(self[value]):\n yield value","def __iter__(self):\n cursor = self._connection.cursor()\n cursor.execute('SELECT * FROM ' + self._table)\n\n column_names = self.columns()\n dict_row = lambda x: dict(zip(column_names, x))\n return (dict_row(row) for row in cursor.fetchall())","def __iter__(self):\n cursor = self._connection.cursor()\n cursor.execute('SELECT * FROM ' + self._table)\n\n column_names = self.columns()\n dict_row = lambda x: dict(zip(column_names, x))\n return (dict_row(row) for row in cursor.fetchall())","def __iter__(self):\n for datum in self.data[self.name]:\n yield datum","def iterkeys(self):\r\n for wr in self.data.iterkeys():\r\n obj = wr()\r\n if obj is not None:\r\n yield obj","def iterkeys(self):\r\n for wr in self.data.iterkeys():\r\n obj = wr()\r\n if obj is not None:\r\n yield obj","def _chain_map_iter(self):\n d = {}\n for mapping in reversed(self.maps):\n d.update(mapping) # reuses stored hash values if possible\n return iter(d)","def __iter__(self):\n for key in sorted(self.keys):\n yield key, self[key]","def __iter__(self) -> Tuple[str, Any]:\n for attr_name, attr_val in self.__dict__.items():\n yield attr_name, attr_val","def __iter__(self):\n for domain in self.keys():\n yield domain","def __iter__(self):\n\n result = []\n\n # d - dict, p - path (keys sequence)\n def recurs_iter(d, p=None):\n p = p or []\n\n # k - key, v - value\n for k, v in iteritems(d):\n next_p = p + [k]\n if isinstance(v, dict):\n recurs_iter(v, next_p)\n else:\n result.append(tuple(next_p))\n\n recurs_iter(self.__dict__)\n\n return iter(result)","def __iter__(self):\r\n results = ResultSet.__iter__(self)\r\n while results:\r\n for obj in results:\r\n yield obj\r\n if self.is_truncated:\r\n self.is_truncated = False\r\n results = self.connection.get_all_rrsets(self.hosted_zone_id, name=self.next_record_name, type=self.next_record_type)\r\n else:\r\n results = None","def __iter__(self):\n for line in self._fp:\n row = line.decode(\"utf-8\").split(\"\\t\")\n yield row[1], row[2], row[3], json.loads(row[4])['weight']","def __iter__(self):\n return dict(self.parameters)","def _get_raw_extract_iter(self) -> Iterable[Dict[str, Any]]:\n rows = self.alchemy_helper.execute_query()\n for row in rows:\n yield row","def inner_generator():\n # A buffer where observed query-document features will be stored.\n # It is a list of dictionaries, one per query-document pair, where\n # each dictionary is a mapping from a feature ID to a feature value.\n for p in processed:\n yield p","def __iter__(\n self,\n ) -> Generator[dict[str, str | int | bool | list[dict[str, str]]], None, None]:\n url = API_PATH[\"user_flair\"].format(subreddit=self.subreddit)\n params = {\"unique\": self.subreddit._reddit._next_unique}\n yield from self.subreddit._reddit.get(url, params=params)","def __iter__(self):\n for item in self._reader:\n yield item","def _get_raw_extract_iter(self) -> Iterator[Dict[str, Any]]:\n row = self._alchemy_extractor.extract()\n while row:\n yield row\n row = self._alchemy_extractor.extract()","def __iter__(self):\n for r in self.cursor:\n yield r","def __iter__( self ) :\n\n for entry in self.__entries : yield entry","def itervalues(self):\n return iter(kvp.value for kvp in self.keyvaluepair_set.all())","def query(self, q):\n for key in self.metadb.query(q):\n yield key, self.datadb[key]","def process_results_iter(self):\n while self.results: # iteratively process each cue in cues\n msgs = bytearray()\n r = self.results.popleft()\n log.info(\"%s got result: %s\\n\", self.name, r)\n msgs.extend(r[\"result\"])\n yield r[\"label\"], msgs","def __iter__(self):\n items = self._fetch()\n for item in items:\n yield item","def _get_raw_extract_iter(self):\n # type: () -> Iterator[Dict[str, Any]]\n row = self._alchemy_extractor.extract()\n while row:\n yield row\n row = self._alchemy_extractor.extract()","def __iter__(self):\n\t\tfor key, value in self.__dict__.iteritems():\n\t\t\tif key[0] != '_':\n\t\t\t\tyield value","def getItemIter(self):\n for key, raw in self.db.getAllItemIter(db=self.sdb, split=False):\n keys = tuple(key.decode(\"utf-8\").split('.'))\n yield (keys, coring.Serder(raw=bytes(raw)))","def iteritems(self):\n\t\tself.filep.seek(self.start + 2048)\n\n\t\t# iterate until we hit the enddata marker\n\t\twhile self.filep.tell() < self.enddata - 1:\n\t\t\t# fetch the lengths of the key and value\n\t\t\t(klen, vlen) = unpack('<LL', self.filep.read(8))\n\n\t\t\t# yield the key and value as a tuple\n\t\t\tyield (self.filep.read(klen), self.filep.read(vlen))","def __iter__(self):\n for classresult in self.classresults:\n yield classresult","def __iter__(self):\n if self._len_keys == 1:\n yield from self._dict.keys()\n else:\n for key in self._dict.keys():\n yield tuple(sorted(list(key)))","def __iter__(self) -> Generator[Optional[dict], None, None]:\n data_list, response, result = self.retrieve_data(self.url)\n\n if result != GithubApiResult.SUCCESS:\n self.logger.debug(\"Failed to retrieve the data even though 10 attempts were given\")\n yield None\n return\n\n # yield the first page data\n for data in data_list:\n yield data\n\n while 'next' in response.links.keys():\n next_page = response.links['next']['url']\n\n # Here we don't need to pass in params with the page, or the default params because the url from the headers already has those values\n data_list, response, result = self.retrieve_data(next_page)\n\n if result != GithubApiResult.SUCCESS:\n self.logger.debug(\"Failed to retrieve the data even though 10 attempts were given\")\n return\n\n for data in data_list:\n yield data","def iterkeys(self):\n return DictKeysIterator(self)","def __iter__(self):\n for key in self._ctx:\n yield key","def Iterator():\n return _table.Iterator()","def __next__(self):\n for (k, v) in pairs(self._data):\n yield (v, k)","def iterate_results(results, extract_fn):\n outputs = {}\n for environment, environment_results in results.items():\n if environment not in outputs:\n outputs[environment] = {}\n for experimental_setting, setting_results in environment_results.items():\n outputs[environment][experimental_setting] = []\n for config, seeds_results in setting_results.items():\n for seed, actual_results in seeds_results.items():\n output = extract_fn(actual_results)\n outputs[environment][experimental_setting].append(output)\n outputs[environment][experimental_setting] = np.array(outputs[environment][experimental_setting])\n return outputs","def __next__(self) -> dict:\n batches = {}\n terminations = 0\n for iterator in self.iterators:\n \n try:\n data, target = next(iterator)\n batches[data.location] = (data, target)\n\n except (TypeError, AttributeError) as e:\n logging.warning(f\"Dangling pointer detected! Skipping operation... Error: {e}\")\n \n except StopIteration:\n terminations += 1\n\n # Every cached iterator has been iterated through completely\n if terminations == len(self.iterators):\n raise StopIteration\n\n return batches","def result_generator(results, metadata):\n try:\n yield '{\"result\": [\\n'\n for line in interleave(['\\n, '], results):\n yield line\n yield '\\n],\\n'\n yield '\"metadata\": {0},\\n'.format(json.dumps(metadata()))\n yield '\"status\": \"success\"}\\n'\n except Exception:\n exc = traceback.format_exc()\n yield '---\\n'\n yield exc","def itervalues(self, multi=False):\n for k, v in self.iteritems(multi=multi):\n yield v","def __iter__(self):\n\t\treturn self.keys()","def __iter__(self):\n for itm in self._user_data:\n yield itm","def json_imap(mapping, iterable):\n for item in iterable:\n yield scraper.json_map(mapping, item)","def classIterator(classIter):\n for attribute, value in classIter.__dict__.iteritems():\n yield attribute, value","def getItemIter(self):\n for key, val in self.db.getAllItemIter(db=self.sdb, split=False):\n keys = tuple(key.decode(\"utf-8\").split('.'))\n yield (keys, self.klas(qb64b=bytes(val)))","def __iter__(self):\n if self.use_dic:\n for data in sorted(self.dic):\n self.data = data\n for activity in sorted(self.dic[data]):\n self.activity = activity\n for imsize in sorted(self.dic[data][activity]):\n self.imsize = imsize\n self.allimgs, self.alllabels = [], []\n for img in sorted(self.dic[data][activity][imsize]):\n self.img = img\n self.labels = self.dic[data][activity][imsize][img]\n if self.imlist:\n self.allimgs.append(self.img)\n self.alllabels.append(self.labels)\n else:\n yield data, activity, imsize, img, self.labels\n self.i += 1\n if self.imlist:\n yield data, activity, imsize, self.allimgs, self.alllabels\n self.i += 1\n else:\n for data in sorted(self.dic):\n self.img = data\n self.labels = self.dic[data]\n yield self.img, self.labels\n self.i += 1","def iter_serp_items(self):\n\n for key, value in self.search_results.items():\n if isinstance(value, list):\n for i, item in enumerate(value):\n if isinstance(item, dict) and item['link']:\n yield (key, i)","def iteroriginal(self):\n for key in self:\n vals = _dict_getitem(self, key)\n for val in vals[1:]:\n yield vals[0], val","def __iter__(self):\n yield from self._type_keys","def __iter__(self):\n cursor = 0\n while cursor < len(self):\n yield self._items[cursor]\n cursor += 1","def __iter__(self):\n for o in self._iter:\n yield o","def __iter__(self):\n for x in sorted(self.keys()):\n yield self[x]","def __iter__(self):\n while self.has_next_page():\n response = self.get_next_page_response()\n for item in self.get_items_from_response(response):\n yield item","def __iter__(self):\n for hit in self._evaluate()['hits']['hits']:\n yield self._to_document(hit)","def __iter__(self):\n\n return self._entries.__iter__()","def itervalues(self, *args, **kwargs):\n for key in self.iterkeys():\n yield self._get(key, *args, **kwargs)","def __iter__(self):\n for bucket in self._table:\n if bucket is not None:\n for key in bucket:\n yield key","def table_generator( db, query):\n db.query(query)\n result = db.store_result()\n done = False\n while not done:\n row = result.fetch_row(1,1)\n done = len(row) == 0\n if not done:\n (dict,) = row\n yield Row(SimpleDictGenerator(dict))","def default_iterator(mapping):\n return getattr(mapping, 'iteritems', mapping.items)()","def __iter__(self) -> Iterator[object]:\n return iter(\n list(self._new.values()) + list(self.identity_map.values())\n )","def __iter__(self) -> Iterator[str]:\n return iter(self._keys)","def _get_iter(self, url, params):\n for current_page_index in itertools.count():\n result_dict = self._get_page(url, params, current_page_index)\n for document in result_dict['entries']:\n yield document\n if not result_dict['isNextPageAvailable']:\n break","async def next(self):\n if not self.has_next():\n raise IteratorExhausted()\n value = await self._source.next()\n if self._values is None:\n return value\n return {k: v for k, v in value.items() if k in self._values}"],"string":"[\n \"def iter_dict(self):\\n\\n itr = iter(self)\\n\\n headers = next(itr)\\n\\n for row in itr:\\n yield dict(zip(headers, row))\",\n \"def __iter__(self) -> iter:\\n return iter(self._dict)\",\n \"def __iter__(self):\\n for key, value in self.read():\\n yield key, value\",\n \"def process_response(self, response: Dict) -> Iterator[dict]:\",\n \"def __iter__(self):\\n for value in self.__dict__.values():\\n yield value\",\n \"def iterresults(self, essid):\\n for key in self.iterkeys(essid):\\n yield self[essid, key]\",\n \"def __iter__(self):\\n\\n for each in list(self.keys()):\\n yield each\",\n \"def __iter__(self):\\n return iter({})\",\n \"def __iter__(self):\\n\\n # For each key in set of keys\\n for key in self.keys_set:\\n\\n # Yield that key and associated value\\n yield key, self.__getitem__(key)\",\n \"def __iter__(self):\\n for instresult in self.instresults:\\n yield instresult\",\n \"def iteritems(self):\\n return DictItemsIterator(self)\",\n \"def __iter__(self):\\n # Return an iterator for the keys in the underlying dictionary.\\n return iter(self.data)\",\n \"def iteritems(self):\\n def make_iter(self=self):\\n keys = self.iterkeys()\\n while True:\\n key = keys.next()\\n yield (key, self[key])\\n return make_iter()\",\n \"def __iter__(self):\\n self._fetch_all()\\n return iter(self._result_cache)\",\n \"def __iter__(self):\\r\\n for item in self._data:\\r\\n yield item # yield the KEY\\r\",\n \"def itervalues(self):\\n return DictValuesIterator(self)\",\n \"def iterator(self):\\n yield\",\n \"def __iter__(self) -> Generator:\\n for k in self.raw.keys():\\n yield k\",\n \"def iterentries(self):\\n for key in self.iterkeys():\\n yield self.get(key)\",\n \"def __iter__(self):\\n for acronym in self.keys:\\n yield acronym, self.dict[acronym]\",\n \"def __iter__(self):\\n yield from chain.from_iterable(self.data.values())\",\n \"def __iter__(self):\\n key = list(self.keys())[0]\\n length = len(self[key])\\n for i in range(length):\\n res = {}\\n for key, feature in self.items():\\n res[key] = feature.data[feature.name][i]\\n yield res\",\n \"def itervalues(self):\\n def make_iter(self=self):\\n keys = self.iterkeys()\\n while True:\\n yield self[keys.next()]\\n return make_iter()\",\n \"def __iter__(self):\\n return iter(self.keys())\",\n \"def iteritems(self):\\n for key in self:\\n yield key, self[key]\",\n \"def __iter__(self):\\n\\n return iter([key for key in self._data.keys()])\",\n \"def iteritems(self):\\r\\n for wr, value in self.data.iteritems():\\r\\n key = wr()\\r\\n if key is not None:\\r\\n yield key, value\",\n \"def iteritems(self):\\r\\n for wr, value in self.data.iteritems():\\r\\n key = wr()\\r\\n if key is not None:\\r\\n yield key, value\",\n \"def __iter__(self):\\n for mapping in self._mappings.values():\\n yield mapping\",\n \"def __iter__(self):\\n for v in self._items:\\n yield v\",\n \"def itervalues(self):\\n for key in self:\\n yield self[key]\",\n \"def __iter__(self):\\n cursor=0\\n while cursor<len(self):\\n yield self._item[cursor].key\\n cursor+=1\",\n \"def iteritems(self):\\n for key in self:\\n yield (key, self[key])\",\n \"def __iter__(self):\\n prefix = len(META_NS) + 2\\n for key, value in self.stats.items():\\n yield (key[prefix:-6], int(value))\",\n \"def __iter__(self):\\n return self._data_dict.__iter__()\",\n \"def iteritems(self):\\n return iter((kvp.key, kvp.value) for kvp in self.keyvaluepair_set.all())\",\n \"def __iter__(self, *args, **kwargs):\\n for key in self.keys(*args, **kwargs):\\n yield key\",\n \"def __iter__(self):\\n for value in dict.__iter__(self):\\n for count in range(self[value]):\\n yield value\",\n \"def __iter__(self):\\n cursor = self._connection.cursor()\\n cursor.execute('SELECT * FROM ' + self._table)\\n\\n column_names = self.columns()\\n dict_row = lambda x: dict(zip(column_names, x))\\n return (dict_row(row) for row in cursor.fetchall())\",\n \"def __iter__(self):\\n cursor = self._connection.cursor()\\n cursor.execute('SELECT * FROM ' + self._table)\\n\\n column_names = self.columns()\\n dict_row = lambda x: dict(zip(column_names, x))\\n return (dict_row(row) for row in cursor.fetchall())\",\n \"def __iter__(self):\\n for datum in self.data[self.name]:\\n yield datum\",\n \"def iterkeys(self):\\r\\n for wr in self.data.iterkeys():\\r\\n obj = wr()\\r\\n if obj is not None:\\r\\n yield obj\",\n \"def iterkeys(self):\\r\\n for wr in self.data.iterkeys():\\r\\n obj = wr()\\r\\n if obj is not None:\\r\\n yield obj\",\n \"def _chain_map_iter(self):\\n d = {}\\n for mapping in reversed(self.maps):\\n d.update(mapping) # reuses stored hash values if possible\\n return iter(d)\",\n \"def __iter__(self):\\n for key in sorted(self.keys):\\n yield key, self[key]\",\n \"def __iter__(self) -> Tuple[str, Any]:\\n for attr_name, attr_val in self.__dict__.items():\\n yield attr_name, attr_val\",\n \"def __iter__(self):\\n for domain in self.keys():\\n yield domain\",\n \"def __iter__(self):\\n\\n result = []\\n\\n # d - dict, p - path (keys sequence)\\n def recurs_iter(d, p=None):\\n p = p or []\\n\\n # k - key, v - value\\n for k, v in iteritems(d):\\n next_p = p + [k]\\n if isinstance(v, dict):\\n recurs_iter(v, next_p)\\n else:\\n result.append(tuple(next_p))\\n\\n recurs_iter(self.__dict__)\\n\\n return iter(result)\",\n \"def __iter__(self):\\r\\n results = ResultSet.__iter__(self)\\r\\n while results:\\r\\n for obj in results:\\r\\n yield obj\\r\\n if self.is_truncated:\\r\\n self.is_truncated = False\\r\\n results = self.connection.get_all_rrsets(self.hosted_zone_id, name=self.next_record_name, type=self.next_record_type)\\r\\n else:\\r\\n results = None\",\n \"def __iter__(self):\\n for line in self._fp:\\n row = line.decode(\\\"utf-8\\\").split(\\\"\\\\t\\\")\\n yield row[1], row[2], row[3], json.loads(row[4])['weight']\",\n \"def __iter__(self):\\n return dict(self.parameters)\",\n \"def _get_raw_extract_iter(self) -> Iterable[Dict[str, Any]]:\\n rows = self.alchemy_helper.execute_query()\\n for row in rows:\\n yield row\",\n \"def inner_generator():\\n # A buffer where observed query-document features will be stored.\\n # It is a list of dictionaries, one per query-document pair, where\\n # each dictionary is a mapping from a feature ID to a feature value.\\n for p in processed:\\n yield p\",\n \"def __iter__(\\n self,\\n ) -> Generator[dict[str, str | int | bool | list[dict[str, str]]], None, None]:\\n url = API_PATH[\\\"user_flair\\\"].format(subreddit=self.subreddit)\\n params = {\\\"unique\\\": self.subreddit._reddit._next_unique}\\n yield from self.subreddit._reddit.get(url, params=params)\",\n \"def __iter__(self):\\n for item in self._reader:\\n yield item\",\n \"def _get_raw_extract_iter(self) -> Iterator[Dict[str, Any]]:\\n row = self._alchemy_extractor.extract()\\n while row:\\n yield row\\n row = self._alchemy_extractor.extract()\",\n \"def __iter__(self):\\n for r in self.cursor:\\n yield r\",\n \"def __iter__( self ) :\\n\\n for entry in self.__entries : yield entry\",\n \"def itervalues(self):\\n return iter(kvp.value for kvp in self.keyvaluepair_set.all())\",\n \"def query(self, q):\\n for key in self.metadb.query(q):\\n yield key, self.datadb[key]\",\n \"def process_results_iter(self):\\n while self.results: # iteratively process each cue in cues\\n msgs = bytearray()\\n r = self.results.popleft()\\n log.info(\\\"%s got result: %s\\\\n\\\", self.name, r)\\n msgs.extend(r[\\\"result\\\"])\\n yield r[\\\"label\\\"], msgs\",\n \"def __iter__(self):\\n items = self._fetch()\\n for item in items:\\n yield item\",\n \"def _get_raw_extract_iter(self):\\n # type: () -> Iterator[Dict[str, Any]]\\n row = self._alchemy_extractor.extract()\\n while row:\\n yield row\\n row = self._alchemy_extractor.extract()\",\n \"def __iter__(self):\\n\\t\\tfor key, value in self.__dict__.iteritems():\\n\\t\\t\\tif key[0] != '_':\\n\\t\\t\\t\\tyield value\",\n \"def getItemIter(self):\\n for key, raw in self.db.getAllItemIter(db=self.sdb, split=False):\\n keys = tuple(key.decode(\\\"utf-8\\\").split('.'))\\n yield (keys, coring.Serder(raw=bytes(raw)))\",\n \"def iteritems(self):\\n\\t\\tself.filep.seek(self.start + 2048)\\n\\n\\t\\t# iterate until we hit the enddata marker\\n\\t\\twhile self.filep.tell() < self.enddata - 1:\\n\\t\\t\\t# fetch the lengths of the key and value\\n\\t\\t\\t(klen, vlen) = unpack('<LL', self.filep.read(8))\\n\\n\\t\\t\\t# yield the key and value as a tuple\\n\\t\\t\\tyield (self.filep.read(klen), self.filep.read(vlen))\",\n \"def __iter__(self):\\n for classresult in self.classresults:\\n yield classresult\",\n \"def __iter__(self):\\n if self._len_keys == 1:\\n yield from self._dict.keys()\\n else:\\n for key in self._dict.keys():\\n yield tuple(sorted(list(key)))\",\n \"def __iter__(self) -> Generator[Optional[dict], None, None]:\\n data_list, response, result = self.retrieve_data(self.url)\\n\\n if result != GithubApiResult.SUCCESS:\\n self.logger.debug(\\\"Failed to retrieve the data even though 10 attempts were given\\\")\\n yield None\\n return\\n\\n # yield the first page data\\n for data in data_list:\\n yield data\\n\\n while 'next' in response.links.keys():\\n next_page = response.links['next']['url']\\n\\n # Here we don't need to pass in params with the page, or the default params because the url from the headers already has those values\\n data_list, response, result = self.retrieve_data(next_page)\\n\\n if result != GithubApiResult.SUCCESS:\\n self.logger.debug(\\\"Failed to retrieve the data even though 10 attempts were given\\\")\\n return\\n\\n for data in data_list:\\n yield data\",\n \"def iterkeys(self):\\n return DictKeysIterator(self)\",\n \"def __iter__(self):\\n for key in self._ctx:\\n yield key\",\n \"def Iterator():\\n return _table.Iterator()\",\n \"def __next__(self):\\n for (k, v) in pairs(self._data):\\n yield (v, k)\",\n \"def iterate_results(results, extract_fn):\\n outputs = {}\\n for environment, environment_results in results.items():\\n if environment not in outputs:\\n outputs[environment] = {}\\n for experimental_setting, setting_results in environment_results.items():\\n outputs[environment][experimental_setting] = []\\n for config, seeds_results in setting_results.items():\\n for seed, actual_results in seeds_results.items():\\n output = extract_fn(actual_results)\\n outputs[environment][experimental_setting].append(output)\\n outputs[environment][experimental_setting] = np.array(outputs[environment][experimental_setting])\\n return outputs\",\n \"def __next__(self) -> dict:\\n batches = {}\\n terminations = 0\\n for iterator in self.iterators:\\n \\n try:\\n data, target = next(iterator)\\n batches[data.location] = (data, target)\\n\\n except (TypeError, AttributeError) as e:\\n logging.warning(f\\\"Dangling pointer detected! Skipping operation... Error: {e}\\\")\\n \\n except StopIteration:\\n terminations += 1\\n\\n # Every cached iterator has been iterated through completely\\n if terminations == len(self.iterators):\\n raise StopIteration\\n\\n return batches\",\n \"def result_generator(results, metadata):\\n try:\\n yield '{\\\"result\\\": [\\\\n'\\n for line in interleave(['\\\\n, '], results):\\n yield line\\n yield '\\\\n],\\\\n'\\n yield '\\\"metadata\\\": {0},\\\\n'.format(json.dumps(metadata()))\\n yield '\\\"status\\\": \\\"success\\\"}\\\\n'\\n except Exception:\\n exc = traceback.format_exc()\\n yield '---\\\\n'\\n yield exc\",\n \"def itervalues(self, multi=False):\\n for k, v in self.iteritems(multi=multi):\\n yield v\",\n \"def __iter__(self):\\n\\t\\treturn self.keys()\",\n \"def __iter__(self):\\n for itm in self._user_data:\\n yield itm\",\n \"def json_imap(mapping, iterable):\\n for item in iterable:\\n yield scraper.json_map(mapping, item)\",\n \"def classIterator(classIter):\\n for attribute, value in classIter.__dict__.iteritems():\\n yield attribute, value\",\n \"def getItemIter(self):\\n for key, val in self.db.getAllItemIter(db=self.sdb, split=False):\\n keys = tuple(key.decode(\\\"utf-8\\\").split('.'))\\n yield (keys, self.klas(qb64b=bytes(val)))\",\n \"def __iter__(self):\\n if self.use_dic:\\n for data in sorted(self.dic):\\n self.data = data\\n for activity in sorted(self.dic[data]):\\n self.activity = activity\\n for imsize in sorted(self.dic[data][activity]):\\n self.imsize = imsize\\n self.allimgs, self.alllabels = [], []\\n for img in sorted(self.dic[data][activity][imsize]):\\n self.img = img\\n self.labels = self.dic[data][activity][imsize][img]\\n if self.imlist:\\n self.allimgs.append(self.img)\\n self.alllabels.append(self.labels)\\n else:\\n yield data, activity, imsize, img, self.labels\\n self.i += 1\\n if self.imlist:\\n yield data, activity, imsize, self.allimgs, self.alllabels\\n self.i += 1\\n else:\\n for data in sorted(self.dic):\\n self.img = data\\n self.labels = self.dic[data]\\n yield self.img, self.labels\\n self.i += 1\",\n \"def iter_serp_items(self):\\n\\n for key, value in self.search_results.items():\\n if isinstance(value, list):\\n for i, item in enumerate(value):\\n if isinstance(item, dict) and item['link']:\\n yield (key, i)\",\n \"def iteroriginal(self):\\n for key in self:\\n vals = _dict_getitem(self, key)\\n for val in vals[1:]:\\n yield vals[0], val\",\n \"def __iter__(self):\\n yield from self._type_keys\",\n \"def __iter__(self):\\n cursor = 0\\n while cursor < len(self):\\n yield self._items[cursor]\\n cursor += 1\",\n \"def __iter__(self):\\n for o in self._iter:\\n yield o\",\n \"def __iter__(self):\\n for x in sorted(self.keys()):\\n yield self[x]\",\n \"def __iter__(self):\\n while self.has_next_page():\\n response = self.get_next_page_response()\\n for item in self.get_items_from_response(response):\\n yield item\",\n \"def __iter__(self):\\n for hit in self._evaluate()['hits']['hits']:\\n yield self._to_document(hit)\",\n \"def __iter__(self):\\n\\n return self._entries.__iter__()\",\n \"def itervalues(self, *args, **kwargs):\\n for key in self.iterkeys():\\n yield self._get(key, *args, **kwargs)\",\n \"def __iter__(self):\\n for bucket in self._table:\\n if bucket is not None:\\n for key in bucket:\\n yield key\",\n \"def table_generator( db, query):\\n db.query(query)\\n result = db.store_result()\\n done = False\\n while not done:\\n row = result.fetch_row(1,1)\\n done = len(row) == 0\\n if not done:\\n (dict,) = row\\n yield Row(SimpleDictGenerator(dict))\",\n \"def default_iterator(mapping):\\n return getattr(mapping, 'iteritems', mapping.items)()\",\n \"def __iter__(self) -> Iterator[object]:\\n return iter(\\n list(self._new.values()) + list(self.identity_map.values())\\n )\",\n \"def __iter__(self) -> Iterator[str]:\\n return iter(self._keys)\",\n \"def _get_iter(self, url, params):\\n for current_page_index in itertools.count():\\n result_dict = self._get_page(url, params, current_page_index)\\n for document in result_dict['entries']:\\n yield document\\n if not result_dict['isNextPageAvailable']:\\n break\",\n \"async def next(self):\\n if not self.has_next():\\n raise IteratorExhausted()\\n value = await self._source.next()\\n if self._values is None:\\n return value\\n return {k: v for k, v in value.items() if k in self._values}\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70707095","0.6937773","0.69119906","0.685489","0.67938584","0.67819273","0.66642076","0.66412884","0.6634738","0.65794516","0.65755105","0.6557807","0.6552341","0.6529979","0.65247136","0.65218616","0.64761126","0.64640063","0.641072","0.63832486","0.6373816","0.6373002","0.63566613","0.6355079","0.63528115","0.63487655","0.6324165","0.6324165","0.62840086","0.6270088","0.6252572","0.6236028","0.6203125","0.61891085","0.61740524","0.6172393","0.6170253","0.61270344","0.61269677","0.61269677","0.6105811","0.6104284","0.6104284","0.6074668","0.60514724","0.6044173","0.60410565","0.6005253","0.600392","0.5992601","0.5983252","0.5976645","0.59722704","0.59683114","0.5967351","0.5962327","0.59621376","0.5958027","0.59478766","0.5945139","0.5940739","0.5937935","0.5917095","0.5914897","0.5913308","0.5912532","0.5905984","0.5903764","0.58918923","0.58844644","0.5880169","0.58673716","0.58609897","0.5857997","0.5846433","0.58423984","0.5835388","0.5834602","0.5831657","0.58282363","0.5827011","0.5816357","0.58123636","0.5800408","0.57975554","0.57973254","0.57967925","0.5796571","0.5794333","0.5792647","0.5789934","0.5780566","0.57743347","0.5755784","0.5753515","0.57533216","0.57436866","0.57399553","0.573917","0.57324636"],"string":"[\n \"0.70707095\",\n \"0.6937773\",\n \"0.69119906\",\n \"0.685489\",\n \"0.67938584\",\n \"0.67819273\",\n \"0.66642076\",\n \"0.66412884\",\n \"0.6634738\",\n \"0.65794516\",\n \"0.65755105\",\n \"0.6557807\",\n \"0.6552341\",\n \"0.6529979\",\n \"0.65247136\",\n \"0.65218616\",\n \"0.64761126\",\n \"0.64640063\",\n \"0.641072\",\n \"0.63832486\",\n \"0.6373816\",\n \"0.6373002\",\n \"0.63566613\",\n \"0.6355079\",\n \"0.63528115\",\n \"0.63487655\",\n \"0.6324165\",\n \"0.6324165\",\n \"0.62840086\",\n \"0.6270088\",\n \"0.6252572\",\n \"0.6236028\",\n \"0.6203125\",\n \"0.61891085\",\n \"0.61740524\",\n \"0.6172393\",\n \"0.6170253\",\n \"0.61270344\",\n \"0.61269677\",\n \"0.61269677\",\n \"0.6105811\",\n \"0.6104284\",\n \"0.6104284\",\n \"0.6074668\",\n \"0.60514724\",\n \"0.6044173\",\n \"0.60410565\",\n \"0.6005253\",\n \"0.600392\",\n \"0.5992601\",\n \"0.5983252\",\n \"0.5976645\",\n \"0.59722704\",\n \"0.59683114\",\n \"0.5967351\",\n \"0.5962327\",\n \"0.59621376\",\n \"0.5958027\",\n \"0.59478766\",\n \"0.5945139\",\n \"0.5940739\",\n \"0.5937935\",\n \"0.5917095\",\n \"0.5914897\",\n \"0.5913308\",\n \"0.5912532\",\n \"0.5905984\",\n \"0.5903764\",\n \"0.58918923\",\n \"0.58844644\",\n \"0.5880169\",\n \"0.58673716\",\n \"0.58609897\",\n \"0.5857997\",\n \"0.5846433\",\n \"0.58423984\",\n \"0.5835388\",\n \"0.5834602\",\n \"0.5831657\",\n \"0.58282363\",\n \"0.5827011\",\n \"0.5816357\",\n \"0.58123636\",\n \"0.5800408\",\n \"0.57975554\",\n \"0.57973254\",\n \"0.57967925\",\n \"0.5796571\",\n \"0.5794333\",\n \"0.5792647\",\n \"0.5789934\",\n \"0.5780566\",\n \"0.57743347\",\n \"0.5755784\",\n \"0.5753515\",\n \"0.57533216\",\n \"0.57436866\",\n \"0.57399553\",\n \"0.573917\",\n \"0.57324636\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6707882"},"document_rank":{"kind":"string","value":"6"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":819,"numItemsPerPage":100,"numTotalItems":95772,"offset":81900,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjE0NzQ2MiwianRpIjoiY2EzZTIwYzEtMzk4My00OTY2LTkxYjYtZDA3MTA2NWZmZmZiIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYxNTEwNjIsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.nq50v9t9T5gnpk_EtJoPBitEoVQ7coB5bNn3YjsaJ6gT9ZfTVOqxSn9Q2SJuALDRsnMfub2cGmKGE2l4bdbTBw","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 |
|---|---|---|---|---|---|---|
Read any data that has been collected since the last call. | async def read(self) -> bytes:
# NOTE(kgriffs): Yield to other tasks to give them a chance to
# send us more body chunks if any are available.
#
# https://bugs.python.org/issue34476
#
await asyncio.sleep(0)
if self._chunk_pos >= len(self._chunks):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def collect(self):\n if self._completion_status is None or not self._completion_status.done:\n raise RuntimeError(\"No reading until done!\")\n self._completion_status = None\n\n yield from self._data",
"def read(self):\n self._read(True)\n return self._readings",
... | [
"0.6824192",
"0.66679394",
"0.65908027",
"0.65646493",
"0.6316166",
"0.6301715",
"0.6260783",
"0.62499213",
"0.61752194",
"0.6141177",
"0.613967",
"0.6104275",
"0.6086361",
"0.60820276",
"0.6038793",
"0.6038682",
"0.6011587",
"0.5987216",
"0.59750587",
"0.59735256",
"0.596673... | 0.0 | -1 |
Finalize the encapsulated simulated request. This method causes the request event emitter to begin emitting ``'http.disconnect'`` events and then awaits the completion of the asyncio task that is running the simulated ASGI request. | async def finalize(self):
self._req_event_emitter.disconnect()
await self._task | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _finalize_request(self, request_no):\n now = _now()\n # Find request info in current requests\n request_info = self._current_requests.pop(request_no, None)\n if not request_info:\n logging.error(\"Couldn't finalize request #{} as it wasn't started \"\n \"or it was started lo... | [
"0.599261",
"0.58126885",
"0.57832295",
"0.57138246",
"0.56882215",
"0.5686544",
"0.5677415",
"0.56466365",
"0.5626848",
"0.5616015",
"0.5615296",
"0.55539614",
"0.55263776",
"0.55126804",
"0.5511265",
"0.54770803",
"0.5459623",
"0.5418623",
"0.54156804",
"0.541335",
"0.53688... | 0.77098256 | 0 |
Simulate a request to a WSGI or ASGI application. Performs a request against a WSGI or ASGI application. In the case of | def simulate_request(
app,
method='GET',
path='/',
query_string=None,
headers=None,
content_type=None,
body=None,
json=None,
file_wrapper=None,
wsgierrors=None,
params=None,
params_csv=False,
protocol='http',
host=helpers.DEFAULT_HOST,
remote_addr=None,
ex... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\r\n run_wsgi_app(app)",
"def application(environ, start_response, app=[]):\n if not app:\n app.append(make_application())\n return app[0](environ, start_response)",
"def test_get_wsgi_application(self):\n application = wsgi.get_wsgi_application()\n\n environ = RequestF... | [
"0.68284094",
"0.6605171",
"0.6591117",
"0.6560543",
"0.6491741",
"0.6410489",
"0.64080065",
"0.6362514",
"0.6343776",
"0.63280624",
"0.6317552",
"0.6280429",
"0.62708604",
"0.6255619",
"0.62199986",
"0.621414",
"0.61968637",
"0.6143944",
"0.6143615",
"0.61340964",
"0.6124544... | 0.63396287 | 9 |
Simulate a request to an ASGI application. | async def _simulate_request_asgi(
app,
method='GET',
path='/',
query_string=None,
headers=None,
content_type=None,
body=None,
json=None,
params=None,
params_csv=True,
protocol='http',
host=helpers.DEFAULT_HOST,
remote_addr=None,
extras=None,
http_version='1.1'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_basic_asgi_call(self):\n app = otel_asgi.OpenTelemetryMiddleware(simple_asgi)\n self.seed_app(app)\n self.send_default_request()\n outputs = self.get_all_output()\n self.validate_outputs(outputs)",
"def test_basic_asgi_call(self):\n app = otel_asgi.OpenTelemetry... | [
"0.6697261",
"0.6697261",
"0.6463477",
"0.64476454",
"0.62754405",
"0.6240101",
"0.6212896",
"0.61975616",
"0.6176701",
"0.6165948",
"0.61617255",
"0.61466104",
"0.6127736",
"0.6127736",
"0.6127736",
"0.6011134",
"0.5981526",
"0.59622854",
"0.5924651",
"0.5876444",
"0.587383"... | 0.696744 | 0 |
Simulate a GET request to an ASGI application. | async def simulate_get(self, path='/', **kwargs) -> _ResultBase:
return await self.simulate_request('GET', path, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def simulate_get(app, path, **kwargs) -> _ResultBase:\n\n return simulate_request(app, 'GET', path, **kwargs)",
"def do_GET(self):\r\n self._send_handler_response('GET')",
"def get(self, url, **kwargs):\n logging.info('OUTGOING HTTP GET: %s' % url)\n try:\n return self.wrappe... | [
"0.7688709",
"0.7209827",
"0.6882398",
"0.6874337",
"0.68675745",
"0.68609643",
"0.6680741",
"0.66037524",
"0.6595958",
"0.6551402",
"0.6513743",
"0.650689",
"0.6501855",
"0.64850557",
"0.6384635",
"0.6384379",
"0.6379069",
"0.6353283",
"0.63353187",
"0.63148445",
"0.62826747... | 0.64601225 | 14 |
Simulate a GET request to an ASGI application with a streamed response. | def simulate_get_stream(self, path='/', **kwargs):
kwargs['_stream_result'] = True
return _AsyncContextManager(self.simulate_request('GET', path, **kwargs)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def simulate_get(app, path, **kwargs) -> _ResultBase:\n\n return simulate_request(app, 'GET', path, **kwargs)",
"def get(*args, **kwargs):\n\n response = yield from aiohttp.request('GET', *args, **kwargs)\n return (yield from response.read())",
"def do_GET(self):\r\n self._send_handler_response... | [
"0.69662255",
"0.6964644",
"0.6791128",
"0.6653924",
"0.6492846",
"0.64581084",
"0.6262218",
"0.61936045",
"0.61565524",
"0.6127867",
"0.6102314",
"0.6101945",
"0.6099907",
"0.60994047",
"0.6095092",
"0.6094662",
"0.6078649",
"0.6070515",
"0.6067862",
"0.60598123",
"0.6054354... | 0.6659492 | 3 |
Simulate a WebSocket connection to an ASGI application. All keyword arguments are passed through to | def simulate_ws(self, path='/', **kwargs):
scope = helpers.create_scope_ws(path=path, **kwargs)
ws = helpers.ASGIWebSocketSimulator()
task_req = create_task(self.app(scope, ws._emit, ws._collect))
return _WSContextManager(ws, task_req) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def test_websocket_application():\n application = URLRouter([path(\"testws/<str:message>/\", KwargsWebSocketApp())])\n communicator = WebsocketCommunicator(application, \"/testws/test/\")\n connected, subprotocol = await communicator.connect()\n # Test connection\n assert connected\n assert... | [
"0.68903196",
"0.6744548",
"0.6687273",
"0.6501984",
"0.624338",
"0.6031254",
"0.5900592",
"0.58548105",
"0.58494914",
"0.58494365",
"0.58278435",
"0.5824977",
"0.58083946",
"0.57835615",
"0.5777688",
"0.57113034",
"0.5706925",
"0.56735003",
"0.5667869",
"0.566028",
"0.562728... | 0.5730795 | 15 |
Simulate a HEAD request to an ASGI application. | async def simulate_head(self, path='/', **kwargs) -> _ResultBase:
return await self.simulate_request('HEAD', path, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def simulate_head(app, path, **kwargs) -> _ResultBase:\n return simulate_request(app, 'HEAD', path, **kwargs)",
"def do_HEAD(self):\n self.do_GET(True)",
"def do_HEAD(self):\n self.log.debug('do_HEAD called')\n self.HeadGet('HEAD')",
"def HEAD(self, req):\r\n resp = req.get_response(se... | [
"0.81544644",
"0.77035207",
"0.75598407",
"0.749035",
"0.7483409",
"0.73954153",
"0.73515546",
"0.7336531",
"0.7186591",
"0.717927",
"0.70954436",
"0.7069544",
"0.7047983",
"0.7047983",
"0.7047983",
"0.7047983",
"0.7008836",
"0.69955856",
"0.6982015",
"0.6925413",
"0.6874912"... | 0.7014018 | 16 |
Simulate a POST request to an ASGI application. | async def simulate_post(self, path='/', **kwargs) -> _ResultBase:
return await self.simulate_request('POST', path, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def simulate_post(app, path, **kwargs) -> _ResultBase:\n return simulate_request(app, 'POST', path, **kwargs)",
"def do_POST(self):\r\n self._send_handler_response('POST')",
"async def test_post_form_urlencoded(app, aiohttp_server):\n server = await aiohttp_server(app)\n url = \"http://localhos... | [
"0.7567842",
"0.68630046",
"0.6829685",
"0.6728402",
"0.6693517",
"0.6613696",
"0.6525269",
"0.65113217",
"0.64988035",
"0.64452595",
"0.6435002",
"0.63261384",
"0.63139784",
"0.6299051",
"0.6291908",
"0.62749785",
"0.6258384",
"0.6258113",
"0.62297994",
"0.62297213",
"0.6220... | 0.6058574 | 24 |
Simulate a PUT request to an ASGI application. | async def simulate_put(self, path='/', **kwargs) -> _ResultBase:
return await self.simulate_request('PUT', path, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def simulate_put(app, path, **kwargs) -> _ResultBase:\n return simulate_request(app, 'PUT', path, **kwargs)",
"def put(self, *args, **kwargs):\n self.request(\"put\", *args, **kwargs)",
"def do_PUT(self,):\n self.http_method = 'PUT'\n # Nothing to do for now.\n pass",
"def _put... | [
"0.8130414",
"0.72275764",
"0.7175433",
"0.71189624",
"0.6995265",
"0.69159925",
"0.69084567",
"0.68669564",
"0.68038714",
"0.6794044",
"0.6616889",
"0.6588042",
"0.6564535",
"0.65348846",
"0.65348846",
"0.65348846",
"0.65310556",
"0.6496377",
"0.6471326",
"0.6454387",
"0.645... | 0.69048744 | 7 |
Simulate an OPTIONS request to an ASGI application. | async def simulate_options(self, path='/', **kwargs) -> _ResultBase:
return await self.simulate_request('OPTIONS', path, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def simulate_options(app, path, **kwargs) -> _ResultBase:\n return simulate_request(app, 'OPTIONS', path, **kwargs)",
"def OPTIONS(self, req):\r\n resp = req.get_response(self.app)\r\n return resp",
"def handleHttpOptions():\n response = flask.Response(\"\", mimetype=\"application/json\")\n... | [
"0.7786664",
"0.76917243",
"0.7064275",
"0.69728106",
"0.6958719",
"0.6952357",
"0.678636",
"0.67658037",
"0.6603403",
"0.64874357",
"0.6471302",
"0.6311861",
"0.623971",
"0.61870867",
"0.6117714",
"0.6087566",
"0.6036492",
"0.59955215",
"0.5879537",
"0.5852436",
"0.5721634",... | 0.6828279 | 6 |
Simulate a PATCH request to an ASGI application. | async def simulate_patch(self, path='/', **kwargs) -> _ResultBase:
return await self.simulate_request('PATCH', path, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def simulate_patch(app, path, **kwargs) -> _ResultBase:\n return simulate_request(app, 'PATCH', path, **kwargs)",
"def patch(self, *args, **kwargs):\n self.request(\"patch\", *args, **kwargs)",
"def simulate_patch(self, path='/', **kwargs):\n return self.simulate_request('PATCH', path, **kwarg... | [
"0.8286581",
"0.7499736",
"0.73026884",
"0.70985633",
"0.70926195",
"0.7085156",
"0.6907411",
"0.6900558",
"0.68608654",
"0.6830805",
"0.6811523",
"0.68058413",
"0.6804034",
"0.673692",
"0.67207915",
"0.6695585",
"0.6695585",
"0.6695585",
"0.6695585",
"0.6695585",
"0.6695585"... | 0.7162519 | 3 |
Simulate a DELETE request to an ASGI application. | async def simulate_delete(self, path='/', **kwargs) -> _ResultBase:
return await self.simulate_request('DELETE', path, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def simulate_delete(app, path, **kwargs) -> _ResultBase:\n return simulate_request(app, 'DELETE', path, **kwargs)",
"def do_DELETE(self,):\n self.http_method = 'DELETE'\n self.response()",
"def delete(self, *args, **kwargs):\n self.request(\"delete\", *args, **kwargs)",
"def delete(se... | [
"0.8164449",
"0.74072415",
"0.7320336",
"0.72981447",
"0.72860307",
"0.724793",
"0.72134966",
"0.7212368",
"0.71407527",
"0.71187055",
"0.71111995",
"0.7101029",
"0.7100111",
"0.69844186",
"0.6937107",
"0.69221526",
"0.6919563",
"0.6910702",
"0.68807673",
"0.6874072",
"0.6870... | 0.6999327 | 13 |
Simulate a request to an ASGI application. | async def simulate_request(self, *args, **kwargs) -> _ResultBase:
if self._default_headers:
# NOTE(kgriffs): Handle the case in which headers is explicitly
# set to None.
additional_headers = kwargs.get('headers', {}) or {}
merged_headers = self._default_headers... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def _simulate_request_asgi(\n app,\n method='GET',\n path='/',\n query_string=None,\n headers=None,\n content_type=None,\n body=None,\n json=None,\n params=None,\n params_csv=True,\n protocol='http',\n host=helpers.DEFAULT_HOST,\n remote_addr=None,\n extras=None,\n ... | [
"0.696744",
"0.6697261",
"0.6697261",
"0.6463477",
"0.64476454",
"0.62754405",
"0.6240101",
"0.6212896",
"0.61975616",
"0.6176701",
"0.61617255",
"0.61466104",
"0.6127736",
"0.6127736",
"0.6127736",
"0.6011134",
"0.5981526",
"0.59622854",
"0.5924651",
"0.5876444",
"0.587383",... | 0.6165948 | 10 |
Simulate a GET request to a WSGI or ASGI application. | def simulate_get(app, path, **kwargs) -> _ResultBase:
return simulate_request(app, 'GET', path, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_GET(self):\r\n self._send_handler_response('GET')",
"def get(self, url, **kwargs):\n logging.info('OUTGOING HTTP GET: %s' % url)\n try:\n return self.wrapped_app.get(url, **kwargs)\n except webtest.AppError as e:\n raise VirtualAppError(msg='HTTP GET faile... | [
"0.7422761",
"0.71843797",
"0.7106445",
"0.70900655",
"0.6984407",
"0.6970873",
"0.6878353",
"0.6760326",
"0.67270213",
"0.6703166",
"0.6636329",
"0.66259116",
"0.6616825",
"0.66046745",
"0.65231144",
"0.6460621",
"0.6452677",
"0.644508",
"0.6409575",
"0.63991606",
"0.6382206... | 0.78489506 | 0 |
Simulate a HEAD request to a WSGI or ASGI application. | def simulate_head(app, path, **kwargs) -> _ResultBase:
return simulate_request(app, 'HEAD', path, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_HEAD(self):\n self.do_GET(True)",
"def HEAD(self, req):\r\n resp = req.get_response(self.app)\r\n\r\n return HTTPOk(headers=resp.headers)",
"def do_HEAD(self):\n self.log.debug('do_HEAD called')\n self.HeadGet('HEAD')",
"def head(self, url, *args, **kwargs):\n with LO... | [
"0.78091705",
"0.7650182",
"0.7624783",
"0.7595388",
"0.753932",
"0.75186324",
"0.7429734",
"0.7328362",
"0.73160917",
"0.72809213",
"0.713504",
"0.71180564",
"0.71009296",
"0.7089121",
"0.7067554",
"0.70673203",
"0.70619255",
"0.7036367",
"0.7036367",
"0.7036367",
"0.7036367... | 0.8178949 | 0 |
Simulate a POST request to a WSGI or ASGI application. | def simulate_post(app, path, **kwargs) -> _ResultBase:
return simulate_request(app, 'POST', path, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_POST(self):\r\n self._send_handler_response('POST')",
"def post(self, *args, **kwargs):\n self.request(\"post\", *args, **kwargs)",
"def do_POST(self): # pylint: disable=invalid-name\n self.handle_request()",
"def do_POST(self,):\n self.http_method = 'POST'\n ... | [
"0.71617234",
"0.7045804",
"0.6867098",
"0.6853614",
"0.6829674",
"0.6813335",
"0.6783007",
"0.6774898",
"0.6717171",
"0.6653153",
"0.6608424",
"0.66032755",
"0.6583824",
"0.6545123",
"0.65369654",
"0.6514101",
"0.65099627",
"0.6505311",
"0.6446184",
"0.63772756",
"0.63557357... | 0.77779883 | 0 |
Simulate a PUT request to a WSGI or ASGI application. | def simulate_put(app, path, **kwargs) -> _ResultBase:
return simulate_request(app, 'PUT', path, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_PUT(self,):\n self.http_method = 'PUT'\n # Nothing to do for now.\n pass",
"def put(self, *args, **kwargs):\n self.request(\"put\", *args, **kwargs)",
"def _put(self, *args, **kwargs):\n return self._request('put', *args, **kwargs)",
"def simulate_put(self, path='/',... | [
"0.7430654",
"0.7420765",
"0.7254375",
"0.72292215",
"0.7130859",
"0.7076189",
"0.70692164",
"0.7004767",
"0.696957",
"0.69484067",
"0.692274",
"0.69176435",
"0.68755746",
"0.683001",
"0.6824943",
"0.68128455",
"0.67805594",
"0.6752393",
"0.6752393",
"0.6752393",
"0.6705847",... | 0.82123727 | 0 |
Simulate an OPTIONS request to a WSGI or ASGI application. | def simulate_options(app, path, **kwargs) -> _ResultBase:
return simulate_request(app, 'OPTIONS', path, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def OPTIONS(self, req):\r\n resp = req.get_response(self.app)\r\n return resp",
"def handleHttpOptions():\n response = flask.Response(\"\", mimetype=\"application/json\")\n response.headers.add(\"Access-Control-Request-Methods\", \"GET,POST,OPTIONS\")\n return response",
"def do_OPTIONS(... | [
"0.7863422",
"0.73523796",
"0.7177669",
"0.71471834",
"0.70651054",
"0.6973183",
"0.6879857",
"0.6852321",
"0.68058544",
"0.6744779",
"0.6601881",
"0.6532627",
"0.6517702",
"0.6396257",
"0.62983924",
"0.6216214",
"0.61781067",
"0.61551476",
"0.612352",
"0.58386046",
"0.578458... | 0.7776818 | 1 |
Simulate a PATCH request to a WSGI or ASGI application. | def simulate_patch(app, path, **kwargs) -> _ResultBase:
return simulate_request(app, 'PATCH', path, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def patch(self, *args, **kwargs):\n self.request(\"patch\", *args, **kwargs)",
"def simulate_patch(self, path='/', **kwargs):\n return self.simulate_request('PATCH', path, **kwargs)",
"def test_client_can_do_patch_request(self):\n response = self.httpbin_4.test_requests_patch_method()\n ... | [
"0.77237695",
"0.7579202",
"0.74945503",
"0.7375038",
"0.7336147",
"0.71931046",
"0.709597",
"0.7059055",
"0.70421225",
"0.70336956",
"0.6954821",
"0.6954437",
"0.69469035",
"0.69469035",
"0.69469035",
"0.69469035",
"0.69469035",
"0.69469035",
"0.69469035",
"0.69469035",
"0.6... | 0.843222 | 0 |
Simulate a DELETE request to a WSGI or ASGI application. | def simulate_delete(app, path, **kwargs) -> _ResultBase:
return simulate_request(app, 'DELETE', path, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_DELETE(self,):\n self.http_method = 'DELETE'\n self.response()",
"def delete(self, url):\n return self.request(url, \"DELETE\")",
"def delete(self, *args, **kwargs):\n self.request(\"delete\", *args, **kwargs)",
"def _delete(self, url):\n return self._request(url, me... | [
"0.7512464",
"0.73937106",
"0.7383249",
"0.7367261",
"0.73230493",
"0.7305496",
"0.72956675",
"0.72301793",
"0.72071403",
"0.7176349",
"0.7168482",
"0.7161482",
"0.7146861",
"0.7128366",
"0.71066153",
"0.7064168",
"0.7042529",
"0.7008366",
"0.6931621",
"0.6908701",
"0.6888692... | 0.81882477 | 0 |
Simulate a GET request to a WSGI application. | def simulate_get(self, path='/', **kwargs) -> _ResultBase:
return self.simulate_request('GET', path, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def simulate_get(app, path, **kwargs) -> _ResultBase:\n\n return simulate_request(app, 'GET', path, **kwargs)",
"def do_GET(self):\r\n self._send_handler_response('GET')",
"def get(self, url, **kwargs):\n logging.info('OUTGOING HTTP GET: %s' % url)\n try:\n return self.wrappe... | [
"0.7414067",
"0.70905364",
"0.6966913",
"0.68963903",
"0.6782912",
"0.67710394",
"0.6763647",
"0.6644425",
"0.6612385",
"0.65589654",
"0.65490484",
"0.6548749",
"0.653869",
"0.65330756",
"0.64896387",
"0.63865507",
"0.6371429",
"0.6362631",
"0.6334786",
"0.63281626",
"0.62953... | 0.6088177 | 34 |
Simulate a HEAD request to a WSGI application. | def simulate_head(self, path='/', **kwargs) -> _ResultBase:
return self.simulate_request('HEAD', path, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def simulate_head(app, path, **kwargs) -> _ResultBase:\n return simulate_request(app, 'HEAD', path, **kwargs)",
"def do_HEAD(self):\n self.do_GET(True)",
"def HEAD(self, req):\r\n resp = req.get_response(self.app)\r\n\r\n return HTTPOk(headers=resp.headers)",
"def head(self, url, *arg... | [
"0.7908282",
"0.7551596",
"0.7536846",
"0.7451651",
"0.73988074",
"0.7387592",
"0.7380635",
"0.73752433",
"0.7091619",
"0.700157",
"0.6942704",
"0.69363654",
"0.6855727",
"0.67979395",
"0.67689836",
"0.6768478",
"0.6755241",
"0.67435205",
"0.67435205",
"0.67435205",
"0.674352... | 0.6762781 | 16 |
Simulate a POST request to a WSGI application. | def simulate_post(self, path='/', **kwargs) -> _ResultBase:
return self.simulate_request('POST', path, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def simulate_post(app, path, **kwargs) -> _ResultBase:\n return simulate_request(app, 'POST', path, **kwargs)",
"def do_POST(self):\r\n self._send_handler_response('POST')",
"def post_app(request):\n return Response({\"Post executado\"}, status=status.HTTP_200_OK)",
"def post(self, *args, **kwar... | [
"0.7369135",
"0.6875777",
"0.66234535",
"0.6511627",
"0.6471913",
"0.6466773",
"0.6410837",
"0.63744384",
"0.6299342",
"0.6294219",
"0.62914264",
"0.62774044",
"0.6254116",
"0.62469804",
"0.62400424",
"0.622621",
"0.61498666",
"0.61446804",
"0.61404383",
"0.61332",
"0.6097913... | 0.5792 | 40 |
Simulate a PUT request to a WSGI application. | def simulate_put(self, path='/', **kwargs) -> _ResultBase:
return self.simulate_request('PUT', path, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def simulate_put(app, path, **kwargs) -> _ResultBase:\n return simulate_request(app, 'PUT', path, **kwargs)",
"def do_PUT(self,):\n self.http_method = 'PUT'\n # Nothing to do for now.\n pass",
"def put(self, *args, **kwargs):\n self.request(\"put\", *args, **kwargs)",
"def PUT(... | [
"0.7857318",
"0.695292",
"0.6949761",
"0.6900196",
"0.68887955",
"0.68399256",
"0.6778951",
"0.676933",
"0.6731947",
"0.668466",
"0.6678236",
"0.66361004",
"0.6608237",
"0.6584145",
"0.65096",
"0.65074146",
"0.65074146",
"0.65074146",
"0.64896715",
"0.6464989",
"0.64510846",
... | 0.65861607 | 13 |
Simulate an OPTIONS request to a WSGI application. | def simulate_options(self, path='/', **kwargs) -> _ResultBase:
return self.simulate_request('OPTIONS', path, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def OPTIONS(self, req):\r\n resp = req.get_response(self.app)\r\n return resp",
"def simulate_options(app, path, **kwargs) -> _ResultBase:\n return simulate_request(app, 'OPTIONS', path, **kwargs)",
"def handleHttpOptions():\n response = flask.Response(\"\", mimetype=\"application/json\")\n... | [
"0.7714373",
"0.7465679",
"0.72053254",
"0.6988005",
"0.69523615",
"0.67809653",
"0.673419",
"0.6707717",
"0.65450895",
"0.6466334",
"0.6328043",
"0.6310527",
"0.62664926",
"0.6206735",
"0.6079744",
"0.60293096",
"0.5989365",
"0.5927499",
"0.5806252",
"0.57818246",
"0.5755045... | 0.64899015 | 9 |
Simulate a PATCH request to a WSGI application. | def simulate_patch(self, path='/', **kwargs) -> _ResultBase:
return self.simulate_request('PATCH', path, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def simulate_patch(app, path, **kwargs) -> _ResultBase:\n return simulate_request(app, 'PATCH', path, **kwargs)",
"def patch(self, *args, **kwargs):\n self.request(\"patch\", *args, **kwargs)",
"def simulate_patch(self, path='/', **kwargs):\n return self.simulate_request('PATCH', path, **kwarg... | [
"0.8154428",
"0.73881894",
"0.72425157",
"0.7032009",
"0.69893557",
"0.69432026",
"0.6927841",
"0.68865746",
"0.68196744",
"0.67764145",
"0.6765585",
"0.67158455",
"0.66943085",
"0.66934305",
"0.6676714",
"0.6676714",
"0.6676714",
"0.6673792",
"0.66581106",
"0.66523695",
"0.6... | 0.69515896 | 5 |
Simulate a DELETE request to a WSGI application. | def simulate_delete(self, path='/', **kwargs) -> _ResultBase:
return self.simulate_request('DELETE', path, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def simulate_delete(app, path, **kwargs) -> _ResultBase:\n return simulate_request(app, 'DELETE', path, **kwargs)",
"def DELETE(url, mime_type='text/html'):\n def_app = DefaultHttpRequestHandler()\n return def_app.RequestMap(url, methods=['DELETE'], produces=mime_type)",
"def delete(self, url):\n ... | [
"0.7797188",
"0.71777534",
"0.71736985",
"0.70925444",
"0.70724267",
"0.70549405",
"0.704958",
"0.69685084",
"0.6963123",
"0.69502246",
"0.68928",
"0.6853945",
"0.6848925",
"0.6831778",
"0.6790113",
"0.6769437",
"0.6737311",
"0.6704643",
"0.66841",
"0.65644574",
"0.6560369",
... | 0.65388966 | 22 |
Simulate a request to a WSGI application. | def simulate_request(self, *args, **kwargs) -> _ResultBase:
if self._default_headers:
# NOTE(kgriffs): Handle the case in which headers is explicitly
# set to None.
additional_headers = kwargs.get('headers', {}) or {}
merged_headers = self._default_headers.copy(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\r\n run_wsgi_app(app)",
"def test_get_wsgi_application(self):\n application = wsgi.get_wsgi_application()\n\n environ = RequestFactory()._base_environ(\n PATH_INFO=\"/taric_books/\",\n CONTENT_TYPE=\"text/html; charset=utf-8\",\n REQUEST_METHOD=\"GET\... | [
"0.7307371",
"0.7021598",
"0.69710606",
"0.68984705",
"0.6853446",
"0.67806476",
"0.67583996",
"0.66636604",
"0.6617578",
"0.660725",
"0.64848566",
"0.64848566",
"0.64848566",
"0.6472964",
"0.6458941",
"0.64460766",
"0.6415451",
"0.6404258",
"0.63989335",
"0.63785857",
"0.634... | 0.0 | -1 |
d = pd.read_csv("queryExamples.csv", sep=';', header=0, dtype=str) dt = np.asarray(d) exID = int(exID) return (dt[exID, 0], dt[exID, 2], dt[exID, 1], dt[exID, 3], dt[exID, 4]) | def loadExample(self, exID):
return "" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def FindIdxValues(X):\n data = X.select_dtypes(include=[\"float64\"])\n idx = np.argwhere(~np.isnan(data.values))\n idx[:, 1] += 4 # add ID variable columns\n StoE = pd.read_csv(\"msresist/data/MS/CPTAC/IDtoExperiment.csv\")\n assert all(StoE.iloc[:, 0] == data.columns), \"Sample labels don't match... | [
"0.57570755",
"0.5555972",
"0.55552924",
"0.5460718",
"0.5453514",
"0.54446",
"0.5435614",
"0.5430254",
"0.54152614",
"0.5390983",
"0.5363977",
"0.53600717",
"0.53240967",
"0.5307169",
"0.5247071",
"0.52451223",
"0.5243506",
"0.5241698",
"0.5207887",
"0.52031714",
"0.5197458"... | 0.0 | -1 |
d = pd.read_csv("queryExamples.csv", sep=';', header=0, dtype=str) dt = np.asarray(d) | def getExampleQueries(self, selectedID = 0):
return "" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def csv_2_numpy(file, path=INPUT_PATH, sep=',', type='int8'):\n file_path = path + file\n reader = csv.reader(open(file_path, \"r\"), delimiter=sep)\n x = list(reader)\n dataset = numpy.array(x).astype(type)\n return dataset",
"def line_to_data(line, np_array=True, dtype=int):\n if np_array:\n ... | [
"0.6832343",
"0.6506066",
"0.64984345",
"0.647986",
"0.6379363",
"0.63469446",
"0.63033277",
"0.63006586",
"0.61761343",
"0.6145286",
"0.61397374",
"0.6042658",
"0.6030253",
"0.6016271",
"0.6007008",
"0.60067964",
"0.5982973",
"0.59794915",
"0.5955656",
"0.59441096",
"0.59338... | 0.0 | -1 |
descriptorsDir = "descriptorsCSV/" descriptors = [f for f in listdir(descriptorsDir) if isfile(join(descriptorsDir, f))] html = "" | def getDescriptors(self, dsc = ""):
return "" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def findhtml(pathused,ticker,typ):\n\n allfiles = [] # initializing the return list\n pathused += \"/\"+ticker.upper()+\"/\"+typ # since SEC_edgar has a standard way to store files as its the Ticker and inside \n # sec-edgar-filings ==> AAPL ==> 10-K \n \n for ... | [
"0.592098",
"0.5837011",
"0.57708496",
"0.57358974",
"0.56856805",
"0.56537116",
"0.5609058",
"0.55295724",
"0.55270106",
"0.5513947",
"0.5473819",
"0.54421717",
"0.5438239",
"0.54315954",
"0.53197914",
"0.5316276",
"0.5309928",
"0.5302465",
"0.52725977",
"0.52526444",
"0.524... | 0.0 | -1 |
set session for current user | def set_current_user(self, user):
self.session['u'] = user.get().key.urlsafe() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_login(user):\n session[CURRENT_USER_KEY] = user.id",
"def set_su_user(self, su_user):\n self.request.session[AUTH_SESSION_KEY] = su_user.id\n self.request.session[AUTH_HASH_SESSION_KEY] = su_user.get_session_auth_hash()\n if su_user.id != self.auth_user.id:\n self.reques... | [
"0.740831",
"0.71369225",
"0.70445764",
"0.6964448",
"0.6953895",
"0.6869955",
"0.6834737",
"0.68247133",
"0.6789445",
"0.6729116",
"0.6723161",
"0.6709489",
"0.6669265",
"0.6656851",
"0.66272396",
"0.66168904",
"0.66127384",
"0.6612591",
"0.66067016",
"0.6592191",
"0.6569845... | 0.7985505 | 0 |
set session for current school that user choose when login | def set_current_school(self, school_key):
self.session['s'] = school_key | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def choose_school():\n if current_user.is_administrator():\n schools = School.query.order_by(School.long_name)\n else:\n schools = current_user.schools_coached\n\n # if initial get request, render add_school.html\n return render_template('choose_school.html', schools=schools)",
"def set... | [
"0.6246114",
"0.6165318",
"0.60238373",
"0.59813094",
"0.5963209",
"0.58441776",
"0.58033544",
"0.5755063",
"0.5727515",
"0.5708403",
"0.56811965",
"0.56026447",
"0.5592895",
"0.5572259",
"0.55581385",
"0.54835755",
"0.5440814",
"0.5436401",
"0.54343957",
"0.5427836",
"0.5427... | 0.7416146 | 0 |
set session for current admin | def setup_admin_session(self, user):
self.session['ad'] = user.get().key.urlsafe() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_current_user(self, user):\n self.session['u'] = user.get().key.urlsafe()",
"def login(test_app):\n from flask_monitoringdashboard import config\n\n with test_app.session_transaction() as sess:\n sess[config.link + '_logged_in'] = True\n sess[config.link + '_admin'] = True",
"... | [
"0.64475083",
"0.640205",
"0.63752884",
"0.6369683",
"0.63622195",
"0.62239605",
"0.6216995",
"0.6164825",
"0.61162066",
"0.60842025",
"0.6078582",
"0.60669124",
"0.6065299",
"0.60632056",
"0.60338914",
"0.6033646",
"0.6027066",
"0.6002428",
"0.5977556",
"0.59413683",
"0.5925... | 0.743749 | 0 |
Logout and delete all session | def get(self, *args, **kwargs):
for key in self.session.keys():
del self.session[key]
self.redirect("/admin/authentication/login") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def logout(self):\n self.session.disconnect()",
"def do_logout():\n del session[CURRENT_USER_KEY]",
"def logout():\n _cookies = ['user', 'pass', 'hash']\n for cookie in _cookies:\n util.web.delete_cookie(cookie)",
"def logout(self):\n pass",
"def logout():\n rin... | [
"0.80323476",
"0.8031286",
"0.79632694",
"0.7731124",
"0.76978016",
"0.7690662",
"0.76204586",
"0.7595756",
"0.7579269",
"0.7578065",
"0.75664246",
"0.7563226",
"0.75515246",
"0.75192845",
"0.75122255",
"0.75072306",
"0.75061965",
"0.7460927",
"0.7455791",
"0.7447719",
"0.743... | 0.0 | -1 |
Returns tuple, x position of center, y position of center | def findEgg(self, image, lower, upper):
lower = np.array(lower)
upper = np.array(upper)
shapeMask = cv2.inRange(image, lower, upper)
# find the contours in the mask
cnts = cv2.findContours(shapeMask.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
cnts = imutils.grab_contours(cnts)
# loop over the... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def center(self) -> Tuple[int, int]:\n center_x = int((self.x1 + self.x2) // 2)\n center_y = int((self.y1 + self.y2) // 2)\n return (center_x, center_y)",
"def center(self):\n xc = (self.x.max() + self.x.min())/2.\n yc = (self.y.max() + self.y.min())/2.\n return (xc, yc)... | [
"0.8680406",
"0.8341965",
"0.8323294",
"0.82362115",
"0.80616033",
"0.8031392",
"0.80029976",
"0.7967143",
"0.7940467",
"0.787328",
"0.7865948",
"0.78087837",
"0.7706403",
"0.7674429",
"0.76208365",
"0.7598615",
"0.75848573",
"0.757273",
"0.75388604",
"0.75382733",
"0.7524019... | 0.0 | -1 |
Just generate all possible payloads and return them in a list. Ignore the `incomings` parameter because there are no inputs. | def process(self, incomings):
payloads = []
payloads.append(["../../../../../../../../var/www/attacker.com/public_html/", "image.jpg"])
payloads.append(["L2V0Yy9wYXNzd2Q="])
payloads.append(["TDJWMFl5OXdZWE56ZDJRPQ%3D%3D"])
#Contains the various types of directory pathing
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_payload(self):\n payload = []\n for i in range(self.elements_per_update):\n payload.append({\n \"uuid\": str(uuid.uuid4()),\n \"symbol\": self.symbols[i % len(self.symbols)],\n \"price\": random.randint(self.min_price, self.max_pric... | [
"0.6261763",
"0.6098073",
"0.5758599",
"0.5671333",
"0.5661374",
"0.54746294",
"0.54583114",
"0.54393774",
"0.53984535",
"0.53903353",
"0.53893536",
"0.5371747",
"0.53708667",
"0.5354138",
"0.53407294",
"0.5324242",
"0.5261285",
"0.5215311",
"0.51777387",
"0.5169679",
"0.5144... | 0.0 | -1 |
generate a gaussian kernel | def gaussian_kernel(kernel_size: (int, tuple, list), width: float):
kernel_size = np.asarray(to_list(kernel_size, 2), np.float)
half_ksize = (kernel_size - 1) / 2.0
x, y = np.mgrid[-half_ksize[0]:half_ksize[0] + 1,
-half_ksize[1]:half_ksize[1] + 1]
kernel = np.exp(-(x ** 2 + y ** 2) / (2 * width ** 2)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def makeGaussianKernel(sigma: float) -> np.ndarray:\n\n # Your code here.\n kernel_size = 8*sigma+1\n kernel = np.zeros([kernel_size,kernel_size], dtype=float)\n center = kernel_size//2\n \n \n s = 2*(sigma**2)\n sum_val = 0\n for i in range(0,kernel_size):\n for j in range(0,kern... | [
"0.77656406",
"0.7668909",
"0.76349425",
"0.7562456",
"0.7491493",
"0.74768865",
"0.74616927",
"0.74480236",
"0.7444865",
"0.74286896",
"0.74195147",
"0.7407134",
"0.7398218",
"0.7387571",
"0.7384498",
"0.73416746",
"0.72804046",
"0.72344667",
"0.7227005",
"0.72260153",
"0.71... | 0.741546 | 11 |
generate anisotropic gaussian kernel | def anisotropic_gaussian_kernel(kernel_size: (int, tuple, list), theta: float,
l1: float, l2: float):
def gmdistribution(mu, sigma):
half_k = (kernel_size - 1) / 2.0
x, y = np.mgrid[-half_k[0]:half_k[0] + 1, -half_k[1]:half_k[1] + 1]
X = np.expand_dims(np.stack([y, x], axi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def makeGaussianKernel(sigma: float) -> np.ndarray:\n\n # Your code here.\n kernel_size = 8*sigma+1\n kernel = np.zeros([kernel_size,kernel_size], dtype=float)\n center = kernel_size//2\n \n \n s = 2*(sigma**2)\n sum_val = 0\n for i in range(0,kernel_size):\n for j in range(0,kern... | [
"0.77107793",
"0.7641565",
"0.7404558",
"0.73151636",
"0.7284177",
"0.7278752",
"0.7257874",
"0.725323",
"0.7217436",
"0.72001195",
"0.71902305",
"0.7181965",
"0.71761817",
"0.7167993",
"0.71560705",
"0.7080714",
"0.7077858",
"0.7072405",
"0.7039239",
"0.7037398",
"0.70350915... | 0.65793484 | 62 |
Estimated CRF, transform irradiance L to RGB image. If `crf_table` is inverted, transform RGB image to irradiance L. | def camera_response_function(inputs, crf_table, max_val=1):
inputs_norm = np.clip(inputs / max_val, 0, 1)
quant = crf_table.shape[0] - 1
inputs_index = (inputs_norm * quant).astype('int32')
ret = []
for i in inputs_index.flatten():
ret.append(crf_table[i])
return np.reshape(ret, inputs.shape) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def crf_refine(label,\n img,\n crf_theta_slider_value,\n crf_mu_slider_value,\n crf_downsample_factor,\n gt_prob):\n\n Horig = label.shape[0]\n Worig = label.shape[1]\n\n l_unique = np.unique(label.flatten())#.tolist()\n scale = 1+(5 * (np.array(img.shape).max() / 3000))\n logging.inf... | [
"0.543145",
"0.54256666",
"0.54248387",
"0.537617",
"0.5180758",
"0.5143052",
"0.50994086",
"0.5099363",
"0.5006858",
"0.49987954",
"0.49229413",
"0.49061176",
"0.4905395",
"0.48856765",
"0.48807964",
"0.48664606",
"0.4861298",
"0.48559242",
"0.48515674",
"0.48475456",
"0.483... | 0.52573466 | 4 |
Consolidates based on filing type upto the given transaction id of a filing. | def get_revision(filing_id, business_id):
business = Business.find_by_internal_id(business_id)
filing = Filing.find_by_id(filing_id)
revision_json = {}
revision_json['filing'] = {}
if filing.filing_type == 'incorporationApplication':
revision_json['filing'] = \
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def consolidate(self, *args, **kwargs):\n kwargs['mode'] = 'consolidate'\n kwargs['mix_before'] = (0, 0)\n kwargs['air_gap'] = 0\n kwargs['disposal_vol'] = 0\n return self.transfer(*args, **kwargs)",
"def merge_supplier_transaction(cleaned_supplier_data, cleaned_transaction_dat... | [
"0.49317023",
"0.47416252",
"0.45447615",
"0.4507857",
"0.44511983",
"0.4415977",
"0.43252644",
"0.43213362",
"0.43195716",
"0.43165377",
"0.43093824",
"0.42502373",
"0.42033148",
"0.42021173",
"0.42003173",
"0.41973242",
"0.41731387",
"0.416284",
"0.41517442",
"0.41230783",
... | 0.0 | -1 |
Consolidates incorporation application upto the given transaction id of a filing. | def get_ia_revision(filing, business) -> dict:
ia_json = {}
ia_json['business'] = \
VersionedBusinessDetailsService.get_business_revision(filing.transaction_id, business)
ia_json['incorporationApplication'] = {}
ia_json['incorporationApplication']['offices'] = \
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def consolidate(self, *args, **kwargs):\n kwargs['mode'] = 'consolidate'\n kwargs['mix_before'] = (0, 0)\n kwargs['air_gap'] = 0\n kwargs['disposal_vol'] = 0\n return self.transfer(*args, **kwargs)",
"def apply(self, transaction, context):\n\n header = transaction.header... | [
"0.51854515",
"0.4774149",
"0.47555128",
"0.45698297",
"0.4471355",
"0.44628233",
"0.4445196",
"0.44214734",
"0.44129953",
"0.44041756",
"0.43950042",
"0.43621913",
"0.43494466",
"0.43302774",
"0.42848316",
"0.42814407",
"0.42765537",
"0.42567483",
"0.4235328",
"0.4192869",
"... | 0.0 | -1 |
Consolidates change of directors upto the given transaction id of a filing. | def get_cod_revision(filing, business) -> dict:
cod_json = {}
cod_json['business'] = \
VersionedBusinessDetailsService.get_business_revision(filing.transaction_id, business)
cod_json['changeOfDirectors'] = {}
cod_json['changeOfDirectors']['directors'] = \
Version... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def action_process(self):\n self.check_difference_balance()\n for statement in self:\n statement_lines = statement.credit_move_line_ids + statement.debit_move_line_ids\n for statement_line in statement_lines:\n if statement_line.move_line_id:\n ... | [
"0.48786485",
"0.47393093",
"0.46903118",
"0.4683563",
"0.4673902",
"0.46331817",
"0.4600814",
"0.45809242",
"0.44975787",
"0.4429772",
"0.44205922",
"0.4400462",
"0.43680486",
"0.43663508",
"0.43542743",
"0.43518484",
"0.43416554",
"0.43398026",
"0.43324035",
"0.43308827",
"... | 0.0 | -1 |
Consolidates change of address upto the given transaction id of a filing. | def get_coa_revision(filing, business) -> dict:
coa_json = {}
coa_json['business'] = \
VersionedBusinessDetailsService.get_business_revision(filing.transaction_id, business)
coa_json['changeOfAddress'] = {}
coa_json['changeOfAddress']['offices'] = \
VersionedBusi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ship_to_pickup_address(self, address):\n self._set('shipping', 'pickup_address_id', address.id)",
"def deposit_to_account(list_of_all_accounts_known, ID_account_to_deposit_to, money_amount_to_deposit):\n for account in list_of_all_accounts_known:\n if ID_account_to_deposit_to == acco... | [
"0.50302166",
"0.49903312",
"0.4896131",
"0.48416403",
"0.47821873",
"0.47475737",
"0.47422007",
"0.4726105",
"0.47027257",
"0.46690908",
"0.4667114",
"0.46177053",
"0.46153784",
"0.45717567",
"0.45618382",
"0.45515",
"0.45197892",
"0.4490286",
"0.44608918",
"0.44540498",
"0.... | 0.0 | -1 |
Consolidates annual report upto the given transaction id of a filing. | def get_ar_revision(filing, business) -> dict:
ar_json = {}
ar_json['business'] = \
VersionedBusinessDetailsService.get_business_revision(filing.transaction_id, business)
ar_json['annualReport'] = {}
if business.last_ar_date:
ar_json['annualReport']['annualRepor... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prep_incorp_filing(session, identifier, payment_id, option, legal_type=None):\n business = create_business(identifier, legal_type=legal_type, legal_name=LEGAL_NAME)\n filing_template = copy.deepcopy(INCORPORATION_FILING_TEMPLATE)\n filing_template['filing']['business'] = {'identifier': business.identi... | [
"0.5235263",
"0.50493723",
"0.50060093",
"0.49657115",
"0.49402353",
"0.4779273",
"0.47779074",
"0.47531906",
"0.47376817",
"0.47280854",
"0.46448475",
"0.4634219",
"0.46263924",
"0.46233433",
"0.4618344",
"0.46152997",
"0.46138",
"0.46027547",
"0.4588643",
"0.45828047",
"0.4... | 0.0 | -1 |
Retrieve header from filing. | def get_header_revision(filing) -> dict:
_header = filing.json['filing']['header']
return _header | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_header(self):\n return self._header",
"def header(self):\n return self[0]",
"def getHeader():\n return _HEADER",
"def header(self):\r\n return self.__header",
"def getHeader(self):\n return self.data.header",
"def _get_header(self, header):\n if header is Non... | [
"0.75873977",
"0.7430095",
"0.7323195",
"0.7295065",
"0.7293838",
"0.7291236",
"0.72339875",
"0.72339875",
"0.72339875",
"0.7061032",
"0.70011765",
"0.6993449",
"0.6981213",
"0.69021666",
"0.68439883",
"0.6841015",
"0.6840614",
"0.68289",
"0.67658603",
"0.6764321",
"0.6752381... | 0.7422671 | 2 |
Consolidates company details upto the given transaction id of a filing. | def get_company_details_revision(filing_id, business_id) -> dict:
company_profile_json = {}
business = Business.find_by_internal_id(business_id)
filing = Filing.find_by_id(filing_id)
company_profile_json['business'] = \
VersionedBusinessDetailsService.get_business_revision(fi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prep_alteration_filing(session, identifier, option, company_name):\n business = create_business(identifier, legal_type=Business.LegalTypes.BCOMP.value, legal_name=company_name)\n filing_template = copy.deepcopy(ALTERATION_FILING_TEMPLATE)\n filing_template['filing']['business'] = \\\n {'identif... | [
"0.53339934",
"0.5223322",
"0.5197929",
"0.5141939",
"0.5136625",
"0.48747456",
"0.48442817",
"0.48181129",
"0.4786767",
"0.47192055",
"0.46794316",
"0.46114996",
"0.45652616",
"0.4548141",
"0.45259282",
"0.4521646",
"0.45143613",
"0.45140252",
"0.44780788",
"0.44776148",
"0.... | 0.4687291 | 10 |
Consolidates the business info as of a particular transaction. | def get_business_revision(transaction_id, business) -> dict:
business_version = version_class(Business)
business_revision = db.session.query(business_version) \
.filter(business_version.transaction_id <= transaction_id) \
.filter(business_version.operation_type != 2) \
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __preprocess_transactions(self):\n\n p_bar = tqdm(range(14), desc=\"Preprocessing transactions\", leave=False)\n\n try:\n # 0. If optional fields not in the transactions add missing\n optional_fields = [\n \"Sector\",\n \"Industry\",\n ... | [
"0.54886127",
"0.53659767",
"0.5251373",
"0.5233803",
"0.5204309",
"0.51957595",
"0.5115674",
"0.5096284",
"0.5044581",
"0.5029625",
"0.49510285",
"0.489361",
"0.48638722",
"0.48422092",
"0.484127",
"0.4826738",
"0.48115295",
"0.48094976",
"0.48029786",
"0.47919956",
"0.47744... | 0.0 | -1 |
Return business version object associated with a given transaction id for a business. | def get_business_revision_obj(transaction_id, business):
business_version = version_class(Business)
business_revision = db.session.query(business_version) \
.filter(business_version.transaction_id <= transaction_id) \
.filter(business_version.operation_type != 2) \
.f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_business_revision(transaction_id, business) -> dict:\n business_version = version_class(Business)\n business_revision = db.session.query(business_version) \\\n .filter(business_version.transaction_id <= transaction_id) \\\n .filter(business_version.operation_type != 2) \... | [
"0.7636616",
"0.6377281",
"0.6335256",
"0.63015807",
"0.6286003",
"0.6253474",
"0.6029115",
"0.5956254",
"0.5956254",
"0.5956254",
"0.593759",
"0.5815979",
"0.5777107",
"0.5764829",
"0.57134163",
"0.55761206",
"0.5534498",
"0.5525413",
"0.55233735",
"0.5461759",
"0.5421985",
... | 0.8101256 | 0 |
Get business info with last value of dissolution_date or restoration_expiry_date. | def find_last_value_from_business_revision(transaction_id, business_id,
is_dissolution_date=False,
is_restoration_expiry_date=False) -> dict:
business_version = version_class(Business)
query = db.session.query(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_adv_acct_business(clean_data, all_slot_coupons, this_advertiser):\n business_id = clean_data['business_id']\n if business_id:\n business = Business.objects.get(id=business_id)\n elif all_slot_coupons:\n # Select the business with the most recently added slot_time_frame.\n busi... | [
"0.63183683",
"0.59914434",
"0.53736246",
"0.5331287",
"0.5306034",
"0.5255722",
"0.51936203",
"0.51891106",
"0.51854855",
"0.51780736",
"0.51550066",
"0.5148936",
"0.5130781",
"0.50994205",
"0.5098762",
"0.5097678",
"0.50936073",
"0.50932556",
"0.50902474",
"0.50853217",
"0.... | 0.6853517 | 0 |
Consolidates the business info as of a particular transaction. | def get_business_revision_after_filing(filing_id, business_id) -> dict:
business = Business.find_by_internal_id(business_id)
filing = Filing.find_by_id(filing_id)
business_version = version_class(Business)
business_revision = db.session.query(business_version) \
.filter(busin... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __preprocess_transactions(self):\n\n p_bar = tqdm(range(14), desc=\"Preprocessing transactions\", leave=False)\n\n try:\n # 0. If optional fields not in the transactions add missing\n optional_fields = [\n \"Sector\",\n \"Industry\",\n ... | [
"0.5488286",
"0.5367723",
"0.5251625",
"0.52338696",
"0.5204787",
"0.51965904",
"0.5116716",
"0.50968915",
"0.50451744",
"0.50295514",
"0.49521682",
"0.4893911",
"0.48631588",
"0.48414692",
"0.4840194",
"0.48270077",
"0.4810524",
"0.48089162",
"0.48022336",
"0.47932863",
"0.4... | 0.0 | -1 |
Consolidates all office changes upto the given transaction id. | def get_office_revision(transaction_id, business_id) -> dict:
offices_json = {}
address_version = version_class(Address)
offices_version = version_class(Office)
offices = db.session.query(offices_version) \
.filter(offices_version.transaction_id <= transaction_id) \
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def all_transactions(self):\n self._update()\n with self.all_tx_lock:\n all_tx_copy = copy.deepcopy(self._all_transactions)\n return all_tx_copy",
"def clean_transactions(transactions):\n\n #Preprocessing\n df = create_datetime_col(transactions)\n\n #Dropping transactions... | [
"0.50735056",
"0.5040346",
"0.4986473",
"0.49364966",
"0.48510218",
"0.4845584",
"0.4815689",
"0.47919053",
"0.47557163",
"0.4748652",
"0.4742432",
"0.4703487",
"0.46967387",
"0.4665292",
"0.46559128",
"0.4577299",
"0.45496902",
"0.45431966",
"0.4524736",
"0.45118833",
"0.449... | 0.4638672 | 15 |
Consolidates all party changes upto the given transaction id. | def get_party_role_revision(transaction_id, business_id, is_ia_or_after=False, role=None) -> dict:
party_role_version = version_class(PartyRole)
party_roles = db.session.query(party_role_version)\
.filter(party_role_version.transaction_id <= transaction_id) \
.filter(party_role_v... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def consolidate(self, *args, **kwargs):\n kwargs['mode'] = 'consolidate'\n kwargs['mix_before'] = (0, 0)\n kwargs['air_gap'] = 0\n kwargs['disposal_vol'] = 0\n return self.transfer(*args, **kwargs)",
"def _merge_block(internal_transactions, transactions, whitelist):\n transa... | [
"0.52449286",
"0.5035682",
"0.50141925",
"0.50126517",
"0.4967316",
"0.48978275",
"0.48791042",
"0.48038042",
"0.47823894",
"0.4781556",
"0.47617856",
"0.47498944",
"0.47413868",
"0.4725821",
"0.47131774",
"0.4705725",
"0.46827042",
"0.46808237",
"0.46777833",
"0.46600205",
"... | 0.0 | -1 |
Consolidates all share classes upto the given transaction id. | def get_share_class_revision(transaction_id, business_id) -> dict:
share_class_version = version_class(ShareClass)
share_classes_list = db.session.query(share_class_version) \
.filter(share_class_version.transaction_id <= transaction_id) \
.filter(share_class_version.operation_ty... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def group_by_namespace(self):\n package = self.container.config.output.package\n groups = collections.group_by(self.container, key=get_target_namespace)\n for namespace, classes in groups.items():\n self.assign(classes, package, namespace or \"\")",
"def group_by_strong_components... | [
"0.5139013",
"0.50330913",
"0.48715967",
"0.48479706",
"0.48171863",
"0.4742321",
"0.46083876",
"0.45552248",
"0.4535983",
"0.4531581",
"0.45151782",
"0.44682208",
"0.4465922",
"0.44380042",
"0.44106326",
"0.44035476",
"0.44020128",
"0.4396122",
"0.43579513",
"0.43411663",
"0... | 0.5442146 | 0 |
Consolidates all share series under the share class upto the given transaction id. | def get_share_series_revision(transaction_id, share_class_id) -> dict:
share_series_version = version_class(ShareSeries)
share_series_list = db.session.query(share_series_version) \
.filter(share_series_version.transaction_id <= transaction_id) \
.filter(share_series_version.oper... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_share_class_revision(transaction_id, business_id) -> dict:\n share_class_version = version_class(ShareClass)\n share_classes_list = db.session.query(share_class_version) \\\n .filter(share_class_version.transaction_id <= transaction_id) \\\n .filter(share_class_version.o... | [
"0.5190824",
"0.5187994",
"0.5142222",
"0.5073142",
"0.4927391",
"0.49156842",
"0.48170972",
"0.48046333",
"0.47612914",
"0.4756013",
"0.46777904",
"0.46077105",
"0.45642272",
"0.45364735",
"0.45220184",
"0.44816855",
"0.4480779",
"0.44729975",
"0.44729114",
"0.44596547",
"0.... | 0.55091697 | 0 |
Consolidates all name translations upto the given transaction id. | def get_name_translations_revision(transaction_id, business_id) -> dict:
name_translations_version = version_class(Alias)
name_translations_list = db.session.query(name_translations_version) \
.filter(name_translations_version.transaction_id <= transaction_id) \
.filter(name_tran... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_name_translations_before_revision(transaction_id, business_id) -> dict:\n name_translations_version = version_class(Alias)\n name_translations_list = db.session.query(name_translations_version) \\\n .filter(name_translations_version.transaction_id <= transaction_id) \\\n ... | [
"0.55154634",
"0.54775083",
"0.5125466",
"0.48724905",
"0.48452628",
"0.48440036",
"0.47670454",
"0.47247544",
"0.46813482",
"0.46743435",
"0.4670805",
"0.46494198",
"0.4585894",
"0.45795876",
"0.45453605",
"0.447221",
"0.44493878",
"0.44377983",
"0.43929964",
"0.43859535",
"... | 0.5474167 | 2 |
Consolidates all name translations before deletion given a transaction id. | def get_name_translations_before_revision(transaction_id, business_id) -> dict:
name_translations_version = version_class(Alias)
name_translations_list = db.session.query(name_translations_version) \
.filter(name_translations_version.transaction_id <= transaction_id) \
.filter(na... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_translated_ids(id, event=True):",
"def remove_transcripts_from_store(_step, subs_id):\r\n filename = 'subs_{0}.srt.sjson'.format(subs_id.strip())\r\n content_location = StaticContent.compute_location(\r\n world.scenario_dict['COURSE'].id,\r\n filename\r\n )\r\n try:\r\n ... | [
"0.6055344",
"0.55234",
"0.545676",
"0.5236792",
"0.5174594",
"0.513172",
"0.5046025",
"0.4999335",
"0.49556133",
"0.491088",
"0.48742318",
"0.48695627",
"0.4771532",
"0.47713655",
"0.47671568",
"0.47589326",
"0.47411644",
"0.47401896",
"0.46936035",
"0.46862566",
"0.46729362... | 0.49059632 | 10 |
Consolidates all resolutions upto the given transaction id. | def get_resolution_dates_revision(transaction_id, business_id) -> dict:
resolution_version = version_class(Resolution)
resolution_list = db.session.query(resolution_version) \
.filter(resolution_version.transaction_id <= transaction_id) \
.filter(resolution_version.operation_type... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transform_datasource(transaction_id):\n from .models import UploadTransaction\n tx = UploadTransaction.objects.get(tx_id=transaction_id)\n tx.run()\n # return tx",
"def aggregateTxnsByRoutes(self, txnSubCollection, ancestry):\n from xpedite.types.route import conflateRoutes\n srcRouteMap = ... | [
"0.5312851",
"0.50690717",
"0.47930416",
"0.4660941",
"0.4579437",
"0.4526906",
"0.45195293",
"0.44836763",
"0.44236094",
"0.44093966",
"0.43754494",
"0.4348329",
"0.43352583",
"0.43277034",
"0.43260756",
"0.43129936",
"0.42875925",
"0.42719135",
"0.42505714",
"0.4243466",
"0... | 0.42772335 | 17 |
Return the party member as a json object. | def party_role_revision_json(transaction_id, party_role_revision, is_ia_or_after) -> dict:
cessation_date = datetime.date(party_role_revision.cessation_date).isoformat()\
if party_role_revision.cessation_date else None
party_revision = VersionedBusinessDetailsService.get_party_revision(trans... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_person_like_json(self):\n return json.dumps(self.get_person())",
"def test_party_json(session):\n party = MhrParty(\n id=1000,\n party_type = MhrPartyTypes.OWNER_BUS,\n status_type = MhrOwnerStatusTypes.ACTIVE,\n business_name='BUSINESS',\n email_id='test@gmai... | [
"0.67256284",
"0.6194612",
"0.6118959",
"0.61017704",
"0.6004083",
"0.59829235",
"0.5981926",
"0.59675497",
"0.58262146",
"0.58163095",
"0.5804764",
"0.5765838",
"0.5736367",
"0.5731408",
"0.5728028",
"0.57178354",
"0.5710809",
"0.56677073",
"0.5652171",
"0.5628076",
"0.56238... | 0.0 | -1 |
Consolidates all party changes upto the given transaction id. | def get_party_revision(transaction_id, party_id) -> dict:
party_version = version_class(Party)
party = db.session.query(party_version) \
.filter(party_version.transaction_id <= transaction_id) \
.filter(party_version.operation_type != 2) \
.filter(party_version.id == ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def consolidate(self, *args, **kwargs):\n kwargs['mode'] = 'consolidate'\n kwargs['mix_before'] = (0, 0)\n kwargs['air_gap'] = 0\n kwargs['disposal_vol'] = 0\n return self.transfer(*args, **kwargs)",
"def _merge_block(internal_transactions, transactions, whitelist):\n transa... | [
"0.5245135",
"0.50370425",
"0.5016701",
"0.5013465",
"0.49686235",
"0.48996598",
"0.4880607",
"0.4806052",
"0.47830546",
"0.478216",
"0.47636852",
"0.4749744",
"0.47431743",
"0.47264412",
"0.47150174",
"0.47077274",
"0.46826148",
"0.46816784",
"0.4679912",
"0.46609294",
"0.46... | 0.0 | -1 |
Return the party member by type as a json object. | def party_revision_type_json(party_revision, is_ia_or_after) -> dict:
member = {}
if party_revision.party_type == Party.PartyTypes.PERSON.value:
member = {
'officer': {
'firstName': party_revision.first_name,
'lastName': party_revision.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_person_like_json(self):\n return json.dumps(self.get_person())",
"def json(self):\n return {'name': self.neighbourhood_group, 'neighbourhood': self.room_type}",
"def to_json(self):\r\n return {'type': self.type, 'name': self.name}",
"def test_party_json(session):\n party = Mhr... | [
"0.59179246",
"0.5765067",
"0.5714951",
"0.5656859",
"0.5601924",
"0.5516952",
"0.5516952",
"0.55098546",
"0.54318315",
"0.5260781",
"0.52107835",
"0.52107835",
"0.52107835",
"0.52107835",
"0.5145145",
"0.5145117",
"0.5118637",
"0.5068482",
"0.50048494",
"0.4981137",
"0.49722... | 0.65182054 | 0 |
Return the party member as a json object. | def party_revision_json(transaction_id, party_revision, is_ia_or_after) -> dict:
member = VersionedBusinessDetailsService.party_revision_type_json(party_revision, is_ia_or_after)
if party_revision.delivery_address_id:
address_revision = VersionedBusinessDetailsService.get_address_revision(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_person_like_json(self):\n return json.dumps(self.get_person())",
"def test_party_json(session):\n party = MhrParty(\n id=1000,\n party_type = MhrPartyTypes.OWNER_BUS,\n status_type = MhrOwnerStatusTypes.ACTIVE,\n business_name='BUSINESS',\n email_id='test@gmai... | [
"0.67284685",
"0.6194194",
"0.611997",
"0.61034185",
"0.6006451",
"0.59830326",
"0.598254",
"0.58288425",
"0.58197945",
"0.5802139",
"0.57688975",
"0.57374674",
"0.57333785",
"0.57320225",
"0.5719263",
"0.57135916",
"0.56694216",
"0.56546605",
"0.5631167",
"0.562607",
"0.5608... | 0.59668255 | 7 |
Consolidates all party changes upto the given transaction id. | def get_address_revision(transaction_id, address_id) -> dict:
address_version = version_class(Address)
address = db.session.query(address_version) \
.filter(address_version.transaction_id <= transaction_id) \
.filter(address_version.operation_type != 2) \
.filter(addr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def consolidate(self, *args, **kwargs):\n kwargs['mode'] = 'consolidate'\n kwargs['mix_before'] = (0, 0)\n kwargs['air_gap'] = 0\n kwargs['disposal_vol'] = 0\n return self.transfer(*args, **kwargs)",
"def _merge_block(internal_transactions, transactions, whitelist):\n transa... | [
"0.5244963",
"0.5036844",
"0.50164324",
"0.50134957",
"0.49683398",
"0.48991808",
"0.488158",
"0.48052537",
"0.4783525",
"0.47817028",
"0.47629765",
"0.4749287",
"0.47427288",
"0.47258097",
"0.4714521",
"0.47077513",
"0.4681658",
"0.46814072",
"0.46796298",
"0.46607122",
"0.4... | 0.0 | -1 |
Return a dict of this object, with keys in JSON format. | def address_revision_json(address_revision):
country_description = ''
if address_revision.country:
country_description = pycountry.countries.search_fuzzy(address_revision.country)[0].name
return {
'streetAddress': address_revision.street,
'streetAddressAdditio... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def json(self):\n return json.dumps(self, default=lambda o: o.__dict__,\n sort_keys=True, indent=4)",
"def to_json(self) -> Dict[str, Any]:\n return self.__dict__",
"def json(self):\n return {\n 'id': self.id,\n 'name': self.name\n }",
... | [
"0.8144109",
"0.8142001",
"0.8105588",
"0.796904",
"0.7954904",
"0.7867204",
"0.78586286",
"0.7856205",
"0.7856205",
"0.785492",
"0.785492",
"0.785492",
"0.7854319",
"0.7854319",
"0.7854319",
"0.783863",
"0.783863",
"0.783863",
"0.783863",
"0.7835416",
"0.7831754",
"0.78317... | 0.0 | -1 |
Return the share_class as a json object. | def share_class_revision_json(share_class_revision) -> dict:
share_class = {
'id': share_class_revision.id,
'name': share_class_revision.name,
'priority': share_class_revision.priority,
'hasMaximumShares': share_class_revision.max_share_flag,
'maxNumbe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_json(self):\n obj_dict = self.__dict__\n obj_dict[\"_class_\"] = self.__class__.__name__\n return obj_dict",
"def cls2json(self):\n return json.dumps(self.__dict__)",
"def cls2json(self):\n return json.dumps(self.__dict__)",
"def to_dict(self):\n result = supe... | [
"0.64385223",
"0.64294195",
"0.64294195",
"0.6168101",
"0.599551",
"0.5803228",
"0.57021445",
"0.57014143",
"0.5676124",
"0.5641927",
"0.5622269",
"0.5605307",
"0.55982053",
"0.55899024",
"0.55899024",
"0.55899024",
"0.5582552",
"0.55741054",
"0.5545515",
"0.5539542",
"0.5539... | 0.692662 | 0 |
Return the share series revision as a json object. | def share_series_revision_json(share_series_revision) -> dict:
share_series = {
'id': share_series_revision.id,
'name': share_series_revision.name,
'priority': share_series_revision.priority,
'hasMaximumShares': share_series_revision.max_share_flag,
'm... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_share_series_revision(transaction_id, share_class_id) -> dict:\n share_series_version = version_class(ShareSeries)\n share_series_list = db.session.query(share_series_version) \\\n .filter(share_series_version.transaction_id <= transaction_id) \\\n .filter(share_series_v... | [
"0.708846",
"0.6720135",
"0.6084429",
"0.58188486",
"0.5759813",
"0.5623428",
"0.5623428",
"0.5560211",
"0.55411124",
"0.55097365",
"0.5487668",
"0.54803145",
"0.54494274",
"0.5414318",
"0.539694",
"0.5353764",
"0.52968645",
"0.5291189",
"0.52851427",
"0.5240236",
"0.52177316... | 0.8145801 | 0 |
Return the name translation revision as a json object. | def name_translations_json(name_translation_revision) -> dict:
name_translation = {
'id': str(name_translation_revision.id),
'name': name_translation_revision.alias,
'type': name_translation_revision.type
}
return name_translation | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def revision_name(self):\n return self._revision_name",
"def get_name_translations_revision(transaction_id, business_id) -> dict:\n name_translations_version = version_class(Alias)\n name_translations_list = db.session.query(name_translations_version) \\\n .filter(name_translation... | [
"0.63252676",
"0.6090434",
"0.59809774",
"0.59141386",
"0.5811075",
"0.5675912",
"0.5657325",
"0.5536982",
"0.54140645",
"0.5410727",
"0.54099125",
"0.5404105",
"0.53842735",
"0.5366681",
"0.5348114",
"0.53427243",
"0.53400004",
"0.5282428",
"0.5273558",
"0.5273386",
"0.52596... | 0.81740797 | 0 |
Return the resolution revision as a json object. | def resolution_json(resolution_revision) -> dict:
resolution = {
'id': resolution_revision.id,
'date': resolution_revision.resolution_date.strftime('%B %-d, %Y'),
'type': resolution_revision.resolution_type
}
return resolution | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_json(self):\n return {\n 'revision': self.revision,\n 'active': self.active,\n 'archived_at': self.archived_at\n }",
"def revision(self):\n return self._revision",
"def revision(self):\n return self._revision",
"def get_revision(self) -> str... | [
"0.6687245",
"0.6393448",
"0.6393448",
"0.62428397",
"0.62007344",
"0.6174118",
"0.6029406",
"0.6012772",
"0.59804827",
"0.5977369",
"0.59660566",
"0.5938327",
"0.5914053",
"0.58789593",
"0.5854711",
"0.58510196",
"0.58412087",
"0.5827877",
"0.5823848",
"0.57971644",
"0.57879... | 0.7941922 | 0 |
Return the business revision as a json object. | def business_revision_json(business_revision, business_json):
business_json['hasRestrictions'] = business_revision.restriction_ind
business_json['dissolutionDate'] = LegislationDatetime.format_as_legislation_date(
business_revision.dissolution_date) if business_revision.dissolution_date else... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_json(self):\n return {\n 'revision': self.revision,\n 'active': self.active,\n 'archived_at': self.archived_at\n }",
"def get_cod_revision(filing, business) -> dict:\n cod_json = {}\n\n cod_json['business'] = \\\n VersionedBusinessDet... | [
"0.73196644",
"0.7150604",
"0.6965336",
"0.69643956",
"0.6898412",
"0.6647638",
"0.6617927",
"0.64494884",
"0.6417139",
"0.6356839",
"0.6356563",
"0.6326582",
"0.618475",
"0.61779064",
"0.6150429",
"0.6115579",
"0.61032957",
"0.6018561",
"0.6018561",
"0.6005441",
"0.59775114"... | 0.76480556 | 0 |
Return incorporation agreement from filing json. | def get_incorporation_agreement_json(filing):
return filing.json['filing']['incorporationApplication'].get('incorporationAgreement', {}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_agreement(self):\n pass",
"def agreements():\n pass",
"def reconcile_somef_data(data):\n out = {}\n for key, value in data.items():\n # for now, we are not exporting provenance keys. Ignore all keys like somef_provenance\n if \"somef\" not in key:\n ... | [
"0.56559736",
"0.55618954",
"0.5244109",
"0.5151223",
"0.5143148",
"0.5112683",
"0.5045774",
"0.49902293",
"0.4906993",
"0.48691648",
"0.48342612",
"0.4829858",
"0.48195443",
"0.48008758",
"0.478164",
"0.47634107",
"0.47534582",
"0.47188726",
"0.47175965",
"0.4712452",
"0.465... | 0.7839245 | 0 |
Return name request from filing json. | def get_name_request_revision(filing):
return filing.json['filing']['incorporationApplication'].get('nameRequest', {}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def name(self):\r\n return self.data[\"name\"]",
"def name(self) -> str:\n\t\treturn self._raw_result['name']",
"def name(self):\n return self.raw.get(\"name\")",
"def name(self):\n return self._data.get('name')",
"def name(self):\n return self._data.get('name')",
"def name(se... | [
"0.6360576",
"0.614522",
"0.606821",
"0.60068506",
"0.60068506",
"0.60066885",
"0.6003148",
"0.5909763",
"0.5893203",
"0.5820227",
"0.57792675",
"0.5760327",
"0.5744369",
"0.571816",
"0.56807256",
"0.5665313",
"0.56221956",
"0.5590636",
"0.5578593",
"0.55743855",
"0.5563658",... | 0.64409065 | 0 |
Return contact point from filing json. | def get_contact_point_revision(filing):
return filing.json['filing']['incorporationApplication'].get('contactPoint', {}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def contact_point(self) -> object:\n return self._contact_point",
"def get_contact_points(contact_points_path, json_name='contact_points.json',\n dataset_type='ycb', use_clustering=True,\n use_filter_penetration=True,\n inf_penetration_chec... | [
"0.6430361",
"0.63854986",
"0.59952515",
"0.59549403",
"0.5636144",
"0.55968314",
"0.5538288",
"0.544604",
"0.5436567",
"0.5314432",
"0.5294083",
"0.52843034",
"0.5142142",
"0.51301235",
"0.5117246",
"0.51044",
"0.50873756",
"0.5062358",
"0.5023777",
"0.50134194",
"0.5011443"... | 0.6746772 | 0 |
Configures cleaned file system schema | def getFilePath( source, paper, month, day, year ):
attributes = { SOURCE : source,
PAPER : paper,
MONTH : month,
DAY : day,
YEAR : year
}
return "\\".join( [ settings.CLEAN_STORE ] + [ attributes[... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dev_clean():\n clean_files(\"csv\", True)\n clean_files(\"jsontxt\", True)",
"def setup_schema(command, conf, vars):",
"def clean():\n user_init.clean_setup()",
"def clean():\n clean_files()",
"def sanitize_config(config):\n\tif not 'dbfile' in config.keys():\n\t\tconfig['dbfile'] = DEFAULT... | [
"0.61135614",
"0.60262734",
"0.5725205",
"0.56841063",
"0.56512666",
"0.55450356",
"0.5523136",
"0.5521303",
"0.55139273",
"0.54976046",
"0.5485929",
"0.5448757",
"0.5442812",
"0.54370314",
"0.54358655",
"0.54351366",
"0.54351366",
"0.5428525",
"0.5426912",
"0.5400248",
"0.53... | 0.0 | -1 |
Given a sourceDirectory, returns the registered schema. MUST Register schema here! | def getSchema( sourceDirectory ):
if( sourceDirectory == settings.LEXISNEXIS_FILETAG ): return LexisNexisSchema()
raise Exception( "Filer for source <%s> is not registered in getSchema( source )." % ( sourceDirectory ) ) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_source_schema(cls) -> dict:\n source_schema = get_base_schema(\n root=True,\n id_=\"source.schema.json\",\n title=\"Source data schema\",\n description=\"Schema for the source data, files and directories\",\n version=\"0.1.0\",\n )\n ... | [
"0.65721476",
"0.6316953",
"0.6152082",
"0.59883946",
"0.59503275",
"0.58201414",
"0.562178",
"0.56007177",
"0.5588063",
"0.55684656",
"0.5486071",
"0.54797757",
"0.54383653",
"0.53457683",
"0.53429353",
"0.5330753",
"0.5323797",
"0.5298691",
"0.5294363",
"0.5268257",
"0.5266... | 0.77906126 | 0 |
Constructs a new model instance. | def __init__(self, params, config=None):
super(NizzaModel, self).__init__(
model_fn=self.nizza_model_fn,
params=params,
config=config) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def MakeModel(self):\n pass",
"def create_model(self):\n pass",
"def create_model(self):\n pass",
"def create_model(self):\n model = solph.Model(self.es)\n return model",
"def make_model():\n m = model_class(*argv[2:-1])\n modelobj[\"model\"] = m",
"def in... | [
"0.7899202",
"0.7808241",
"0.7808241",
"0.7705843",
"0.7621898",
"0.755002",
"0.7448681",
"0.7389971",
"0.7365762",
"0.73443246",
"0.7253948",
"0.7253948",
"0.72371763",
"0.7213994",
"0.71964335",
"0.7186855",
"0.7179065",
"0.71506745",
"0.7128975",
"0.7128975",
"0.7128975",
... | 0.0 | -1 |
This is the model_fn for nizza models. Subclasses should not override this function directly, but rather control its behavior by implementing `precompute()` and `compute_loss()` | def nizza_model_fn(self, features, mode, params):
precomputed = self.precompute(features, mode, params)
loss = self.compute_loss(features, mode, params, precomputed)
train_op = tf.contrib.layers.optimize_loss(
loss=loss,
global_step=tf.train.get_global_step(),
optimizer=tf.train.Adam... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_loss(self, features, mode, params, precomputed):\n raise NotImplementedError(\"Model does not implement loss.\")",
"def model_fn(self, features, labels, mode, params, config):\n raise NotImplementedError()",
"def build_model_fn(self):\n # Define the model_fn we want to return\n ... | [
"0.6493121",
"0.64661187",
"0.63006353",
"0.6268264",
"0.6256369",
"0.62445",
"0.6237785",
"0.6226766",
"0.6207205",
"0.6190259",
"0.6169209",
"0.6139843",
"0.61165994",
"0.61126524",
"0.6089907",
"0.60873324",
"0.60776514",
"0.6052805",
"0.60448414",
"0.60442406",
"0.6020787... | 0.7382619 | 0 |
This is a helper function for alignment models for embeddings. This function returns an embedding for features[name] of size params.name_embed_size assuming a vocab size of params.name_vocab_size. features[feature_name] has to be an integer tensor of shape [batch_size, max_sequence_length]. | def embed(self, features, feature_name, params):
with tf.variable_scope("%s_embed" % feature_name):
embed_matrix = tf.get_variable("embedding_matrix",
[getattr(params, "%s_vocab_size" % feature_name),
getattr(params, "%s_embed_size" % feature_name)])
return tf.nn.embedding_look... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_embedding_layer(inputs_, vocab_size, embed_size):\n embedding = tf.Variable(tf.random_uniform((vocab_size, embed_size), -1, 1))\n embed = tf.nn.embedding_lookup(embedding, inputs_)\n \n return embed",
"def embed_features(batch, f_size):\n for f in range(Config.num_feature):\n ... | [
"0.6896678",
"0.66577274",
"0.6655466",
"0.6557072",
"0.6546917",
"0.6513097",
"0.6508412",
"0.6499041",
"0.648341",
"0.6480802",
"0.63810956",
"0.6362331",
"0.6333119",
"0.62890506",
"0.6286926",
"0.62582594",
"0.6158827",
"0.61498016",
"0.61458313",
"0.61418664",
"0.6091481... | 0.7802241 | 0 |
Implemnenting this function can bundle the computation of variables which are used for both decoding (alignment/translation) and training. The return value of that function is passed to compute_loss() etc. as the `precomputed` argumemnt. | def precompute(self, features, mode, params):
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def precalculate():\n pass",
"def precalculate():\n pass",
"def E_step_precompute(self, model_params, my_suff_stat, my_data):",
"def pre_forward(self, *args, **kwargs):\n batch_size = args[0].shape[0]\n if not self.instantiated:\n self.hidden_dim = args[0].shape[-1]\n ... | [
"0.6046909",
"0.6046909",
"0.5747046",
"0.5558208",
"0.5538616",
"0.54545367",
"0.54432714",
"0.54280794",
"0.541424",
"0.5409307",
"0.5395517",
"0.53825015",
"0.5354495",
"0.5351136",
"0.52674043",
"0.52538127",
"0.5232878",
"0.52251",
"0.52243966",
"0.5220421",
"0.5217032",... | 0.5792342 | 2 |
Computes the training loss for the alignment model. For example, you could implement crossentropy loss as loss_num, loss_den = common_utils.padded_cross_entropy( precomputed, features["targets"], params.label_smoothing) loss = loss_num / tf.maximum(1.0, loss_den) return loss assuming that precomputed holds the logits f... | def compute_loss(self, features, mode, params, precomputed):
raise NotImplementedError("Model does not implement loss.") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_loss(self):\n self.test_logits = self.compute_logits()\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(\n labels=self.data.test_labels, logits=self.test_logits)\n cross_entropy_loss = tf.reduce_mean(loss)\n regularization = tf.reduce_sum(\n tf.get_collection(tf.GraphKe... | [
"0.712148",
"0.70395255",
"0.7023037",
"0.6964694",
"0.6878926",
"0.6830145",
"0.6824834",
"0.6801352",
"0.6765133",
"0.67370236",
"0.67324895",
"0.67233557",
"0.67031574",
"0.67031574",
"0.6662697",
"0.6619361",
"0.6566079",
"0.6541267",
"0.6530644",
"0.6516976",
"0.6510028"... | 0.7048177 | 1 |
Implementing this function makes the model usable for translation, eg. for use in SGNMT via the nizza predictor. This function must return a distribution log P(f_j|f_1^j_1, e_1^I) such that summing over all target words yields log P(f_1^J|e_1^J). For example, This often requires maginalizing over the alignments. | def predict_next_word(self, features, params, precomputed):
raise NotImplementedError("Model does not implement word prediction.") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_log_probs(self, phrases, save_to_file=None):\n # Co-ocurrence for source and target phrase\n tgt_src_cnt = defaultdict(lambda: defaultdict(int))\n \n # ocurrence for target (English)\n tgt_cnt = defaultdict(int)\n\n # Compute frequency and co-occurence\n ... | [
"0.6477803",
"0.6240592",
"0.61621064",
"0.6086333",
"0.6047775",
"0.60093266",
"0.5995965",
"0.5995107",
"0.5966389",
"0.59642804",
"0.59056777",
"0.5902837",
"0.58759403",
"0.58725774",
"0.5862674",
"0.5825452",
"0.58017606",
"0.58002657",
"0.5793231",
"0.57751673",
"0.5762... | 0.0 | -1 |
Mark a hyperparameter as having a simple monotonic increasing relationship with both CPU time and the goodness of the model. | def patience_param(x):
# -- TODO: make this do something!
return x | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mark(self) -> None:\n self.zero = self._monotonic_ms()",
"def preformance(self, perf):\n self.perf = perf",
"def __init__(self, time_constant: float, sampling_time: float):\n self.alpha = sampling_time / (time_constant + sampling_time)\n self.state = None",
"def E_step_precompute(self... | [
"0.56833273",
"0.5587425",
"0.55274343",
"0.55222327",
"0.5340982",
"0.52688646",
"0.5254172",
"0.5253672",
"0.5252122",
"0.5175494",
"0.51732254",
"0.51373166",
"0.50936973",
"0.5061794",
"0.5060478",
"0.50589293",
"0.50571275",
"0.5055805",
"0.50344336",
"0.5032078",
"0.502... | 0.48939082 | 43 |
Mark a hyperparameter as having a simple monotonic decreasing relationship with both CPU time and the goodness of the model. | def inv_patience_param(x):
# -- TODO: make this do something!
return x | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preformance(self, perf):\n self.perf = perf",
"def __init__(self, time_constant: float, sampling_time: float):\n self.alpha = sampling_time / (time_constant + sampling_time)\n self.state = None",
"def E_step_precompute(self, model_params, my_suff_stat, my_data):",
"def mark(self) -> None:\n ... | [
"0.5497046",
"0.5494867",
"0.5455038",
"0.53865165",
"0.5378648",
"0.53281236",
"0.532049",
"0.5289464",
"0.5282969",
"0.5282969",
"0.5274334",
"0.52491134",
"0.518313",
"0.51513946",
"0.5125276",
"0.51124686",
"0.50949377",
"0.50924283",
"0.5072421",
"0.5062427",
"0.5047174"... | 0.0 | -1 |
The combination of penalty='l1' and loss='hinge' is not supported penalty='l2' and loss='hinge' is only supported when dual='true' penalty='l1' is only supported when dual='false'. | def _svm_loss_penalty_dual(name):
return hp.choice(name, [
('hinge', 'l2', True),
('squared_hinge', 'l2', True),
('squared_hinge', 'l1', False),
('squared_hinge', 'l2', False)
]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def l2_training_penalty(batched_out: base.Output):\n if isinstance(batched_out, base.OutputWithPrior):\n return 0.5 * jnp.mean(jnp.square(batched_out.train))\n else:\n logging.warning('L2 weight penalty only works for OutputWithPrior.')\n return 0.",
"def test_hinge_loss_backward():\n from your_cod... | [
"0.6574107",
"0.58923316",
"0.57923156",
"0.57098234",
"0.5634288",
"0.56300277",
"0.55809635",
"0.5567596",
"0.5531175",
"0.55264515",
"0.55053544",
"0.5501286",
"0.54875517",
"0.54657626",
"0.546015",
"0.54392153",
"0.5435707",
"0.5426929",
"0.54195803",
"0.5418796",
"0.538... | 0.75576925 | 0 |
Return a pyll graph with hyperparamters that will construct a sklearn.svm.SVC model with a user specified kernel. See help(hpsklearn.components._svm_hp_space) for info on additional SVM arguments. | def svc_kernel(name, kernel, random_state=None, probability=False, **kwargs):
def _name(msg):
return '%s.%s_%s' % (name, kernel, msg)
hp_space = _svm_hp_space(_name, kernel=kernel, **kwargs)
hp_space.update(_svc_hp_space(_name, random_state, probability))
return scope.sklearn_SVC(**hp_space) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_svm_hyperparams():\n NUM_ITERS = 10\n # coefs = np.arange(-5, 5).astype(np.float)\n coefs = np.linspace(0.25, 1, 10)\n Cs = np.power(2, coefs)\n results = []\n\n for _ in range(NUM_ITERS):\n data = FaceDataset(\"embeddings/dev\", n=50)\n train_data, train_labels = data.trai... | [
"0.73476094",
"0.70958614",
"0.6964052",
"0.67831784",
"0.67662734",
"0.66739416",
"0.65586966",
"0.64921445",
"0.64792943",
"0.63226485",
"0.6296224",
"0.62792623",
"0.610844",
"0.61017793",
"0.61011374",
"0.6083185",
"0.6076828",
"0.6073266",
"0.6069783",
"0.6007494",
"0.59... | 0.71698 | 1 |
Return a pyll graph with hyperparamters that will construct a sklearn.svm.SVR model with a user specified kernel. | def svr_kernel(name, kernel, epsilon=None, **kwargs):
def _name(msg):
return '%s.%s_%s' % (name, kernel, msg)
hp_space = _svm_hp_space(_name, kernel=kernel, **kwargs)
hp_space.update(_svr_hp_space(_name, epsilon))
return scope.sklearn_SVR(**hp_space) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def svm():",
"def __init__(self, kernel='poly', degree=3, verbose=False, gamma='auto', reg=1/1000, random_state=0):\n print(\"Initialize model SVM\")\n # Check if gamma='auto' is useful\n self.kernel = kernel\n self.random_state = random_state\n self.model = SVC(gamma=gamma, ke... | [
"0.69277614",
"0.6893122",
"0.68732125",
"0.6781692",
"0.6691403",
"0.6546042",
"0.64860064",
"0.6480777",
"0.6352892",
"0.632312",
"0.6207076",
"0.61844045",
"0.6074828",
"0.60648793",
"0.60161895",
"0.5979811",
"0.5845912",
"0.580389",
"0.57575077",
"0.5752655",
"0.5745429"... | 0.71148735 | 0 |
Generic preprocessing appropriate for a wide variety of data | def any_preprocessing(name):
return hp.choice('%s' % name, [
[pca(name + '.pca')],
[standard_scaler(name + '.standard_scaler')],
[min_max_scaler(name + '.min_max_scaler')],
[normalizer(name + '.normalizer')],
# -- not putting in one-hot because it can make vectors huge
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preprocess(data):\n raise NotImplementedError",
"def preprocess(self, data, label):\n\t\traise NotImplementedError",
"def preprocess(self):",
"def preprocess(self,data):\n preprocessObj = PreprocessData()\n preprocess_data = preprocessObj.preprocess(data)\n return preprocess_data"... | [
"0.83073246",
"0.7156899",
"0.70585245",
"0.6997039",
"0.6968472",
"0.6931928",
"0.69065046",
"0.6890153",
"0.67705256",
"0.67405057",
"0.67354226",
"0.67354226",
"0.67354226",
"0.66801184",
"0.6675895",
"0.6633443",
"0.6612644",
"0.6601693",
"0.65921974",
"0.6591618",
"0.657... | 0.5916439 | 66 |
Generic preprocessing appropriate for text data | def any_text_preprocessing(name):
return hp.choice('%s' % name, [
[tfidf(name + '.tfidf')],
]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preprocess(data):\n raise NotImplementedError",
"def preprocess(self, text):\r\n return text",
"def _preprocess(self):\n self.data['sentences'] = self.data['text'].apply(self._tokenize_sent)\n self.data['nouns'] = self.data['sentences'].apply(self._get_nouns)\n # self._get_fr... | [
"0.7779607",
"0.7526521",
"0.7176781",
"0.7096829",
"0.7073286",
"0.6976883",
"0.6929176",
"0.6907419",
"0.687628",
"0.68656975",
"0.67926234",
"0.6746842",
"0.6743114",
"0.6733834",
"0.6726861",
"0.6723832",
"0.67099166",
"0.66652983",
"0.6643692",
"0.65456325",
"0.65281934"... | 0.6244845 | 44 |
Call an arbitrary management method on this entity | def call(self, operation, expect=error.OK, **arguments):
request = self._node.request(
operation=operation, type=self.type, identity=self.identity, **arguments)
return self._node.call(request, expect=expect).body | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_manage(self, expanded, unexpanded) :\n\t\treturn self.manage_view_properties(expanded, unexpanded, \"/manage\", roles = \"Manager\")",
"def management(self):\r\n return management.Management(self)",
"def manage(ctx, user_cmd):\n ScalingoInterface(ctx.obj).manage_py(user_cmd)",
"def __getatt... | [
"0.6228392",
"0.61691713",
"0.59387267",
"0.55060166",
"0.5382175",
"0.5382175",
"0.5302523",
"0.5181179",
"0.5172928",
"0.51687676",
"0.5075816",
"0.5048617",
"0.504479",
"0.50290024",
"0.50237244",
"0.5021495",
"0.5004086",
"0.4995686",
"0.49407494",
"0.4918267",
"0.4901621... | 0.0 | -1 |
Read the remote entity attributes into the local attributes. | def read(self):
self.attributes = self.call('READ', expect=error.OK) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_attributes(self, dataset):\n if 'attributes' in self.configs:\n for key, value in self.configs['attributes'].items():\n setattr(dataset, key, value)",
"def _read_local(self):\n\n self.attributions = np.genfromtxt(\n self.attributions_path, dtype=float, ... | [
"0.5523847",
"0.55163735",
"0.5404263",
"0.53723055",
"0.5261947",
"0.52431804",
"0.5242798",
"0.5209427",
"0.51474196",
"0.5137612",
"0.51318413",
"0.50730455",
"0.50500995",
"0.5048805",
"0.5024441",
"0.49533403",
"0.49302346",
"0.49292526",
"0.49168682",
"0.49107",
"0.4903... | 0.5443011 | 2 |
Update the remote entity attributes from the local attributes. | def update(self):
self.attributes = self.call('UPDATE', expect=error.OK, body=self.attributes) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self) -> None:\n self._api.update()\n if self.available:\n self._attr_native_value = self._api.data[self.entity_description.key]\n else:\n self._attr_native_value = None",
"def _async_update_attrs(self) -> None:\n self._attr_is_on = self.entity_descrip... | [
"0.62692803",
"0.58587396",
"0.5731269",
"0.5658316",
"0.5653894",
"0.5645511",
"0.56131625",
"0.5568307",
"0.5567129",
"0.55060637",
"0.54385704",
"0.54360443",
"0.5434658",
"0.5410549",
"0.5394486",
"0.5393542",
"0.5386407",
"0.5382385",
"0.5378643",
"0.5375315",
"0.5351614... | 0.6422116 | 0 |
Delete the remote entity | def delete(self):
self.call('DELETE', expect=error.NO_CONTENT) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_otoroshi_controllers_adminapi_tcp_service_api_controller_delete_entity_action(self):\n pass",
"def delete(self, obj):",
"def delete(self):\n ...",
"def remove(self):\n instance = self.get_object() \n instance.delete() \n return self.response(status='Successfully De... | [
"0.7196658",
"0.70685035",
"0.7056511",
"0.7055168",
"0.7014683",
"0.69954413",
"0.6993684",
"0.6924908",
"0.6901423",
"0.6901423",
"0.6901423",
"0.6901423",
"0.6825376",
"0.681299",
"0.681299",
"0.6777683",
"0.67732435",
"0.67707646",
"0.6770634",
"0.6756004",
"0.67313147",
... | 0.6575764 | 36 |
Return a Node connected with the given parameters, see L{connection} | def connect(cls, url=None, router=None, timeout=10, ssl_domain=None, sasl=None, edge_router=None):
url_ = Url(url) # Convert string to Url class.
if url_.path is not None:
path = url_.path
elif router:
path = '_topo/0/%s/$management' % router
elif edge_r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_node(conn, name):\n datacenter_id = get_datacenter_id()\n\n for item in conn.list_servers(datacenter_id)[\"items\"]:\n if item[\"properties\"][\"name\"] == name:\n node = {\"id\": item[\"id\"]}\n node.update(item[\"properties\"])\n return node",
"def connect_... | [
"0.618464",
"0.61416286",
"0.6074083",
"0.60132295",
"0.6008891",
"0.59954274",
"0.5794639",
"0.57695985",
"0.5758491",
"0.5756829",
"0.5743585",
"0.56941",
"0.5691204",
"0.56248885",
"0.5612602",
"0.5611256",
"0.56028306",
"0.5598274",
"0.558752",
"0.55844176",
"0.5578297",
... | 0.53575635 | 40 |
Create a management node proxy using the given connection. | def __init__(self, connection, path, locales=None):
self.name = self.identity = 'self'
self.type = 'org.amqp.management' # AMQP management node type
self.locales = locales
self.locales = locales
self.url = Url(connection.url)
self.url.path = path
self.client = S... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def _create_proxy(self):\n self._proxy = await self._controller.fopen_tcp_proxy(\n Cellular._DRONE_WEB_API_PORT\n )\n\n self._drone_http_url = f\"http://{self._proxy.address}:{self._proxy.port}\"\n\n if self._autoconfigure and self._user_apc_token is None:\n ... | [
"0.6048795",
"0.58742714",
"0.5802584",
"0.5657759",
"0.5605936",
"0.5493677",
"0.54126096",
"0.5399687",
"0.5381373",
"0.53703874",
"0.53361976",
"0.53073025",
"0.52932906",
"0.5273362",
"0.5243213",
"0.52396035",
"0.5215712",
"0.5199959",
"0.51762295",
"0.51659554",
"0.5154... | 0.5361504 | 10 |
Shut down the node | def close(self):
if self.client:
self.client.connection.close()
self.client = None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shutdown(self) -> None:",
"def shutdown(self) -> None:",
"def shutdown(self):",
"def shutdown(self, *args):\n return _SALOMERuntime.PythonNode_shutdown(self, *args)",
"def shutdown(self):\n ...",
"def shutdown(self, *args):\n return _SALOMERuntime.SalomeNode_shutdown(self, *args)... | [
"0.75445867",
"0.75445867",
"0.7528702",
"0.7525221",
"0.74484587",
"0.7446821",
"0.7276193",
"0.72565746",
"0.72565746",
"0.72565746",
"0.7210875",
"0.71629465",
"0.71189094",
"0.7095154",
"0.70900863",
"0.7088388",
"0.7069015",
"0.7035386",
"0.6970288",
"0.69025195",
"0.689... | 0.0 | -1 |
Check a management response message for errors and correlation ID. | def check_response(response, expect=error.OK):
code = response.properties.get('statusCode')
if code != expect:
if 200 <= code <= 299:
raise ValueError("Response was %s(%s) but expected %s(%s): %s" % (
code, error.STATUS_TEXT[code], expect, error.STATUS_TEX... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_response_errors(self, resp):\n return True",
"def validate_reply(request, reply):\n assert isinstance(reply, dict) and 'id' in reply\n assert ('result' in reply) != ('error' in reply)\n assert reply['id'] == request['id'] or \\\n reply['id'] == '00' and 'error... | [
"0.63983744",
"0.6147145",
"0.6012438",
"0.5871563",
"0.5813378",
"0.5793791",
"0.579217",
"0.5788185",
"0.5732082",
"0.5707856",
"0.5679702",
"0.5675938",
"0.5664866",
"0.5634316",
"0.5605626",
"0.56005645",
"0.5583741",
"0.5568571",
"0.55622566",
"0.55569047",
"0.55382013",... | 0.61792576 | 1 |
Make a L{proton.Message} containining a management request. | def request(self, body=None, **properties):
if self.locales:
properties.setdefault('locales', self.locales)
request = proton.Message()
request.properties = clean_dict(properties)
request.body = body or {}
return request | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def construct_message(self):\n msg_type = self.msg_type\n if msg_type == \"PUBMSG\":\n msg_type = \"PRIVMSG\"\n ret = \"{} {}\".format(msg_type, self.target)\n if self.content:\n ret += \" :{}\".format(self.content)\n return ret + \"\\r\\n\"",
"def makeAMQ... | [
"0.62443095",
"0.5764357",
"0.5720762",
"0.5711052",
"0.56360126",
"0.5537137",
"0.552277",
"0.5499183",
"0.5487821",
"0.545782",
"0.54448134",
"0.5425465",
"0.54167366",
"0.54080194",
"0.54045284",
"0.5402524",
"0.53995603",
"0.5392736",
"0.5373429",
"0.53681254",
"0.5349975... | 0.5406406 | 14 |
Construct a request for the managment node itself | def node_request(self, body=None, **properties):
return self.request(body, name=self.name, type=self.type, **properties) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def newRequest(self):\n return Request( )",
"def newMCRequest(self, request):\n raise NotImplementedError",
"def createRequest(self):\n self.get_bmc_website()\n self.__createChangeRequest = Create(self.browser)\n self.__createChangeRequest.createNCR()",
"def req():\n ret... | [
"0.6537257",
"0.6405457",
"0.6351566",
"0.6287773",
"0.61076057",
"0.6059556",
"0.6055695",
"0.6024805",
"0.59167784",
"0.5776078",
"0.57564014",
"0.57313454",
"0.57100374",
"0.56927186",
"0.5671444",
"0.5669032",
"0.5644252",
"0.5641237",
"0.5638615",
"0.5605619",
"0.5604527... | 0.58303213 | 9 |
Send a management request message, wait for a response. | def call(self, request, expect=error.OK):
response = self.client.call(request)
self.check_response(response, expect=expect)
return response | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def _send_request(self, command, waitResponse=False):\n # Make sure we're connected.\n await self._perform_connect()\n \n while self._timeout > 0:\n self.logger.debug('waiting for previous command response')\n await asyncio.sleep(1)\n \n self.logger.de... | [
"0.6157053",
"0.611986",
"0.59369206",
"0.5933973",
"0.5905822",
"0.5852787",
"0.58384734",
"0.5809734",
"0.5773247",
"0.5763428",
"0.5689041",
"0.5659244",
"0.5653349",
"0.5627476",
"0.559565",
"0.5584633",
"0.5567643",
"0.55364376",
"0.55341464",
"0.55341464",
"0.55341464",... | 0.0 | -1 |
Return an iterator that yields a dictionary for each result. | def iter_dicts(self, clean=False):
for r in self.results:
if clean:
yield clean_dict(zip(self.attribute_names, r))
else:
yield dict(zip(self.attribute_names, r)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def iter_dict(self):\n\n itr = iter(self)\n\n headers = next(itr)\n\n for row in itr:\n yield dict(zip(headers, row))",
"def __iter__(self) -> iter:\n return iter(self._dict)",
"def __iter__(self):\n for key, value in self.read():\n yield key, value",
"def proce... | [
"0.70707095",
"0.6937773",
"0.69119906",
"0.685489",
"0.67938584",
"0.67819273",
"0.66642076",
"0.66412884",
"0.6634738",
"0.65794516",
"0.65755105",
"0.6557807",
"0.6552341",
"0.6529979",
"0.65247136",
"0.65218616",
"0.64761126",
"0.64640063",
"0.641072",
"0.63832486",
"0.63... | 0.6707882 | 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.