np.ndarray:\n if self.i - 1 >= self.k:\n logging.error(\"No more training iterations!!\")\n return np.array([])\n _, test = self.indexes[self.i - 1]\n return self.labels.take(test, axis=-1)","def train(self, dataset): \n dataset = dataset[dataset[:,-1].argsort()] # Sort the dataset by classes.\n #print dataset\n \n ########\n # Compute p(y=1) for all ys.\n ########\n label_counts = np.bincount(dataset[:,-1]) # Get the number of occurrences of each class, sorted. \n self.p_ys = label_counts * 1.0 / len(dataset) # Compute probs. \n \n ########\n # Compute p(x|y) for all x,y.\n ########\n self.feature_count = len(dataset[0]) - 1 \n self.class_count = len(label_counts)\n \n self.p_xi_given_ys = np.zeros((self.class_count, self.feature_count)) # Initialize matrix\n start_index = 0\n for i in range(self.class_count): # Loop over each class \n end_index = start_index + label_counts[i] # end of this class index \n denominator = label_counts[i] + 2.0 * self.alpha\n \n for j in range(self.feature_count): # Loop over each feature\n numerator = np.sum(dataset[start_index:end_index,j]) + self.alpha # Sum number of times word j = 1 in class i\n self.p_xi_given_ys[i][j] = numerator * 1.0 / denominator # Compute p(xi|y)\n \n start_index = end_index","def gen_data(low, high, n_samples, scale=4, test_size=0.2, random_state=3):\n np.random.seed(15)\n X = np.random.uniform(low, high, size=n_samples)\n\n # generate the response from the ground truth function and add\n # some random noise to it, scale controls the variance of the noise.\n y = ground_truth(X) + np.random.normal(scale=scale, size=n_samples)\n X_train, X_test, y_train, y_test = train_test_split(\n X, y, test_size=test_size, random_state=random_state)\n\n return X_train, X_test, y_train, y_test","def generate_labels(cfg, split_files):\n for file_name in split_files:\n file_name = join(cfg.data_dir, file_name)\n\n for example in generate_examples(file_name):\n yield from example['labels']","def prepare_data():\n #data, label = load_ta_data(), load_ta_target()\n data, label = load_own_data(), load_own_target()\n tra_x, tst_x = split_samples(data)\n tra_y, tst_y = split_samples(label)\n return (tra_x, tst_x, tra_y, tst_y)","def get_train_examples(self, data_dir):\r\n raise NotImplementedError()","def _GenerateTestData(self, num_classes, dim, batch_size, num_true, labels,\n sampled, subtract_log_q):\n weights = np.random.randn(num_classes, dim).astype(np.float32)\n biases = np.random.randn(num_classes).astype(np.float32)\n hidden_acts = np.random.randn(batch_size, dim).astype(np.float32)\n\n true_exp = np.full([batch_size, 1], fill_value=0.5, dtype=np.float32)\n sampled_exp = np.full([len(sampled)], fill_value=0.5, dtype=np.float32)\n sampled_vals = (sampled, true_exp, sampled_exp)\n\n sampled_w, sampled_b = weights[sampled], biases[sampled]\n true_w, true_b = weights[labels], biases[labels]\n\n true_logits = np.sum(\n hidden_acts.reshape((batch_size, 1, dim)) * true_w.reshape(\n (batch_size, num_true, dim)),\n axis=2)\n true_b = true_b.reshape((batch_size, num_true))\n true_logits += true_b\n sampled_logits = np.dot(hidden_acts, sampled_w.T) + sampled_b\n\n if subtract_log_q:\n true_logits -= np.log(true_exp)\n sampled_logits -= np.log(sampled_exp[np.newaxis, :])\n\n exp_logits = np.concatenate([true_logits, sampled_logits], axis=1)\n exp_labels = np.hstack(\n (np.ones_like(true_logits) / num_true, np.zeros_like(sampled_logits)))\n\n return weights, biases, hidden_acts, sampled_vals, exp_logits, exp_labels","def gen_data(res, train, label_no, num, save_path='../mnist/mnist_train'):\n size = len(label_no)\n infer_res, infer_conf, gt_conf = compare_result(res, label_no)\n threshold = sorted(infer_conf)[num]\n print(\"threshold:\"+str(threshold))\n data_ = []\n label_ = []\n for i in range(size):\n if infer_conf[i] < threshold:\n data_.append(train[i].astype(np.uint8))\n label_.append(label_no[i])\n data_ = np.array(data_)\n label_ = np.array(label_)\n if not os.path.exists(save_path):\n os.makedirs(save_path)\n np.save(save_path+'/data_'+str(num)+'.npy', data_)\n np.save(save_path+'/label_'+str(num)+'.npy', label_)","def generate_train_test(self):\n x, y = self.read_data()\n x_train, y_train, x_test, y_test = self.sample_data(x, y)\n self.train = (x_train, y_train)\n self.test = (x_test, y_test)","def nnPredict(w1,w2,data): \r\n \r\n labels = np.array([])\r\n #Your code here\r\n #Get bias dimension\r\n bias_dimension = data.shape[0]\r\n\r\n #Fill it all with ones\r\n bias = np.ones((bias_dimension,1))\r\n\r\n #Add bias to weights \r\n data_with_bias = np.concatenate((data,bias),1)\r\n\r\n #Feed Foward Start By Multiplying Training data by weights of w1\r\n z2 = np.dot(data_with_bias,np.transpose(w1))\r\n\r\n #Apply Sigmoid function\r\n a2= sigmoid(z2)\r\n #Apply Another Bias Dimension to the new matrix\r\n\r\n #bias_dimension=a2.shape[0]\r\n #bias = np.ones((bias_dimension,1))\r\n a2_bias= np.concatenate((a2,bias),1)\r\n\r\n #Multiply new matrix by the weights of w2\r\n z3 = np.dot(a2_bias,np.transpose(w2))\r\n \r\n #Apply Sigmoid Function to the new data\r\n y= sigmoid(z3)\r\n\r\n #find max value and add that digit to the labels vector\r\n labels= np.zeros((y.shape[0],1))\r\n count=0\r\n for x in y:\r\n index=0\r\n max=0\r\n inmax=0\r\n for p in x:\r\n if p >= max:\r\n max=p\r\n inmax=index\r\n index+=1\r\n labels[count][0]=inmax\r\n count+=1\r\n \r\n print('results n ', labels)\r\n return labels","def splitfeatdata(rawdata, fold=10):\n\n labeldata = []\n for row in rawdata:\n\n # if row[2] > 0:\n # label = 'pos'\n # elif row[2] == 0:\n # label = 'neutral'\n # else:\n # label = 'neg'\n\n\n label = row[2]\n labeldata.append((row[4], label))\n\n\n random.shuffle(labeldata)\n\n size = int(math.floor(len(labeldata) / 10.0))\n # train = labeldata[:split]\n # test = labeldata[split:]\n\n # code for k-fold validation referred from:\n # http://stackoverflow.com/questions/16379313/how-to-use-the-a-10-fold-cross-validation-with-naive-bayes-classifier-and-nltk\n claccuracy = []\n for i in range(fold):\n test_this_round = labeldata[i*size:][:size]\n train_this_round = labeldata[:i*size] + labeldata[(i+1)*size:]\n\n acc = myclassifier(train_this_round, test_this_round)\n\n claccuracy.append(acc)\n\n\n\n print os.getcwd()\n\n\n mySentClassifier = nltk.NaiveBayesClassifier.train(labeldata)\n f = open('../../../mySentClassifier2.pickle', 'wb')\n dump(mySentClassifier, f)\n f.close()\n\n\n return claccuracy","def generate_data(self):\n\n # cfg.d_sour_num = 20 # number of source domains\n self.d_sour_a = [np.random.uniform(0.1, 5.0) for _ in range(cfg.d_sour_num)]\n self.d_sour_b = [np.random.uniform(0, np.pi) for _ in range(cfg.d_sour_num)]\n # cfg.d_targ_num = 1 # number of target domain\n self.d_targ_a = [np.random.uniform(0.1, 5.0) for _ in range(cfg.d_targ_num)]\n self.d_targ_b = [np.random.uniform(0, np.pi) for _ in range(cfg.d_targ_num)]\n\n\n # cfg.train_num = 100 # number of training point in each domain\n self.train_x = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.train_num)], dtype=np.float32).reshape(-1,1)\n self.train_y = np.array([[self.d_sour_a[j] * np.sin(i + self.d_sour_b[j]) for i in self.train_x] for j in range(cfg.d_sour_num)], dtype=np.float32).reshape(cfg.d_sour_num, cfg.train_num, 1)\n\n # cfg.val_num = 100\n self.val_x = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.val_num)], dtype=np.float32).reshape(-1,1)\n self.val_y = np.array([[self.d_sour_a[j] * np.sin(i + self.d_sour_b[j]) for i in self.val_x] for j in range(cfg.d_sour_num)], dtype=np.float32).reshape(cfg.d_sour_num, cfg.val_num, 1)\n\n # cfg.support_num = 10\n self.support_x = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.support_num)], dtype=np.float32).reshape(-1,1)\n self.support_y = np.array([[self.d_targ_a[j] * np.sin(i + self.d_targ_b[j]) for i in self.support_x] for j in range(cfg.d_targ_num)], dtype=np.float32).reshape(cfg.d_targ_num, cfg.support_num, 1)\n\n # cfg.test_num = 100\n self.test_x = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.test_num)], dtype=np.float32).reshape(-1,1)\n self.test_y = np.array([[self.d_targ_a[j] * np.sin(i + self.d_targ_b[j]) for i in self.test_x] for j in range(cfg.d_targ_num)], dtype=np.float32).reshape(cfg.d_targ_num, cfg.test_num, 1)\n\n self.test_x_old = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.test_num)], dtype=np.float32).reshape(-1,1)\n self.test_y_old = np.array([[self.d_sour_a[j] * np.sin(i + self.d_sour_b[j]) for i in self.test_x_old] for j in range(cfg.d_sour_num)], dtype=np.float32).reshape(cfg.d_sour_num, cfg.test_num, 1)","def generate_data(n, data, labels, param, label):\n\n\tmu = param[0]\n\tsigma = param[1]\n\n\tfor i in range(n):\n\n\t\t# TODO: Recall the notation of x in the exercise sheet.\n\t\t# \t\tGenerate a 2-d Gaussian distributed data point plus an offset value for the bias.\n\t\t# \t\tUse our rand_gaussian method.\n\n\t\tx1 = rand_gaussian(mu[0], sigma[0]) \n\t\tx2 = rand_gaussian(mu[1], sigma[1]) \n\n\t\tdata_point = [1, x1, x2]\n\t\tdata.append(data_point)\n\t\tlabels.append(label)\n\n\treturn data,labels","def train(self, dataset): \n dataset = dataset[dataset[:,-1].argsort()] # Sort the dataset by classes.\n #print dataset\n \n ########\n # Compute p(y=1) for all ys.\n ########\n label_counts = np.bincount(dataset[:,-1]) # Get the number of occurrences of each class, sorted. \n self.p_ys = np.log(label_counts * 1.0 / len(dataset)) # Compute probs. \n \n ########\n # Compute p(x|y) for all x,y.\n ########\n self.feature_count = len(dataset[0]) - 1 \n self.class_count = len(label_counts)\n \n self.p_xi_given_ys = np.zeros((self.class_count, self.feature_count)) # Initialize matrix\n start_index = 0\n for i in range(self.class_count): # Loop over each class \n end_index = start_index + label_counts[i] # end of this class index \n class_word_counts = np.sum(dataset[start_index:end_index,:-1]) # sum all words of class i \n denominator = class_word_counts + self.alpha * self.feature_count # Here we add the feature_count as Laplace smoothing\n \n for j in range(self.feature_count): # Loop over each feature\n single_word_count = np.sum(dataset[start_index:end_index,j]) # sum number times word j appears in class i \n numerator = single_word_count + self.alpha\n self.p_xi_given_ys[i][j] = log(numerator * 1.0 / denominator) # Compute p(xi|y)\n \n start_index = end_index","def sample_labels(self, y, num_of_sents = 5, num_of_samples = 10,\n num_of_classes = 3, start_index = 5, get_prob = True):\n classes = self.classes_()\n ret = []\n am = lambda myList: [i[0] for i in sorted(enumerate(myList), key=lambda x:x[1], reverse= True)]\n\n for sent in y[:num_of_sents]:\n cur = []\n for word in sent[start_index: start_index + num_of_samples]:\n sorted_prob = am(word)\n cur.append([(classes[ind], word[ind]) if get_prob else classes[ind]\n for ind in sorted_prob[:num_of_classes]])\n ret.append(cur)\n return ret","def label(d, X, ind_class0, ind_class1, N, V, binary):\n if binary == True:\n K = 1\n C = torch.zeros(N + V, K)\n C[ind_class0, :] = 0.0\n C[ind_class1, :] = 1.0\n else:\n K = 2\n C = torch.zeros(N + V, K)\n C[ind_class0, :] = torch.tensor([1.0, 0.0])\n C[ind_class1, :] = torch.tensor([0.0, 1.0])\n\n X_train = X[:N, :]\n X_val = X[N:, :]\n C_train = C[:N, :]\n C_val = C[N:, :]\n\n return [X_train, C_train, X_val, C_val, d, K]","def bl_predict(self, n_samples, data=None):\n\n if data is None:\n data = self.datas[self.train_idx]\n\n y_train = data.gen_labels()\n bl = DummyClassifier()\n bl.fit(np.random.rand(len(y_train), 1), y_train)\n\n return self._predict_proba(bl, np.random.rand(n_samples, 1))","def get_data(numbers):\r\n numbers = numbers\r\n n_classes = len(numbers)\r\n z = zipfile.ZipFile('lab3/mnist.pkl.zip', 'r')\r\n k = z.extract('mnist.pkl') # Извлечь файл из архива\r\n with open(k, 'rb') as f:\r\n train_set, _, test_set = pickle.load(f, encoding=\"bytes\")\r\n x_train = train_set[0]\r\n x_test = test_set[0]\r\n x_train[x_train >= 0.5] = 1\r\n x_train[x_train < 0.5] = 0\r\n x_test[x_test >= 0.5] = 1\r\n x_test[x_test < 0.5] = 0\r\n y_train = train_set[1]\r\n y_test = test_set[1]\r\n idx_train = [[np.where(y_train == i)] for i in numbers]\r\n idx_test = [[np.where(y_test == i)] for i in numbers]\r\n idx_x_train = [x_train[idx_train[i][0]] for i in range(len(idx_train))]\r\n idx_x_test = [x_test[idx_test[i][0]] for i in range(len(idx_test))]\r\n idx_y_test = [y_test[idx_test[i][0]] for i in range(len(idx_test))]\r\n x_train_new = shuffle(np.concatenate(idx_x_train))\r\n x_test_new = shuffle(np.concatenate(idx_x_test))\r\n y_test_new = shuffle(np.concatenate(idx_y_test))\r\n return x_train_new, x_test_new, y_test_new, numbers, n_classes","def data_labels(data):\n\n # The data consists of a equal number of benign and deleterious samples\n # The first part of the data are the benign samples (label 0), and the second part the deleterious ones (label 1)\n n_samples = data.shape[0]\n n_class_samples = int(n_samples / 2)\n\n # Get a numpy array of the labels\n labels_ben = [0] * n_class_samples\n labels_del = [1] * n_class_samples\n labels = np.array(labels_ben + labels_del)\n\n # Convert the data into one hot encoded data\n labels = initialization_based(labels)\n\n return labels","def make_classification(\n nb_samples: int,\n nb_class: int,\n nb_features: int) -> Tuple[np.ndarray, np.ndarray]:\n # Initialisation x et y\n x_points = np.zeros((nb_samples, nb_features))\n y_points = np.zeros((nb_samples, 1))\n lim_plan = [0, 6] # on pose ça pour changer plus tard?\n nb_sample_class = (int)(nb_samples / nb_class)\n for i in range(nb_class):\n #print(i)\n #On choisi un centre de cluster aléatoirement\n centre = list()\n for _ in range(nb_features):\n centre.append(random.randint(lim_plan[0] * 10, lim_plan[1] * 10) / 10)\n lower_lim = np.arange(0, nb_sample_class) / nb_sample_class\n upper_lim = np.arange(1, nb_sample_class + 1) / nb_sample_class\n points = np.random.uniform(low=lower_lim, high=upper_lim,\n size=[nb_features, nb_sample_class]).T\n np.random.shuffle(points[:, 1])\n # On place les points dans l'espace approprié\n for p, point in enumerate(points):\n for j in range(nb_features):\n x_points[i * nb_sample_class + p][j] = point[j] + centre[j]\n y_points[i * nb_sample_class + p] = i\n return x_points, y_points","def train(length, n_ep, show=False):\r\n al_dict = {'a':0, 'b':1, 'c':2, 'd':3, 'e':4, 'f':5, 'g':6, 'h':7, 'i':8, \r\n 'j':9, 'k':10, 'l':11, 'm':12, 'n':13, 'o':14, 'p':15, 'q':16, \r\n 'r':17, 's':18, 't':19, 'u':20, 'v':21, 'w':22, 'x':23, 'y':24, \r\n 'z':25}\r\n \r\n #Load proper data\r\n raw_rand = open(f'Length {length} Data/rand_data_len{length}.txt', 'r').readlines()\r\n raw_human = open(f'Length {length} Data/human_data_len{length}.txt','r').readlines()\r\n \r\n #Turn data into numbers\r\n raw_rand = [string[:length] for string in raw_rand]\r\n raw_human = [string[:length] for string in raw_human]\r\n \r\n raw_rand = [list(string) for string in raw_rand]\r\n raw_human = [list(string) for string in raw_human]\r\n \r\n for lists in raw_rand:\r\n for i in range(length):\r\n lists[i] = al_dict[lists[i]]\r\n for lists in raw_human:\r\n for i in range(length):\r\n lists[i] = al_dict[lists[i]]\r\n \r\n #Set aside 1/3 for test data\r\n test_rand = raw_rand[:len(raw_rand)//3]\r\n test_human = raw_human[:len(raw_human)//3]\r\n train_rand = raw_rand[len(raw_rand)//3:]\r\n train_human = raw_human[len(raw_human)//3:]\r\n \r\n #Intersperse both samples randomly with labels (0 = rand, 1 = human)\r\n train = []\r\n trn_labels = []\r\n test = []\r\n tst_labels = []\r\n while len(test_rand) and len(test_human) != 0:\r\n num = random.random()\r\n if num > .5 and len(test_rand) > 0:\r\n test.append(test_rand.pop())\r\n tst_labels.append(0)\r\n else:\r\n test.append(test_human.pop())\r\n tst_labels.append(1)\r\n \r\n while len(train_rand) and len(train_human) != 0:\r\n num = random.random()\r\n if num > .5 and len(train_rand) > 0:\r\n train.append(train_rand.pop())\r\n trn_labels.append(0)\r\n else:\r\n train.append(train_human.pop())\r\n trn_labels.append(1)\r\n \r\n # Build network, 2 hidden layers, 26 dimensional vectors for alphabet\r\n model = keras.Sequential()\r\n model.add(keras.layers.Embedding(26, 16)) #26=numletters\r\n model.add(keras.layers.GlobalAveragePooling1D())\r\n model.add(keras.layers.Dense(16, activation=tf.nn.relu))\r\n model.add(keras.layers.Dense(1, activation=tf.nn.sigmoid))\r\n \r\n # Loss function, Using Probabilities\r\n model.compile(optimizer=tf.train.AdamOptimizer(),\r\n loss='binary_crossentropy',\r\n metrics=['accuracy'])\r\n \r\n # Perform n_ep epochs of training on train_data\r\n partial_train = np.array(train[len(train)//10:])\r\n partial_labels = trn_labels[len(train)//10:]\r\n val_train = np.array(train[:len(train)//10])\r\n val_labels = trn_labels[:len(train)//10]\r\n print((len(partial_train), len(partial_labels)),\r\n (len(val_train), len(val_labels)),\r\n (len(test), len(tst_labels)))\r\n \r\n history = model.fit(partial_train,\r\n partial_labels,\r\n epochs=n_ep,\r\n batch_size=512,\r\n validation_data=(val_train, val_labels),\r\n verbose=1)\r\n \r\n #EVALUATE THE FINAL MODEL\r\n\r\n results = model.evaluate(np.array(test), tst_labels)\r\n print(results)\r\n \r\n # GRAPH ACCURACY AND LOSS OVER TIME\r\n if show:\r\n acc = history.history['acc']\r\n val_acc = history.history['val_acc']\r\n loss = history.history['loss']\r\n val_loss = history.history['val_loss']\r\n \r\n history_dict = history.history\r\n \r\n epochs = range(1, len(acc) + 1)\r\n \r\n # \"bo\" is for \"blue dot\"\r\n plt.plot(epochs, loss, 'bo', label='Training loss')\r\n # b is for \"solid blue line\"\r\n plt.plot(epochs, val_loss, 'b', label='Validation loss')\r\n plt.title('Training and validation loss')\r\n plt.xlabel('Epochs')\r\n plt.ylabel('Loss')\r\n plt.legend()\r\n \r\n plt.show()\r\n \r\n plt.clf() # clear figure\r\n acc_values = history_dict['acc']\r\n val_acc_values = history_dict['val_acc']\r\n \r\n plt.plot(epochs, acc, 'bo', label='Training acc')\r\n plt.plot(epochs, val_acc, 'b', label='Validation acc')\r\n plt.title('Training and validation accuracy')\r\n plt.xlabel('Epochs')\r\n plt.ylabel('Accuracy')\r\n plt.legend()\r\n \r\n plt.show()\r\n \r\n return model","def label(filenames, train_path='../data/train_molecules_30.mat'):\n unlabeled = [scipy.io.loadmat(fname) for fname in filenames]\n unlabeled_X = np.vstack([data['X'] for data in unlabeled])\n X, Y = load_data(train_path, shape=(-1, 30, 30, 30))\n\n num_unlabeled = unlabeled_X.shape[0]\n unlabeled_Y = np.zeros(num_unlabeled) - 1\n unlabeled_Y = unlabeled_Y.reshape((-1, 1))\n Y = Y.reshape((-1, 1))\n Y_all = np.vstack((Y, unlabeled_Y))\n\n X_all = np.vstack((X, unlabeled_X))\n X_all = X_all.reshape((-1, 27000))\n\n label_prop_model = LabelSpreading()\n label_prop_model.fit(X_all, Y_all)\n Y_all = label_prop_model.transduction_\n unlabeled_Y = Y_all[num_unlabeled:]\n return (unlabeled_X, unlabeled_Y), (X_all, Y_all)","def generate(self, labels, list_IDs, n_classes):\n # Infinite loop\n while 1:\n # Generate order of exploration of dataset\n indexes = self.__get_exploration_order(list_IDs)\n\n # Generate batches\n imax = int(len(indexes)/self.batch_size)\n for i in range(imax):\n # Find list of IDs\n list_IDs_temp = [list_IDs[k] for k in indexes[i*self.batch_size:(i+1)*self.batch_size]]\n print(\"Producing\")\n #print(list_IDs_temp)\n # Generate data\n X, y = self.__data_generation(labels, list_IDs_temp, n_classes)\n # print(X.shape)\n # print(y.shape)\n #print(\"Target Label\")\n #print(y)\n gc.collect()\n yield X, y","def loadtrainData_undersampling():\n train = []\n fileIn = open(PATH + 'traindata_Subtask4.txt')\n for line in fileIn.readlines():\n lineArr = line.strip().split()\n train.append([float(lineArr[i]) for i in range(len(lineArr))])\n\n pos = []\n neg = []\n for i in train:\n if i[-1] == 1.0:\n pos.append(i)\n else:\n neg.append(i)\n slice1 = random.sample(neg, len(pos))\n data = pos + slice1\n train_x = []\n train_y = []\n y = []\n for line in data:\n train_x.append([float(line[i]) for i in range(len(line) - 1)])\n y.append([int(line[-1])])\n for i in range(len(y)):\n train_y.append(y[i][0])\n return np.mat(train_x), np.mat(train_y).transpose()","def gen_random_labels(\n X: Union[np.ndarray, int], n_classes: int, pvec=None\n) -> np.ndarray:\n\n if isinstance(X, int):\n num = X\n else:\n num = X.shape[0]\n\n pvec = np.ones((n_classes,)) / n_classes\n\n return npr.multinomial(1, pvec, size=num)","def _get_classification_data(self, real, synthetic, real_label, synthetic_label):\n split_index = int(self.train_test_split * len(real))\n X_train = synthetic[:split_index]\n y_train = synthetic_label[:split_index]\n X_test = real[split_index:]\n y_test = real_label[split_index:]\n return X_train, y_train, X_test, y_test","def _generate_training_batch(ground_truth_data, representation_function,\n batch_size, num_points, random_state):\n points = None # Dimensionality depends on the representation function.\n labels = np.zeros(num_points, dtype=np.int64)\n for i in range(num_points):\n labels[i], feature_vector = _generate_training_sample(\n ground_truth_data, representation_function, batch_size, random_state)\n if points is None:\n points = np.zeros((num_points, feature_vector.shape[0]))\n points[i, :] = feature_vector\n return points, labels","def get_train_examples(self, data_dir):\n\t\traise NotImplementedError()","def classify():\n yes_dataset = df[df[\"_class\"] == 1] # 470588\n no_dataset = df[df[\"_class\"] == 0] # 1971\n\n parameter_analysis = list()\n for criterion in np.arange(0.05, 0.91, 0.05):\n print(\"doing experiment at criterion = %s ...\" % criterion)\n rate_list = list()\n for i in range(10):\n # shuffle yes_dataset and no_dataset, so we can randomly choose 90% yes_dataset\n # + 90% no_dataset as train dataset, 10% yes_dataset + 10% no_dataset as test dataset\n yes_index = yes_dataset.index.tolist()\n random.shuffle(yes_index)\n no_index = no_dataset.index.tolist()\n random.shuffle(no_index)\n \n # concatenate 90%yes + 90%no, 10%yes + 10%no\n train = pd.concat([\n yes_dataset.loc[yes_index[:1774], :],\n no_dataset.loc[no_index[:423530], :]\n ])\n test = pd.concat([\n yes_dataset.loc[yes_index[1774:], :],\n no_dataset.loc[no_index[423530:], :]\n ]) \n \n # split data and label\n train_data, train_label = (train[[\"Revenue.Code\", \n \"Service.Code\", \n \"Procedure.Code\", \n \"Diagnosis.Code\", \n \"Subscriber.Index\"]], \n train[\"_class\"])\n test_data, test_label = (test[[\"Revenue.Code\", \n \"Service.Code\", \n \"Procedure.Code\", \n \"Diagnosis.Code\", \n \"Subscriber.Index\"]], \n test[\"_class\"])\n \n # apply classifier\n clf = GaussianNB()\n clf.fit(train_data, train_label)\n probability = clf.predict_proba(test_data).T[1]\n \n result = pd.DataFrame()\n result[\"_class\"] = test_label\n result[\"_predict\"] = probability >= criterion\n \n result_yes = result[result[\"_class\"] == 1]\n yes_yes_rate = sum(result_yes[\"_class\"] == result_yes[\"_predict\"])/len(result_yes[\"_predict\"])\n \n result_no = result[result[\"_class\"] == 0]\n no_no_rate = sum(result_no[\"_class\"] == result_no[\"_predict\"])/len(result_no[\"_predict\"])\n \n rate_list.append((yes_yes_rate, no_no_rate))\n\n rate_list = pd.DataFrame(rate_list)\n yes_yes_rate, no_no_rate = rate_list.mean()[0], rate_list.mean()[1]\n parameter_analysis.append((criterion, yes_yes_rate, no_no_rate))\n \n # save data to excel spreadsheet\n parameter_analysis = pd.DataFrame(parameter_analysis, columns=[\"criterion\", \"yes_yes_rate\", \"no_no_rate\"])\n writer = pd.ExcelWriter(\"parameter_analysis.xlsx\")\n parameter_analysis.to_excel(writer, \"parameter_analysis\", index=False)\n writer.save()","def data_labels(data):\n\n # The data consists of a equal number of benign and deleterious samples\n # The first part of the data are the benign samples (label 0), and the second part the deleterious ones (label 1)\n n_samples = data.shape[0]\n n_class_samples = int(n_samples / 2)\n\n # Get a numpy array of the labels\n labels_ben = [0] * n_class_samples\n labels_del = [1] * n_class_samples\n labels = np.array(labels_ben + labels_del)\n\n # Create float numbers for the labels\n labels = labels.astype(float)\n\n # Convert the data into a numpy array\n # One hot encoded vector is not necessary, because the data is binary\n labels = np.reshape(labels, [-1, 1])\n\n return labels","def my_impl_variational(in_train, in_test, labels):\n X_train = []\n X_test = []\n for lab in labels:\n for datum in in_train[lab]:\n X_train.append([datum, lab])\n for datum in in_test[lab]:\n X_test.append([datum, lab])\n Variationer_learn(X_train, 500, 1, 0.01, X_test, labels)","def init_train(self):\n data = self.loader.load_labelled_data(self.conf.split, 'training')\n\n # Initialise unlabelled data iterator\n num_ul = 0\n if self.conf.ul_mix > 0:\n ul_data = self.loader.load_unlabelled_data(self.conf.split, 'all')\n\n # calculate number of unlabelled images as a proportion of the labelled images\n num_ul = int(data.size() * self.conf.ul_mix)\n num_ul = num_ul if num_ul <= ul_data.size() else ul_data.size()\n log.info('Sampling %d unlabelled images out of total %d.' % (num_ul, ul_data.size()))\n ul_data.sample(num_ul)\n self.gen_X_U = data_utils.generator(self.conf.batch_size, 'overflow', ul_data.images)\n\n # Initialise labelled data iterator\n assert self.conf.l_mix >= 0\n\n # calculate number of labelled images\n num_l = int(data.size() * self.conf.l_mix)\n num_l = num_l if num_l <= data.size() else data.size()\n log.info('Using %d labelled images out of total %d.' % (num_l, data.size()))\n train_images = data.images[:num_l]\n train_masks = data.masks[:num_l]\n\n self.conf.unlabelled_image_num = num_ul\n self.conf.labelled_image_num = num_l\n self.conf.data_len = num_ul if num_ul > num_l else num_l\n self.conf.batches = int(np.ceil(self.conf.data_len / self.conf.batch_size))\n self.conf.save()\n\n self.gen_X_L = data_utils.generator(self.conf.batch_size, 'overflow', train_images, train_masks)\n\n # Initialise real masks iterator for discriminator training, using the real masks from the data CV split.\n self.other_masks = data_utils.generator(self.conf.batch_size, 'overflow', data.masks + 0)","def dataset_preparation():\r\n with open('../data/patterns_num.txt', 'r') as f:\r\n data = f.readlines()\r\n X, Y = [], []\r\n for line in data:\r\n x, y = line.split('\\t')\r\n if len(x) > 5 and x not in X: # better results are achieved excluding short query patterns\r\n X.append(x.replace(\"X\", \"\").replace(\"Y\", \"\").lower())\r\n Y.append(int(y.replace('\\n', '')))\r\n test_size = 0.2\r\n # print('Test size:', test_size, '\\nWrong classifications:\\n')\r\n\r\n X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=test_size, random_state=42, stratify=Y)\r\n return X_train, y_train, X_test, y_test","def get_train_examples(self, data_dir):\n raise NotImplementedError()","def get_train_examples(self, data_dir):\n raise NotImplementedError()","def generate_samples(self, n_samples):","def generate_samples(self, n_samples):","def next(self):\n #print('next')\n batch_size = self.batch_size\n batch_data = nd.empty((batch_size,)+self.data_shape)\n batch_label = nd.empty((batch_size,)+self.label_shape)\n i = 0\n #self.cutoff = random.randint(800,1280)\n try:\n while i < batch_size:\n #print('N', i)\n data, label, annot = self.next_sample()\n R = self.get_data(data, label, annot)\n if R is None:\n continue\n data_out, label_out, flip_data_out, flip_label_out = R\n if not self.use_coherent:\n data = nd.array(data_out)\n data = nd.transpose(data, axes=(2, 0, 1))\n label = nd.array(label_out)\n #print(data.shape, label.shape)\n batch_data[i][:] = data\n batch_label[i][:] = label\n i += 1\n else:\n data = nd.array(data_out)\n data = nd.transpose(data, axes=(2, 0, 1))\n label = nd.array(label_out)\n data2 = nd.array(flip_data_out)\n data2 = nd.transpose(data2, axes=(2, 0, 1))\n label2 = nd.array(flip_label_out)\n #M = nd.array(M)\n #print(data.shape, label.shape)\n batch_data[i][:] = data\n batch_label[i][:] = label\n #i+=1\n j = i+self.per_batch_size//2\n batch_data[j][:] = data2\n batch_label[j][:] = label2\n i += 1\n if j%self.per_batch_size==self.per_batch_size-1:\n i = j+1\n except StopIteration:\n if i<batch_size:\n raise StopIteration\n\n #return {self.data_name : batch_data,\n # self.label_name : batch_label}\n #print(batch_data.shape, batch_label.shape)\n return mx.io.DataBatch([batch_data], [batch_label], batch_size - i)","def train_eval_rnd(self, train_data, test_data, rand_iter, train_labels, test_labels):\n np.random.seed(0)\n shuf_tr = [np.random.permutation(train_labels)\n for _ in range(rand_iter)]\n misclass_tr, misclass_ts = [], []\n for lab in shuf_tr:\n self.class_method.fit(train_data, lab)\n misclass_tr.append(zero_one_loss(lab, self.class_method.predict(train_data)))\n misclass_ts.append(zero_one_loss(test_labels,\n _kuhn_munkres_algorithm(test_labels,\n self.class_method.predict(test_data))))\n return np.mean(misclass_tr), np.mean(misclass_ts)\n # start = time.process_time()\n # np.random.seed(0)\n # shuf_tr, shuf_val = zip(*[list(map(lambda x: np.random.permutation(x),\n # [tr_labels, val_labels])) for _ in range(rand_iter)])\n # # print(f'Shuffle train:{shuf_tr}, Shuffle val:{shuf_val}')\n # # logging.info(f'Shuffle labels: {time.process_time()-start}s')\n # # part = time.process_time()\n # model_tr = [self.class_method.fit(train_data, lab) for lab in shuf_tr]\n # # print(f'Models:{model_tr}')\n # # logging.info(f'Train model: {time.process_time()-part}s')\n # # part = time.process_time()\n # misclass_tr = [zero_one_loss(x, y.predict(train_data)) for x, y in\n # zip(shuf_tr, model_tr)]\n # # print(f'Misclassification tr:{misclass_tr}')\n # # logging.info(f'Misclass TR: {time.process_time()-part}s')\n # # part = time.process_time()\n # misclass_val = [zero_one_loss(x, _kuhn_munkres_algorithm(x,\n # y.predict(val_data))) for x, y in\n # zip(shuf_val, model_tr)]\n # # print(f'Misclassification val:{misclass_val}')\n # # logging.info(f'Misclass VAL: {time.process_time()-part}s')\n # return np.mean(misclass_tr), np.mean(misclass_val)\n # misc_avg_tr, misc_avg_ts = [], []\n # append_tr = misc_avg_tr.append\n # append_ts = misc_avg_ts.append\n # for it in range(rand_iter):\n # np.random.seed(0)\n # np.random.shuffle(tr_labels)\n # np.random.seed(0)\n # np.random.shuffle(val_labels)\n # model_tr = self.class_method.fit(train_data, tr_labels)\n # misclass_tr = zero_one_loss(tr_labels,\n # self.class_method.predict(train_data))\n # misclass_ts = zero_one_loss(val_labels,\n # _kuhn_munkres_algorithm(val_labels,\n # model_tr.predict(val_data)))\n # append_tr(misclass_tr)\n # append_ts(misclass_ts)\n # return np.mean(misc_avg_tr), np.mean(misc_avg_ts)","def trainData(self, X, y, NeuralNet, epochs):","def get_train_examples(self, data_dir):\r\n raise NotImplementedError()","def get_train_examples(self, data_dir):\r\n raise NotImplementedError()","def get_train_examples(self, data_dir):\r\n raise NotImplementedError()","def get_train_examples(self, data_dir):\r\n raise NotImplementedError()","def get_train_examples(self, data_dir):\r\n raise NotImplementedError()","def get_train_examples(self, data_dir):\r\n raise NotImplementedError()","def get_train_examples(self, data_dir):\r\n raise NotImplementedError()","def prepare_data(self,d):\n train_loaders, train_iters = {}, {}\n unlabeled_loaders, unlabeled_iters = {}, {}\n for domain in opt.domains:\n #CONVERT TO FLOAT32\n features, target = torch.from_numpy(d[domain].X.todense().astype('float32')), torch.from_numpy(d[domain].y)#.reshape((-1,1))\n train = data_utils.TensorDataset(features,target)\n train_loaders[domain] = DataLoader(train, opt.batch_size, shuffle = True)\n train_iters[domain] = iter(train_loaders[domain])\n for domain in opt.unlabeled_domains:\n features, target = torch.from_numpy(d[domain].X.todense().astype('float32')), torch.from_numpy(d[domain].y)#.reshape(-1,1))\n uset = data_utils.TensorDataset(features,target)\n unlabeled_loaders[domain] = DataLoader(uset,opt.batch_size, shuffle = True)\n unlabeled_iters[domain] = iter(unlabeled_loaders[domain])\n \n return train_loaders, train_iters, unlabeled_loaders, unlabeled_iters","def next_data(self, n_way, n_shot, n_query, num_unlabel=0, n_distractor=0, train=True):\n support = np.zeros([n_way, n_shot, self.im_height, self.im_width, self.channels], dtype=np.float32)\n query = np.zeros([n_way, n_query, self.im_height, self.im_width, self.channels], dtype=np.float32)\n if num_unlabel>0:\n unlabel = np.zeros([n_way+n_distractor, num_unlabel, self.im_height, self.im_width, self.channels], dtype=np.float32)\n else:\n unlabel = []\n n_distractor = 0\n\n selected_classes = np.random.permutation(self.n_classes)[:n_way+n_distractor]\n for i, cls in enumerate(selected_classes[0:n_way]): # train way\n # labled data\n idx1 = np.random.permutation(self.n_label)[:n_shot + n_query]\n support[i] = self.dataset_l[cls, idx1[:n_shot]]\n query[i] = self.dataset_l[cls, idx1[n_shot:]]\n # unlabel\n if num_unlabel>0:\n idx2 = np.random.permutation(self.n_unlabel)[:num_unlabel]\n unlabel[i] = self.dataset_u[cls,idx2]\n\n for j,cls in enumerate(selected_classes[self.n_classes:]): # distractor way\n idx3 = np.random.permutation(self.n_unlabel)[:num_unlabel]\n unlabel[i+j] = self.dataset_u[cls,idx3]\n\n support_labels = np.tile(np.arange(n_way)[:, np.newaxis], (1, n_shot)).astype(np.uint8)\n query_labels = np.tile(np.arange(n_way)[:, np.newaxis], (1, n_query)).astype(np.uint8)\n # unlabel_labels = np.tile(np.arange(n_way+n_distractor)[:, np.newaxis], (1, num_unlabel)).astype(np.uint8)\n\n return support, support_labels, query, query_labels, unlabel","def _fetch_labels(self, list_fams, no_imgs, num_samples) -> Tuple[np.ndarray, List]:\n y_train = np.zeros(num_samples)\n pos = 0\n label = 0\n indexes = []\n for i in no_imgs:\n indexes.append(i)\n print(\"Label:%2d\\tFamily: %15s\\tNumber of images: %d\" % (label, list_fams[label], i))\n for j in range(i):\n y_train[pos] = label\n pos += 1\n label += 1\n return y_train, indexes","def prepare_dataset():\n with open('gold-posts.txt', encoding='utf-8') as f:\n posts = f.readlines()\n with open('gold-labels.txt', encoding='utf-8') as f:\n labels = f.readlines()\n\n def to_cat(x: str) -> int:\n if x == 'p':\n return 1\n elif x == 'n':\n return 2\n else:\n return 0\n X = np.array([x.strip() for x in posts])\n y = np.array([to_cat(x.strip()) for x in labels])\n\n # DOES NOT WORK - too imbalanced\n #skf = StratifiedKFold(n_splits=5, random_state=None, shuffle=False)\n #for train_index, test_index in skf.split(X, y):\n # X_train, X_test = X[train_index], X[test_index]\n # y_train, y_test = y[train_index], y[test_index]\n # break\n\n # WORKS better\n trI, teI = balanced_split(y)\n\n train_texts = X[trI].tolist()\n train_labels = y[trI].tolist()\n valid_texts = X[teI].tolist()\n valid_labels = y[teI].tolist()\n return train_texts, train_labels, valid_texts, valid_labels","def reset(self, n_start=2):\n\n # SAMPLE INITIAL DATAPOINTS\n self.dataset.regenerate()\n self.episode_qualities = []\n # To train an initial classifier we need at least self.n_classes samples\n if n_start < self.n_classes:\n n_start = self.n_classes\n # Sample n_start datapoints\n self.indeces_known = []\n self.indeces_unknown = []\n for i in np.unique(self.dataset.train_labels):\n # First get 1 point from each class\n cl = np.nonzero(self.dataset.train_labels==i)[0]\n # Insure that we select random datapoints\n indeces = np.random.permutation(cl)\n self.indeces_known.append(indeces[0])\n self.indeces_unknown.extend(indeces[1:]) \n self.indeces_known = np.array(self.indeces_known)\n self.indeces_unknown = np.array(self.indeces_unknown)\n # self.indeces_unknown now containts first all points of class1, then all points of class2 etc.\n # So, we permute them\n self.indeces_unknown = np.random.permutation(self.indeces_unknown)\n # Then, sample the rest of the datapoints at random\n if n_start > self.n_classes:\n self.indeces_known = np.concatenate(([self.indeces_known, self.indeces_unknown[0:n_start-self.n_classes]]))\n self.indeces_unknown = self.indeces_unknown[n_start-self.n_classes:] \n \n # BUILD AN INITIAL MODEL\n # Get the data corresponding to the selected indeces\n known_data = self.dataset.train_data[self.indeces_known,:]\n known_labels = self.dataset.train_labels[self.indeces_known]\n unknown_data = self.dataset.train_data[self.indeces_unknown,:]\n unknown_labels = self.dataset.train_labels[self.indeces_unknown]\n # Train a model using data corresponding to indeces_known\n known_labels = np.ravel(known_labels)\n self.model.fit(known_data, known_labels)\n # Compute the quality score\n test_prediction = self.model.predict(self.dataset.test_data)\n new_score = self.quality_method(self.dataset.test_labels, test_prediction)\n self.episode_qualities.append(new_score)\n # Get the features categorizing the state \n classifier_state, next_action_state = self._get_state() \n self.n_actions = np.size(self.indeces_unknown) \n return classifier_state, next_action_state","def train(self, X, labels, n_epochs=100, n_batch=128, reporting_period=10):\n bat_per_epo = int(X.shape[0] / n_batch)\n half_batch = int(n_batch / 2)\n \n # for recording metrics.\n self.g_loss = np.zeros((n_epochs * bat_per_epo, 1))\n self.d_loss_real = np.zeros((n_epochs * bat_per_epo, 1)) \n self.d_loss_fake = np.zeros((n_epochs * bat_per_epo, 1))\n self.d_acc_real = np.zeros((n_epochs * bat_per_epo, 1))\n self.d_acc_fake = np.zeros((n_epochs * bat_per_epo, 1))\n self.d_acc_real_epochs = np.zeros((n_epochs, 1))\n self.d_acc_fake_epochs = np.zeros((n_epochs, 1))\n \n # manually enumerate epochs\n for i in range(n_epochs):\n \n # enumerate batches over the training set\n for j in range(bat_per_epo):\n # update discriminator model weights on randomly selected 'real' samples\n [X_real, labels_real], y_real = self.generate_real_samples(X, labels, half_batch)\n d_loss1, d_acc1 = self.d_model.train_on_batch([X_real, labels_real], y_real)\n \n # update discriminator model weights on generated 'fake' examples\n [X_fake, labels_fake], y_fake = self.generate_generator_prediction_samples(half_batch)\n d_loss2, d_acc2 = self.d_model.train_on_batch([X_fake, labels_fake], y_fake)\n \n # prepare points in latent space as input for the generator\n [z_input, labels_input] = self.generate_latent_points(n_batch)\n # create inverted labels for the fake samples\n y_gan = np.ones((n_batch, 1))\n # update the generator via the discriminator's error\n g_loss = self.gan_model.train_on_batch([z_input, labels_input], y_gan)\n \n # summarize loss on this batch\n print('>%d, %d/%d, d1=%.3f, d2=%.3f g=%.3f' %\n (i+1, j+1, bat_per_epo, d_loss1, d_loss2, g_loss))\n\n # record losses for later\n self.g_loss[i*bat_per_epo + j] = g_loss\n self.d_loss_real[i*bat_per_epo + j] = d_loss1\n self.d_loss_fake[i*bat_per_epo + j] = d_loss2\n self.d_acc_real[i*bat_per_epo + j] = d_acc1\n self.d_acc_fake[i*bat_per_epo + j] = d_acc2\n\n # save per epoch metrics \n # evaluate discriminator on real examples\n n_samples = 100\n x_real, y_real = self.generate_real_samples(X, labels, n_samples)\n _, acc_real = self.d_model.evaluate(x_real, y_real, verbose=0)\n self.d_acc_real_epochs[i] = acc_real\n \n # evaluate discriminator on fake examples\n x_fake, y_fake = self.generate_generator_prediction_samples(n_samples)\n _, acc_fake = self.d_model.evaluate(x_fake, y_fake, verbose=0)\n self.d_acc_fake_epochs[i] = acc_fake\n \n # every reporting_period, plot out images.\n if i == 0 or (i+1) % reporting_period == 0 or (i+1) == n_epochs:\n self.summarize_performance(i+1, 'conditional-gan')\n \n # save the generator model\n self.save_model('conditional-gan')","def build_models_NLP(train_pos_vec, train_neg_vec):\n Y = [\"pos\"]*len(train_pos_vec) + [\"neg\"]*len(train_neg_vec)\n\n # Use sklearn's BernoulliNB and LogisticRegression functions to fit two models to the training data.\n # For BernoulliNB, use alpha=1.0 and binarize=None\n # For LogisticRegression, pass no parameters\n # YOUR CODE HERE\n from sklearn import linear_model,naive_bayes\n lr = linear_model.LogisticRegression()\n lr_model = lr.fit(train_pos_vec + train_neg_vec, Y)\n\n nb = naive_bayes.BernoulliNB(alpha=1.0, binarize=None)\n nb_model = nb.fit(train_pos_vec + train_neg_vec, Y)\n\n return nb_model, lr_model","def load_data(self):\n print('Loading {} dataset'.format(self.split))\n data_split_path = os.path.join(self.root_dir, 'splits', '{}.csv'.format(self.split))\n with open(data_split_path,'r') as f:\n reader = csv.reader(f, delimiter=',')\n data_classes = {}\n for i,row in enumerate(reader):\n if i==0:\n continue\n data_classes[row[1]] = 1\n data_classes = data_classes.keys()\n print(data_classes)\n\n n_classes = len(data_classes)\n print('n_classes:{}, n_label:{}, n_unlabel:{}'.format(n_classes,self.n_label,self.n_unlabel))\n dataset_l = np.zeros([n_classes, self.n_label, self.im_height, self.im_width, self.channels], dtype=np.float32)\n if self.n_unlabel>0:\n dataset_u = np.zeros([n_classes, self.n_unlabel, self.im_height, self.im_width, self.channels], dtype=np.float32)\n else:\n dataset_u = []\n\n for i, cls in enumerate(data_classes):\n im_dir = os.path.join(self.root_dir, 'data/{}/'.format(self.split), cls)\n im_files = sorted(glob.glob(os.path.join(im_dir, '*.jpg')))\n np.random.RandomState(self.seed).shuffle(im_files) # fix the seed to keep label,unlabel fixed\n for j, im_file in enumerate(im_files):\n im = np.array(Image.open(im_file).resize((self.im_width, self.im_height)), \n np.float32, copy=False)\n if j<self.n_label:\n dataset_l[i, j] = im\n else:\n dataset_u[i,j-self.n_label] = im\n print('labeled data:', np.shape(dataset_l))\n print('unlabeled data:', np.shape(dataset_u))\n \n self.dataset_l = dataset_l\n self.dataset_u = dataset_u\n self.n_classes = n_classes","def trainNet():","def fixture_input_data(wrapper_arguments):\n n_features, classes = wrapper_arguments\n num_data = 50\n data = np.random.rand(num_data, n_features)\n labels = np.random.choice(classes, size=num_data)\n\n return data, labels","def generate_syntetic_data( self ):\n label_list = []\n img_ground_truth = np.zeros( ( self.img_h, self.img_w ), dtype = np.float32 )\n img = np.zeros( ( self.img_h, self.img_w, 3 ), dtype = np.float32 )\n class_blue = np.zeros( ( self.img_h, self.img_w ), dtype = np.float32 )\n class_red = np.zeros( ( self.img_h, self.img_w ), dtype = np.float32 )\n\n '''line, square, grill, rectangle, cross'''\n if self.option_shape == 'line':\n sample_type = 0\n elif self.option_shape == 'circle':\n sample_type = 1\n elif self.option_shape == 'rectangle':\n sample_type = 2\n else: \n sample_type = np.random.randint( 3 ) #0,1,2\n\n if sample_type == 0:\n self.generate_line( img_ground_truth, img, class_blue, class_red )\n elif sample_type == 1:\n self.generate_circle( img_ground_truth, img, class_blue, class_red )\n else:\n self.generate_rectangle( img_ground_truth, img, class_blue, class_red )\n\n label_list.append( class_blue )\n label_list.append( class_red )\n # 2 classes generates\n label_all = np.dstack( label_list ).astype( np.float32 ) \n r, g, b = cv2.split( img )\n img_bgr = cv2.merge( [ b, g, r ] )\n\n gen_adj = GenerateAdjMatrx( type_dist = self.type_dist )\n A_gt = gen_adj.adjmatrx_groundthuth( img_ground_truth )\n\n B_in = gen_adj.adjmatrx_groundthuth(img_ground_truth * 0)\n\n return img_bgr, img_ground_truth, label_all, A_gt, B_in","def multiclass_toy_data(): \n #dataset = np.zeros((10,5), np.int)\n dataset = np.array([[0,0,0,0,4],\n [0,0,0,0,5],\n [1,3,0,0,0],\n [3,1,0,0,1],\n [0,0,6,2,0],\n [0,0,0,0,0],\n [0,0,1,7,2], \n [0,0,5,1,5],\n [0,0,34,0,0],\n [0,0,3,0,0]])\n Y = np.array([3,3,2,2,1,0,1,1,0,0])\n #for i in range(10):\n #for j in range(5):\n #dataset[i][j] = np.random.randint(0,10) \n dataset = np.column_stack((dataset, Y))\n return (dataset)","def learn(self, Xtrain, ytrain):","def pp_labels(y_train, y_dev, y_test):\n\n lb = LabelBinarizer()\n ym_train = lb.fit_transform(y_train).T\n ym_dev = lb.fit_transform(y_dev).T\n ym_test = lb.fit_transform(y_test).T\n\n return ym_train, ym_dev, ym_test","def load_data(data_dir, split=1.0):\n n = 123 * 41\n positive_examples = glob.glob(data_dir + '/positive_set/*.png')\n negative_examples = glob.glob(data_dir + '/negative_set/*.png')\n x = np.zeros((n, len(positive_examples) + len(negative_examples)))\n for k in range(len(positive_examples)):\n x[:,k] = np.reshape(img.imread(positive_examples[k]), (n,))\n for k in range(len(negative_examples)):\n x[:, k+len(positive_examples)] = np.reshape(img.imread(negative_examples[k]), (n,))\n y = np.concatenate((np.ones((1,len(positive_examples))), np.zeros((1,len(negative_examples)))), axis=1)\n arr = np.concatenate((x,y), axis=0)\n part_train = int(math.floor(split * arr.shape[1]))\n np.random.shuffle(arr.T)\n x_train = arr[0:-1,0:part_train]\n y_train = arr[-1,0:part_train]\n x_test = arr[0:-1,part_train:]\n y_test = arr[-1,part_train:]\n if split == 1.0:\n return (x_train.T, y_train.T)\n else:\n return (x_train.T, y_train.T),(x_test.T,y_test.T)","def demo():\n def load_data():\n train = open(\"csv/svd_train.csv\", \"r\")\n r = csv.reader(train)\n next(r)\n\n data = []\n target = []\n\n print \"Prepping data...\"\n for row in r:\n aux = [0 for x in xrange(10)]\n aux[int(row[0])] = 1\n target.append(aux)\n data.append([float(x) for x in row[1:]])\n\n train.close()\n\n data = np.array(data)\n\n target = np.array(target)\n\n #train = [target[:35000],data[:35000]]\n #test = [target[35000:],data[35000:]]\n\n return [target, data]\n\n NN = MLP_NeuralNetwork(101, 75, 35, 10,\n iterations = 200,\n learning_rate = 0.5,\n momentum = 0.05,\n rate_decay = 0.005)\n\n train = load_data()\n\n NN.train(train)\n #NN.test_cross(test)\n #NN.test()\n NN.test_against()"],"string":"[\n \"def generate_data(groups):\\n # get path list for the intended classification problem\\n input_paths = generate_input_list(groups) \\n X_lst = []\\n y = []\\n for p in input_paths:\\n dp = pd.read_csv(p, sep = '\\\\t') #datapoint\\n # Normalization \\n # norm = lambda x: (x - x.mean()) / x.std()\\n # dp = dp.apply(norm)\\n # Min-Max scaling \\n #dp_norm = (dp - dp.min()) / (dp.max() - dp.min())\\n #dp = dp_norm.values\\n if dp.isnull().sum().sum()>0:\\n# print(p, dp.isnull().sum().sum())\\n continue\\n dp = dp.drop(['time'], axis = 1) \\n dp = dp.iloc[:1600:4]\\n\\n if dp.isnull().sum().sum()>0:\\n# print('after norm',p, dp.isnull().sum().sum())\\n continue\\n dp = dp.values\\n\\n X_lst.append(dp)\\n sample_y = get_target(p, text= True)\\n y.append(sample_y)\\n X = np.stack(X_lst, axis=0)\\n \\n # convert y into int 0 and 1\\n encoder = LabelEncoder()\\n encoder.fit(y)\\n y = encoder.transform(y)\\n y_dummy = y\\n # convert y into one-hot encoding\\n if len(groups)>2:\\n y_dummy = pd.get_dummies(y)\\n y_dummy = y_dummy.values\\n return X, y , y_dummy\",\n \"def generate_data(nb_samples):\\n inputs = torch.empty(nb_samples, 2).uniform_(0, 1)\\n center = Tensor([0.5, 0.5]).view(1, -1)\\n distances = torch.norm((inputs - center).abs(), 2, 1)\\n labels = (distances < 1 / math.sqrt(2 * math.pi)).type(LongTensor)\\n return inputs.t(), labels\",\n \"def generate_labels(n_samples):\\n return np.ones([n_samples, 1]), np.zeros([n_samples, 1])\",\n \"def createDataset(n, d=100, d_inf=5, is_classification=True, no_signal=False):\\n \\n # making random inputs, outputs\\n X = np.random.normal(0, 1, (3*n, d))\\n y = np.random.normal(0, 1, (3*n, 1))\\n \\n # thresholding y values for classification\\n if is_classification:\\n y = 2.0*((y>0) - 0.5)\\n \\n # making the first d_inf dimensions informative\\n\\n if is_classification:\\n X[:,:d_inf] += y*np.random.normal(1.0, 1.5, X[:,:d_inf].shape)\\n else:\\n snr = 0.05\\n X[:,:d_inf] += snr*y\\n X = zscore(X, axis=0)\\n \\n # if you dont want useful signal, randomize the labels\\n if no_signal:\\n np.random.shuffle(y)\\n\\n # Divide into train/test/holdout pairs\\n outputs = [[X[i::3, :], y[i::3, 0]] for i in range(3)] \\n \\n return outputs\",\n \"def trainNN():\\n\\n yTrain = [] # holds y vals of curves/lines\\n trainLabels = [] # holds center labels\\n\\n tryCenters = np.linspace(1, 9, 45)\\n\\n for i in range(len(tryCenters)):\\n x = np.linspace(tryCenters[i]-.2, tryCenters[i]+.2, 18)\\n for j in range(1000):\\n centers = round(random.uniform(tryCenters[i]-.05,\\n tryCenters[i]+.05), 1)\\n y = gauss_func(x, .05, centers, 1)\\n yTrain.append(y)\\n trainLabels.append(1)\\n\\n y = gauss_func(x, .05,\\n round(random.uniform(tryCenters[i]-.3,\\n tryCenters[i]-.17), 1), 1)\\n yTrain.append(y)\\n trainLabels.append(0)\\n\\n y = gauss_func(x, .05,\\n round(random.uniform(tryCenters[i]+.17,\\n tryCenters[i]+.3), 1), 1)\\n yTrain.append(y)\\n trainLabels.append(0)\\n\\n y = 0*x\\n yTrain.append(y)\\n trainLabels.append(0)\\n clf = MLPClassifier(solver='lbfgs')\\n clf.fit(yTrain, trainLabels)\\n return clf\",\n \"def getExamples(n=100,d=2):\\n Xp = randn(n,d)+1 #generate n examples of the positie class\\n #Xp[:,0]=Xp[:,0]+1\\n Xn = randn(n,d)-1 #generate n examples of the negative class\\n #Xn[:,0]=Xn[:,0]-1\\n X = np.vstack((Xp,Xn)) #Stack the examples together to a single matrix\\n Y = np.array([+1]*n+[-1]*n) #Associate Labels\\n return (X,Y)\",\n \"def create_data(num_sample=None):\\n I = np.eye(3, dtype=np.float32)\\n\\n\\n if (num_sample == None):\\n num_sample = 100\\n\\n # Generate first class\\n m1 = np.asarray([0.5, 0.5], dtype=np.float32)\\n cov1 = np.asarray([[0.1, 0],\\n [0, 0.1]], dtype=np.float32)\\n data1 = rng.multivariate_normal(m1, cov1, num_sample)\\n label1 = np.ones((num_sample), dtype=np.uint16) - 1\\n label1 = I[label1,:]\\n\\n # Generate second class\\n m2 = np.asarray([0.3,0.3], dtype=np.float32)\\n cov2 = np.asarray([[0.5, 0], [0, 0.5]], dtype=np.float32)\\n data2 = rng.multivariate_normal(m2, cov2, num_sample)\\n label2 = np.ones((num_sample), dtype=np.uint16)\\n label2 = I[label2, :]\\n\\n\\n return (data1, label1, data2, label2)\",\n \"def _generate_data(self, x_data, y_data, max_seq_len, digits, seq_len,\\n n_samples, use_one_hot, class_partition,\\n upsample_control):\\n # modify seq_len in case we do upsampling control\\n if upsample_control:\\n upsample_factor = seq_len\\n seq_len = 1\\n if not self.two_class:\\n raise NotImplementedError()\\n\\n # construct all possible classes\\n classes = [\\\"\\\".join(seq) for seq in \\\\\\n itertools.product(\\\"01\\\", repeat=seq_len)]\\n\\n # get the right number of samples per class to get a balanced data set\\n # with the desired n_samples.\\n num = n_samples\\n div = len(classes)\\n n_samples_per_class = [num // div + (1 if x < num % div else 0) \\\\\\n for x in range (div)]\\n\\n # find indices of samples with the wanted digit class\\n y_data = [np.argmax(y) for y in y_data]\\n digit_idx = []\\n digit_idx.append(np.where(np.asarray(y_data) == digits[0])[0])\\n digit_idx.append(np.where(np.asarray(y_data) == digits[1])[0])\\n\\n # generate samples for every class\\n samples = []\\n labels = []\\n for i,c in enumerate(classes):\\n this_label = i\\n digits_to_sample = [int(c[i]) for i in range(len(c))]\\n for s in range(n_samples_per_class[i]):\\n this_sample = None\\n for d in digits_to_sample:\\n rand_idx = self._rstate.randint(len(digit_idx[d]))\\n sample_idx = digit_idx[d][rand_idx]\\n digit_sample = x_data[sample_idx]\\n if this_sample is None:\\n this_sample = digit_sample\\n else:\\n this_sample = np.vstack((this_sample,digit_sample)) \\n samples.append(this_sample)\\n labels.append(this_label)\\n\\n # if configured sort labels into 2 classes\\n labels = np.asarray(labels)\\n if self.two_class and not upsample_control:\\n lbl_mask = np.isin(labels, class_partition)\\n labels[~lbl_mask] = 0\\n labels[lbl_mask] = 1\\n\\n if upsample_control:\\n for i,s in enumerate(samples):\\n # Initial timestep is absolute start position of digit. To\\n # translate to a higher resolution image, we can just multiply\\n # the abolute position vby the scaling factor.\\n upsample = s[0,:]*upsample_factor\\n for t in np.arange(1,s.shape[0]):\\n # don't do upsampling at end of strokes or end of digits\\n if all((s[t,2] == 0, s[t,3] == 0)):\\n # Repeat original stroke \\\"upsample_factor\\\" times, such\\n # that the relative stroke length is identical if\\n # images are normalized to same resolution.\\n for k in range(upsample_factor):\\n upsample = np.vstack((upsample, s[t,:]))\\n else:\\n upsample = np.vstack((upsample, s[t,:]))\\n samples[i] = upsample\\n\\n # structure output data\\n out_data = labels.reshape(-1, 1)\\n if use_one_hot:\\n n_classes = 2**seq_len\\n if self.two_class:\\n n_classes = 2\\n\\n # FIXME We shouldn't call this method if the validation set size is\\n # zero.\\n if out_data.size == 0:\\n out_data = np.matlib.repmat(out_data, 1, n_classes)\\n else:\\n # FIXME use internal method `_to_one_hot` and set required class\\n # attributes beforehand.\\n one_hot_encoder = OneHotEncoder(categories=[range(n_classes)])\\n one_hot_encoder.fit(npm.repmat(np.arange(n_classes), 1, 1).T)\\n out_data = one_hot_encoder.transform(out_data).toarray()\\n\\n if self.target_per_timestep:\\n out_data = np.matlib.repmat(np.asarray(out_data), 1, max_seq_len)\\n\\n # structure input data\\n in_data = np.zeros((n_samples,max_seq_len,4))\\n sample_lengths = np.zeros(n_samples)\\n for i,s in enumerate(samples):\\n in_data[i,:s.shape[0],:] = s\\n sample_lengths[i] = s.shape[0]\\n\\n in_data = self._flatten_array(in_data)\\n\\n return in_data, out_data, sample_lengths\",\n \"def GenerateSeparableData(num_samples):\\n\\n\\tdata, true_labels = make_blobs(n_samples=num_samples, n_features=2, centers=2, cluster_std=0.7, random_state=0)\\n\\t# save the data as .npy file\\n\\tnp.save('./data/data_cal.npy', data)\\n\\tnp.save('./data/labels_cal.npy', true_labels)\\n\\treturn data, true_labels\",\n \"def get_example_data():\\n nnz = np.random.randint(FLAGS.min_nnz, FLAGS.max_nnz)\\n nz_idx = np.random.randint(FLAGS.dense_size, size=nnz)\\n nz_idx = np.unique(nz_idx)\\n nz_values = np.random.uniform(10, size=nz_idx.size)\\n label = np.random.randint(FLAGS.num_classes)\\n return nz_idx, nz_values, label\",\n \"def generate_fake_samples(generator, latent_dim, n):\\n\\n # Sample points from latent space\\n x_input = generate_latent_points(latent_dim, n)\\n\\n # Forward pass\\n X = generator.predict(x_input)\\n\\n # Generate labels for the discriminator\\n y = np.zeros((n, 1))\\n\\n return X, y\",\n \"def random_split(data, labels, n_classes, n_samples_per_class):\\r\\n train_X, train_Y, valid_X, valid_Y = [],[],[],[]\\r\\n\\r\\n for c in range(n_classes):\\r\\n # get indices of all class 'c' samples\\r\\n c_idx = (np.array(labels) == c).nonzero()[0]\\r\\n # get n unique class 'c' samples\\r\\n valid_samples = np.random.choice(c_idx, n_samples_per_class[c], replace=False)\\r\\n # get remaining samples of class 'c'\\r\\n train_samples = np.setdiff1d(c_idx, valid_samples)\\r\\n # assign class c samples to validation, and remaining to training\\r\\n train_X.extend(data[train_samples])\\r\\n train_Y.extend(labels[train_samples])\\r\\n valid_X.extend(data[valid_samples])\\r\\n valid_Y.extend(labels[valid_samples])\\r\\n\\r\\n if isinstance(data, torch.Tensor):\\r\\n # torch.stack transforms list of tensors to tensor\\r\\n return {'valid_mode_train': torch.stack(train_X), 'valid_mode_valid': torch.stack(valid_X)}, \\\\\\r\\n {'valid_mode_train': torch.stack(train_Y), 'valid_mode_valid': torch.stack(valid_Y)}\\r\\n else:\\r\\n # transforms list of np arrays to tensor\\r\\n return {'valid_mode_train': torch.from_numpy(np.stack(train_X)), \\\\\\r\\n 'valid_mode_valid': torch.from_numpy(np.stack(valid_X))}, \\\\\\r\\n {'valid_mode_train': torch.from_numpy(np.stack(train_Y)), \\\\\\r\\n 'valid_mode_valid': torch.from_numpy(np.stack(valid_Y))}\",\n \"def generate_mog_dataset():\\n\\n n_per_class = 100\\n dim = 2\\n n_gaussians = 4\\n mus = [(0, 1), (-1, 0), (0, -1), (1, 0)]\\n mus = [torch.tensor(m) for m in mus]\\n var = 0.05\\n\\n inputs, labels = [], []\\n\\n for id in range(n_gaussians):\\n # Generate input data by mu + x @ sqrt(cov)\\n cov = np.sqrt(var) * torch.eye(dim)\\n mu = mus[id]\\n inputs.append(mu + torch.randn(n_per_class, dim) @ cov)\\n\\n # Labels\\n labels.append(torch.tensor(n_per_class * [1.0 if id < 2 else 0.0]))\\n\\n return torch.cat(inputs, dim=0), torch.cat(labels, dim=0)\",\n \"def ytrain(self,)->list:\",\n \"def generate_generator_prediction_samples(self, n_samples):\\n # generate points in latent space\\n latent_points, labels = self.generate_latent_points(n_samples)\\n # predict outputs\\n X = self.generator_prediction(latent_points, labels)\\n # create class labels\\n y = np.zeros((n_samples, 1))\\n return [X, labels], y\",\n \"def nonlearning():\\n\\taT.featureAndTrain(['../../AudioData/chunked_data_sorted/pos', '../../AudioData/chunked_data_sorted/neg'], \\n\\t\\t\\t\\t\\t\\t1.0, 1.0, aT.shortTermWindow, aT.shortTermStep, \\n \\\"svm\\\", \\\"emotion_classifier\\\", True)\",\n \"def generate_data(data, samples, targeted=True, start=0, inception=False):\\n inputs = []\\n targets = []\\n labels = []\\n true_ids = []\\n for i in range(samples):\\n if targeted:\\n if inception:\\n # for inception, randomly choose 10 target classes\\n seq = np.random.choice(range(1, 1001), 1)\\n # seq = [580] # grand piano\\n else:\\n # for CIFAR and MNIST, generate all target classes\\n seq = range(data.test_labels.shape[1])\\n\\n # print ('image label:', np.argmax(data.test_labels[start+i]))\\n for j in seq:\\n # skip the original image label\\n if (j == np.argmax(data.test_labels[start + i])) and (inception == False):\\n continue\\n inputs.append(data.test_data[start + i])\\n targets.append(np.eye(data.test_labels.shape[1])[j])\\n labels.append(data.test_labels[start + i])\\n true_ids.append(start + i)\\n else:\\n inputs.append(data.test_data[start + i])\\n targets.append(data.test_labels[start + i])\\n labels.append(data.test_labels[start + i])\\n true_ids.append(start + i)\\n\\n inputs = np.array(inputs)\\n targets = np.array(targets)\\n labels = np.array(labels)\\n true_ids = np.array(true_ids)\\n\\n return inputs, targets, labels, true_ids\",\n \"def load_data_and_labels_without_shuffled():\\n # Load data from files\\n with codecs.open('./data/train_pos.txt', 'r+', 'utf-8') as f:\\n train_pos = f.readlines()\\n with codecs.open('./data/dev_pos.txt', 'r+', 'utf-8') as f:\\n dev_pos = f.readlines()\\n with codecs.open('./data/train_neg.txt', 'r+', 'utf-8') as f:\\n train_neg = f.readlines()\\n with codecs.open('./data/dev_neg.txt', 'r+', 'utf-8') as f:\\n dev_neg = f.readlines()\\n\\n positive_examples1 = []\\n positive_examples2 = []\\n negative_examples1 = []\\n negative_examples2 = []\\n\\n for i in train_pos:\\n item1, item2 = i.split('\\\\t')\\n item1 = remove_stop_word(item1)\\n item2 = remove_stop_word(item2)\\n positive_examples1.append(item1)\\n positive_examples2.append(item2)\\n\\n for i in train_neg:\\n item1, item2 = i.split('\\\\t')\\n item1 = remove_stop_word(item1)\\n item2 = remove_stop_word(item2)\\n negative_examples1.append(item1)\\n negative_examples2.append(item2)\\n\\n # Split by words\\n x_text_train1 = positive_examples1 + negative_examples1\\n x_text_train2 = positive_examples2 + negative_examples2\\n\\n positive_dev1 = []\\n positive_dev2 = []\\n negative_dev1 = []\\n negative_dev2 = []\\n\\n for i in dev_pos:\\n item1, item2 = i.split('\\\\t')\\n item1 = remove_stop_word(item1)\\n item2 = remove_stop_word(item2)\\n positive_dev1.append(item1)\\n positive_dev2.append(item2)\\n\\n for i in dev_neg:\\n item1, item2 = i.split('\\\\t')\\n item1 = remove_stop_word(item1)\\n item2 = remove_stop_word(item2)\\n negative_dev1.append(item1)\\n negative_dev2.append(item2)\\n\\n x_text_dev1 = positive_dev1 + negative_dev1\\n x_text_dev2 = positive_dev2 + negative_dev2\\n\\n # Generate labels\\n train_positive_labels = [[0, 1] for _ in train_pos]\\n dev_positive_labels = [[0, 1] for _ in dev_pos]\\n train_negative_labels = [[1, 0] for _ in train_neg]\\n dev_negative_labels = [[1, 0] for _ in dev_neg]\\n y_train = np.concatenate([train_positive_labels, train_negative_labels], 0)\\n y_dev = np.concatenate([dev_positive_labels, dev_negative_labels], 0)\\n\\n return [x_text_train1, x_text_train2, x_text_dev1, x_text_dev2, y_train, y_dev]\",\n \"def generate_fake_samples(n=1000):\\n train_samples = torch.rand(n, 2)#(n,2) tensor of values between 0 and 1\\n test_samples = torch.rand(n, 2)\\n train_labels = torch.rand(n, 2)\\n test_labels = torch.rand(n, 2)\\n\\n train_labels[:, 0] = (train_samples[:, 0] - 0.5) ** 2 + (train_samples[:, 1] - 0.5) ** 2 < 1 / (2 * pi)\\n train_labels[:, 1] = 1 - train_labels[:, 0]\\n test_labels[:, 0] = (test_samples[:, 0] - 0.5) ** 2 + (test_samples[:, 1] - 0.5) ** 2 < 1 / (2 * pi)\\n test_labels[:, 1] = 1 - test_labels[:, 0]\\n return train_samples, test_samples, train_labels.type(torch.FloatTensor), test_labels.type(torch.FloatTensor)\",\n \"def train(self,X,y):\\n self.X_train = X\\n self.y_train = y\\n self.class_labels = np.unique(self.y_train)\",\n \"def make_nonlinear_batch_data(self):\\n self.reset_batch()\\n g = SampleGenerator()\\n for i in range(self.batch_size):\\n # Draw a random sample on the interval [0,1]\\n x = np.random.random()\\n y = g.generate_non_linear_samples(x)\\n self.x_data.append(x)\\n self.y_data.append(y)\",\n \"def generate_combigen_x_y_dataset(n_samples=config.n_train, *args, **kwargs):\\n y = cg.generate_labels(n_samples=n_samples, *args, **kwargs)\\n x = cg.inverse_transform(y)\\n return x, y\",\n \"def get_xy(preprocessor, target='Coding:Level1'):\\n set_names = ['train', 'valid']\\n dfs = [pd.read_csv(f'data/roatan_{s}.csv') for s in set_names]\\n\\n # fit preprocessor with training set\\n preprocessor.fit(dfs[0]['message'])\\n # transform all data sets\\n xs = [preprocessor.transform(df['message']) for df in dfs]\\n\\n # encode labels as integers 0 ... n-1 using training set\\n le = LabelEncoder().fit(dfs[0][target])\\n # transform labels for all data sets\\n ys = [le.transform(df[target]) for df in dfs]\\n\\n classes = le.classes_\\n data_sets = list(zip(xs, ys))\\n return classes, data_sets, set_names\",\n \"def gen_data(n_samples=200):\\r\\n\\tnp.random.seed(13)\\r\\n\\tx = np.random.uniform(0,10,size=n_samples) #从一个均匀分布[0,10)中随机采样\\r\\n\\tx.sort()\\r\\n\\ty = ground_truth(x) + 0.75*np.random.normal(size=n_samples) #均值为0，标准差为1的正态分布\\r\\n\\t#print(\\\"x, y: \\\", x[:10], y[:10])\\r\\n\\ttrain_mask = np.random.randint(0,2,size=n_samples).astype(np.bool) #返回值为True or False\\r\\n\\t#print(\\\"train_mask: \\\",train_mask[:10])\\r\\n\\tx_train, y_train = x[train_mask, np.newaxis], y[train_mask] #如果train_mask是1，就将x,y作为训练集，np.newaxis表示将行向量转为列向量\\r\\n\\t#print(\\\"x_train, y_train: \\\", x_train[:10], y_train[:10])\\r\\n\\tx_test, y_test = x[~train_mask, np.newaxis], y[~train_mask] #train_mask为False，将x,y作为测试集\\r\\n\\t#print(\\\"x_test, y_test: \\\", x_test[:10], y_test[:10])\\r\\n\\treturn x_train, x_test, y_train, y_test\",\n \"def nnRegression(data):\",\n \"def gen_labels(loader, model):\\r\\n y_true, y_pred = [], []\\r\\n for X, y in loader:\\r\\n with torch.no_grad():\\r\\n output = model(X)\\r\\n predicted = predictions(output.data)\\r\\n y_true = np.append(y_true, y.numpy())\\r\\n y_pred = np.append(y_pred, predicted.numpy())\\r\\n return y_true, y_pred\",\n \"def get_train_labels(self):\\n raise NotImplementedError\",\n \"def generate_non_sensitive_feat():\\n def gen_gaussian(mean_in, cov_in, class_label):\\n nv = multivariate_normal(mean = mean_in, cov = cov_in)\\n X = nv.rvs(n_samples)\\n y = np.ones(n_samples, dtype=float) * class_label\\n return nv,X,y\\n \\n # generate 1000 data points per class label\\n n_samples = 1000\\n \\n # draw non-sensitive features for class label 1 (positive class)\\n mu1, sigma1 = [2, 2], [[5, 1], [1, 5]]\\n pos_dist, X_non_sensitive_positive, y_positive = gen_gaussian(mu1, sigma1, 1)\\n \\n # draw non-sensitive features for class label -1 (negative class)\\n mu2, sigma2 = [-2,-2], [[10, 1], [1, 3]]\\n neg_dist, X_non_sensitive_negative, y_negative = gen_gaussian(mu2, sigma2, -1)\\n\\n # combine the positive and negative class\\n X_non_sensitive = np.vstack((X_non_sensitive_positive, X_non_sensitive_negative))\\n y = np.hstack((y_positive, y_negative))\\n\\n # randomly shuffle the data\\n idx = np.arange(0, n_samples * 2)\\n np.random.shuffle(idx)\\n X_non_sensitive = X_non_sensitive[idx]\\n y = y[idx]\\n \\n return X_non_sensitive, y, pos_dist, neg_dist\",\n \"def generate_latent_points(self, n_samples):\\n # generate points in the latent space\\n latent_points = super().generate_latent_points(n_samples)\\n # generate labels\\n labels = np.random.randint(0, self.n_classes, n_samples)\\n return [latent_points, labels]\",\n \"def generate_labels():\\n label_set = set([])\\n for data in load_data():\\n label = data.split(' ', 1)[0]\\n label_set.add(label)\\n labels = list(label_set)\\n labels.sort()\\n return labels\",\n \"def generate_data(self,seed):\\n X, y = make_classification( n_samples = 250, random_state = seed )\\n # Add bias term\\n X = np.concatenate( ( np.ones( ( 250, 1 ) ), X ), axis = 1 )\\n self.X_train, self.X_test, self.y_train, self.y_test = train_test_split( \\n X, y, test_size = 50, random_state = seed )\",\n \"def load_data_and_labels(data_file=train_file):\\n \\\"\\\"\\\"\\n There are 7 categories - \\n 1. DEMO\\n 2. DISE\\n 3. TRMT\\n 4. GOAL\\n 5. PREG\\n 6. FMLY\\n 7. SOCL\\n \\\"\\\"\\\"\\n d = {}\\n d['DEMO'] = [1, 0, 0, 0, 0, 0, 0]\\n d['DISE'] = [0, 1, 0, 0, 0, 0, 0]\\n d['TRMT'] = [0, 0, 1, 0, 0, 0, 0]\\n d['GOAL'] = [0, 0, 0, 1, 0, 0, 0]\\n d['PREG'] = [0, 0, 0, 0, 1, 0, 0]\\n d['FAML'] = [0, 0, 0, 0, 0, 1, 0]\\n d['SOCL'] = [0, 0, 0, 0, 0, 0, 1]\\n\\n max_len = -1\\n\\n #Load data from files\\n samples = []\\n with open(data_file, 'rb') as csvfile:\\n spamreader = csv.reader(csvfile, delimiter='\\\\t', quotechar='|')\\n for i, row in enumerate(spamreader):\\n if (row[0] == \\\"Category\\\"):\\n continue\\n print (i, row[1])\\n #samples.append([row[0], row[2]])\\n #getting class and title = row[0] and row[1] respectively\\n samples.append([row[1], row[2], row[0]])\\n #split by words\\n\\n return samples\",\n \"def train(self, data, labels):\\n\\t\\tdata = DataFrame(data)\\n\\t\\tdata['labels'] = labels\\n\\t\\t#print data.head()\\n\\t\\tfor label in self.possible_labels:\\n\\t\\t\\tdf = data.loc[(data['labels'] == label)]\\n\\t\\t\\tmean_list = np.array(df.mean())\\n\\t\\t\\tsum_list = np.array(df.sum())\\n\\t\\t\\tstd_list = np.array(df.std())\\n\\t\\t\\tself.gaussians[label] = [zip(mean_list, std_list)]\\n\\t\\t\\tprint mean_list\",\n \"def non_linear_classifier(position_array, class_array, n_classes):\\n with tf.Graph().as_default():\\n # YOUR CODE FOR PROBLEM 6C GOES HERE\\n # Build neural network\\n net = tflearn.input_data(shape=[None, 2])\\n # 'None' always has to be the first parameter in shape because it tells\\n # tensor flow that the number of data points we have can be variable\\n # and 2 for 2 input nodes (x and y coordinates)\\n #sgd = tflearn.optimizers.SGD(learning_rate=2.0, lr_decay=0.5, decay_step=100)\\n\\n net = tflearn.fully_connected(net, 20000, activation='relu') # 20,0000 nodes\\n net = tflearn.fully_connected(net, n_classes, activation='softmax') # layer with 4 nodes and softmax\\n net = tflearn.regression(net, loss='categorical_crossentropy') #regression with categorical_crossentropy\\n\\n # Define model\\n model = tflearn.DNN(net)\\n new_class_array = np.zeros((len(class_array), 4))\\n index = 0\\n\\n #change to be four dimensional\\n for x in class_array:\\n if x == 0:\\n new_class_array[index] = [1,0,0,0]\\n elif x == 1:\\n new_class_array[index] = [0,1,0,0]\\n elif x == 2:\\n new_class_array[index]= [0,0,1,0]\\n elif x == 3:\\n new_class_array[index] = [0,0,0,1]\\n index +=1 \\n\\n # Start training (apply gradient descent algorithm)\\n model.fit(position_array, new_class_array, n_epoch=10, batch_size=10, show_metric=True, snapshot_step=1)\\n return position_array, new_class_array, model\",\n \"def generate_data(data, samples, targeted=True, start=0, inception=True):\\n \\n assert (targeted==True and start==0 and inception==True)\\n \\n \\n inputs = []\\n targets = []\\n \\n '''\\n for i in range(samples):\\n if targeted:\\n if inception:\\n seq = random.sample(range(1,1001), 10)\\n else:\\n seq = range(data.test_labels.shape[1])\\n\\n for j in seq:\\n if (j == np.argmax(data.test_labels[start+i])) and (inception == False):\\n continue\\n inputs.append(data.test_data[start+i])\\n targets.append(np.eye(data.test_labels.shape[1])[j])\\n else:\\n inputs.append(data.test_data[start+i])\\n targets.append(data.test_labels[start+i])\\n\\n inputs = np.array(inputs)\\n targets = np.array(targets)\\n '''\\n\\n return inputs, targets\",\n \"def generate_data(data, samples, targeted=True, start=0, inception=False):\\n inputs = []\\n targets_1hot = []\\n i = 0\\n samples_sofar = 0\\n while samples_sofar < samples:\\n i += 1\\n if torch.argmax(model(torch.tensor(data.test_data[start+i:start+i+1]+0.5, device=\\\"cuda\\\", dtype=torch.float32).permute(0, 3, 1, 2))) != np.argmax(data.test_labels_1hot[start+i]):\\n continue\\n\\n if targeted:\\n if inception:\\n seq = random.sample(range(1, 1001), 10)\\n else:\\n seq = range(data.test_labels_1hot.shape[1])\\n\\n # print ('image label:', torch.argmax(data.test_labels[start+i]))\\n for j in seq:\\n # skip the original image label\\n if (j == torch.argmax(data.test_labels_1hot[start+i])) and (inception == False):\\n continue\\n inputs.append(data.test_data[start+i])\\n targets_1hot.append(\\n torch.eye(data.test_labels_1hot.shape[1])[j])\\n else:\\n inputs.append(data.test_data[start+i])\\n targets_1hot.append(data.test_labels_1hot[start+i])\\n\\n samples_sofar += 1\\n\\n inputs = torch.tensor(inputs).permute(0, 3, 1, 2)\\n targets_1hot = torch.tensor(targets_1hot)\\n\\n return inputs, targets_1hot\",\n \"def sample_labels(self, y, num_of_sents = 5, num_of_samples = 10,\\n num_of_classes = 3, start_index = 5, get_prob = True):\\n classes = self.classes_()\\n ret = []\\n for sent in y[:num_of_sents]:\\n cur = []\\n for word in sent[start_index: start_index + num_of_samples]:\\n sorted_prob = am(word)\\n cur.append([(classes[ind], word[ind]) if get_prob else classes[ind]\\n for ind in sorted_prob[:num_of_classes]])\\n ret.append(cur)\\n return ret\",\n \"def get_labels(self) -> np.ndarray:\\n if self.i - 1 >= self.k:\\n logging.error(\\\"No more training iterations!!\\\")\\n return np.array([])\\n _, test = self.indexes[self.i - 1]\\n return self.labels.take(test, axis=-1)\",\n \"def train(self, dataset): \\n dataset = dataset[dataset[:,-1].argsort()] # Sort the dataset by classes.\\n #print dataset\\n \\n ########\\n # Compute p(y=1) for all ys.\\n ########\\n label_counts = np.bincount(dataset[:,-1]) # Get the number of occurrences of each class, sorted. \\n self.p_ys = label_counts * 1.0 / len(dataset) # Compute probs. \\n \\n ########\\n # Compute p(x|y) for all x,y.\\n ########\\n self.feature_count = len(dataset[0]) - 1 \\n self.class_count = len(label_counts)\\n \\n self.p_xi_given_ys = np.zeros((self.class_count, self.feature_count)) # Initialize matrix\\n start_index = 0\\n for i in range(self.class_count): # Loop over each class \\n end_index = start_index + label_counts[i] # end of this class index \\n denominator = label_counts[i] + 2.0 * self.alpha\\n \\n for j in range(self.feature_count): # Loop over each feature\\n numerator = np.sum(dataset[start_index:end_index,j]) + self.alpha # Sum number of times word j = 1 in class i\\n self.p_xi_given_ys[i][j] = numerator * 1.0 / denominator # Compute p(xi|y)\\n \\n start_index = end_index\",\n \"def gen_data(low, high, n_samples, scale=4, test_size=0.2, random_state=3):\\n np.random.seed(15)\\n X = np.random.uniform(low, high, size=n_samples)\\n\\n # generate the response from the ground truth function and add\\n # some random noise to it, scale controls the variance of the noise.\\n y = ground_truth(X) + np.random.normal(scale=scale, size=n_samples)\\n X_train, X_test, y_train, y_test = train_test_split(\\n X, y, test_size=test_size, random_state=random_state)\\n\\n return X_train, X_test, y_train, y_test\",\n \"def generate_labels(cfg, split_files):\\n for file_name in split_files:\\n file_name = join(cfg.data_dir, file_name)\\n\\n for example in generate_examples(file_name):\\n yield from example['labels']\",\n \"def prepare_data():\\n #data, label = load_ta_data(), load_ta_target()\\n data, label = load_own_data(), load_own_target()\\n tra_x, tst_x = split_samples(data)\\n tra_y, tst_y = split_samples(label)\\n return (tra_x, tst_x, tra_y, tst_y)\",\n \"def get_train_examples(self, data_dir):\\r\\n raise NotImplementedError()\",\n \"def _GenerateTestData(self, num_classes, dim, batch_size, num_true, labels,\\n sampled, subtract_log_q):\\n weights = np.random.randn(num_classes, dim).astype(np.float32)\\n biases = np.random.randn(num_classes).astype(np.float32)\\n hidden_acts = np.random.randn(batch_size, dim).astype(np.float32)\\n\\n true_exp = np.full([batch_size, 1], fill_value=0.5, dtype=np.float32)\\n sampled_exp = np.full([len(sampled)], fill_value=0.5, dtype=np.float32)\\n sampled_vals = (sampled, true_exp, sampled_exp)\\n\\n sampled_w, sampled_b = weights[sampled], biases[sampled]\\n true_w, true_b = weights[labels], biases[labels]\\n\\n true_logits = np.sum(\\n hidden_acts.reshape((batch_size, 1, dim)) * true_w.reshape(\\n (batch_size, num_true, dim)),\\n axis=2)\\n true_b = true_b.reshape((batch_size, num_true))\\n true_logits += true_b\\n sampled_logits = np.dot(hidden_acts, sampled_w.T) + sampled_b\\n\\n if subtract_log_q:\\n true_logits -= np.log(true_exp)\\n sampled_logits -= np.log(sampled_exp[np.newaxis, :])\\n\\n exp_logits = np.concatenate([true_logits, sampled_logits], axis=1)\\n exp_labels = np.hstack(\\n (np.ones_like(true_logits) / num_true, np.zeros_like(sampled_logits)))\\n\\n return weights, biases, hidden_acts, sampled_vals, exp_logits, exp_labels\",\n \"def gen_data(res, train, label_no, num, save_path='../mnist/mnist_train'):\\n size = len(label_no)\\n infer_res, infer_conf, gt_conf = compare_result(res, label_no)\\n threshold = sorted(infer_conf)[num]\\n print(\\\"threshold:\\\"+str(threshold))\\n data_ = []\\n label_ = []\\n for i in range(size):\\n if infer_conf[i] < threshold:\\n data_.append(train[i].astype(np.uint8))\\n label_.append(label_no[i])\\n data_ = np.array(data_)\\n label_ = np.array(label_)\\n if not os.path.exists(save_path):\\n os.makedirs(save_path)\\n np.save(save_path+'/data_'+str(num)+'.npy', data_)\\n np.save(save_path+'/label_'+str(num)+'.npy', label_)\",\n \"def generate_train_test(self):\\n x, y = self.read_data()\\n x_train, y_train, x_test, y_test = self.sample_data(x, y)\\n self.train = (x_train, y_train)\\n self.test = (x_test, y_test)\",\n \"def nnPredict(w1,w2,data): \\r\\n \\r\\n labels = np.array([])\\r\\n #Your code here\\r\\n #Get bias dimension\\r\\n bias_dimension = data.shape[0]\\r\\n\\r\\n #Fill it all with ones\\r\\n bias = np.ones((bias_dimension,1))\\r\\n\\r\\n #Add bias to weights \\r\\n data_with_bias = np.concatenate((data,bias),1)\\r\\n\\r\\n #Feed Foward Start By Multiplying Training data by weights of w1\\r\\n z2 = np.dot(data_with_bias,np.transpose(w1))\\r\\n\\r\\n #Apply Sigmoid function\\r\\n a2= sigmoid(z2)\\r\\n #Apply Another Bias Dimension to the new matrix\\r\\n\\r\\n #bias_dimension=a2.shape[0]\\r\\n #bias = np.ones((bias_dimension,1))\\r\\n a2_bias= np.concatenate((a2,bias),1)\\r\\n\\r\\n #Multiply new matrix by the weights of w2\\r\\n z3 = np.dot(a2_bias,np.transpose(w2))\\r\\n \\r\\n #Apply Sigmoid Function to the new data\\r\\n y= sigmoid(z3)\\r\\n\\r\\n #find max value and add that digit to the labels vector\\r\\n labels= np.zeros((y.shape[0],1))\\r\\n count=0\\r\\n for x in y:\\r\\n index=0\\r\\n max=0\\r\\n inmax=0\\r\\n for p in x:\\r\\n if p >= max:\\r\\n max=p\\r\\n inmax=index\\r\\n index+=1\\r\\n labels[count][0]=inmax\\r\\n count+=1\\r\\n \\r\\n print('results n ', labels)\\r\\n return labels\",\n \"def splitfeatdata(rawdata, fold=10):\\n\\n labeldata = []\\n for row in rawdata:\\n\\n # if row[2] > 0:\\n # label = 'pos'\\n # elif row[2] == 0:\\n # label = 'neutral'\\n # else:\\n # label = 'neg'\\n\\n\\n label = row[2]\\n labeldata.append((row[4], label))\\n\\n\\n random.shuffle(labeldata)\\n\\n size = int(math.floor(len(labeldata) / 10.0))\\n # train = labeldata[:split]\\n # test = labeldata[split:]\\n\\n # code for k-fold validation referred from:\\n # http://stackoverflow.com/questions/16379313/how-to-use-the-a-10-fold-cross-validation-with-naive-bayes-classifier-and-nltk\\n claccuracy = []\\n for i in range(fold):\\n test_this_round = labeldata[i*size:][:size]\\n train_this_round = labeldata[:i*size] + labeldata[(i+1)*size:]\\n\\n acc = myclassifier(train_this_round, test_this_round)\\n\\n claccuracy.append(acc)\\n\\n\\n\\n print os.getcwd()\\n\\n\\n mySentClassifier = nltk.NaiveBayesClassifier.train(labeldata)\\n f = open('../../../mySentClassifier2.pickle', 'wb')\\n dump(mySentClassifier, f)\\n f.close()\\n\\n\\n return claccuracy\",\n \"def generate_data(self):\\n\\n # cfg.d_sour_num = 20 # number of source domains\\n self.d_sour_a = [np.random.uniform(0.1, 5.0) for _ in range(cfg.d_sour_num)]\\n self.d_sour_b = [np.random.uniform(0, np.pi) for _ in range(cfg.d_sour_num)]\\n # cfg.d_targ_num = 1 # number of target domain\\n self.d_targ_a = [np.random.uniform(0.1, 5.0) for _ in range(cfg.d_targ_num)]\\n self.d_targ_b = [np.random.uniform(0, np.pi) for _ in range(cfg.d_targ_num)]\\n\\n\\n # cfg.train_num = 100 # number of training point in each domain\\n self.train_x = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.train_num)], dtype=np.float32).reshape(-1,1)\\n self.train_y = np.array([[self.d_sour_a[j] * np.sin(i + self.d_sour_b[j]) for i in self.train_x] for j in range(cfg.d_sour_num)], dtype=np.float32).reshape(cfg.d_sour_num, cfg.train_num, 1)\\n\\n # cfg.val_num = 100\\n self.val_x = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.val_num)], dtype=np.float32).reshape(-1,1)\\n self.val_y = np.array([[self.d_sour_a[j] * np.sin(i + self.d_sour_b[j]) for i in self.val_x] for j in range(cfg.d_sour_num)], dtype=np.float32).reshape(cfg.d_sour_num, cfg.val_num, 1)\\n\\n # cfg.support_num = 10\\n self.support_x = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.support_num)], dtype=np.float32).reshape(-1,1)\\n self.support_y = np.array([[self.d_targ_a[j] * np.sin(i + self.d_targ_b[j]) for i in self.support_x] for j in range(cfg.d_targ_num)], dtype=np.float32).reshape(cfg.d_targ_num, cfg.support_num, 1)\\n\\n # cfg.test_num = 100\\n self.test_x = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.test_num)], dtype=np.float32).reshape(-1,1)\\n self.test_y = np.array([[self.d_targ_a[j] * np.sin(i + self.d_targ_b[j]) for i in self.test_x] for j in range(cfg.d_targ_num)], dtype=np.float32).reshape(cfg.d_targ_num, cfg.test_num, 1)\\n\\n self.test_x_old = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.test_num)], dtype=np.float32).reshape(-1,1)\\n self.test_y_old = np.array([[self.d_sour_a[j] * np.sin(i + self.d_sour_b[j]) for i in self.test_x_old] for j in range(cfg.d_sour_num)], dtype=np.float32).reshape(cfg.d_sour_num, cfg.test_num, 1)\",\n \"def generate_data(n, data, labels, param, label):\\n\\n\\tmu = param[0]\\n\\tsigma = param[1]\\n\\n\\tfor i in range(n):\\n\\n\\t\\t# TODO: Recall the notation of x in the exercise sheet.\\n\\t\\t# \\t\\tGenerate a 2-d Gaussian distributed data point plus an offset value for the bias.\\n\\t\\t# \\t\\tUse our rand_gaussian method.\\n\\n\\t\\tx1 = rand_gaussian(mu[0], sigma[0]) \\n\\t\\tx2 = rand_gaussian(mu[1], sigma[1]) \\n\\n\\t\\tdata_point = [1, x1, x2]\\n\\t\\tdata.append(data_point)\\n\\t\\tlabels.append(label)\\n\\n\\treturn data,labels\",\n \"def train(self, dataset): \\n dataset = dataset[dataset[:,-1].argsort()] # Sort the dataset by classes.\\n #print dataset\\n \\n ########\\n # Compute p(y=1) for all ys.\\n ########\\n label_counts = np.bincount(dataset[:,-1]) # Get the number of occurrences of each class, sorted. \\n self.p_ys = np.log(label_counts * 1.0 / len(dataset)) # Compute probs. \\n \\n ########\\n # Compute p(x|y) for all x,y.\\n ########\\n self.feature_count = len(dataset[0]) - 1 \\n self.class_count = len(label_counts)\\n \\n self.p_xi_given_ys = np.zeros((self.class_count, self.feature_count)) # Initialize matrix\\n start_index = 0\\n for i in range(self.class_count): # Loop over each class \\n end_index = start_index + label_counts[i] # end of this class index \\n class_word_counts = np.sum(dataset[start_index:end_index,:-1]) # sum all words of class i \\n denominator = class_word_counts + self.alpha * self.feature_count # Here we add the feature_count as Laplace smoothing\\n \\n for j in range(self.feature_count): # Loop over each feature\\n single_word_count = np.sum(dataset[start_index:end_index,j]) # sum number times word j appears in class i \\n numerator = single_word_count + self.alpha\\n self.p_xi_given_ys[i][j] = log(numerator * 1.0 / denominator) # Compute p(xi|y)\\n \\n start_index = end_index\",\n \"def sample_labels(self, y, num_of_sents = 5, num_of_samples = 10,\\n num_of_classes = 3, start_index = 5, get_prob = True):\\n classes = self.classes_()\\n ret = []\\n am = lambda myList: [i[0] for i in sorted(enumerate(myList), key=lambda x:x[1], reverse= True)]\\n\\n for sent in y[:num_of_sents]:\\n cur = []\\n for word in sent[start_index: start_index + num_of_samples]:\\n sorted_prob = am(word)\\n cur.append([(classes[ind], word[ind]) if get_prob else classes[ind]\\n for ind in sorted_prob[:num_of_classes]])\\n ret.append(cur)\\n return ret\",\n \"def label(d, X, ind_class0, ind_class1, N, V, binary):\\n if binary == True:\\n K = 1\\n C = torch.zeros(N + V, K)\\n C[ind_class0, :] = 0.0\\n C[ind_class1, :] = 1.0\\n else:\\n K = 2\\n C = torch.zeros(N + V, K)\\n C[ind_class0, :] = torch.tensor([1.0, 0.0])\\n C[ind_class1, :] = torch.tensor([0.0, 1.0])\\n\\n X_train = X[:N, :]\\n X_val = X[N:, :]\\n C_train = C[:N, :]\\n C_val = C[N:, :]\\n\\n return [X_train, C_train, X_val, C_val, d, K]\",\n \"def bl_predict(self, n_samples, data=None):\\n\\n if data is None:\\n data = self.datas[self.train_idx]\\n\\n y_train = data.gen_labels()\\n bl = DummyClassifier()\\n bl.fit(np.random.rand(len(y_train), 1), y_train)\\n\\n return self._predict_proba(bl, np.random.rand(n_samples, 1))\",\n \"def get_data(numbers):\\r\\n numbers = numbers\\r\\n n_classes = len(numbers)\\r\\n z = zipfile.ZipFile('lab3/mnist.pkl.zip', 'r')\\r\\n k = z.extract('mnist.pkl') # Извлечь файл из архива\\r\\n with open(k, 'rb') as f:\\r\\n train_set, _, test_set = pickle.load(f, encoding=\\\"bytes\\\")\\r\\n x_train = train_set[0]\\r\\n x_test = test_set[0]\\r\\n x_train[x_train >= 0.5] = 1\\r\\n x_train[x_train < 0.5] = 0\\r\\n x_test[x_test >= 0.5] = 1\\r\\n x_test[x_test < 0.5] = 0\\r\\n y_train = train_set[1]\\r\\n y_test = test_set[1]\\r\\n idx_train = [[np.where(y_train == i)] for i in numbers]\\r\\n idx_test = [[np.where(y_test == i)] for i in numbers]\\r\\n idx_x_train = [x_train[idx_train[i][0]] for i in range(len(idx_train))]\\r\\n idx_x_test = [x_test[idx_test[i][0]] for i in range(len(idx_test))]\\r\\n idx_y_test = [y_test[idx_test[i][0]] for i in range(len(idx_test))]\\r\\n x_train_new = shuffle(np.concatenate(idx_x_train))\\r\\n x_test_new = shuffle(np.concatenate(idx_x_test))\\r\\n y_test_new = shuffle(np.concatenate(idx_y_test))\\r\\n return x_train_new, x_test_new, y_test_new, numbers, n_classes\",\n \"def data_labels(data):\\n\\n # The data consists of a equal number of benign and deleterious samples\\n # The first part of the data are the benign samples (label 0), and the second part the deleterious ones (label 1)\\n n_samples = data.shape[0]\\n n_class_samples = int(n_samples / 2)\\n\\n # Get a numpy array of the labels\\n labels_ben = [0] * n_class_samples\\n labels_del = [1] * n_class_samples\\n labels = np.array(labels_ben + labels_del)\\n\\n # Convert the data into one hot encoded data\\n labels = initialization_based(labels)\\n\\n return labels\",\n \"def make_classification(\\n nb_samples: int,\\n nb_class: int,\\n nb_features: int) -> Tuple[np.ndarray, np.ndarray]:\\n # Initialisation x et y\\n x_points = np.zeros((nb_samples, nb_features))\\n y_points = np.zeros((nb_samples, 1))\\n lim_plan = [0, 6] # on pose ça pour changer plus tard?\\n nb_sample_class = (int)(nb_samples / nb_class)\\n for i in range(nb_class):\\n #print(i)\\n #On choisi un centre de cluster aléatoirement\\n centre = list()\\n for _ in range(nb_features):\\n centre.append(random.randint(lim_plan[0] * 10, lim_plan[1] * 10) / 10)\\n lower_lim = np.arange(0, nb_sample_class) / nb_sample_class\\n upper_lim = np.arange(1, nb_sample_class + 1) / nb_sample_class\\n points = np.random.uniform(low=lower_lim, high=upper_lim,\\n size=[nb_features, nb_sample_class]).T\\n np.random.shuffle(points[:, 1])\\n # On place les points dans l'espace approprié\\n for p, point in enumerate(points):\\n for j in range(nb_features):\\n x_points[i * nb_sample_class + p][j] = point[j] + centre[j]\\n y_points[i * nb_sample_class + p] = i\\n return x_points, y_points\",\n \"def train(length, n_ep, show=False):\\r\\n al_dict = {'a':0, 'b':1, 'c':2, 'd':3, 'e':4, 'f':5, 'g':6, 'h':7, 'i':8, \\r\\n 'j':9, 'k':10, 'l':11, 'm':12, 'n':13, 'o':14, 'p':15, 'q':16, \\r\\n 'r':17, 's':18, 't':19, 'u':20, 'v':21, 'w':22, 'x':23, 'y':24, \\r\\n 'z':25}\\r\\n \\r\\n #Load proper data\\r\\n raw_rand = open(f'Length {length} Data/rand_data_len{length}.txt', 'r').readlines()\\r\\n raw_human = open(f'Length {length} Data/human_data_len{length}.txt','r').readlines()\\r\\n \\r\\n #Turn data into numbers\\r\\n raw_rand = [string[:length] for string in raw_rand]\\r\\n raw_human = [string[:length] for string in raw_human]\\r\\n \\r\\n raw_rand = [list(string) for string in raw_rand]\\r\\n raw_human = [list(string) for string in raw_human]\\r\\n \\r\\n for lists in raw_rand:\\r\\n for i in range(length):\\r\\n lists[i] = al_dict[lists[i]]\\r\\n for lists in raw_human:\\r\\n for i in range(length):\\r\\n lists[i] = al_dict[lists[i]]\\r\\n \\r\\n #Set aside 1/3 for test data\\r\\n test_rand = raw_rand[:len(raw_rand)//3]\\r\\n test_human = raw_human[:len(raw_human)//3]\\r\\n train_rand = raw_rand[len(raw_rand)//3:]\\r\\n train_human = raw_human[len(raw_human)//3:]\\r\\n \\r\\n #Intersperse both samples randomly with labels (0 = rand, 1 = human)\\r\\n train = []\\r\\n trn_labels = []\\r\\n test = []\\r\\n tst_labels = []\\r\\n while len(test_rand) and len(test_human) != 0:\\r\\n num = random.random()\\r\\n if num > .5 and len(test_rand) > 0:\\r\\n test.append(test_rand.pop())\\r\\n tst_labels.append(0)\\r\\n else:\\r\\n test.append(test_human.pop())\\r\\n tst_labels.append(1)\\r\\n \\r\\n while len(train_rand) and len(train_human) != 0:\\r\\n num = random.random()\\r\\n if num > .5 and len(train_rand) > 0:\\r\\n train.append(train_rand.pop())\\r\\n trn_labels.append(0)\\r\\n else:\\r\\n train.append(train_human.pop())\\r\\n trn_labels.append(1)\\r\\n \\r\\n # Build network, 2 hidden layers, 26 dimensional vectors for alphabet\\r\\n model = keras.Sequential()\\r\\n model.add(keras.layers.Embedding(26, 16)) #26=numletters\\r\\n model.add(keras.layers.GlobalAveragePooling1D())\\r\\n model.add(keras.layers.Dense(16, activation=tf.nn.relu))\\r\\n model.add(keras.layers.Dense(1, activation=tf.nn.sigmoid))\\r\\n \\r\\n # Loss function, Using Probabilities\\r\\n model.compile(optimizer=tf.train.AdamOptimizer(),\\r\\n loss='binary_crossentropy',\\r\\n metrics=['accuracy'])\\r\\n \\r\\n # Perform n_ep epochs of training on train_data\\r\\n partial_train = np.array(train[len(train)//10:])\\r\\n partial_labels = trn_labels[len(train)//10:]\\r\\n val_train = np.array(train[:len(train)//10])\\r\\n val_labels = trn_labels[:len(train)//10]\\r\\n print((len(partial_train), len(partial_labels)),\\r\\n (len(val_train), len(val_labels)),\\r\\n (len(test), len(tst_labels)))\\r\\n \\r\\n history = model.fit(partial_train,\\r\\n partial_labels,\\r\\n epochs=n_ep,\\r\\n batch_size=512,\\r\\n validation_data=(val_train, val_labels),\\r\\n verbose=1)\\r\\n \\r\\n #EVALUATE THE FINAL MODEL\\r\\n\\r\\n results = model.evaluate(np.array(test), tst_labels)\\r\\n print(results)\\r\\n \\r\\n # GRAPH ACCURACY AND LOSS OVER TIME\\r\\n if show:\\r\\n acc = history.history['acc']\\r\\n val_acc = history.history['val_acc']\\r\\n loss = history.history['loss']\\r\\n val_loss = history.history['val_loss']\\r\\n \\r\\n history_dict = history.history\\r\\n \\r\\n epochs = range(1, len(acc) + 1)\\r\\n \\r\\n # \\\"bo\\\" is for \\\"blue dot\\\"\\r\\n plt.plot(epochs, loss, 'bo', label='Training loss')\\r\\n # b is for \\\"solid blue line\\\"\\r\\n plt.plot(epochs, val_loss, 'b', label='Validation loss')\\r\\n plt.title('Training and validation loss')\\r\\n plt.xlabel('Epochs')\\r\\n plt.ylabel('Loss')\\r\\n plt.legend()\\r\\n \\r\\n plt.show()\\r\\n \\r\\n plt.clf() # clear figure\\r\\n acc_values = history_dict['acc']\\r\\n val_acc_values = history_dict['val_acc']\\r\\n \\r\\n plt.plot(epochs, acc, 'bo', label='Training acc')\\r\\n plt.plot(epochs, val_acc, 'b', label='Validation acc')\\r\\n plt.title('Training and validation accuracy')\\r\\n plt.xlabel('Epochs')\\r\\n plt.ylabel('Accuracy')\\r\\n plt.legend()\\r\\n \\r\\n plt.show()\\r\\n \\r\\n return model\",\n \"def label(filenames, train_path='../data/train_molecules_30.mat'):\\n unlabeled = [scipy.io.loadmat(fname) for fname in filenames]\\n unlabeled_X = np.vstack([data['X'] for data in unlabeled])\\n X, Y = load_data(train_path, shape=(-1, 30, 30, 30))\\n\\n num_unlabeled = unlabeled_X.shape[0]\\n unlabeled_Y = np.zeros(num_unlabeled) - 1\\n unlabeled_Y = unlabeled_Y.reshape((-1, 1))\\n Y = Y.reshape((-1, 1))\\n Y_all = np.vstack((Y, unlabeled_Y))\\n\\n X_all = np.vstack((X, unlabeled_X))\\n X_all = X_all.reshape((-1, 27000))\\n\\n label_prop_model = LabelSpreading()\\n label_prop_model.fit(X_all, Y_all)\\n Y_all = label_prop_model.transduction_\\n unlabeled_Y = Y_all[num_unlabeled:]\\n return (unlabeled_X, unlabeled_Y), (X_all, Y_all)\",\n \"def generate(self, labels, list_IDs, n_classes):\\n # Infinite loop\\n while 1:\\n # Generate order of exploration of dataset\\n indexes = self.__get_exploration_order(list_IDs)\\n\\n # Generate batches\\n imax = int(len(indexes)/self.batch_size)\\n for i in range(imax):\\n # Find list of IDs\\n list_IDs_temp = [list_IDs[k] for k in indexes[i*self.batch_size:(i+1)*self.batch_size]]\\n print(\\\"Producing\\\")\\n #print(list_IDs_temp)\\n # Generate data\\n X, y = self.__data_generation(labels, list_IDs_temp, n_classes)\\n # print(X.shape)\\n # print(y.shape)\\n #print(\\\"Target Label\\\")\\n #print(y)\\n gc.collect()\\n yield X, y\",\n \"def loadtrainData_undersampling():\\n train = []\\n fileIn = open(PATH + 'traindata_Subtask4.txt')\\n for line in fileIn.readlines():\\n lineArr = line.strip().split()\\n train.append([float(lineArr[i]) for i in range(len(lineArr))])\\n\\n pos = []\\n neg = []\\n for i in train:\\n if i[-1] == 1.0:\\n pos.append(i)\\n else:\\n neg.append(i)\\n slice1 = random.sample(neg, len(pos))\\n data = pos + slice1\\n train_x = []\\n train_y = []\\n y = []\\n for line in data:\\n train_x.append([float(line[i]) for i in range(len(line) - 1)])\\n y.append([int(line[-1])])\\n for i in range(len(y)):\\n train_y.append(y[i][0])\\n return np.mat(train_x), np.mat(train_y).transpose()\",\n \"def gen_random_labels(\\n X: Union[np.ndarray, int], n_classes: int, pvec=None\\n) -> np.ndarray:\\n\\n if isinstance(X, int):\\n num = X\\n else:\\n num = X.shape[0]\\n\\n pvec = np.ones((n_classes,)) / n_classes\\n\\n return npr.multinomial(1, pvec, size=num)\",\n \"def _get_classification_data(self, real, synthetic, real_label, synthetic_label):\\n split_index = int(self.train_test_split * len(real))\\n X_train = synthetic[:split_index]\\n y_train = synthetic_label[:split_index]\\n X_test = real[split_index:]\\n y_test = real_label[split_index:]\\n return X_train, y_train, X_test, y_test\",\n \"def _generate_training_batch(ground_truth_data, representation_function,\\n batch_size, num_points, random_state):\\n points = None # Dimensionality depends on the representation function.\\n labels = np.zeros(num_points, dtype=np.int64)\\n for i in range(num_points):\\n labels[i], feature_vector = _generate_training_sample(\\n ground_truth_data, representation_function, batch_size, random_state)\\n if points is None:\\n points = np.zeros((num_points, feature_vector.shape[0]))\\n points[i, :] = feature_vector\\n return points, labels\",\n \"def get_train_examples(self, data_dir):\\n\\t\\traise NotImplementedError()\",\n \"def classify():\\n yes_dataset = df[df[\\\"_class\\\"] == 1] # 470588\\n no_dataset = df[df[\\\"_class\\\"] == 0] # 1971\\n\\n parameter_analysis = list()\\n for criterion in np.arange(0.05, 0.91, 0.05):\\n print(\\\"doing experiment at criterion = %s ...\\\" % criterion)\\n rate_list = list()\\n for i in range(10):\\n # shuffle yes_dataset and no_dataset, so we can randomly choose 90% yes_dataset\\n # + 90% no_dataset as train dataset, 10% yes_dataset + 10% no_dataset as test dataset\\n yes_index = yes_dataset.index.tolist()\\n random.shuffle(yes_index)\\n no_index = no_dataset.index.tolist()\\n random.shuffle(no_index)\\n \\n # concatenate 90%yes + 90%no, 10%yes + 10%no\\n train = pd.concat([\\n yes_dataset.loc[yes_index[:1774], :],\\n no_dataset.loc[no_index[:423530], :]\\n ])\\n test = pd.concat([\\n yes_dataset.loc[yes_index[1774:], :],\\n no_dataset.loc[no_index[423530:], :]\\n ]) \\n \\n # split data and label\\n train_data, train_label = (train[[\\\"Revenue.Code\\\", \\n \\\"Service.Code\\\", \\n \\\"Procedure.Code\\\", \\n \\\"Diagnosis.Code\\\", \\n \\\"Subscriber.Index\\\"]], \\n train[\\\"_class\\\"])\\n test_data, test_label = (test[[\\\"Revenue.Code\\\", \\n \\\"Service.Code\\\", \\n \\\"Procedure.Code\\\", \\n \\\"Diagnosis.Code\\\", \\n \\\"Subscriber.Index\\\"]], \\n test[\\\"_class\\\"])\\n \\n # apply classifier\\n clf = GaussianNB()\\n clf.fit(train_data, train_label)\\n probability = clf.predict_proba(test_data).T[1]\\n \\n result = pd.DataFrame()\\n result[\\\"_class\\\"] = test_label\\n result[\\\"_predict\\\"] = probability >= criterion\\n \\n result_yes = result[result[\\\"_class\\\"] == 1]\\n yes_yes_rate = sum(result_yes[\\\"_class\\\"] == result_yes[\\\"_predict\\\"])/len(result_yes[\\\"_predict\\\"])\\n \\n result_no = result[result[\\\"_class\\\"] == 0]\\n no_no_rate = sum(result_no[\\\"_class\\\"] == result_no[\\\"_predict\\\"])/len(result_no[\\\"_predict\\\"])\\n \\n rate_list.append((yes_yes_rate, no_no_rate))\\n\\n rate_list = pd.DataFrame(rate_list)\\n yes_yes_rate, no_no_rate = rate_list.mean()[0], rate_list.mean()[1]\\n parameter_analysis.append((criterion, yes_yes_rate, no_no_rate))\\n \\n # save data to excel spreadsheet\\n parameter_analysis = pd.DataFrame(parameter_analysis, columns=[\\\"criterion\\\", \\\"yes_yes_rate\\\", \\\"no_no_rate\\\"])\\n writer = pd.ExcelWriter(\\\"parameter_analysis.xlsx\\\")\\n parameter_analysis.to_excel(writer, \\\"parameter_analysis\\\", index=False)\\n writer.save()\",\n \"def data_labels(data):\\n\\n # The data consists of a equal number of benign and deleterious samples\\n # The first part of the data are the benign samples (label 0), and the second part the deleterious ones (label 1)\\n n_samples = data.shape[0]\\n n_class_samples = int(n_samples / 2)\\n\\n # Get a numpy array of the labels\\n labels_ben = [0] * n_class_samples\\n labels_del = [1] * n_class_samples\\n labels = np.array(labels_ben + labels_del)\\n\\n # Create float numbers for the labels\\n labels = labels.astype(float)\\n\\n # Convert the data into a numpy array\\n # One hot encoded vector is not necessary, because the data is binary\\n labels = np.reshape(labels, [-1, 1])\\n\\n return labels\",\n \"def my_impl_variational(in_train, in_test, labels):\\n X_train = []\\n X_test = []\\n for lab in labels:\\n for datum in in_train[lab]:\\n X_train.append([datum, lab])\\n for datum in in_test[lab]:\\n X_test.append([datum, lab])\\n Variationer_learn(X_train, 500, 1, 0.01, X_test, labels)\",\n \"def init_train(self):\\n data = self.loader.load_labelled_data(self.conf.split, 'training')\\n\\n # Initialise unlabelled data iterator\\n num_ul = 0\\n if self.conf.ul_mix > 0:\\n ul_data = self.loader.load_unlabelled_data(self.conf.split, 'all')\\n\\n # calculate number of unlabelled images as a proportion of the labelled images\\n num_ul = int(data.size() * self.conf.ul_mix)\\n num_ul = num_ul if num_ul <= ul_data.size() else ul_data.size()\\n log.info('Sampling %d unlabelled images out of total %d.' % (num_ul, ul_data.size()))\\n ul_data.sample(num_ul)\\n self.gen_X_U = data_utils.generator(self.conf.batch_size, 'overflow', ul_data.images)\\n\\n # Initialise labelled data iterator\\n assert self.conf.l_mix >= 0\\n\\n # calculate number of labelled images\\n num_l = int(data.size() * self.conf.l_mix)\\n num_l = num_l if num_l <= data.size() else data.size()\\n log.info('Using %d labelled images out of total %d.' % (num_l, data.size()))\\n train_images = data.images[:num_l]\\n train_masks = data.masks[:num_l]\\n\\n self.conf.unlabelled_image_num = num_ul\\n self.conf.labelled_image_num = num_l\\n self.conf.data_len = num_ul if num_ul > num_l else num_l\\n self.conf.batches = int(np.ceil(self.conf.data_len / self.conf.batch_size))\\n self.conf.save()\\n\\n self.gen_X_L = data_utils.generator(self.conf.batch_size, 'overflow', train_images, train_masks)\\n\\n # Initialise real masks iterator for discriminator training, using the real masks from the data CV split.\\n self.other_masks = data_utils.generator(self.conf.batch_size, 'overflow', data.masks + 0)\",\n \"def dataset_preparation():\\r\\n with open('../data/patterns_num.txt', 'r') as f:\\r\\n data = f.readlines()\\r\\n X, Y = [], []\\r\\n for line in data:\\r\\n x, y = line.split('\\\\t')\\r\\n if len(x) > 5 and x not in X: # better results are achieved excluding short query patterns\\r\\n X.append(x.replace(\\\"X\\\", \\\"\\\").replace(\\\"Y\\\", \\\"\\\").lower())\\r\\n Y.append(int(y.replace('\\\\n', '')))\\r\\n test_size = 0.2\\r\\n # print('Test size:', test_size, '\\\\nWrong classifications:\\\\n')\\r\\n\\r\\n X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=test_size, random_state=42, stratify=Y)\\r\\n return X_train, y_train, X_test, y_test\",\n \"def get_train_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def generate_samples(self, n_samples):\",\n \"def generate_samples(self, n_samples):\",\n \"def next(self):\\n #print('next')\\n batch_size = self.batch_size\\n batch_data = nd.empty((batch_size,)+self.data_shape)\\n batch_label = nd.empty((batch_size,)+self.label_shape)\\n i = 0\\n #self.cutoff = random.randint(800,1280)\\n try:\\n while i < batch_size:\\n #print('N', i)\\n data, label, annot = self.next_sample()\\n R = self.get_data(data, label, annot)\\n if R is None:\\n continue\\n data_out, label_out, flip_data_out, flip_label_out = R\\n if not self.use_coherent:\\n data = nd.array(data_out)\\n data = nd.transpose(data, axes=(2, 0, 1))\\n label = nd.array(label_out)\\n #print(data.shape, label.shape)\\n batch_data[i][:] = data\\n batch_label[i][:] = label\\n i += 1\\n else:\\n data = nd.array(data_out)\\n data = nd.transpose(data, axes=(2, 0, 1))\\n label = nd.array(label_out)\\n data2 = nd.array(flip_data_out)\\n data2 = nd.transpose(data2, axes=(2, 0, 1))\\n label2 = nd.array(flip_label_out)\\n #M = nd.array(M)\\n #print(data.shape, label.shape)\\n batch_data[i][:] = data\\n batch_label[i][:] = label\\n #i+=1\\n j = i+self.per_batch_size//2\\n batch_data[j][:] = data2\\n batch_label[j][:] = label2\\n i += 1\\n if j%self.per_batch_size==self.per_batch_size-1:\\n i = j+1\\n except StopIteration:\\n if i<batch_size:\\n raise StopIteration\\n\\n #return {self.data_name : batch_data,\\n # self.label_name : batch_label}\\n #print(batch_data.shape, batch_label.shape)\\n return mx.io.DataBatch([batch_data], [batch_label], batch_size - i)\",\n \"def train_eval_rnd(self, train_data, test_data, rand_iter, train_labels, test_labels):\\n np.random.seed(0)\\n shuf_tr = [np.random.permutation(train_labels)\\n for _ in range(rand_iter)]\\n misclass_tr, misclass_ts = [], []\\n for lab in shuf_tr:\\n self.class_method.fit(train_data, lab)\\n misclass_tr.append(zero_one_loss(lab, self.class_method.predict(train_data)))\\n misclass_ts.append(zero_one_loss(test_labels,\\n _kuhn_munkres_algorithm(test_labels,\\n self.class_method.predict(test_data))))\\n return np.mean(misclass_tr), np.mean(misclass_ts)\\n # start = time.process_time()\\n # np.random.seed(0)\\n # shuf_tr, shuf_val = zip(*[list(map(lambda x: np.random.permutation(x),\\n # [tr_labels, val_labels])) for _ in range(rand_iter)])\\n # # print(f'Shuffle train:{shuf_tr}, Shuffle val:{shuf_val}')\\n # # logging.info(f'Shuffle labels: {time.process_time()-start}s')\\n # # part = time.process_time()\\n # model_tr = [self.class_method.fit(train_data, lab) for lab in shuf_tr]\\n # # print(f'Models:{model_tr}')\\n # # logging.info(f'Train model: {time.process_time()-part}s')\\n # # part = time.process_time()\\n # misclass_tr = [zero_one_loss(x, y.predict(train_data)) for x, y in\\n # zip(shuf_tr, model_tr)]\\n # # print(f'Misclassification tr:{misclass_tr}')\\n # # logging.info(f'Misclass TR: {time.process_time()-part}s')\\n # # part = time.process_time()\\n # misclass_val = [zero_one_loss(x, _kuhn_munkres_algorithm(x,\\n # y.predict(val_data))) for x, y in\\n # zip(shuf_val, model_tr)]\\n # # print(f'Misclassification val:{misclass_val}')\\n # # logging.info(f'Misclass VAL: {time.process_time()-part}s')\\n # return np.mean(misclass_tr), np.mean(misclass_val)\\n # misc_avg_tr, misc_avg_ts = [], []\\n # append_tr = misc_avg_tr.append\\n # append_ts = misc_avg_ts.append\\n # for it in range(rand_iter):\\n # np.random.seed(0)\\n # np.random.shuffle(tr_labels)\\n # np.random.seed(0)\\n # np.random.shuffle(val_labels)\\n # model_tr = self.class_method.fit(train_data, tr_labels)\\n # misclass_tr = zero_one_loss(tr_labels,\\n # self.class_method.predict(train_data))\\n # misclass_ts = zero_one_loss(val_labels,\\n # _kuhn_munkres_algorithm(val_labels,\\n # model_tr.predict(val_data)))\\n # append_tr(misclass_tr)\\n # append_ts(misclass_ts)\\n # return np.mean(misc_avg_tr), np.mean(misc_avg_ts)\",\n \"def trainData(self, X, y, NeuralNet, epochs):\",\n \"def get_train_examples(self, data_dir):\\r\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\r\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\r\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\r\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\r\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\r\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\r\\n raise NotImplementedError()\",\n \"def prepare_data(self,d):\\n train_loaders, train_iters = {}, {}\\n unlabeled_loaders, unlabeled_iters = {}, {}\\n for domain in opt.domains:\\n #CONVERT TO FLOAT32\\n features, target = torch.from_numpy(d[domain].X.todense().astype('float32')), torch.from_numpy(d[domain].y)#.reshape((-1,1))\\n train = data_utils.TensorDataset(features,target)\\n train_loaders[domain] = DataLoader(train, opt.batch_size, shuffle = True)\\n train_iters[domain] = iter(train_loaders[domain])\\n for domain in opt.unlabeled_domains:\\n features, target = torch.from_numpy(d[domain].X.todense().astype('float32')), torch.from_numpy(d[domain].y)#.reshape(-1,1))\\n uset = data_utils.TensorDataset(features,target)\\n unlabeled_loaders[domain] = DataLoader(uset,opt.batch_size, shuffle = True)\\n unlabeled_iters[domain] = iter(unlabeled_loaders[domain])\\n \\n return train_loaders, train_iters, unlabeled_loaders, unlabeled_iters\",\n \"def next_data(self, n_way, n_shot, n_query, num_unlabel=0, n_distractor=0, train=True):\\n support = np.zeros([n_way, n_shot, self.im_height, self.im_width, self.channels], dtype=np.float32)\\n query = np.zeros([n_way, n_query, self.im_height, self.im_width, self.channels], dtype=np.float32)\\n if num_unlabel>0:\\n unlabel = np.zeros([n_way+n_distractor, num_unlabel, self.im_height, self.im_width, self.channels], dtype=np.float32)\\n else:\\n unlabel = []\\n n_distractor = 0\\n\\n selected_classes = np.random.permutation(self.n_classes)[:n_way+n_distractor]\\n for i, cls in enumerate(selected_classes[0:n_way]): # train way\\n # labled data\\n idx1 = np.random.permutation(self.n_label)[:n_shot + n_query]\\n support[i] = self.dataset_l[cls, idx1[:n_shot]]\\n query[i] = self.dataset_l[cls, idx1[n_shot:]]\\n # unlabel\\n if num_unlabel>0:\\n idx2 = np.random.permutation(self.n_unlabel)[:num_unlabel]\\n unlabel[i] = self.dataset_u[cls,idx2]\\n\\n for j,cls in enumerate(selected_classes[self.n_classes:]): # distractor way\\n idx3 = np.random.permutation(self.n_unlabel)[:num_unlabel]\\n unlabel[i+j] = self.dataset_u[cls,idx3]\\n\\n support_labels = np.tile(np.arange(n_way)[:, np.newaxis], (1, n_shot)).astype(np.uint8)\\n query_labels = np.tile(np.arange(n_way)[:, np.newaxis], (1, n_query)).astype(np.uint8)\\n # unlabel_labels = np.tile(np.arange(n_way+n_distractor)[:, np.newaxis], (1, num_unlabel)).astype(np.uint8)\\n\\n return support, support_labels, query, query_labels, unlabel\",\n \"def _fetch_labels(self, list_fams, no_imgs, num_samples) -> Tuple[np.ndarray, List]:\\n y_train = np.zeros(num_samples)\\n pos = 0\\n label = 0\\n indexes = []\\n for i in no_imgs:\\n indexes.append(i)\\n print(\\\"Label:%2d\\\\tFamily: %15s\\\\tNumber of images: %d\\\" % (label, list_fams[label], i))\\n for j in range(i):\\n y_train[pos] = label\\n pos += 1\\n label += 1\\n return y_train, indexes\",\n \"def prepare_dataset():\\n with open('gold-posts.txt', encoding='utf-8') as f:\\n posts = f.readlines()\\n with open('gold-labels.txt', encoding='utf-8') as f:\\n labels = f.readlines()\\n\\n def to_cat(x: str) -> int:\\n if x == 'p':\\n return 1\\n elif x == 'n':\\n return 2\\n else:\\n return 0\\n X = np.array([x.strip() for x in posts])\\n y = np.array([to_cat(x.strip()) for x in labels])\\n\\n # DOES NOT WORK - too imbalanced\\n #skf = StratifiedKFold(n_splits=5, random_state=None, shuffle=False)\\n #for train_index, test_index in skf.split(X, y):\\n # X_train, X_test = X[train_index], X[test_index]\\n # y_train, y_test = y[train_index], y[test_index]\\n # break\\n\\n # WORKS better\\n trI, teI = balanced_split(y)\\n\\n train_texts = X[trI].tolist()\\n train_labels = y[trI].tolist()\\n valid_texts = X[teI].tolist()\\n valid_labels = y[teI].tolist()\\n return train_texts, train_labels, valid_texts, valid_labels\",\n \"def reset(self, n_start=2):\\n\\n # SAMPLE INITIAL DATAPOINTS\\n self.dataset.regenerate()\\n self.episode_qualities = []\\n # To train an initial classifier we need at least self.n_classes samples\\n if n_start < self.n_classes:\\n n_start = self.n_classes\\n # Sample n_start datapoints\\n self.indeces_known = []\\n self.indeces_unknown = []\\n for i in np.unique(self.dataset.train_labels):\\n # First get 1 point from each class\\n cl = np.nonzero(self.dataset.train_labels==i)[0]\\n # Insure that we select random datapoints\\n indeces = np.random.permutation(cl)\\n self.indeces_known.append(indeces[0])\\n self.indeces_unknown.extend(indeces[1:]) \\n self.indeces_known = np.array(self.indeces_known)\\n self.indeces_unknown = np.array(self.indeces_unknown)\\n # self.indeces_unknown now containts first all points of class1, then all points of class2 etc.\\n # So, we permute them\\n self.indeces_unknown = np.random.permutation(self.indeces_unknown)\\n # Then, sample the rest of the datapoints at random\\n if n_start > self.n_classes:\\n self.indeces_known = np.concatenate(([self.indeces_known, self.indeces_unknown[0:n_start-self.n_classes]]))\\n self.indeces_unknown = self.indeces_unknown[n_start-self.n_classes:] \\n \\n # BUILD AN INITIAL MODEL\\n # Get the data corresponding to the selected indeces\\n known_data = self.dataset.train_data[self.indeces_known,:]\\n known_labels = self.dataset.train_labels[self.indeces_known]\\n unknown_data = self.dataset.train_data[self.indeces_unknown,:]\\n unknown_labels = self.dataset.train_labels[self.indeces_unknown]\\n # Train a model using data corresponding to indeces_known\\n known_labels = np.ravel(known_labels)\\n self.model.fit(known_data, known_labels)\\n # Compute the quality score\\n test_prediction = self.model.predict(self.dataset.test_data)\\n new_score = self.quality_method(self.dataset.test_labels, test_prediction)\\n self.episode_qualities.append(new_score)\\n # Get the features categorizing the state \\n classifier_state, next_action_state = self._get_state() \\n self.n_actions = np.size(self.indeces_unknown) \\n return classifier_state, next_action_state\",\n \"def train(self, X, labels, n_epochs=100, n_batch=128, reporting_period=10):\\n bat_per_epo = int(X.shape[0] / n_batch)\\n half_batch = int(n_batch / 2)\\n \\n # for recording metrics.\\n self.g_loss = np.zeros((n_epochs * bat_per_epo, 1))\\n self.d_loss_real = np.zeros((n_epochs * bat_per_epo, 1)) \\n self.d_loss_fake = np.zeros((n_epochs * bat_per_epo, 1))\\n self.d_acc_real = np.zeros((n_epochs * bat_per_epo, 1))\\n self.d_acc_fake = np.zeros((n_epochs * bat_per_epo, 1))\\n self.d_acc_real_epochs = np.zeros((n_epochs, 1))\\n self.d_acc_fake_epochs = np.zeros((n_epochs, 1))\\n \\n # manually enumerate epochs\\n for i in range(n_epochs):\\n \\n # enumerate batches over the training set\\n for j in range(bat_per_epo):\\n # update discriminator model weights on randomly selected 'real' samples\\n [X_real, labels_real], y_real = self.generate_real_samples(X, labels, half_batch)\\n d_loss1, d_acc1 = self.d_model.train_on_batch([X_real, labels_real], y_real)\\n \\n # update discriminator model weights on generated 'fake' examples\\n [X_fake, labels_fake], y_fake = self.generate_generator_prediction_samples(half_batch)\\n d_loss2, d_acc2 = self.d_model.train_on_batch([X_fake, labels_fake], y_fake)\\n \\n # prepare points in latent space as input for the generator\\n [z_input, labels_input] = self.generate_latent_points(n_batch)\\n # create inverted labels for the fake samples\\n y_gan = np.ones((n_batch, 1))\\n # update the generator via the discriminator's error\\n g_loss = self.gan_model.train_on_batch([z_input, labels_input], y_gan)\\n \\n # summarize loss on this batch\\n print('>%d, %d/%d, d1=%.3f, d2=%.3f g=%.3f' %\\n (i+1, j+1, bat_per_epo, d_loss1, d_loss2, g_loss))\\n\\n # record losses for later\\n self.g_loss[i*bat_per_epo + j] = g_loss\\n self.d_loss_real[i*bat_per_epo + j] = d_loss1\\n self.d_loss_fake[i*bat_per_epo + j] = d_loss2\\n self.d_acc_real[i*bat_per_epo + j] = d_acc1\\n self.d_acc_fake[i*bat_per_epo + j] = d_acc2\\n\\n # save per epoch metrics \\n # evaluate discriminator on real examples\\n n_samples = 100\\n x_real, y_real = self.generate_real_samples(X, labels, n_samples)\\n _, acc_real = self.d_model.evaluate(x_real, y_real, verbose=0)\\n self.d_acc_real_epochs[i] = acc_real\\n \\n # evaluate discriminator on fake examples\\n x_fake, y_fake = self.generate_generator_prediction_samples(n_samples)\\n _, acc_fake = self.d_model.evaluate(x_fake, y_fake, verbose=0)\\n self.d_acc_fake_epochs[i] = acc_fake\\n \\n # every reporting_period, plot out images.\\n if i == 0 or (i+1) % reporting_period == 0 or (i+1) == n_epochs:\\n self.summarize_performance(i+1, 'conditional-gan')\\n \\n # save the generator model\\n self.save_model('conditional-gan')\",\n \"def build_models_NLP(train_pos_vec, train_neg_vec):\\n Y = [\\\"pos\\\"]*len(train_pos_vec) + [\\\"neg\\\"]*len(train_neg_vec)\\n\\n # Use sklearn's BernoulliNB and LogisticRegression functions to fit two models to the training data.\\n # For BernoulliNB, use alpha=1.0 and binarize=None\\n # For LogisticRegression, pass no parameters\\n # YOUR CODE HERE\\n from sklearn import linear_model,naive_bayes\\n lr = linear_model.LogisticRegression()\\n lr_model = lr.fit(train_pos_vec + train_neg_vec, Y)\\n\\n nb = naive_bayes.BernoulliNB(alpha=1.0, binarize=None)\\n nb_model = nb.fit(train_pos_vec + train_neg_vec, Y)\\n\\n return nb_model, lr_model\",\n \"def load_data(self):\\n print('Loading {} dataset'.format(self.split))\\n data_split_path = os.path.join(self.root_dir, 'splits', '{}.csv'.format(self.split))\\n with open(data_split_path,'r') as f:\\n reader = csv.reader(f, delimiter=',')\\n data_classes = {}\\n for i,row in enumerate(reader):\\n if i==0:\\n continue\\n data_classes[row[1]] = 1\\n data_classes = data_classes.keys()\\n print(data_classes)\\n\\n n_classes = len(data_classes)\\n print('n_classes:{}, n_label:{}, n_unlabel:{}'.format(n_classes,self.n_label,self.n_unlabel))\\n dataset_l = np.zeros([n_classes, self.n_label, self.im_height, self.im_width, self.channels], dtype=np.float32)\\n if self.n_unlabel>0:\\n dataset_u = np.zeros([n_classes, self.n_unlabel, self.im_height, self.im_width, self.channels], dtype=np.float32)\\n else:\\n dataset_u = []\\n\\n for i, cls in enumerate(data_classes):\\n im_dir = os.path.join(self.root_dir, 'data/{}/'.format(self.split), cls)\\n im_files = sorted(glob.glob(os.path.join(im_dir, '*.jpg')))\\n np.random.RandomState(self.seed).shuffle(im_files) # fix the seed to keep label,unlabel fixed\\n for j, im_file in enumerate(im_files):\\n im = np.array(Image.open(im_file).resize((self.im_width, self.im_height)), \\n np.float32, copy=False)\\n if j<self.n_label:\\n dataset_l[i, j] = im\\n else:\\n dataset_u[i,j-self.n_label] = im\\n print('labeled data:', np.shape(dataset_l))\\n print('unlabeled data:', np.shape(dataset_u))\\n \\n self.dataset_l = dataset_l\\n self.dataset_u = dataset_u\\n self.n_classes = n_classes\",\n \"def trainNet():\",\n \"def fixture_input_data(wrapper_arguments):\\n n_features, classes = wrapper_arguments\\n num_data = 50\\n data = np.random.rand(num_data, n_features)\\n labels = np.random.choice(classes, size=num_data)\\n\\n return data, labels\",\n \"def generate_syntetic_data( self ):\\n label_list = []\\n img_ground_truth = np.zeros( ( self.img_h, self.img_w ), dtype = np.float32 )\\n img = np.zeros( ( self.img_h, self.img_w, 3 ), dtype = np.float32 )\\n class_blue = np.zeros( ( self.img_h, self.img_w ), dtype = np.float32 )\\n class_red = np.zeros( ( self.img_h, self.img_w ), dtype = np.float32 )\\n\\n '''line, square, grill, rectangle, cross'''\\n if self.option_shape == 'line':\\n sample_type = 0\\n elif self.option_shape == 'circle':\\n sample_type = 1\\n elif self.option_shape == 'rectangle':\\n sample_type = 2\\n else: \\n sample_type = np.random.randint( 3 ) #0,1,2\\n\\n if sample_type == 0:\\n self.generate_line( img_ground_truth, img, class_blue, class_red )\\n elif sample_type == 1:\\n self.generate_circle( img_ground_truth, img, class_blue, class_red )\\n else:\\n self.generate_rectangle( img_ground_truth, img, class_blue, class_red )\\n\\n label_list.append( class_blue )\\n label_list.append( class_red )\\n # 2 classes generates\\n label_all = np.dstack( label_list ).astype( np.float32 ) \\n r, g, b = cv2.split( img )\\n img_bgr = cv2.merge( [ b, g, r ] )\\n\\n gen_adj = GenerateAdjMatrx( type_dist = self.type_dist )\\n A_gt = gen_adj.adjmatrx_groundthuth( img_ground_truth )\\n\\n B_in = gen_adj.adjmatrx_groundthuth(img_ground_truth * 0)\\n\\n return img_bgr, img_ground_truth, label_all, A_gt, B_in\",\n \"def multiclass_toy_data(): \\n #dataset = np.zeros((10,5), np.int)\\n dataset = np.array([[0,0,0,0,4],\\n [0,0,0,0,5],\\n [1,3,0,0,0],\\n [3,1,0,0,1],\\n [0,0,6,2,0],\\n [0,0,0,0,0],\\n [0,0,1,7,2], \\n [0,0,5,1,5],\\n [0,0,34,0,0],\\n [0,0,3,0,0]])\\n Y = np.array([3,3,2,2,1,0,1,1,0,0])\\n #for i in range(10):\\n #for j in range(5):\\n #dataset[i][j] = np.random.randint(0,10) \\n dataset = np.column_stack((dataset, Y))\\n return (dataset)\",\n \"def learn(self, Xtrain, ytrain):\",\n \"def pp_labels(y_train, y_dev, y_test):\\n\\n lb = LabelBinarizer()\\n ym_train = lb.fit_transform(y_train).T\\n ym_dev = lb.fit_transform(y_dev).T\\n ym_test = lb.fit_transform(y_test).T\\n\\n return ym_train, ym_dev, ym_test\",\n \"def load_data(data_dir, split=1.0):\\n n = 123 * 41\\n positive_examples = glob.glob(data_dir + '/positive_set/*.png')\\n negative_examples = glob.glob(data_dir + '/negative_set/*.png')\\n x = np.zeros((n, len(positive_examples) + len(negative_examples)))\\n for k in range(len(positive_examples)):\\n x[:,k] = np.reshape(img.imread(positive_examples[k]), (n,))\\n for k in range(len(negative_examples)):\\n x[:, k+len(positive_examples)] = np.reshape(img.imread(negative_examples[k]), (n,))\\n y = np.concatenate((np.ones((1,len(positive_examples))), np.zeros((1,len(negative_examples)))), axis=1)\\n arr = np.concatenate((x,y), axis=0)\\n part_train = int(math.floor(split * arr.shape[1]))\\n np.random.shuffle(arr.T)\\n x_train = arr[0:-1,0:part_train]\\n y_train = arr[-1,0:part_train]\\n x_test = arr[0:-1,part_train:]\\n y_test = arr[-1,part_train:]\\n if split == 1.0:\\n return (x_train.T, y_train.T)\\n else:\\n return (x_train.T, y_train.T),(x_test.T,y_test.T)\",\n \"def demo():\\n def load_data():\\n train = open(\\\"csv/svd_train.csv\\\", \\\"r\\\")\\n r = csv.reader(train)\\n next(r)\\n\\n data = []\\n target = []\\n\\n print \\\"Prepping data...\\\"\\n for row in r:\\n aux = [0 for x in xrange(10)]\\n aux[int(row[0])] = 1\\n target.append(aux)\\n data.append([float(x) for x in row[1:]])\\n\\n train.close()\\n\\n data = np.array(data)\\n\\n target = np.array(target)\\n\\n #train = [target[:35000],data[:35000]]\\n #test = [target[35000:],data[35000:]]\\n\\n return [target, data]\\n\\n NN = MLP_NeuralNetwork(101, 75, 35, 10,\\n iterations = 200,\\n learning_rate = 0.5,\\n momentum = 0.05,\\n rate_decay = 0.005)\\n\\n train = load_data()\\n\\n NN.train(train)\\n #NN.test_cross(test)\\n #NN.test()\\n NN.test_against()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6725396","0.64309126","0.63958347","0.63937193","0.6377529","0.636468","0.63290304","0.62903607","0.6288107","0.6281172","0.62540567","0.62314403","0.62133723","0.6178726","0.614421","0.6132435","0.612361","0.61162657","0.6115919","0.6110773","0.6107986","0.61017925","0.60892725","0.6060079","0.6056729","0.6044332","0.6022794","0.60152704","0.60142344","0.60092235","0.60045516","0.60034126","0.5982944","0.59729326","0.5971869","0.59506834","0.5944021","0.59298694","0.5921282","0.5898433","0.58982563","0.5897109","0.589519","0.5893244","0.5886348","0.58805627","0.5877412","0.58580166","0.5854992","0.58482295","0.58465725","0.58444136","0.5840366","0.5833804","0.5823574","0.581649","0.5811425","0.58100927","0.5799368","0.5797367","0.57962424","0.57921857","0.5791416","0.5785602","0.57855713","0.577495","0.5774506","0.5774498","0.5766083","0.57582563","0.574376","0.574376","0.57388335","0.57388335","0.5737662","0.5733751","0.57242733","0.5724097","0.5724097","0.5724097","0.5724097","0.5724097","0.5724097","0.5724097","0.57238233","0.5722545","0.57099074","0.5705914","0.56971544","0.56945753","0.5692312","0.5689206","0.5685426","0.5678773","0.5678585","0.5675608","0.5672572","0.567015","0.5666478","0.5664012"],"string":"[\n \"0.6725396\",\n \"0.64309126\",\n \"0.63958347\",\n \"0.63937193\",\n \"0.6377529\",\n \"0.636468\",\n \"0.63290304\",\n \"0.62903607\",\n \"0.6288107\",\n \"0.6281172\",\n \"0.62540567\",\n \"0.62314403\",\n \"0.62133723\",\n \"0.6178726\",\n \"0.614421\",\n \"0.6132435\",\n \"0.612361\",\n \"0.61162657\",\n \"0.6115919\",\n \"0.6110773\",\n \"0.6107986\",\n \"0.61017925\",\n \"0.60892725\",\n \"0.6060079\",\n \"0.6056729\",\n \"0.6044332\",\n \"0.6022794\",\n \"0.60152704\",\n \"0.60142344\",\n \"0.60092235\",\n \"0.60045516\",\n \"0.60034126\",\n \"0.5982944\",\n \"0.59729326\",\n \"0.5971869\",\n \"0.59506834\",\n \"0.5944021\",\n \"0.59298694\",\n \"0.5921282\",\n \"0.5898433\",\n \"0.58982563\",\n \"0.5897109\",\n \"0.589519\",\n \"0.5893244\",\n \"0.5886348\",\n \"0.58805627\",\n \"0.5877412\",\n \"0.58580166\",\n \"0.5854992\",\n \"0.58482295\",\n \"0.58465725\",\n \"0.58444136\",\n \"0.5840366\",\n \"0.5833804\",\n \"0.5823574\",\n \"0.581649\",\n \"0.5811425\",\n \"0.58100927\",\n \"0.5799368\",\n \"0.5797367\",\n \"0.57962424\",\n \"0.57921857\",\n \"0.5791416\",\n \"0.5785602\",\n \"0.57855713\",\n \"0.577495\",\n \"0.5774506\",\n \"0.5774498\",\n \"0.5766083\",\n \"0.57582563\",\n \"0.574376\",\n \"0.574376\",\n \"0.57388335\",\n \"0.57388335\",\n \"0.5737662\",\n \"0.5733751\",\n \"0.57242733\",\n \"0.5724097\",\n \"0.5724097\",\n \"0.5724097\",\n \"0.5724097\",\n \"0.5724097\",\n \"0.5724097\",\n \"0.5724097\",\n \"0.57238233\",\n \"0.5722545\",\n \"0.57099074\",\n \"0.5705914\",\n \"0.56971544\",\n \"0.56945753\",\n \"0.5692312\",\n \"0.5689206\",\n \"0.5685426\",\n \"0.5678773\",\n \"0.5678585\",\n \"0.5675608\",\n \"0.5672572\",\n \"0.567015\",\n \"0.5666478\",\n \"0.5664012\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.60316014"},"document_rank":{"kind":"string","value":"26"}}},{"rowIdx":22883,"cells":{"query":{"kind":"string","value":"setup GPU device if available, move model into configured device"},"document":{"kind":"string","value":"def _prepare_device(self, n_gpu_use):\n n_gpu = torch.cuda.device_count()\n if n_gpu_use > 0 and n_gpu == 0:\n self.logger.warning(\n \"Warning: There\\'s no GPU available on this machine, training will be performed on CPU.\")\n n_gpu_use = 0\n if n_gpu_use > n_gpu:\n self.logger.warning(\n \"Warning: The number of GPU\\'s configured to use is {}, but only {} are available on this machine.\".format(\n n_gpu_use, n_gpu))\n n_gpu_use = n_gpu\n device = torch.device('cuda:0' if n_gpu_use > 0 else 'cpu')\n list_ids = list(range(n_gpu_use))\n return device, list_ids"},"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 setup_device(n_gpus: int) -> object:\n if n_gpus >= 1 and torch.cuda.is_available():\n LOG.info('\\n CUDA is available! using GPU...')\n return torch.device('cuda')\n else:\n LOG.info('\\n Using CPU...')\n return torch.device('cpu')","def create_gpu_device_if_present():\n d = dpctl.SyclDevice(\"gpu,cpu\")\n print(\"Selected \" + (\"GPU\" if d.is_gpu else \"CPU\") + \" device\")","def set_device(device, backend='autograd'):\n if backend == 'autograd':\n return None\n elif backend == 'pytorch':\n try:\n tc.cuda.set_device(device)\n except:\n pass","def device_placement(self):\n if is_tf_available():\n import tensorflow as tf\n with tf.device('/CPU:0' if self.device == -1 else '/device:GPU:{}'.format(self.device)):\n yield\n else:\n import torch\n if self.device >= 0:\n torch.cuda.set_device(self.device)\n\n yield","def setup_gpu(use_gpu: int, silent=None) -> None:\n if silent is None:\n local_msg = Printer()\n else:\n local_msg = Printer(no_print=silent, pretty=not silent)\n if use_gpu >= 0:\n local_msg.info(f\"Using GPU: {use_gpu}\")\n require_gpu(use_gpu)\n else:\n local_msg.info(\"Using CPU\")\n if gpu_is_available():\n local_msg.info(\"To switch to GPU 0, use the option: --gpu-id 0\")","def setup_device(gpuid=None):\n\n if gpuid is not None and not isinstance(gpuid, str):\n gpuid = str(gpuid)\n\n if gpuid is not None:\n nb_devices = len(gpuid.split(','))\n else:\n nb_devices = 1\n\n if gpuid is not None and (gpuid != '-1'):\n device = '/gpu:' + gpuid\n os.environ['CUDA_VISIBLE_DEVICES'] = gpuid\n\n # GPU memory configuration differs between TF 1 and 2\n if hasattr(tf, 'ConfigProto'):\n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True\n config.allow_soft_placement = True\n tf.keras.backend.set_session(tf.Session(config=config))\n else:\n tf.config.set_soft_device_placement(True)\n for pd in tf.config.list_physical_devices('GPU'):\n tf.config.experimental.set_memory_growth(pd, True)\n else:\n device = '/cpu:0'\n os.environ['CUDA_VISIBLE_DEVICES'] = '-1'\n\n return device, nb_devices","def _create_device(self):\n return torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")","def cuda(self):\n if torch.cuda.is_available():\n self.automata = self.automata.cuda()\n self.inv_automata = self.inv_automata.cuda()\n self.action = self.action.cuda()\n self.inv_action = self.inv_action.cuda()","def configure_gpu_tf():\n\n try:\n # locate available devices & set required environment variables\n available_device_ids = GPUtil.getFirstAvailable(order='first', maxLoad=0.7, maxMemory=0.7, attempts=1, interval=10)\n available_device_id = available_device_ids[0]\n os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'\n os.environ['CUDA_VISIBLE_DEVICES'] = str(available_device_id)\n print(f\"\\n GPU Found! running on GPU:{available_device_id}\\n\")\n\n # set GPU configuration (use all GPU memory if device 0, else use <50% of memory)\n tf.debugging.set_log_device_placement(False)\n physical_gpu = tf.config.experimental.list_physical_devices('GPU')[0]\n\n if available_device_id == 0:\n tf.config.experimental.set_memory_growth(physical_gpu, True)\n else:\n tf.config.experimental.set_virtual_device_configuration(\n physical_gpu,\n [tf.config.experimental.VirtualDeviceConfiguration(memory_limit=4500)]\n )\n logical_gpus = tf.config.experimental.list_logical_devices('GPU')\n assert len(logical_gpus) == 1, \"error creating virtual GPU to fractionally use memory\"\n\n # if we can't find a GPU, or they are all busy, default to using CPU\n except RuntimeError:\n print(\"\\n No GPUs available... running on CPU\\n\")\n os.environ['CUDA_VISIBLE_DEVICES'] = '-1'","def setup_device(device):\n try:\n # Gets around \"Resource busy\" errors\n device.detach_kernel_driver(0)\n except Exception:\n pass\n device.set_configuration()","def move2gpu(self):\n if self.generator.backend.upper() == \"LOOPY\":\n try:\n import pyopencl as cl\n import pyopencl.array # pylint: disable=unused-variable\n from .context import queue\n except ImportError:\n raise ImportError(\"Please install loo.py\")\n\n self.rhs = cl.array.to_device(queue, self.rhs)\n if hasattr(self, \"s\"):\n self.s = cl.array.to_device(\n queue, self.s\n ) # pylint: disable=attribute-defined-outside-init\n self.istore = cl.array.to_device(queue, self.istore)\n for i in range(len(self.iload)):\n self.iload[i] = cl.array.to_device(queue, self.iload[i])","def set_current_device_id():\n import paddle\n curr_dev = paddle.device.get_device()\n select_gpu = os.getenv(\"FLAGS_selected_gpus\", \"0\")\n paddle.set_flags({\n 'FLAGS_selected_gpus': os.getenv(\"FLAGS_selected_gpus\", \"0\")\n })\n if \"gpu\" in curr_dev and select_gpu != curr_dev.split(\":\")[-1]:\n paddle.set_device(\"gpu:\" + select_gpu)\n\n curr_dev_id = paddle.framework.core.get_cuda_current_device_id()\n if \"gpu\" in curr_dev and select_gpu != str(curr_dev_id):\n paddle.zeros([])","def setGPU(state):\n\n\timport tensorflow as tf\n\tfrom keras import backend as K\n\n\tcheckGPU()\n\n\tnum_cores = 1\n\tnum_CPU = 1\n\tnum_GPU = 0\n\tif state:\n\t\tnum_GPU = 1\n\n\tconfig = tf.ConfigProto(intra_op_parallelism_threads=num_cores,\\\n\t inter_op_parallelism_threads=num_cores, allow_soft_placement=True,\\\n\t device_count = {'CPU' : num_CPU, 'GPU' : num_GPU})\n\tsession = tf.Session(config=config)\n\tK.set_session(session)","def _setup_gpu_environment() -> None:\n gpu_memory_config = os.getenv(ENV_GPU_CONFIG)\n\n if not gpu_memory_config:\n return\n\n # Import from tensorflow only if necessary (environment variable was set)\n from tensorflow import config as tf_config\n\n parsed_gpu_config = _parse_gpu_config(gpu_memory_config)\n physical_gpus = tf_config.list_physical_devices(\"GPU\")\n\n # Logic taken from https://www.tensorflow.org/guide/gpu\n if physical_gpus:\n for gpu_id, gpu_id_memory in parsed_gpu_config.items():\n _allocate_gpu_memory(physical_gpus[gpu_id], gpu_id_memory)\n\n else:\n rasa.shared.utils.io.raise_warning(\n f\"You have an environment variable '{ENV_GPU_CONFIG}' set but no GPUs were \"\n f\"detected to configure.\"\n )","def set_device(sys_device_id):\n device_id = -1\n cuda = (sys_device_id != -1)\n if cuda:\n # CUDA_VISIBLE_DEVICE is a list, and device_id is the index of its members.\n import os\n os.environ['CUDA_VISIBLE_DEVICES'] = str(sys_device_id)\n device_id = 0\n TVT = TransferVarTensor(device_id)\n TMO = TransferModulesOptims(device_id)\n return TVT, TMO","def set_device(self, cuda=True):\n if cuda and torch.cuda.is_available():\n self.cuda = True\n self.device = torch.device('cuda')\n else:\n self.cuda = False\n self.device = torch.device('cpu')\n\n if self.verbose:\n if not cuda:\n print('Using CPU device')\n elif not self.cuda:\n print('CUDA is not available. Defaulting to CPU device')\n else:\n print('Using CUDA device')\n\n self.encoder.to(self.device)\n self.decoder.to(self.device)\n self.critic.to(self.device)","def set_device(in_arg): \n \n return torch.device(\"cuda\" if torch.cuda.is_available() and in_arg.gpu == 1 else \"cpu\")","def dist_setting(current_gpu, model, args):\n print(\"channels_last : {}\".format(args.channels_last))\n if args.channels_last:\n args.memory_format = torch.channels_last\n else:\n args.memory_format = torch.contiguous_format\n\n if args.apex:\n args.lr = args.lr*float(args.batch_size*args.world_size)/256.\n args.current_gpu = current_gpu\n if args.current_gpu is not None:\n print(\"Use GPU: {} for training\".format(args.current_gpu))\n\n if args.multigpus_distributed:\n args.rank = args.num_gpus * args.host_num + args.current_gpu\n dist.init_process_group(backend=args.backend,\n rank=args.rank, world_size=args.world_size)\n logger.info('Initialized the distributed environment: \\'{}\\' backend on {} nodes. '.format(\n args.backend, dist.get_world_size()) + 'Current host rank is {}. Number of gpus: {}'.format(\n dist.get_rank(), args.num_gpus))\n else:\n args.rank = 0\n\n if args.sync_bn:\n import apex\n print(\"using apex synced BN\")\n model = apex.parallel.convert_syncbn_model(model)\n\n if args.multigpus_distributed:\n if args.current_gpu is not None:\n torch.cuda.set_device(args.current_gpu)\n args.batch_size = int(args.batch_size / args.num_gpus)\n logger.info(\"Batch size for each GPU: {}\".format(args.batch_size))\n if not args.apex:\n model.cuda(args.current_gpu)\n model = torch.nn.parallel.DistributedDataParallel(\n model, device_ids=[args.current_gpu])\n else:\n if not args.apex:\n model.cuda()\n model = torch.nn.parallel.DistributedDataParallel(model)\n elif args.current_gpu is not None:\n torch.cuda.set_device(args.current_gpu)\n if not args.apex:\n model = model.cuda(args.current_gpu)\n else:\n if not args.apex:\n model = torch.nn.DataParallel(model).cuda()\n\n return model, args","def set_gpu(gpus):\n os.environ[\"CUDA_DEVICE_ORDER\"] = \"PCI_BUS_ID\"\n os.environ[\"CUDA_VISIBLE_DEVICES\"] = gpus","def set_device(gpu_arg):\n\n dev = 'cpu'\n if gpu_arg and torch.cuda.is_available():\n dev = 'cuda'\n elif gpu_arg:\n print('Not gpu found. Using cpu instead.') \n\n return torch.device(dev)","def setup_device(self, conf: DictConfig) -> device:\n device = torch.device(conf.runner.device) if torch.cuda.is_available() else torch.device('cpu')\n\n return device","def prepare_device(n_gpu_use):\n n_gpu = torch.cuda.device_count()\n if n_gpu_use > 0 and n_gpu == 0:\n print(\"Warning: There\\'s no GPU available on this machine,\"\n \"training will be performed on CPU.\")\n n_gpu_use = 0\n if n_gpu_use > n_gpu:\n print(\"Warning: The number of GPU\\'s configured to use is {}, but only {} are available \"\n \"on this machine.\".format(n_gpu_use, n_gpu))\n n_gpu_use = n_gpu\n device = torch.device('cuda:0' if n_gpu_use > 0 else 'cpu')\n list_ids = list(range(n_gpu_use))\n return device, list_ids","def torch_setup(device_type=None, gpu_offset=0):\n from mpi4py import MPI\n import torch\n\n if device_type is None:\n device_type = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n\n local_rank, local_size = _get_local_rank_size(MPI.COMM_WORLD)\n if device_type == \"cuda\":\n device_index = (local_rank + gpu_offset) % torch.cuda.device_count()\n torch.cuda.set_device(device_index)\n else:\n device_index = 0\n if \"RCALL_NUM_CPU_PER_PROC\" in os.environ:\n num_threads = int(os.environ[\"RCALL_NUM_CPU_PER_PROC\"])\n else:\n num_threads = max(round(mp.cpu_count() // 2 / local_size), 1)\n torch.set_num_threads(num_threads)\n return torch.device(type=device_type, index=device_index)","def prepare_device(n_gpu_use):\n n_gpu = torch.cuda.device_count()\n if n_gpu_use > 0 and n_gpu == 0:\n print(\"Warning: There\\'s no GPU available on this machine,\"\n \"training will be performed on CPU.\")\n n_gpu_use = 0\n if n_gpu_use > n_gpu:\n print(f\"Warning: The number of GPU\\'s configured to use is {n_gpu_use}, but only {n_gpu} are \"\n \"available on this machine.\")\n n_gpu_use = n_gpu\n device = torch.device('cuda:0' if n_gpu_use > 0 else 'cpu')\n list_ids = list(range(n_gpu_use))\n return device, list_ids","def prepare_device(n_gpu_use):\n n_gpu = torch.cuda.device_count()\n if n_gpu_use > 0 and n_gpu == 0:\n print(\"Warning: There\\'s no GPU available on this machine,\"\n \"training will be performed on CPU.\")\n n_gpu_use = 0\n if n_gpu_use > n_gpu:\n print(f\"Warning: The number of GPU\\'s configured to use is {n_gpu_use}, but only {n_gpu} are \"\n \"available on this machine.\")\n n_gpu_use = n_gpu\n device = torch.device('cuda:0' if n_gpu_use > 0 else 'cpu')\n list_ids = list(range(n_gpu_use))\n return device, list_ids","def prepare_model_optimizer_and_scheduler(self):\n\n ###################################################################\n # MODEL PREPARATION\n # -----------------\n # - step 1: Initialize a random model from config\n # - step 2: Load model weights from checkpoint if any\n # - step 3: Move model to device (GPU)\n ###################################################################\n\n # Initialize a random model according to a specific config:\n # NOTE: here we load from a physical path instead of using a keyword\n # as compute nodes may not allow downloading from online hubs\n if self.is_character_bert:\n model_config = CharacterBertConfig.from_pretrained(\n os.path.join(WORKDIR, 'data', 'character-bert'))\n model = CharacterBertForPreTraining(model_config)\n else:\n model_config = BertConfig.from_pretrained(\n os.path.join(WORKDIR, 'data', 'bert-base-uncased'))\n model = BertForPreTraining(model_config)\n if self.is_main_process:\n logging.info(\n \"Initialized %s using Config:\\n%s\",\n \"CharacterBERT\" if self.is_character_bert else \"BERT\",\n model_config\n )\n\n # Load checkpoint if any:\n if not self.resume_pretraining:\n # CASE: no checkpoint -> training from scratch\n self.global_step = 0\n if self.is_main_process:\n logging.info(\"Pre-training from scratch (good luck!)\")\n else:\n if self.init_checkpoint:\n # CASE: load checkpoint from direct path\n self.global_step = 0\n init_checkpoint = self.init_checkpoint\n if self.is_main_process:\n logging.info(\n \"Resuming pre-training from specific checkpoint `%s`\",\n init_checkpoint\n )\n else:\n # CASE: load checkpoint from resume_step\n if self.is_main_process:\n logging.info(\n \"Resuming pre-training from step `%s`. \"\n \"Looking inside `output_directory` for checkpoints...\",\n self.resume_step\n )\n\n if self.resume_step == -1:\n # CASE: resume_step == -1, load latest checkpoint\n model_names = [\n fname\n for fname in os.listdir(self.output_directory)\n if fname.endswith(\".pt\")]\n assert model_names, \"Could not find any checkpoints to resume from.\"\n self.resume_step = max([\n int(x.split('.pt')[0].split('_')[1].strip())\n for x in model_names]) # TODO: find a better way for this\n if self.is_main_process:\n logging.info(\n \"Resuming from latest checkpoint: ckpt_%s.pt\",\n self.resume_step\n )\n else:\n # CASE: resume_step == X, load checkpoint: `ckpt_X.pt`\n if self.is_main_process:\n logging.info(\n \"Resuming from checkpoint: ckpt_%s.pt\",\n self.resume_step\n )\n self.global_step = self.resume_step\n init_checkpoint = os.path.join(\n self.output_directory, f\"ckpt_{self.resume_step}.pt\")\n\n # Load the actual checkpoint file\n self.checkpoint = torch.load(\n init_checkpoint, map_location=\"cpu\"\n )\n\n # NOTE: Keeping these lines below as a reminder that re-training on\n # a different domain with CharacterBERT requires changing the\n # output layer with a topK tokens matrix from the new domain.\n\n # # Case where we would retrain a general_domain CharacterBERT\n # # on the medical domain. Don't use the general domain output layer:\n # if self.is_medical_domain and self.is_character_bert and (not self.phase2):\n # model.load_state_dict(\n # {\n # k: v for (k, v) in self.checkpoint['model'].items()\n # # Don't load output matrix from general domain model\n # if not k.startswith('cls.predictions') # ignoring the old output layer\n # },\n # strict=False)\n # if self.is_main_process:\n # logging.warning(\n # \"Loaded model weights from `%s`, \"\n # \"but ignored the `cls.predictions` module.\",\n # init_checkpoint)\n\n # # General case: load weights from checkpoint\n # else:\n # model.load_state_dict(self.checkpoint['model'], strict=True)\n # if self.is_main_process:\n # logging.info('Loaded model weights from `%s`',\n # init_checkpoint)\n\n # General case: load weights from checkpoint\n model.load_state_dict(self.checkpoint['model'], strict=True)\n if self.is_main_process:\n logging.info('Loaded model weights from `%s`', init_checkpoint)\n\n # Deduce previous steps from phase1 when in phase2\n if self.phase2 and not self.init_checkpoint:\n self.global_step -= self.phase1_end_step\n\n if self.is_main_process:\n logging.info(\"Training will start at global_step=%s\", self.global_step)\n\n # Move model to GPU:\n model.to(self.device)\n if self.is_main_process:\n logging.info(\"Model was moved to device: %s\", self.device)\n\n ###################################################################\n # OPTIMIZER / SCHEDULER PREPARATION\n # ---------------------------------\n # - step 1: Define the optimizer (FusedLAMB w/ some weight decay)\n # - step 2: Define the learning rate scheduler (PolyWarmUpScheduler)\n ###################################################################\n\n # Initialize an optimizer:\n no_decay = ['bias', 'gamma', 'beta', 'LayerNorm'] # no weight decay\n optimizer_grouped_parameters = [\n {\n 'params': [\n param for name, param in model.named_parameters()\n if not any((nd in name) for nd in no_decay)],\n 'weight_decay': 0.01\n },\n {\n 'params': [\n param for name, param in model.named_parameters()\n if any((nd in name) for nd in no_decay)],\n 'weight_decay': 0.0\n }\n ]\n optimizer = FusedLAMB(\n optimizer_grouped_parameters, lr=self.learning_rate)\n if self.is_main_process:\n logging.info(\"Using optimizer: %s\", optimizer)\n\n # Initialize a learning rate scheduler:\n self.lr_scheduler = PolyWarmUpScheduler(\n optimizer,\n warmup=self.warmup_proportion,\n total_steps=self.total_steps\n )\n if self.is_main_process:\n logging.info(\"Using scheduler: %s\", self.lr_scheduler)\n\n ###################################################################\n # OTHER PREPARATION STEPS\n # -----------------------\n # - step 1: Set up Mixed Precision training (fp16) if required\n # - step 2: Load optimizer stat from checkpoint if any\n # - step 2: Set up DataParallel\n ###################################################################\n\n # Set up fp16:\n if self.fp16:\n if self.is_main_process:\n logging.info(\"Setting up `Almost FP16` Mixed Precision...\")\n if self.loss_scale == 0:\n model, optimizer = amp.initialize(\n model, optimizer, opt_level=\"O2\", loss_scale=\"dynamic\")\n else:\n model, optimizer = amp.initialize(\n model, optimizer, opt_level=\"O2\", loss_scale=self.loss_scale)\n amp._amp_state.loss_scalers[0]._loss_scale = 2**20\n\n # Load optimizer state from checkpoint\n if self.resume_pretraining:\n if self.is_main_process:\n logging.info(\"Loading optimizer state from checkpoint...\")\n if self.phase2 or self.init_checkpoint:\n keys = list(self.checkpoint['optimizer']['state'].keys())\n # Override hyperparameters from previous self.checkpoint\n for key in keys:\n self.checkpoint['optimizer']['state'][key]['step'] = self.global_step\n for i, _ in enumerate(self.checkpoint['optimizer']['param_groups']):\n self.checkpoint['optimizer']['param_groups'][i]['step'] = self.global_step\n self.checkpoint['optimizer']['param_groups'][i]['t_total'] = self.total_steps\n self.checkpoint['optimizer']['param_groups'][i]['warmup'] = self.warmup_proportion\n self.checkpoint['optimizer']['param_groups'][i]['lr'] = self.learning_rate\n if self.is_main_process:\n logging.info(\"Overwrote the following parameters with new values:\")\n logging.info(\"* step: %s\", self.global_step)\n logging.info(\"* t_total: %s\", self.total_steps)\n logging.info(\"* warmup: %s\", self.warmup_proportion)\n logging.info(\"* lr: %s\", self.learning_rate)\n optimizer.load_state_dict(self.checkpoint['optimizer'])\n # Restore AMP master parameters\n if self.fp16:\n if self.is_main_process:\n logging.info(\"Restoring AMP master parameters (optimizer)...\")\n optimizer._lazy_init_maybe_master_weights()\n optimizer._amp_stash.lazy_init_called = True\n optimizer.load_state_dict(self.checkpoint['optimizer'])\n for param, saved_param in zip(amp.master_params(optimizer), self.checkpoint['master params']):\n param.data.copy_(saved_param.data)\n\n # Distribute model\n if self.training_is_distributed:\n if not self.allreduce_post_accumulation:\n model = DistributedDataParallel(\n model,\n message_size=250000000,\n gradient_predivide_factor=\\\n torch.distributed.get_world_size()\n )\n else:\n flat_dist_call(\n [param.data for param in model.parameters()],\n torch.distributed.broadcast,\n (0,)\n )\n elif self.n_gpu > 1:\n model = torch.nn.DataParallel(model)\n\n # Set the values of self.model and self.optimizer\n self.model = model\n self.optimizer = optimizer","def cuda(self):\n for i in self.modules:\n if torch.cuda.is_available():\n self.modules[i] = self.modules[i].cuda()","def setup(self):\n print(\"setup\")\n \n self.modelToUse = 1\n if self.train:\n print(\"train\")\n else:\n print(\"no train\")\n \n device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n self.envSize = 17\n \n #init model\n if self.train or not os.path.isfile(\"my-saved-model.pt\"):\n self.logger.info(\"Setting up model from scratch.\")\n if self.modelToUse == 0:\n self.policy_net = Model_global_view(self.envSize, self.envSize, 6).to(device)\n self.model = Model_global_view(self.envSize, self.envSize, 6).to(device)\n elif self.modelToUse == 1:\n self.policy_net = Model_local_view(self.envSize, self.envSize, 6).to(device)\n self.model = Model_local_view(self.envSize, self.envSize, 6).to(device)\n else:\n self.policy_net = Model_combined_view(self.envSize, self.envSize, 6).to(device)\n self.model = Model_combined_view(self.envSize, self.envSize, 6).to(device)\n self.model.load_state_dict(self.policy_net.state_dict())\n self.model.eval()\n else:\n self.logger.info(\"Loading model from saved state.\")\n with open(\"my-saved-model.pt\", \"rb\") as file:\n if self.modelToUse == 0:\n self.model = Model_global_view(self.envSize, self.envSize, 6)\n elif self.modelToUse == 1:\n self.model = Model_local_view(self.envSize, self.envSize, 6)\n else:\n self.model = Model_combined_view(self.envSize, self.envSize, 6)\n if torch.cuda.is_available():\n self.model.load_state_dict(torch.load(file))\n self.model.to(device)\n else:\n self.model.load_state_dict(torch.load(file, map_location=device))","def gpu(self, gpu):\n\n self._gpu = gpu","def SetGPU(id):\n global option\n option['device_id'] = id","def setup_tf_environment() -> None:\n _setup_cpu_environment()\n _setup_gpu_environment()","def setupGPUSwept(solver):\n solver.gpuBlock = (slice(0,solver.sharedShape[0],1),)+solver.gpuBlock\n getGPUReadBlockSwept(solver) #Finish creating gpuReadBlock here\n blockShape =[element.stop for element in solver.gpuBlock]\n blockShape[-1] += int(2*solver.blocksize[0]) #Adding 2 blocks in the column direction\n # Creating local GPU array with split\n grid = (int((blockShape[2])/solver.blocksize[0]),int((blockShape[3])/solver.blocksize[1])) #Grid size\n #Creating constants\n bsp = lambda x: int(numpy.prod(blockShape[x:])) #block shape product returned as an integer\n const_dict = ({\"NV\":blockShape[1],'SX':blockShape[2],'SY':blockShape[3],\"VARS\":bsp(2),\"TIMES\":bsp(1),\"MPSS\":solver.maxPyramidSize,\"MOSS\":solver.maxOctSize,\"OPS\":solver.operating,\"ITS\":solver.intermediate})\n solver.GPUArray = mallocGPUArray(blockShape) #Allocated GPU\n solver.localGPUArray = numpy.zeros(blockShape)\n #Building CUDA source code\n solver.gpu = io.buildGPUSource(solver.gpu)\n io.copyConstants(solver.gpu,const_dict) #This copys cpu constants not global constants\n solver.cpu.set_globals(*solver.globals,source_mod=solver.gpu)\n # Make GPU geometry\n solver.Up.initializeGPU(solver.gpu.get_function(\"UpPyramid\"),solver.blocksize,(grid[0],grid[1]-1))\n solver.Oct.initializeGPU(solver.gpu.get_function(\"Octahedron\"),solver.blocksize,(grid[0],grid[1]-1))\n solver.Down.initializeGPU(solver.gpu.get_function(\"DownPyramid\"),solver.blocksize,(grid[0],grid[1]-1))\n solver.Yb.initializeGPU(solver.gpu.get_function(\"YBridge\"),solver.blocksize,grid)\n solver.Xb.initializeGPU(solver.gpu.get_function(\"XBridge\"),solver.blocksize,grid)","def _adjust_for_gpus(cls, model: DeviceAwareModule, config: ModelConfigBase,\n model_execution_mode: ModelExecutionMode) -> DeviceAwareModule:\n if config.use_gpu:\n model = model.cuda()\n logging.info(\"Adjusting the model to use mixed precision training.\")\n # If model parallel is set to True, then partition the network across all available gpus.\n if config.use_model_parallel:\n devices = config.get_cuda_devices()\n assert devices is not None # for mypy\n model.partition_model(devices=devices) # type: ignore\n else:\n logging.info(\"Making no adjustments to the model because no GPU was found.\")\n\n # Update model related config attributes (After Model Parallel Activated)\n config.adjust_after_mixed_precision_and_parallel(model)\n\n # DataParallel enables running the model with multiple gpus by splitting samples across GPUs\n # If the model is used in training mode, data parallel is activated by default.\n # Similarly, if model parallel is not activated, data parallel is used as a backup option\n use_data_parallel = (model_execution_mode == ModelExecutionMode.TRAIN) or (not config.use_model_parallel)\n if config.use_gpu and use_data_parallel:\n logging.info(\"Adjusting the model to use DataParallel\")\n # Move all layers to the default GPU before activating data parallel.\n # This needs to happen even though we put the model to the GPU at the beginning of the method,\n # but we may have spread it across multiple GPUs later.\n model = model.cuda()\n model = DataParallelModel(model, device_ids=config.get_cuda_devices())\n\n return model","def process_initializer():\n os.environ['TF_CPP_MIN_LOG_LEVEL'] = '1'\n import tensorflow as tf\n physical_devices = tf.config.experimental.list_physical_devices('GPU')\n if len(physical_devices) > 0:\n os.environ['CUDA_VISIBLE_DEVICES'] = '0'\n tf.config.experimental.set_memory_growth(physical_devices[0], True)","def deploy_to_device(self):\n if self.device_ids is not None and len(self.device_ids) > 1:\n if not isinstance(self.model, torch.nn.DataParallel):\n self.model = torch.nn.DataParallel(self.model, self.device_ids)\n\n self.model = self.model.to(self.device)\n self.criterion = self.criterion.to(self.device)","def CUDA(self):\n\n if helpers.CUDA:\n self.generator.cuda()\n self.discriminator.cuda()\n self.adv_loss.cuda()","def cuda(self):\n self.reader.model.cuda()\n self.reader.device = torch.device(\"cuda\")\n return self","def create_gpu_device():\n d1 = dpctl.SyclDevice(\"gpu\")\n d2 = dpctl.select_gpu_device()\n assert d1 == d2\n print_device(d1)\n return d1","def check_device(use_gpu, use_xpu=False, use_npu=False, use_mlu=False):\n err = \"Config {} cannot be set as true while your paddle \" \\\n \"is not compiled with {} ! \\nPlease try: \\n\" \\\n \"\\t1. Install paddlepaddle to run model on {} \\n\" \\\n \"\\t2. Set {} as false in config file to run \" \\\n \"model on CPU\"\n\n try:\n if use_gpu and use_xpu:\n print(\"use_xpu and use_gpu can not both be ture.\")\n if use_gpu and not paddle.is_compiled_with_cuda():\n print(err.format(\"use_gpu\", \"cuda\", \"gpu\", \"use_gpu\"))\n sys.exit(1)\n if use_xpu and not paddle.device.is_compiled_with_xpu():\n print(err.format(\"use_xpu\", \"xpu\", \"xpu\", \"use_xpu\"))\n sys.exit(1)\n if use_npu:\n if int(paddle.version.major) != 0 and int(\n paddle.version.major) <= 2 and int(\n paddle.version.minor) <= 4:\n if not paddle.device.is_compiled_with_npu():\n print(err.format(\"use_npu\", \"npu\", \"npu\", \"use_npu\"))\n sys.exit(1)\n # is_compiled_with_npu() has been updated after paddle-2.4\n else:\n if not paddle.device.is_compiled_with_custom_device(\"npu\"):\n print(err.format(\"use_npu\", \"npu\", \"npu\", \"use_npu\"))\n sys.exit(1)\n if use_mlu and not paddle.device.is_compiled_with_mlu():\n print(err.format(\"use_mlu\", \"mlu\", \"mlu\", \"use_mlu\"))\n sys.exit(1)\n except Exception as e:\n pass","def magma_setdevice(dev):\n\n _libmagma.magma_setdevice(dev)","def main(gpu_device='/gpu:0', cpu_device='/cpu:0'):\n config = Config()\n params = experiment_params()\n model_tools.model_builder(\n params=params,\n config=config,\n model_spec=build_model,\n gpu_device=gpu_device,\n cpu_device=cpu_device)","def main(gpu_device='/gpu:0', cpu_device='/cpu:0'):\n config = Config()\n params = experiment_params()\n model_tools.model_builder(\n params=params,\n config=config,\n model_spec=build_model,\n gpu_device=gpu_device,\n cpu_device=cpu_device)","def setup(params):\n os.environ['TF_ENABLE_WINOGRAD_NONFUSED'] = '1'\n os.environ['TF_SYNC_ON_FINISH'] = str(int(params.sync_on_finish))\n argparse.ArgumentParser(\n formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n\n\n # Sets GPU thread settings\n params = params._replace(gpu_thread_mode=params.gpu_thread_mode.lower())\n os.environ['TF_GPU_THREAD_MODE'] = params.gpu_thread_mode\n\n # Default to two threads. One for the device compute and the other for\n # memory copies.\n per_gpu_thread_count = params.per_gpu_thread_count or 2\n total_gpu_thread_count = per_gpu_thread_count * params.num_gpus\n\n os.environ['TF_GPU_THREAD_COUNT'] = str(per_gpu_thread_count)\n\n if not params.num_inter_threads and params.gpu_thread_mode in [\n 'gpu_private', 'gpu_shared'\n ]:\n cpu_count = multiprocessing.cpu_count()\n main_thread_count = max(cpu_count - total_gpu_thread_count, 1)\n params = params._replace(num_inter_threads=main_thread_count)\n\n platforms_util.initialize(params, create_config_proto(params))\n\n return params","def _prepare_device(self, n_gpu_use):\n n_gpu = torch.cuda.device_count()\n if n_gpu_use > 0 and n_gpu == 0:\n self.logger.warning(\"Warning: There\\'s no GPU available on this machine,\"\n \"training will be performed on CPU.\")\n n_gpu_use = 0\n if n_gpu_use > n_gpu:\n self.logger.warning(\"Warning: The number of GPU\\'s configured to use is {}, but only {} are available \"\n \"on this machine.\".format(n_gpu_use, n_gpu))\n n_gpu_use = n_gpu\n device = torch.device('cuda:0' if n_gpu_use > 0 else 'cpu')\n list_ids = list(range(n_gpu_use))\n return device, list_ids","def set_device(self, device: torch.Tensor) -> None:\n raise NotImplementedError","def setupGPUStandard(solver):\n #Correct GPU block\n solver.gpuBlock = (slice(0,solver.sharedShape[0],1),)+solver.gpuBlock\n solver.gpuReadBlock = solver.gpuBlock[:2]+tuple([slice(cs.start-solver.operating,cs.stop+solver.operating,1) for cs in solver.gpuBlock[2:]])\n blockShape =[element.stop-element.start for element in solver.gpuBlock]\n blockShape[-1] += int(2*solver.operating) #Adding 2 blocks in the column direction\n blockShape[-2] += int(2*solver.operating) #Adding 2 blocks in the column direction\n #Creating local GPU array with split\n grid = (int((blockShape[2]-2*solver.operating)/solver.blocksize[0]),int((blockShape[3]-2*solver.operating)/solver.blocksize[1])) #Grid size\n #Creating constants\n bsp = lambda x: int(numpy.prod(blockShape[x:])) #block shape product returned as an integer\n const_dict = ({\"NV\":blockShape[1],'SX':blockShape[2],'SY':blockShape[3],\"VARS\":bsp(2),\"TIMES\":bsp(1),\"OPS\":solver.operating,\"ITS\":solver.intermediate})\n solver.GPUArray = mallocGPUArray(blockShape)\n solver.localGPUArray = numpy.zeros(blockShape)\n #Building CUDA source code\n solver.gpu = io.buildGPUSource(solver.gpu)\n io.copyConstants(solver.gpu,const_dict) #This copys gpu constants not global constants\n solver.cpu.set_globals(*solver.globals,source_mod=solver.gpu)\n #Make GPU geometry\n solver.standard.initializeGPU(solver.gpu.get_function(\"Standard\"),solver.blocksize,grid)","def handle_gpu_compatibility():\n try:\n gpus = tf.config.experimental.list_physical_devices(\"GPU\")\n for gpu in gpus:\n tf.config.experimental.set_memory_growth(gpu, True)\n except Exception as e:\n print(e)","def build_model(self):\n if self.args.network_type == 'unet':\n self.shared = models.Unet(self.args)\n else:\n raise NotImplementedError(f'Network type '\n f'`{self.args.network_type}` is not '\n f'defined')\n self.controller = models.Controller(self.args)\n\n if self.args.num_gpu == 1:\n self.shared.cuda()\n self.controller.cuda()\n elif self.args.num_gpu > 1:\n raise NotImplementedError('`num_gpu > 1` is in progress')","def prepare_device(self):\n self._get_pairing_status()\n self._update_system_clock()\n self._update_system()\n # Above will block during update process and kill this instance if\n # new software is installed\n\n if self.backend_down:\n self._notify_backend_down()\n else:\n self._display_skill_loading_notification()\n self.bus.emit(Message('mycroft.internet.connected'))\n self._ensure_device_is_paired()\n self._update_device_attributes_on_backend()","def to_device(model, device):\n p = next(model.parameters())\n if p.device == device:\n return\n model.to(device)","def test_torch_auto_gpu_to_cpu(ray_start_4_cpus_2_gpus):\n\n # Disable GPU on the driver.\n os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"\"\n\n num_workers = 2\n\n class ValidateCPUCallback(TrainingCallback):\n def handle_result(self, results, **info):\n for result in results:\n model = result[\"model\"]\n assert not next(model.parameters()).is_cuda\n\n def train_func():\n model = torch.nn.Linear(1, 1)\n\n # Move to GPU device.\n model = ray.train.torch.prepare_model(model)\n\n assert next(model.parameters()).is_cuda\n\n ray.train.save_checkpoint(model=model)\n ray.train.report(model=model)\n\n trainer = Trainer(\"torch\", num_workers=num_workers, use_gpu=True)\n trainer.start()\n trainer.run(train_func, callbacks=[ValidateCPUCallback()])\n model = trainer.latest_checkpoint[\"model\"]\n assert not next(model.parameters()).is_cuda\n trainer.shutdown()\n\n # Test the same thing for state dict.\n\n class ValidateCPUStateDictCallback(TrainingCallback):\n def handle_result(self, results, **info):\n for result in results:\n state_dict = result[\"state_dict\"]\n for tensor in state_dict.values():\n assert not tensor.is_cuda\n\n def train_func():\n model = torch.nn.Linear(1, 1)\n\n # Move to GPU device.\n model = ray.train.torch.prepare_model(model)\n\n assert next(model.parameters()).is_cuda\n\n state_dict = model.state_dict()\n\n for tensor in state_dict.values():\n assert tensor.is_cuda\n\n ray.train.save_checkpoint(state_dict=state_dict)\n ray.train.report(state_dict=state_dict)\n\n trainer = Trainer(\"torch\", num_workers=num_workers, use_gpu=True)\n trainer.start()\n trainer.run(train_func, callbacks=[ValidateCPUStateDictCallback()])\n\n state_dict = trainer.latest_checkpoint[\"state_dict\"]\n for tensor in state_dict.values():\n assert not tensor.is_cuda\n trainer.shutdown()\n\n # Reset the env var.\n os.environ.pop(\"CUDA_VISIBLE_DEVICES\")","def _copy_to_gpu(self):\n self.dispatch('on_texture')","def load_device():","def magma_device_sync():\n\n _libmagma.magma_device_sync()","def setup_gpu_and_random(config):\n random.seed(config.general.manualSeed)\n np.random.seed(config.general.manualSeed)\n torch.manual_seed(config.general.manualSeed)\n torch.cuda.manual_seed(config.general.manualSeed)\n\n cudnn.benchmark = True\n cudnn.deterministic = True\n config.num_gpu = torch.cuda.device_count()\n\n if config.num_gpu > 1:\n print('------ Use multi-GPU setting ------')\n print('if you stuck too long time with multi-GPU setting, try to set --workers 0')\n # check multi-GPU issue https://github.com/clovaai/deep-text-recognition-benchmark/issues/1\n config.workers = config.workers * config.num_gpu\n config.batch_size = config.batch_size * config.num_gpu\n\n \"\"\" previous version\n print('To equlize batch stats to 1-GPU setting, the batch_size is multiplied with num_gpu and multiplied batch_size is ', opt.batch_size)\n opt.batch_size = opt.batch_size * opt.num_gpu\n print('To equalize the number of epochs to 1-GPU setting, num_iter is divided with num_gpu by default.')\n If you dont care about it, just commnet out these line.)\n opt.num_iter = int(opt.num_iter / opt.num_gpu)\n \"\"\"","def set_devices(args):\n global devices\n if args is not None:\n devices = [torch.device(i) for i in ast.literal_eval('[' + args + ']')]\n torch.cuda.set_device(devices[0])\n else:\n devices = [torch.device('cpu')]","def setup_CL():\n\n #Set up openCL platform\n NAME = 'NVIDIA CUDA'\n platforms = cl.get_platforms()\n\n dev = None\n for p in platforms:\n #Easy switching for local vs remote machine\n if p.name == 'Apple':\n NAME = 'Apple'\n if p.name == NAME:\n dev = p.get_devices()\n\n # Command queue, enable GPU profiling\n ctx = cl.Context(dev)\n queue = cl.CommandQueue(ctx,properties=cl.command_queue_properties.PROFILING_ENABLE)\n\n return [dev,ctx,queue]","def cuda(self) -> 'BatchEmbedder':\n self.is_cuda = True\n self.embedding_layer = self.embedding_layer.cuda()\n\n return self","def return_free_GPU():\r\n if torch.cuda.is_available():\r\n gpu_num = torch.cuda.device_count()\r\n device = torch.device('cuda:{}'.format(gpu_num-1))\r\n print('Using GPU:[{}]/[{}] for training...'.format(gpu_num-1,gpu_num-1))\r\n return device\r\n \r\n raise ValueError('GPU not available for training. Check CUDA env with function \"check_cuda_env\"')","def test_auto_transfer_correct_device(ray_start_4_cpus_2_gpus):\n import nvidia_smi\n\n nvidia_smi.nvmlInit()\n\n def get_gpu_used_mem(i):\n handle = nvidia_smi.nvmlDeviceGetHandleByIndex(i)\n info = nvidia_smi.nvmlDeviceGetMemoryInfo(handle)\n return info.used\n\n start_gpu_memory = get_gpu_used_mem(1)\n\n device = torch.device(\"cuda:1\")\n small_dataloader = [(torch.randn((1024 * 4, 1024 * 4)),) for _ in range(10)]\n wrapped_dataloader = ( # noqa: F841\n ray.train.torch.train_loop_utils._WrappedDataLoader(\n small_dataloader, device, True\n )\n )\n\n end_gpu_memory = get_gpu_used_mem(1)\n\n # Verify GPU memory usage increases on the right cuda device\n assert end_gpu_memory > start_gpu_memory","def set_max_gpu(self):\r\n gpu_getter = GPUGetter()\r\n gpu = str(gpu_getter.get_free_gpu())\r\n\r\n if gpu:\r\n print(\"Using GPU: %s\" % gpu)\r\n os.environ[\"CUDA_DEVICE_ORDER\"] = \"PCI_BUS_ID\" # see issue #152\r\n os.environ['CUDA_VISIBLE_DEVICES'] = gpu\r\n\r\n if not gpu:\r\n print('No GPU detected')","def OnGPU(gpu_id):\n device_option = caffe2_pb2.DeviceOption()\n device_option.device_type = workspace.GpuDeviceType\n device_option.device_id = gpu_id\n return device_option","def set_gpu(gpu):\r\n os.environ['CUDA_VISIBLE_DEVICES'] = gpu\r\n tf_config = tf.ConfigProto()\r\n tf_config.gpu_options.allow_growth = True\r\n return tf_config","def device():\n return torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')","def do_device(self, args):\n self.device_command.cmdloop(\"Enter to device mode\")","def test_gpu_cuda_code() -> None:\n if get_from_environ(\"DISABLE_GPU_FOR_TESTING\") is not None:\n print(\"GPU payload disabled for testing\")\n return\n\n # if the command exists it can run on the hardware below\n proc = subprocess.Popen([\"nvidia-smi\"], stdout=subprocess.PIPE)\n stdout, _ = proc.communicate()\n str_stdout = stdout.decode()\n assert \"NVIDIA-SMI\" in str_stdout, str_stdout\n assert proc.returncode == 0\n # search the history for the CUDA implementation","def config_training_instance(self):\n # Compute the average of the gradients main_train_device\n tower_grads = []\n\n # Distribute the model onto available GPUs\n for i in range(self.num_gpus):\n with tf.device(\"/gpu:{}\".format(i)):\n\n optimizer = tf.train.AdamOptimizer(\n learning_rate=self.learning_rate)\n batch_size_instance = self.batch_size // self.num_gpus\n\n # Split data between GPUs\n inputs_instance = self.inputs[i * batch_size_instance:(i + 1) *\n batch_size_instance]\n labels_instance = self.labels[i * batch_size_instance:(i + 1) *\n batch_size_instance]\n\n logits = self.model(inputs_instance)\n trainable_variables = self.model.trainable_variables\n model_loss = self.construct_loss(logits=logits,\n labels=labels_instance)\n network_regularizers, regularizer_loss, exporter, costs = self.embed_morphnet(\n input_boundary=[inputs_instance.op],\n output_boundary=[logits.op],\n morphnet_regularization_strength=self.\n morphnet_regularization_strength_placeholder,\n morphnet_cost_thresholds=self.morphnet_target_cost_thresholds)\n total_loss = model_loss + regularizer_loss\n\n grads = optimizer.compute_gradients(\n total_loss, var_list=trainable_variables)\n tower_grads.append(grads)\n\n # Usually we would use the first GPU\n if i == 0:\n # Evaluate model (with test logits, for dropout to be disabled)\n self.logits_train_instance = logits\n self.model_loss_train_instance = model_loss\n self.probs_train_instance = tf.nn.softmax(logits)\n self.correct_pred_train_instance = tf.equal(\n tf.argmax(logits, 1), tf.argmax(labels_instance, 1))\n self.accuracy_train_instance = tf.reduce_mean(\n tf.cast(self.correct_pred_train_instance, tf.float32))\n\n self.network_regularizer_train_instance = network_regularizers\n self.regularizer_loss_train_instance = regularizer_loss\n self.total_loss_train_instance = total_loss\n self.exporter_train_instance = exporter\n self.cost_train_instance = costs\n\n # Compute the average of the gradients main_train_device\n with tf.device(self.main_train_device):\n grads = self.average_gradients(tower_grads)\n self.train_op = optimizer.apply_gradients(grads, global_step=None)","def _minimal_device_test(device: torch.device) -> bool:\n try:\n with torch.no_grad():\n model = torch.nn.Conv2d(1, 1, 1).to(device)\n x = torch.zeros(1, 1, 1, 1).to(device)\n y = model(x)\n del model, x, y\n except Exception as e:\n return False\n\n return True","def device(request):\n d = request.param()\n\n # enable GPU error checking\n if isinstance(d, hoomd.device.GPU):\n d.gpu_error_checking = True\n\n return d","def try_gpu():\r\n try:\r\n ctx = mx.gpu()\r\n _ = nd.array([0], ctx=ctx)\r\n except mx.base.MXNetError:\r\n ctx = mx.cpu()\r\n return ctx","def try_gpu():\n try:\n ctx = mx.gpu()\n _ = nd.array([0], ctx=ctx)\n except:\n ctx = mx.cpu()\n return ctx","def try_gpu():\n try:\n ctx = mx.gpu()\n _ = nd.array([0], ctx=ctx)\n except:\n ctx = mx.cpu()\n return ctx","def set_device(device: Union[str, torch.device]) -> torch.device:\n err_msg = None\n if isinstance(device, torch.device):\n pass\n elif device == 'auto':\n cuda = torch.cuda.is_available()\n device = torch.device('cuda' if cuda else 'cpu')\n elif device == 'gpu':\n cuda = torch.cuda.is_available()\n if cuda:\n device = torch.device('cuda')\n else:\n err_msg = ('Device set to \"gpu\", but could not access '\n 'any CUDA-enabled GPU. Please make sure that '\n 'a GPU is available and CUDA is installed '\n 'on this machine.')\n elif device == 'cpu':\n device = torch.device('cpu')\n else:\n err_msg = f'Unknown device \"{device}\". Try \"auto\".'\n if err_msg is not None:\n logger = get_logger(__name__, verbose=0)\n logger.error(f'Unknown device \"{device}\". Try \"auto\".')\n import sys\n sys.exit(1)\n return device","def set_gpu_from_theano():\r\n # Transfer the theano gpu binding to pycuda, for consistency\r\n if config.device.startswith(\"gpu\") and len(config.device) > 3:\r\n os.environ[\"CUDA_DEVICE\"] = theano.config.device[3:]\r\n elif (config.init_gpu_device.startswith(\"gpu\") and\r\n len(config.init_gpu_device) > 3):\r\n os.environ[\"CUDA_DEVICE\"] = theano.config.init_gpu_device[3:]","def mat_device(self): # pylint: disable=C0103\n if cp is None:\n raise ModuleNotFoundError(\"Could not import cupy -- cannot use GPU!\")\n if self._mat_device is None:\n gp_device = cp.array(self._gp)\n object.__setattr__(\n self,\n \"_mat_device\",\n cp.diag(self._disp_over_m) - gp_device.reshape(-1, 1) * gp_device,\n )\n return self._mat_device","def gpu(device_id=0):\n return Context('gpu', device_id)","def gpu(device_id=0):\n return Context('gpu', device_id)","def setUp(self):\n self.setup_model()\n self.sess = tf.Session(\n config=tf.ConfigProto(\n allow_soft_placement=True,\n gpu_options=tf.GPUOptions(allow_growth=True),\n log_device_placement=self.params['log_device_placement'],\n ))\n\n # TODO: Determine whether this should be called here or\n # in dbinterface.initialize()\n self.sess.run(tf.global_variables_initializer())\n\n self.dbinterface = DBInterface(\n sess=self.sess,\n params=self.params,\n cache_dir=self.CACHE_DIR,\n save_params=self.save_params,\n load_params=self.load_params)\n\n self.step = 0","def __init__(self,model,device):\n self.model = model\n self.device = device","def test_torch_prepare_model(ray_start_4_cpus_2_gpus):\n\n def train_fn():\n model = torch.nn.Linear(1, 1)\n\n # Wrap in DDP.\n model = train.torch.prepare_model(model)\n\n # Make sure model is wrapped in DDP.\n assert isinstance(model, DistributedDataParallel)\n\n # Make sure model is on cuda.\n assert next(model.parameters()).is_cuda\n\n trainer = Trainer(\"torch\", num_workers=2, use_gpu=True)\n trainer.start()\n trainer.run(train_fn)\n trainer.shutdown()","def init():\n\tN = np.int32(DIM) #prepare for stitching\n\t#HII_DIM = np.int32(HII_DIM)\n\tf_pixel_factor = DIM/HII_DIM;\n\tscale = np.float32(BOX_LEN)/DIM\n\tHII_scale = np.float32(BOX_LEN)/HII_DIM\n\tshape = (N,N,N)\n\t\n\tMRGgen = MRG32k3aRandomNumberGenerator(seed_getter=seed_getter_uniform, offset=0)\n\n\tkernel_source = open(cmd_folder+\"/initialize.cu\").read()\n\tkernel_code = kernel_source % {\n\n\t\t'DELTAK': DELTA_K,\n\t\t'VOLUME': VOLUME,\n\t\t'DIM': DIM\n\t}\n\tmain_module = nvcc.SourceModule(kernel_code)\n\tinit_kernel = main_module.get_function(\"init_kernel\")\n\tHII_filter = main_module.get_function(\"HII_filter\")\n\tadj_complex_conj = main_module.get_function(\"adj_complex_conj\")\n\tsubsample_kernel = main_module.get_function(\"subsample\")\n\tvelocity_kernel = main_module.get_function(\"set_velocity\")\n\tpspec_texture = main_module.get_texref(\"pspec\")\n\n\tinterpPspec, interpSize = init_pspec() #interpPspec contains both k array and P array\n\tinterp_cu = cuda.matrix_to_array(interpPspec, order='F')\n\tcuda.bind_array_to_texref(interp_cu, pspec_texture)\n\n\tlargebox_d = gpuarray.zeros(shape, dtype=np.float32)\n\tinit_kernel(largebox_d, np.int32(DIM), block=block_size, grid=grid_size)\n\n\t#import IPython; IPython.embed()\n\tlargebox_d_imag = gpuarray.zeros(shape, dtype=np.float32)\n\tinit_kernel(largebox_d_imag, np.int32(DIM), block=block_size, grid=grid_size)\n\n\tlargebox_d *= MRGgen.gen_normal(shape, dtype=np.float32)\n\tlargebox_d_imag *= MRGgen.gen_normal(shape, dtype=np.float32)\n\tlargebox_d = largebox_d + np.complex64(1.j) * largebox_d_imag\n\n\t#adj_complex_conj(largebox_d, DIM, block=block_size, grid=grid_size)\n\tlargebox = largebox_d.get()\n\t#np.save(parent_folder+\"/Boxes/deltak_z0.00_{0:d}_{1:.0f}Mpc\".format(DIM, BOX_LEN), largebox)\n\n\t#save real space box before smoothing\n\tplan = Plan(shape, dtype=np.complex64)\n\tplan.execute(largebox_d, inverse=True) #FFT to real space of smoothed box\n\tlargebox_d /= scale**3\n\tnp.save(parent_folder+\"/Boxes/deltax_z0.00_{0:d}_{1:.0f}Mpc\".format(DIM, BOX_LEN), largebox_d.real.get_async())\n\n\t#save real space box after smoothing and subsampling\n\t# host largebox is still in k space, no need to reload from disk\n\tlargebox_d = gpuarray.to_gpu(largebox)\n\tsmoothR = np.float32(L_FACTOR*BOX_LEN/HII_DIM)\n\tHII_filter(largebox_d, N, ZERO, smoothR, block=block_size, grid=grid_size);\n\tplan.execute(largebox_d, inverse=True) #FFT to real space of smoothed box\n\tlargebox_d /= scale**3\n\tsmallbox_d = gpuarray.zeros(HII_shape, dtype=np.float32)\n\tsubsample_kernel(largebox_d.real, smallbox_d, N, HII_DIM, PIXEL_FACTOR, block=block_size, grid=HII_grid_size) #subsample in real space\n\tnp.save(parent_folder+\"/Boxes/smoothed_deltax_z0.00_{0:d}_{1:.0f}Mpc\".format(HII_DIM, BOX_LEN), smallbox_d.get_async())\n\n\t# reload the k-space box for velocity boxes\n\tlargebox_d = gpuarray.to_gpu(largebox)\n\t\n\t#largebox_d /= VOLUME #divide by VOLUME if using fft (vs ifft)\n\tsmoothR = np.float32(L_FACTOR*BOX_LEN/HII_DIM)\n\tlargevbox_d = gpuarray.zeros((DIM,DIM,DIM), dtype=np.complex64)\n\tsmallbox_d = gpuarray.zeros(HII_shape, dtype=np.float32)\n\tfor num, mode in enumerate(['x', 'y', 'z']):\n\t\tvelocity_kernel(largebox_d, largevbox_d, DIM, np.int32(num), block=block_size, grid=grid_size)\n\t\tHII_filter(largevbox_d, DIM, ZERO, smoothR, block=block_size, grid=grid_size)\n\t\tplan.execute(largevbox_d, inverse=True)\n\t\tlargevbox_d /= scale**3\n\t\t#import IPython; IPython.embed()\n\t\tsubsample_kernel(largevbox_d.real, smallbox_d, DIM, HII_DIM,PIXEL_FACTOR, block=block_size, grid=HII_grid_size)\n\t\tnp.save(parent_folder+\"/Boxes/v{0}overddot_{1:d}_{2:.0f}Mpc\".format(mode, HII_DIM, BOX_LEN), smallbox_d.get())\n\n\treturn","def load_model(self, gpus=1):\r\n\t\t\r\n\t\tif self.model != None:\r\n\t\t\treturn\r\n\r\n\t\t## build the model on the CPU if parallelism is targeted\r\n\t\tif isinstance(gpus, Sequence):\r\n\t\t\tif len(gpus) != 1:\r\n\t\t\t\tdevice = \"/cpu:0\"\r\n\t\t\t\tmultigpu = True\r\n\t\t\telse:\r\n\t\t\t\tdevice = \"/gpu:{:d}\".format(gpus[0])\r\n\t\t\t\tmultigpu = False\r\n\t\telse:\r\n\t\t\tif gpus != 1:\r\n\t\t\t\tdevice = \"/cpu:0\"\r\n\t\t\t\tmultigpu = True\r\n\t\t\telse:\r\n\t\t\t\tdevice = \"/gpu:{:d}\".format(gpus)\r\n\t\t\t\tmultigpu = False\r\n\r\n\r\n\t\tif self.__prop__(\"Resume\"):\r\n\t\t\tself.model = keras.models.load_model(\r\n\t\t\t\tself.__prop__(\"SnapshotDirectory\") + self.__prop__(\"Prefix\") + self.__prop__(\"Resume\") + '.h5\"')\r\n\t\t\tself.single_model = self.model\r\n\t\t\tif multigpu:\r\n\t\t\t\tself.model = multi_gpu_model(self.model, gpus)\r\n\t\telse: \r\n\t\t\t\r\n\t\t\twith tensorflow.device(device):\r\n\t\t\t\tif self.__prop__(\"Prefix\").startswith(\"i3PosNet_VGG16\"):\r\n\t\t\t\t\tself.model = i3PosNetVGG(\r\n\t\t\t\t\t\tinput_shape=self.__prop__(\"InputShape\"), \r\n\t\t\t\t\t\tout_number=self.__prop__(\"TargetShape\"),\r\n\t\t\t\t\t\tlayer_count=self.__prop__(\"LayerCount\"), \r\n\t\t\t\t\t\tfc_layer_count=self.__prop__(\"FCLayerCount\"), \r\n\t\t\t\t\t\tfc_reg=self.__prop__(\"FCReg\"), \r\n\t\t\t\t\t\tconv_reg=self.__prop__(\"ConvReg\"), \r\n\t\t\t\t\t\tshrinking=self.__prop__(\"Shrinking\"),\r\n\t\t\t\t\t\tpadding=self.__prop__(\"Padding\"))\r\n\t\t\t\telse:\r\n\t\t\t\t\tself.model = i3PosNet(image_shape, out = self.__prop__(\"TargetShape\"))\r\n\r\n\t\t\tself.single_model = self.model\r\n\t\t\tif multigpu:\r\n\t\t\t\tself.model = multi_gpu_model(self.model, gpus)\r\n\t\t\t\t\r\n\t\t\t# clear model\r\n\t\t\t# try:\r\n\t\t\t\t# del self.model\r\n\t\t\t# except:\r\n\t\t\t\t# pass\r\n\r\n\t\t\tif self.__prop__(\"Optimizer\") == \"SGD\":\r\n\t\t\t\toptimizer = SGD(\r\n\t\t\t\t\tlr=self.__prop__(\"BaseLR\"),\r\n\t\t\t\t\tdecay=self.__prop__(\"Gamma\") if self.__prop__(\"LRPolicy\") == \"decay\" else 0.,\r\n\t\t\t\t\tmomentum= self.__prop__(\"Momentum\"),\r\n\t\t\t\t\tnesterov=True)\r\n\t\t\telif self.__prop__(\"Optimizer\") == \"Adam\":\r\n\t\t\t\toptimizer = Adam(\r\n\t\t\t\t\tlr=self.__prop__(\"BaseLR\"),\r\n\t\t\t\t\tdecay=self.__prop__(\"Gamma\") if self.__prop__(\"LRPolicy\") == \"decay\" else 0.,\r\n\t\t\t\t\t# use defaults for these for now (b1 = 0.9, b2 = 0.999, e = 1e-8\r\n\t\t\t\t\tbeta_1=self.__prop__(\"Beta1\"),\r\n\t\t\t\t\tbeta_2=self.__prop__(\"Beta2\"),\r\n\t\t\t\t\tepsilon=self.__prop__(\"Epsilon\")\r\n\t\t\t\t\t)\r\n\t\t\t\r\n\t\t\tself.model.compile(loss='mean_squared_error', optimizer=optimizer)","def cuda_if_gpu(T):\n\n return T.cuda() if use_cuda else T","def cudaLoader(model, train_set, val_set):\n device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n # device = ('cpu') # comment/uncomment to use GPU\n print(\"device:\\t\", device)\n\n if torch.cuda.device_count() > 1:\n print(\"Let's use\", torch.cuda.device_count(), \"GPUs!\")\n # dim = 0 [30, xxx] -> [10, ...], [10, ...], [10, ...] on 3 GPUs\n model = nn.DataParallel(model)\n\n model.to(dtype = torch.double) #typecasting\n train_set = train_set.to(device)\n val_set = val_set.to(device)\n model = model.to(device);\n return model, train_set, val_set","def test_nvidia_driver2():\r\n a = numpy.random.rand(10000).astype(\"float32\")\r\n cuda.shared_constructor(a)\r\n assert theano.sandbox.cuda.use.device_number is not None","def train_on_device(data_dir, dataset_id, model_path, ckpt_path, weight_updates_path):\r\n\r\n # Store pre-trained model and weights\r\n old_model = load_model(model_path)\r\n old_model.load_weights(ckpt_path)\r\n\r\n # Initialize model and checkpoint, which are obtained from server\r\n device_model = load_model(model_path)\r\n device_model.load_weights(ckpt_path)\r\n\r\n # print(device_model.summary())\r\n\r\n # load the vocabulary\r\n vocab_filename = os.path.join(data_dir, \"vocab.txt\")\r\n vocab = load_doc(vocab_filename)\r\n vocab = vocab.split()\r\n vocab = set(vocab)\r\n\r\n # create the tokenizer\r\n tokenizer = Tokenizer()\r\n\r\n # loading tokenizer from file\r\n tokenizer_filename = os.path.join(data_dir, \"tokenizer.pickle\")\r\n with open(tokenizer_filename, \"rb\") as handle:\r\n tokenizer = pickle.load(handle)\r\n\r\n # Get training data present on device\r\n X_train, y_train = get_data(data_dir, dataset_id, vocab, tokenizer, is_train=True)\r\n\r\n X_test, y_test = get_data(data_dir, dataset_id, vocab, tokenizer, is_train=False)\r\n\r\n scores = device_model.evaluate(X_test, y_test, verbose=0)\r\n print(\"Test Accuracy(before training): %.2f%%\" % (scores[1] * 100))\r\n\r\n # Train model\r\n device_model.fit(\r\n X_train, y_train, epochs=NUM_EPOCHS, batch_size=BATCH_SIZE,\r\n )\r\n\r\n scores = device_model.evaluate(X_test, y_test, verbose=0)\r\n print(\"Test Accuracy(after training): %.2f%%\" % (scores[1] * 100))\r\n\r\n # Load model to store weight updates\r\n weight_updates = load_model(model_path)\r\n\r\n # Number of batches trained on device\r\n num_batches = X_train.shape[0] // BATCH_SIZE\r\n\r\n # Calculate weight updates\r\n for i in range(len(device_model.layers)):\r\n\r\n # Pre-trained weights\r\n old_layer_weights = old_model.layers[i].get_weights()\r\n\r\n # Post-trained weights\r\n new_layer_weights = device_model.layers[i].get_weights()\r\n\r\n # Weight updates calculation\r\n weight_updates.layers[i].set_weights(\r\n num_batches\r\n * (np.asarray(new_layer_weights) - np.asarray(old_layer_weights)),\r\n )\r\n\r\n # print(\"old weights: \", old_layer_weights)\r\n # print(\"new weights: \", new_layer_weights)\r\n # print(\"weight updates: \", weight_updates.layers[i].get_weights())\r\n\r\n # Save weight updates\r\n weight_updates.save_weights(weight_updates_path)\r\n\r\n return (num_batches, weight_updates_path)","def __init__(self):\n \n self.model = Net()\n\n if torch.cuda.is_available():\n map_location=torch.device('cuda')\n else:\n map_location=torch.device('cpu')\n\n # load parameters\n self.model.load_state_dict(torch.load('model.pt',\n map_location=map_location)) \n \n if torch.cuda.is_available():\n self.model.cuda()\n else:\n self.model.cpu()\n \n self.model.eval()","def EnableCUDA(gpu_id=0, use_cudnn=True):\n global option\n option['device'] = 'CUDA'\n option['device_id'] = gpu_id\n option['use_cudnn'] = use_cudnn","def main():\n args = arg_parser()\n if(args.gpu):\n gpu = args.gpu\n else:\n print(\"GPU mode not specified, will use the default value - Use GPU\")\n gpu = \"Y\"\n # Device setting:\n device = device_setting(gpu)\n \n # Prepare the datasets and dataloaders:\n print(\"\\nPreparing dataset for train/valid/test ...\")\n train_loader, valid_loader, test_loader, train_data, valid_data, test_data = load_dataset()\n \n # Model architects, criterion and optimizer:\n print(\"\\nNetwork archetecture building ...\")\n model, criterion, optimizer = network(device=device,\n architecture=args.architecture,\n learning_rate=args.learning_rate,\n hidden_size=args.hidden_size,\n dropout=args.dropout,\n output_size=args.output_size)\n \n # Train the model:\n print(\"\\n\")\n model = train(model=model,\n epochs=5,\n learning_rate=args.learning_rate,\n criterion=criterion,\n optimizer=optimizer,\n train_loader=train_loader,\n valid_loader=valid_loader,\n device=device)\n \n # Validate the model performance on the test set:\n print(\"\\nValidate model performance on test set ...\")\n test(model=model, test_loader=test_loader, device=device)\n \n # Save model checkpoint:\n print(\"\\nSave model checkpoint ...\")\n save(model=model, train_data=train_data, epochs=args.epochs, architecture=args.architecture)","def set_devices_for_ml(sys_device_ids):\n import os\n\n all_ids = []\n for ids in sys_device_ids:\n all_ids += ids\n unique_sys_device_ids = list(set(all_ids))\n unique_sys_device_ids.sort()\n if -1 in unique_sys_device_ids:\n unique_sys_device_ids.remove(-1)\n\n # Set the CUDA_VISIBLE_DEVICES environment variable\n\n visible_devices = ''\n for i in unique_sys_device_ids:\n visible_devices += '{}, '.format(i)\n os.environ['CUDA_VISIBLE_DEVICES'] = visible_devices\n\n # Return wrappers\n\n relative_device_ids = []\n TVTs, TMOs = [], []\n for ids in sys_device_ids:\n relative_ids = []\n for id in ids:\n if id != -1:\n id = find_index(unique_sys_device_ids, id)\n relative_ids.append(id)\n relative_device_ids.append(relative_ids)\n\n # Models and user defined Variables/Tensors would be transferred to the\n # first device.\n TVTs.append(TransferVarTensor(relative_ids[0]))\n TMOs.append(TransferModulesOptims(relative_ids[0]))\n return TVTs, TMOs, relative_device_ids","def try_gpu(i=0): #@save\n if len(tf.config.experimental.list_physical_devices('GPU')) >= i + 1:\n return tf.device(f'/GPU:{i}')\n return tf.device('/CPU:0')","def set_cuda(self, is_cuda):\n self.is_cuda = is_cuda","def set_devices(sys_device_ids):\n # Set the CUDA_VISIBLE_DEVICES environment variable\n import os\n visible_devices = ''\n for i in sys_device_ids:\n visible_devices += '{}, '.format(i)\n os.environ['CUDA_VISIBLE_DEVICES'] = visible_devices\n # Return wrappers.\n # Models and user defined Variables/Tensors would be transferred to the\n # first device.\n device_id = 0 if len(sys_device_ids) > 0 else -1\n TVT = TransferVarTensor(device_id)\n TMO = TransferModulesOptims(device_id)\n return TVT, TMO","def get_device(args: dict) -> torch.device:\n\n if is_distributed(args):\n device = torch.device(\"cuda\", args.local_rank)\n else:\n if torch.cuda.is_available():\n device = torch.device(\"cuda\", 0)\n else:\n device = torch.device(\"cpu\")\n return device","def get_device(arguments):\n\n # Checks if the GPU is available to be used and sets the .\n if arguments.gpu and torch.cuda.is_available():\n return torch.device(f\"cuda:{torch.cuda.device_count() - 1}\")\n\n # Sets the device to CPU.\n else:\n return torch.device(\"cpu\")","def trainer(current_gpu, args):\n\n model_history = train_utils.init_model_history()\n batch_size = args.batch_size\n num_epochs = args.num_epochs\n feature_extract = False\n\n model = train_utils.initialize_ft_model(args.model_name, num_classes=args.num_classes, feature_extract=feature_extract)\n model, args = dist_setting(current_gpu, model, args)\n logger.info(f\"==> Training on rank {args.rank}.\")\n logger.info(args)\n \n dataloaders, transforms, train_sampler = train_utils.create_dataloaders(\n args.train_dir, args.valid_dir, rank=args.rank, \n world_size=args.world_size, batch_size=batch_size,\n num_workers=args.num_workers\n )\n \n optimizer = train_utils.initialize_optimizer(model, feature_extract, lr=args.lr*args.world_size, momentum=0.9) \n criterion = nn.CrossEntropyLoss()\n\n since = time.time()\n val_acc_history = []\n best_model_wts = copy.deepcopy(model.state_dict())\n best_acc1 = 0.0\n num_samples = {k: len(dataloaders[k].dataset) for k, v in dataloaders.items()}\n num_steps = {k: int(np.ceil(len(dataloaders[k].dataset) / (batch_size*args.world_size))) for k, v in dataloaders.items()}\n device = torch.device(f'cuda:{current_gpu}') \n\n for epoch in range(1, num_epochs+1):\n \n batch_time = train_utils.AverageMeter('Time', ':6.3f')\n data_time = train_utils.AverageMeter('Data', ':6.3f')\n losses = train_utils.AverageMeter('Loss', ':.4e')\n top1 = train_utils.AverageMeter('Acc@1', ':6.2f')\n \n logger.info('-' * 40)\n logger.info('[Rank {}, Epoch {}/{}] Processing...'.format(args.rank, epoch, num_epochs))\n logger.info('-' * 40)\n\n # Each epoch has a training and validation phase\n for phase in ['train', 'valid']: \n\n if phase == 'train':\n model.train() # Set model to training mode\n if args.multigpus_distributed:\n dataloaders[phase].sampler.set_epoch(epoch) # Set epoch count for DistributedSampler \n else:\n model.eval() # Set model to evaluate mode\n\n running_loss = 0.0\n running_corrects = 0\n epoch_tic = time.time() \n tic = time.time()\n \n for i, (inputs, labels) in enumerate(dataloaders[phase]):\n # measure data loading time\n data_time.update(time.time() - tic) \n \n inputs = inputs.to(device)\n labels = labels.to(device)\n\n optimizer.zero_grad()\n\n with torch.set_grad_enabled(phase=='train'):\n outputs = model(inputs)\n loss = criterion(outputs, labels)\n probs, preds = torch.max(outputs, 1)\n \n # Compute gradient and do stochastic gradient descent\n if phase == 'train':\n loss.backward()\n optimizer.step()\n \n running_loss += loss.item() * inputs.size(0)\n running_corrects += torch.sum(preds == labels.data)\n acc1 = train_utils.accuracy(outputs, labels, topk=(1,))\n \n # Average loss and accuracy across processes for logging\n if args.multigpus_distributed:\n reduced_loss = train_utils.reduce_tensor(loss.data, args)\n reduced_acc1 = train_utils.reduce_tensor(acc1[0], args)\n else:\n reduced_loss = loss.data\n reduced_acc1 = acc1[0]\n\n losses.update(train_utils.to_python_float(reduced_loss), inputs.size(0))\n top1.update(train_utils.to_python_float(reduced_acc1), inputs.size(0))\n \n # measure elapsed time\n batch_time.update(time.time() - tic)\n tic = time.time()\n\n if phase == 'train' and i % args.log_interval == 0:\n step_loss = running_loss / ((i+1)*batch_size)\n step_acc = running_corrects.double() / ((i+1)*batch_size)\n logger.info(f'[Rank {args.rank}, Epoch {epoch}/{num_epochs}, Step {i+1}/{num_steps[phase]}] {phase}-acc: {step_acc:.4f}, '\n f'{phase}-loss: {step_loss:.4f}, data-time: {data_time.val:.4f}, batch-time: {batch_time.val:.4f}') \n \n\n ## Waiting until finishing operations on GPU (Pytorch default: async)\n torch.cuda.synchronize()\n \n if current_gpu == 0: \n logger.info(f'[Epoch {epoch}/{num_epochs}] {phase}-acc: {top1.avg:.4f}, '\n f'{phase}-loss: {losses.val:.4f}, time: {time.time()-epoch_tic:.4f}') \n \n model_history['epoch'].append(epoch)\n model_history['batch_idx'].append(i)\n model_history['data_time'].append(data_time.val) \n model_history['batch_time'].append(batch_time.val)\n model_history['losses'].append(losses.val)\n model_history['top1'].append(top1.val)\n\n if phase == 'valid':\n is_best = top1.avg > best_acc1\n best_acc1 = max(top1.avg, best_acc1)\n \n if (args.multigpus_distributed and args.rank % args.num_gpus == 0):\n #train_utils.save_history(os.path.join(args.output_data_dir, 'model_history.p'), model_history) \n train_utils.save_model({\n 'epoch': epoch + 1,\n 'model_name': args.model_name,\n 'state_dict': model.module.state_dict(),\n 'optimizer': optimizer.state_dict(),\n 'best_acc1': best_acc1,\n 'loss': losses\n }, is_best, args.model_chkpt_dir, args.model_dir)\n elif not args.multigpus_distributed:\n #train_utils.save_history(os.path.join(args.output_data_dir, 'model_history.p'), model_history) \n train_utils.save_model({\n 'epoch': epoch + 1,\n 'model_name': args.model_name,\n 'state_dict': model.state_dict(),\n 'optimizer': optimizer.state_dict(),\n 'best_acc1': best_acc1,\n 'loss': losses\n }, is_best, args.model_chkpt_dir, args.model_dir) \n \n \n time_elapsed = time.time() - since\n if current_gpu == 0:\n logger.info('Training complete in {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60))\n logger.info('Best val acc: {:.4f}'.format(best_acc1))\n \n if args.multigpus_distributed:\n dist_cleanup()","def config_keras() -> None:\n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True\n kbackend.tensorflow_backend.set_session(tf.Session(config=config))","def model_device(model):\n # Source: https://discuss.pytorch.org/t/how-to-check-if-model-is-on-cuda/180\n try:\n return str(next(model.parameters()).device)\n except StopIteration:\n # Model has no parameters\n pass\n return 'cpu'","def __init__(self, *args, **kwargs):\n super(MadryEtAlMultiGPU, self).__init__(*args, **kwargs)\n self.structural_kwargs += ['ngpu']","def is_gpu_available() -> bool:\n return torch.cuda.is_available()"],"string":"[\n \"def setup_device(n_gpus: int) -> object:\\n if n_gpus >= 1 and torch.cuda.is_available():\\n LOG.info('\\\\n CUDA is available! using GPU...')\\n return torch.device('cuda')\\n else:\\n LOG.info('\\\\n Using CPU...')\\n return torch.device('cpu')\",\n \"def create_gpu_device_if_present():\\n d = dpctl.SyclDevice(\\\"gpu,cpu\\\")\\n print(\\\"Selected \\\" + (\\\"GPU\\\" if d.is_gpu else \\\"CPU\\\") + \\\" device\\\")\",\n \"def set_device(device, backend='autograd'):\\n if backend == 'autograd':\\n return None\\n elif backend == 'pytorch':\\n try:\\n tc.cuda.set_device(device)\\n except:\\n pass\",\n \"def device_placement(self):\\n if is_tf_available():\\n import tensorflow as tf\\n with tf.device('/CPU:0' if self.device == -1 else '/device:GPU:{}'.format(self.device)):\\n yield\\n else:\\n import torch\\n if self.device >= 0:\\n torch.cuda.set_device(self.device)\\n\\n yield\",\n \"def setup_gpu(use_gpu: int, silent=None) -> None:\\n if silent is None:\\n local_msg = Printer()\\n else:\\n local_msg = Printer(no_print=silent, pretty=not silent)\\n if use_gpu >= 0:\\n local_msg.info(f\\\"Using GPU: {use_gpu}\\\")\\n require_gpu(use_gpu)\\n else:\\n local_msg.info(\\\"Using CPU\\\")\\n if gpu_is_available():\\n local_msg.info(\\\"To switch to GPU 0, use the option: --gpu-id 0\\\")\",\n \"def setup_device(gpuid=None):\\n\\n if gpuid is not None and not isinstance(gpuid, str):\\n gpuid = str(gpuid)\\n\\n if gpuid is not None:\\n nb_devices = len(gpuid.split(','))\\n else:\\n nb_devices = 1\\n\\n if gpuid is not None and (gpuid != '-1'):\\n device = '/gpu:' + gpuid\\n os.environ['CUDA_VISIBLE_DEVICES'] = gpuid\\n\\n # GPU memory configuration differs between TF 1 and 2\\n if hasattr(tf, 'ConfigProto'):\\n config = tf.ConfigProto()\\n config.gpu_options.allow_growth = True\\n config.allow_soft_placement = True\\n tf.keras.backend.set_session(tf.Session(config=config))\\n else:\\n tf.config.set_soft_device_placement(True)\\n for pd in tf.config.list_physical_devices('GPU'):\\n tf.config.experimental.set_memory_growth(pd, True)\\n else:\\n device = '/cpu:0'\\n os.environ['CUDA_VISIBLE_DEVICES'] = '-1'\\n\\n return device, nb_devices\",\n \"def _create_device(self):\\n return torch.device(\\\"cuda\\\" if torch.cuda.is_available() else \\\"cpu\\\")\",\n \"def cuda(self):\\n if torch.cuda.is_available():\\n self.automata = self.automata.cuda()\\n self.inv_automata = self.inv_automata.cuda()\\n self.action = self.action.cuda()\\n self.inv_action = self.inv_action.cuda()\",\n \"def configure_gpu_tf():\\n\\n try:\\n # locate available devices & set required environment variables\\n available_device_ids = GPUtil.getFirstAvailable(order='first', maxLoad=0.7, maxMemory=0.7, attempts=1, interval=10)\\n available_device_id = available_device_ids[0]\\n os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'\\n os.environ['CUDA_VISIBLE_DEVICES'] = str(available_device_id)\\n print(f\\\"\\\\n GPU Found! running on GPU:{available_device_id}\\\\n\\\")\\n\\n # set GPU configuration (use all GPU memory if device 0, else use <50% of memory)\\n tf.debugging.set_log_device_placement(False)\\n physical_gpu = tf.config.experimental.list_physical_devices('GPU')[0]\\n\\n if available_device_id == 0:\\n tf.config.experimental.set_memory_growth(physical_gpu, True)\\n else:\\n tf.config.experimental.set_virtual_device_configuration(\\n physical_gpu,\\n [tf.config.experimental.VirtualDeviceConfiguration(memory_limit=4500)]\\n )\\n logical_gpus = tf.config.experimental.list_logical_devices('GPU')\\n assert len(logical_gpus) == 1, \\\"error creating virtual GPU to fractionally use memory\\\"\\n\\n # if we can't find a GPU, or they are all busy, default to using CPU\\n except RuntimeError:\\n print(\\\"\\\\n No GPUs available... running on CPU\\\\n\\\")\\n os.environ['CUDA_VISIBLE_DEVICES'] = '-1'\",\n \"def setup_device(device):\\n try:\\n # Gets around \\\"Resource busy\\\" errors\\n device.detach_kernel_driver(0)\\n except Exception:\\n pass\\n device.set_configuration()\",\n \"def move2gpu(self):\\n if self.generator.backend.upper() == \\\"LOOPY\\\":\\n try:\\n import pyopencl as cl\\n import pyopencl.array # pylint: disable=unused-variable\\n from .context import queue\\n except ImportError:\\n raise ImportError(\\\"Please install loo.py\\\")\\n\\n self.rhs = cl.array.to_device(queue, self.rhs)\\n if hasattr(self, \\\"s\\\"):\\n self.s = cl.array.to_device(\\n queue, self.s\\n ) # pylint: disable=attribute-defined-outside-init\\n self.istore = cl.array.to_device(queue, self.istore)\\n for i in range(len(self.iload)):\\n self.iload[i] = cl.array.to_device(queue, self.iload[i])\",\n \"def set_current_device_id():\\n import paddle\\n curr_dev = paddle.device.get_device()\\n select_gpu = os.getenv(\\\"FLAGS_selected_gpus\\\", \\\"0\\\")\\n paddle.set_flags({\\n 'FLAGS_selected_gpus': os.getenv(\\\"FLAGS_selected_gpus\\\", \\\"0\\\")\\n })\\n if \\\"gpu\\\" in curr_dev and select_gpu != curr_dev.split(\\\":\\\")[-1]:\\n paddle.set_device(\\\"gpu:\\\" + select_gpu)\\n\\n curr_dev_id = paddle.framework.core.get_cuda_current_device_id()\\n if \\\"gpu\\\" in curr_dev and select_gpu != str(curr_dev_id):\\n paddle.zeros([])\",\n \"def setGPU(state):\\n\\n\\timport tensorflow as tf\\n\\tfrom keras import backend as K\\n\\n\\tcheckGPU()\\n\\n\\tnum_cores = 1\\n\\tnum_CPU = 1\\n\\tnum_GPU = 0\\n\\tif state:\\n\\t\\tnum_GPU = 1\\n\\n\\tconfig = tf.ConfigProto(intra_op_parallelism_threads=num_cores,\\\\\\n\\t inter_op_parallelism_threads=num_cores, allow_soft_placement=True,\\\\\\n\\t device_count = {'CPU' : num_CPU, 'GPU' : num_GPU})\\n\\tsession = tf.Session(config=config)\\n\\tK.set_session(session)\",\n \"def _setup_gpu_environment() -> None:\\n gpu_memory_config = os.getenv(ENV_GPU_CONFIG)\\n\\n if not gpu_memory_config:\\n return\\n\\n # Import from tensorflow only if necessary (environment variable was set)\\n from tensorflow import config as tf_config\\n\\n parsed_gpu_config = _parse_gpu_config(gpu_memory_config)\\n physical_gpus = tf_config.list_physical_devices(\\\"GPU\\\")\\n\\n # Logic taken from https://www.tensorflow.org/guide/gpu\\n if physical_gpus:\\n for gpu_id, gpu_id_memory in parsed_gpu_config.items():\\n _allocate_gpu_memory(physical_gpus[gpu_id], gpu_id_memory)\\n\\n else:\\n rasa.shared.utils.io.raise_warning(\\n f\\\"You have an environment variable '{ENV_GPU_CONFIG}' set but no GPUs were \\\"\\n f\\\"detected to configure.\\\"\\n )\",\n \"def set_device(sys_device_id):\\n device_id = -1\\n cuda = (sys_device_id != -1)\\n if cuda:\\n # CUDA_VISIBLE_DEVICE is a list, and device_id is the index of its members.\\n import os\\n os.environ['CUDA_VISIBLE_DEVICES'] = str(sys_device_id)\\n device_id = 0\\n TVT = TransferVarTensor(device_id)\\n TMO = TransferModulesOptims(device_id)\\n return TVT, TMO\",\n \"def set_device(self, cuda=True):\\n if cuda and torch.cuda.is_available():\\n self.cuda = True\\n self.device = torch.device('cuda')\\n else:\\n self.cuda = False\\n self.device = torch.device('cpu')\\n\\n if self.verbose:\\n if not cuda:\\n print('Using CPU device')\\n elif not self.cuda:\\n print('CUDA is not available. Defaulting to CPU device')\\n else:\\n print('Using CUDA device')\\n\\n self.encoder.to(self.device)\\n self.decoder.to(self.device)\\n self.critic.to(self.device)\",\n \"def set_device(in_arg): \\n \\n return torch.device(\\\"cuda\\\" if torch.cuda.is_available() and in_arg.gpu == 1 else \\\"cpu\\\")\",\n \"def dist_setting(current_gpu, model, args):\\n print(\\\"channels_last : {}\\\".format(args.channels_last))\\n if args.channels_last:\\n args.memory_format = torch.channels_last\\n else:\\n args.memory_format = torch.contiguous_format\\n\\n if args.apex:\\n args.lr = args.lr*float(args.batch_size*args.world_size)/256.\\n args.current_gpu = current_gpu\\n if args.current_gpu is not None:\\n print(\\\"Use GPU: {} for training\\\".format(args.current_gpu))\\n\\n if args.multigpus_distributed:\\n args.rank = args.num_gpus * args.host_num + args.current_gpu\\n dist.init_process_group(backend=args.backend,\\n rank=args.rank, world_size=args.world_size)\\n logger.info('Initialized the distributed environment: \\\\'{}\\\\' backend on {} nodes. '.format(\\n args.backend, dist.get_world_size()) + 'Current host rank is {}. Number of gpus: {}'.format(\\n dist.get_rank(), args.num_gpus))\\n else:\\n args.rank = 0\\n\\n if args.sync_bn:\\n import apex\\n print(\\\"using apex synced BN\\\")\\n model = apex.parallel.convert_syncbn_model(model)\\n\\n if args.multigpus_distributed:\\n if args.current_gpu is not None:\\n torch.cuda.set_device(args.current_gpu)\\n args.batch_size = int(args.batch_size / args.num_gpus)\\n logger.info(\\\"Batch size for each GPU: {}\\\".format(args.batch_size))\\n if not args.apex:\\n model.cuda(args.current_gpu)\\n model = torch.nn.parallel.DistributedDataParallel(\\n model, device_ids=[args.current_gpu])\\n else:\\n if not args.apex:\\n model.cuda()\\n model = torch.nn.parallel.DistributedDataParallel(model)\\n elif args.current_gpu is not None:\\n torch.cuda.set_device(args.current_gpu)\\n if not args.apex:\\n model = model.cuda(args.current_gpu)\\n else:\\n if not args.apex:\\n model = torch.nn.DataParallel(model).cuda()\\n\\n return model, args\",\n \"def set_gpu(gpus):\\n os.environ[\\\"CUDA_DEVICE_ORDER\\\"] = \\\"PCI_BUS_ID\\\"\\n os.environ[\\\"CUDA_VISIBLE_DEVICES\\\"] = gpus\",\n \"def set_device(gpu_arg):\\n\\n dev = 'cpu'\\n if gpu_arg and torch.cuda.is_available():\\n dev = 'cuda'\\n elif gpu_arg:\\n print('Not gpu found. Using cpu instead.') \\n\\n return torch.device(dev)\",\n \"def setup_device(self, conf: DictConfig) -> device:\\n device = torch.device(conf.runner.device) if torch.cuda.is_available() else torch.device('cpu')\\n\\n return device\",\n \"def prepare_device(n_gpu_use):\\n n_gpu = torch.cuda.device_count()\\n if n_gpu_use > 0 and n_gpu == 0:\\n print(\\\"Warning: There\\\\'s no GPU available on this machine,\\\"\\n \\\"training will be performed on CPU.\\\")\\n n_gpu_use = 0\\n if n_gpu_use > n_gpu:\\n print(\\\"Warning: The number of GPU\\\\'s configured to use is {}, but only {} are available \\\"\\n \\\"on this machine.\\\".format(n_gpu_use, n_gpu))\\n n_gpu_use = n_gpu\\n device = torch.device('cuda:0' if n_gpu_use > 0 else 'cpu')\\n list_ids = list(range(n_gpu_use))\\n return device, list_ids\",\n \"def torch_setup(device_type=None, gpu_offset=0):\\n from mpi4py import MPI\\n import torch\\n\\n if device_type is None:\\n device_type = \\\"cuda\\\" if torch.cuda.is_available() else \\\"cpu\\\"\\n\\n local_rank, local_size = _get_local_rank_size(MPI.COMM_WORLD)\\n if device_type == \\\"cuda\\\":\\n device_index = (local_rank + gpu_offset) % torch.cuda.device_count()\\n torch.cuda.set_device(device_index)\\n else:\\n device_index = 0\\n if \\\"RCALL_NUM_CPU_PER_PROC\\\" in os.environ:\\n num_threads = int(os.environ[\\\"RCALL_NUM_CPU_PER_PROC\\\"])\\n else:\\n num_threads = max(round(mp.cpu_count() // 2 / local_size), 1)\\n torch.set_num_threads(num_threads)\\n return torch.device(type=device_type, index=device_index)\",\n \"def prepare_device(n_gpu_use):\\n n_gpu = torch.cuda.device_count()\\n if n_gpu_use > 0 and n_gpu == 0:\\n print(\\\"Warning: There\\\\'s no GPU available on this machine,\\\"\\n \\\"training will be performed on CPU.\\\")\\n n_gpu_use = 0\\n if n_gpu_use > n_gpu:\\n print(f\\\"Warning: The number of GPU\\\\'s configured to use is {n_gpu_use}, but only {n_gpu} are \\\"\\n \\\"available on this machine.\\\")\\n n_gpu_use = n_gpu\\n device = torch.device('cuda:0' if n_gpu_use > 0 else 'cpu')\\n list_ids = list(range(n_gpu_use))\\n return device, list_ids\",\n \"def prepare_device(n_gpu_use):\\n n_gpu = torch.cuda.device_count()\\n if n_gpu_use > 0 and n_gpu == 0:\\n print(\\\"Warning: There\\\\'s no GPU available on this machine,\\\"\\n \\\"training will be performed on CPU.\\\")\\n n_gpu_use = 0\\n if n_gpu_use > n_gpu:\\n print(f\\\"Warning: The number of GPU\\\\'s configured to use is {n_gpu_use}, but only {n_gpu} are \\\"\\n \\\"available on this machine.\\\")\\n n_gpu_use = n_gpu\\n device = torch.device('cuda:0' if n_gpu_use > 0 else 'cpu')\\n list_ids = list(range(n_gpu_use))\\n return device, list_ids\",\n \"def prepare_model_optimizer_and_scheduler(self):\\n\\n ###################################################################\\n # MODEL PREPARATION\\n # -----------------\\n # - step 1: Initialize a random model from config\\n # - step 2: Load model weights from checkpoint if any\\n # - step 3: Move model to device (GPU)\\n ###################################################################\\n\\n # Initialize a random model according to a specific config:\\n # NOTE: here we load from a physical path instead of using a keyword\\n # as compute nodes may not allow downloading from online hubs\\n if self.is_character_bert:\\n model_config = CharacterBertConfig.from_pretrained(\\n os.path.join(WORKDIR, 'data', 'character-bert'))\\n model = CharacterBertForPreTraining(model_config)\\n else:\\n model_config = BertConfig.from_pretrained(\\n os.path.join(WORKDIR, 'data', 'bert-base-uncased'))\\n model = BertForPreTraining(model_config)\\n if self.is_main_process:\\n logging.info(\\n \\\"Initialized %s using Config:\\\\n%s\\\",\\n \\\"CharacterBERT\\\" if self.is_character_bert else \\\"BERT\\\",\\n model_config\\n )\\n\\n # Load checkpoint if any:\\n if not self.resume_pretraining:\\n # CASE: no checkpoint -> training from scratch\\n self.global_step = 0\\n if self.is_main_process:\\n logging.info(\\\"Pre-training from scratch (good luck!)\\\")\\n else:\\n if self.init_checkpoint:\\n # CASE: load checkpoint from direct path\\n self.global_step = 0\\n init_checkpoint = self.init_checkpoint\\n if self.is_main_process:\\n logging.info(\\n \\\"Resuming pre-training from specific checkpoint `%s`\\\",\\n init_checkpoint\\n )\\n else:\\n # CASE: load checkpoint from resume_step\\n if self.is_main_process:\\n logging.info(\\n \\\"Resuming pre-training from step `%s`. \\\"\\n \\\"Looking inside `output_directory` for checkpoints...\\\",\\n self.resume_step\\n )\\n\\n if self.resume_step == -1:\\n # CASE: resume_step == -1, load latest checkpoint\\n model_names = [\\n fname\\n for fname in os.listdir(self.output_directory)\\n if fname.endswith(\\\".pt\\\")]\\n assert model_names, \\\"Could not find any checkpoints to resume from.\\\"\\n self.resume_step = max([\\n int(x.split('.pt')[0].split('_')[1].strip())\\n for x in model_names]) # TODO: find a better way for this\\n if self.is_main_process:\\n logging.info(\\n \\\"Resuming from latest checkpoint: ckpt_%s.pt\\\",\\n self.resume_step\\n )\\n else:\\n # CASE: resume_step == X, load checkpoint: `ckpt_X.pt`\\n if self.is_main_process:\\n logging.info(\\n \\\"Resuming from checkpoint: ckpt_%s.pt\\\",\\n self.resume_step\\n )\\n self.global_step = self.resume_step\\n init_checkpoint = os.path.join(\\n self.output_directory, f\\\"ckpt_{self.resume_step}.pt\\\")\\n\\n # Load the actual checkpoint file\\n self.checkpoint = torch.load(\\n init_checkpoint, map_location=\\\"cpu\\\"\\n )\\n\\n # NOTE: Keeping these lines below as a reminder that re-training on\\n # a different domain with CharacterBERT requires changing the\\n # output layer with a topK tokens matrix from the new domain.\\n\\n # # Case where we would retrain a general_domain CharacterBERT\\n # # on the medical domain. Don't use the general domain output layer:\\n # if self.is_medical_domain and self.is_character_bert and (not self.phase2):\\n # model.load_state_dict(\\n # {\\n # k: v for (k, v) in self.checkpoint['model'].items()\\n # # Don't load output matrix from general domain model\\n # if not k.startswith('cls.predictions') # ignoring the old output layer\\n # },\\n # strict=False)\\n # if self.is_main_process:\\n # logging.warning(\\n # \\\"Loaded model weights from `%s`, \\\"\\n # \\\"but ignored the `cls.predictions` module.\\\",\\n # init_checkpoint)\\n\\n # # General case: load weights from checkpoint\\n # else:\\n # model.load_state_dict(self.checkpoint['model'], strict=True)\\n # if self.is_main_process:\\n # logging.info('Loaded model weights from `%s`',\\n # init_checkpoint)\\n\\n # General case: load weights from checkpoint\\n model.load_state_dict(self.checkpoint['model'], strict=True)\\n if self.is_main_process:\\n logging.info('Loaded model weights from `%s`', init_checkpoint)\\n\\n # Deduce previous steps from phase1 when in phase2\\n if self.phase2 and not self.init_checkpoint:\\n self.global_step -= self.phase1_end_step\\n\\n if self.is_main_process:\\n logging.info(\\\"Training will start at global_step=%s\\\", self.global_step)\\n\\n # Move model to GPU:\\n model.to(self.device)\\n if self.is_main_process:\\n logging.info(\\\"Model was moved to device: %s\\\", self.device)\\n\\n ###################################################################\\n # OPTIMIZER / SCHEDULER PREPARATION\\n # ---------------------------------\\n # - step 1: Define the optimizer (FusedLAMB w/ some weight decay)\\n # - step 2: Define the learning rate scheduler (PolyWarmUpScheduler)\\n ###################################################################\\n\\n # Initialize an optimizer:\\n no_decay = ['bias', 'gamma', 'beta', 'LayerNorm'] # no weight decay\\n optimizer_grouped_parameters = [\\n {\\n 'params': [\\n param for name, param in model.named_parameters()\\n if not any((nd in name) for nd in no_decay)],\\n 'weight_decay': 0.01\\n },\\n {\\n 'params': [\\n param for name, param in model.named_parameters()\\n if any((nd in name) for nd in no_decay)],\\n 'weight_decay': 0.0\\n }\\n ]\\n optimizer = FusedLAMB(\\n optimizer_grouped_parameters, lr=self.learning_rate)\\n if self.is_main_process:\\n logging.info(\\\"Using optimizer: %s\\\", optimizer)\\n\\n # Initialize a learning rate scheduler:\\n self.lr_scheduler = PolyWarmUpScheduler(\\n optimizer,\\n warmup=self.warmup_proportion,\\n total_steps=self.total_steps\\n )\\n if self.is_main_process:\\n logging.info(\\\"Using scheduler: %s\\\", self.lr_scheduler)\\n\\n ###################################################################\\n # OTHER PREPARATION STEPS\\n # -----------------------\\n # - step 1: Set up Mixed Precision training (fp16) if required\\n # - step 2: Load optimizer stat from checkpoint if any\\n # - step 2: Set up DataParallel\\n ###################################################################\\n\\n # Set up fp16:\\n if self.fp16:\\n if self.is_main_process:\\n logging.info(\\\"Setting up `Almost FP16` Mixed Precision...\\\")\\n if self.loss_scale == 0:\\n model, optimizer = amp.initialize(\\n model, optimizer, opt_level=\\\"O2\\\", loss_scale=\\\"dynamic\\\")\\n else:\\n model, optimizer = amp.initialize(\\n model, optimizer, opt_level=\\\"O2\\\", loss_scale=self.loss_scale)\\n amp._amp_state.loss_scalers[0]._loss_scale = 2**20\\n\\n # Load optimizer state from checkpoint\\n if self.resume_pretraining:\\n if self.is_main_process:\\n logging.info(\\\"Loading optimizer state from checkpoint...\\\")\\n if self.phase2 or self.init_checkpoint:\\n keys = list(self.checkpoint['optimizer']['state'].keys())\\n # Override hyperparameters from previous self.checkpoint\\n for key in keys:\\n self.checkpoint['optimizer']['state'][key]['step'] = self.global_step\\n for i, _ in enumerate(self.checkpoint['optimizer']['param_groups']):\\n self.checkpoint['optimizer']['param_groups'][i]['step'] = self.global_step\\n self.checkpoint['optimizer']['param_groups'][i]['t_total'] = self.total_steps\\n self.checkpoint['optimizer']['param_groups'][i]['warmup'] = self.warmup_proportion\\n self.checkpoint['optimizer']['param_groups'][i]['lr'] = self.learning_rate\\n if self.is_main_process:\\n logging.info(\\\"Overwrote the following parameters with new values:\\\")\\n logging.info(\\\"* step: %s\\\", self.global_step)\\n logging.info(\\\"* t_total: %s\\\", self.total_steps)\\n logging.info(\\\"* warmup: %s\\\", self.warmup_proportion)\\n logging.info(\\\"* lr: %s\\\", self.learning_rate)\\n optimizer.load_state_dict(self.checkpoint['optimizer'])\\n # Restore AMP master parameters\\n if self.fp16:\\n if self.is_main_process:\\n logging.info(\\\"Restoring AMP master parameters (optimizer)...\\\")\\n optimizer._lazy_init_maybe_master_weights()\\n optimizer._amp_stash.lazy_init_called = True\\n optimizer.load_state_dict(self.checkpoint['optimizer'])\\n for param, saved_param in zip(amp.master_params(optimizer), self.checkpoint['master params']):\\n param.data.copy_(saved_param.data)\\n\\n # Distribute model\\n if self.training_is_distributed:\\n if not self.allreduce_post_accumulation:\\n model = DistributedDataParallel(\\n model,\\n message_size=250000000,\\n gradient_predivide_factor=\\\\\\n torch.distributed.get_world_size()\\n )\\n else:\\n flat_dist_call(\\n [param.data for param in model.parameters()],\\n torch.distributed.broadcast,\\n (0,)\\n )\\n elif self.n_gpu > 1:\\n model = torch.nn.DataParallel(model)\\n\\n # Set the values of self.model and self.optimizer\\n self.model = model\\n self.optimizer = optimizer\",\n \"def cuda(self):\\n for i in self.modules:\\n if torch.cuda.is_available():\\n self.modules[i] = self.modules[i].cuda()\",\n \"def setup(self):\\n print(\\\"setup\\\")\\n \\n self.modelToUse = 1\\n if self.train:\\n print(\\\"train\\\")\\n else:\\n print(\\\"no train\\\")\\n \\n device = torch.device(\\\"cuda\\\" if torch.cuda.is_available() else \\\"cpu\\\")\\n self.envSize = 17\\n \\n #init model\\n if self.train or not os.path.isfile(\\\"my-saved-model.pt\\\"):\\n self.logger.info(\\\"Setting up model from scratch.\\\")\\n if self.modelToUse == 0:\\n self.policy_net = Model_global_view(self.envSize, self.envSize, 6).to(device)\\n self.model = Model_global_view(self.envSize, self.envSize, 6).to(device)\\n elif self.modelToUse == 1:\\n self.policy_net = Model_local_view(self.envSize, self.envSize, 6).to(device)\\n self.model = Model_local_view(self.envSize, self.envSize, 6).to(device)\\n else:\\n self.policy_net = Model_combined_view(self.envSize, self.envSize, 6).to(device)\\n self.model = Model_combined_view(self.envSize, self.envSize, 6).to(device)\\n self.model.load_state_dict(self.policy_net.state_dict())\\n self.model.eval()\\n else:\\n self.logger.info(\\\"Loading model from saved state.\\\")\\n with open(\\\"my-saved-model.pt\\\", \\\"rb\\\") as file:\\n if self.modelToUse == 0:\\n self.model = Model_global_view(self.envSize, self.envSize, 6)\\n elif self.modelToUse == 1:\\n self.model = Model_local_view(self.envSize, self.envSize, 6)\\n else:\\n self.model = Model_combined_view(self.envSize, self.envSize, 6)\\n if torch.cuda.is_available():\\n self.model.load_state_dict(torch.load(file))\\n self.model.to(device)\\n else:\\n self.model.load_state_dict(torch.load(file, map_location=device))\",\n \"def gpu(self, gpu):\\n\\n self._gpu = gpu\",\n \"def SetGPU(id):\\n global option\\n option['device_id'] = id\",\n \"def setup_tf_environment() -> None:\\n _setup_cpu_environment()\\n _setup_gpu_environment()\",\n \"def setupGPUSwept(solver):\\n solver.gpuBlock = (slice(0,solver.sharedShape[0],1),)+solver.gpuBlock\\n getGPUReadBlockSwept(solver) #Finish creating gpuReadBlock here\\n blockShape =[element.stop for element in solver.gpuBlock]\\n blockShape[-1] += int(2*solver.blocksize[0]) #Adding 2 blocks in the column direction\\n # Creating local GPU array with split\\n grid = (int((blockShape[2])/solver.blocksize[0]),int((blockShape[3])/solver.blocksize[1])) #Grid size\\n #Creating constants\\n bsp = lambda x: int(numpy.prod(blockShape[x:])) #block shape product returned as an integer\\n const_dict = ({\\\"NV\\\":blockShape[1],'SX':blockShape[2],'SY':blockShape[3],\\\"VARS\\\":bsp(2),\\\"TIMES\\\":bsp(1),\\\"MPSS\\\":solver.maxPyramidSize,\\\"MOSS\\\":solver.maxOctSize,\\\"OPS\\\":solver.operating,\\\"ITS\\\":solver.intermediate})\\n solver.GPUArray = mallocGPUArray(blockShape) #Allocated GPU\\n solver.localGPUArray = numpy.zeros(blockShape)\\n #Building CUDA source code\\n solver.gpu = io.buildGPUSource(solver.gpu)\\n io.copyConstants(solver.gpu,const_dict) #This copys cpu constants not global constants\\n solver.cpu.set_globals(*solver.globals,source_mod=solver.gpu)\\n # Make GPU geometry\\n solver.Up.initializeGPU(solver.gpu.get_function(\\\"UpPyramid\\\"),solver.blocksize,(grid[0],grid[1]-1))\\n solver.Oct.initializeGPU(solver.gpu.get_function(\\\"Octahedron\\\"),solver.blocksize,(grid[0],grid[1]-1))\\n solver.Down.initializeGPU(solver.gpu.get_function(\\\"DownPyramid\\\"),solver.blocksize,(grid[0],grid[1]-1))\\n solver.Yb.initializeGPU(solver.gpu.get_function(\\\"YBridge\\\"),solver.blocksize,grid)\\n solver.Xb.initializeGPU(solver.gpu.get_function(\\\"XBridge\\\"),solver.blocksize,grid)\",\n \"def _adjust_for_gpus(cls, model: DeviceAwareModule, config: ModelConfigBase,\\n model_execution_mode: ModelExecutionMode) -> DeviceAwareModule:\\n if config.use_gpu:\\n model = model.cuda()\\n logging.info(\\\"Adjusting the model to use mixed precision training.\\\")\\n # If model parallel is set to True, then partition the network across all available gpus.\\n if config.use_model_parallel:\\n devices = config.get_cuda_devices()\\n assert devices is not None # for mypy\\n model.partition_model(devices=devices) # type: ignore\\n else:\\n logging.info(\\\"Making no adjustments to the model because no GPU was found.\\\")\\n\\n # Update model related config attributes (After Model Parallel Activated)\\n config.adjust_after_mixed_precision_and_parallel(model)\\n\\n # DataParallel enables running the model with multiple gpus by splitting samples across GPUs\\n # If the model is used in training mode, data parallel is activated by default.\\n # Similarly, if model parallel is not activated, data parallel is used as a backup option\\n use_data_parallel = (model_execution_mode == ModelExecutionMode.TRAIN) or (not config.use_model_parallel)\\n if config.use_gpu and use_data_parallel:\\n logging.info(\\\"Adjusting the model to use DataParallel\\\")\\n # Move all layers to the default GPU before activating data parallel.\\n # This needs to happen even though we put the model to the GPU at the beginning of the method,\\n # but we may have spread it across multiple GPUs later.\\n model = model.cuda()\\n model = DataParallelModel(model, device_ids=config.get_cuda_devices())\\n\\n return model\",\n \"def process_initializer():\\n os.environ['TF_CPP_MIN_LOG_LEVEL'] = '1'\\n import tensorflow as tf\\n physical_devices = tf.config.experimental.list_physical_devices('GPU')\\n if len(physical_devices) > 0:\\n os.environ['CUDA_VISIBLE_DEVICES'] = '0'\\n tf.config.experimental.set_memory_growth(physical_devices[0], True)\",\n \"def deploy_to_device(self):\\n if self.device_ids is not None and len(self.device_ids) > 1:\\n if not isinstance(self.model, torch.nn.DataParallel):\\n self.model = torch.nn.DataParallel(self.model, self.device_ids)\\n\\n self.model = self.model.to(self.device)\\n self.criterion = self.criterion.to(self.device)\",\n \"def CUDA(self):\\n\\n if helpers.CUDA:\\n self.generator.cuda()\\n self.discriminator.cuda()\\n self.adv_loss.cuda()\",\n \"def cuda(self):\\n self.reader.model.cuda()\\n self.reader.device = torch.device(\\\"cuda\\\")\\n return self\",\n \"def create_gpu_device():\\n d1 = dpctl.SyclDevice(\\\"gpu\\\")\\n d2 = dpctl.select_gpu_device()\\n assert d1 == d2\\n print_device(d1)\\n return d1\",\n \"def check_device(use_gpu, use_xpu=False, use_npu=False, use_mlu=False):\\n err = \\\"Config {} cannot be set as true while your paddle \\\" \\\\\\n \\\"is not compiled with {} ! \\\\nPlease try: \\\\n\\\" \\\\\\n \\\"\\\\t1. Install paddlepaddle to run model on {} \\\\n\\\" \\\\\\n \\\"\\\\t2. Set {} as false in config file to run \\\" \\\\\\n \\\"model on CPU\\\"\\n\\n try:\\n if use_gpu and use_xpu:\\n print(\\\"use_xpu and use_gpu can not both be ture.\\\")\\n if use_gpu and not paddle.is_compiled_with_cuda():\\n print(err.format(\\\"use_gpu\\\", \\\"cuda\\\", \\\"gpu\\\", \\\"use_gpu\\\"))\\n sys.exit(1)\\n if use_xpu and not paddle.device.is_compiled_with_xpu():\\n print(err.format(\\\"use_xpu\\\", \\\"xpu\\\", \\\"xpu\\\", \\\"use_xpu\\\"))\\n sys.exit(1)\\n if use_npu:\\n if int(paddle.version.major) != 0 and int(\\n paddle.version.major) <= 2 and int(\\n paddle.version.minor) <= 4:\\n if not paddle.device.is_compiled_with_npu():\\n print(err.format(\\\"use_npu\\\", \\\"npu\\\", \\\"npu\\\", \\\"use_npu\\\"))\\n sys.exit(1)\\n # is_compiled_with_npu() has been updated after paddle-2.4\\n else:\\n if not paddle.device.is_compiled_with_custom_device(\\\"npu\\\"):\\n print(err.format(\\\"use_npu\\\", \\\"npu\\\", \\\"npu\\\", \\\"use_npu\\\"))\\n sys.exit(1)\\n if use_mlu and not paddle.device.is_compiled_with_mlu():\\n print(err.format(\\\"use_mlu\\\", \\\"mlu\\\", \\\"mlu\\\", \\\"use_mlu\\\"))\\n sys.exit(1)\\n except Exception as e:\\n pass\",\n \"def magma_setdevice(dev):\\n\\n _libmagma.magma_setdevice(dev)\",\n \"def main(gpu_device='/gpu:0', cpu_device='/cpu:0'):\\n config = Config()\\n params = experiment_params()\\n model_tools.model_builder(\\n params=params,\\n config=config,\\n model_spec=build_model,\\n gpu_device=gpu_device,\\n cpu_device=cpu_device)\",\n \"def main(gpu_device='/gpu:0', cpu_device='/cpu:0'):\\n config = Config()\\n params = experiment_params()\\n model_tools.model_builder(\\n params=params,\\n config=config,\\n model_spec=build_model,\\n gpu_device=gpu_device,\\n cpu_device=cpu_device)\",\n \"def setup(params):\\n os.environ['TF_ENABLE_WINOGRAD_NONFUSED'] = '1'\\n os.environ['TF_SYNC_ON_FINISH'] = str(int(params.sync_on_finish))\\n argparse.ArgumentParser(\\n formatter_class=argparse.ArgumentDefaultsHelpFormatter)\\n\\n\\n # Sets GPU thread settings\\n params = params._replace(gpu_thread_mode=params.gpu_thread_mode.lower())\\n os.environ['TF_GPU_THREAD_MODE'] = params.gpu_thread_mode\\n\\n # Default to two threads. One for the device compute and the other for\\n # memory copies.\\n per_gpu_thread_count = params.per_gpu_thread_count or 2\\n total_gpu_thread_count = per_gpu_thread_count * params.num_gpus\\n\\n os.environ['TF_GPU_THREAD_COUNT'] = str(per_gpu_thread_count)\\n\\n if not params.num_inter_threads and params.gpu_thread_mode in [\\n 'gpu_private', 'gpu_shared'\\n ]:\\n cpu_count = multiprocessing.cpu_count()\\n main_thread_count = max(cpu_count - total_gpu_thread_count, 1)\\n params = params._replace(num_inter_threads=main_thread_count)\\n\\n platforms_util.initialize(params, create_config_proto(params))\\n\\n return params\",\n \"def _prepare_device(self, n_gpu_use):\\n n_gpu = torch.cuda.device_count()\\n if n_gpu_use > 0 and n_gpu == 0:\\n self.logger.warning(\\\"Warning: There\\\\'s no GPU available on this machine,\\\"\\n \\\"training will be performed on CPU.\\\")\\n n_gpu_use = 0\\n if n_gpu_use > n_gpu:\\n self.logger.warning(\\\"Warning: The number of GPU\\\\'s configured to use is {}, but only {} are available \\\"\\n \\\"on this machine.\\\".format(n_gpu_use, n_gpu))\\n n_gpu_use = n_gpu\\n device = torch.device('cuda:0' if n_gpu_use > 0 else 'cpu')\\n list_ids = list(range(n_gpu_use))\\n return device, list_ids\",\n \"def set_device(self, device: torch.Tensor) -> None:\\n raise NotImplementedError\",\n \"def setupGPUStandard(solver):\\n #Correct GPU block\\n solver.gpuBlock = (slice(0,solver.sharedShape[0],1),)+solver.gpuBlock\\n solver.gpuReadBlock = solver.gpuBlock[:2]+tuple([slice(cs.start-solver.operating,cs.stop+solver.operating,1) for cs in solver.gpuBlock[2:]])\\n blockShape =[element.stop-element.start for element in solver.gpuBlock]\\n blockShape[-1] += int(2*solver.operating) #Adding 2 blocks in the column direction\\n blockShape[-2] += int(2*solver.operating) #Adding 2 blocks in the column direction\\n #Creating local GPU array with split\\n grid = (int((blockShape[2]-2*solver.operating)/solver.blocksize[0]),int((blockShape[3]-2*solver.operating)/solver.blocksize[1])) #Grid size\\n #Creating constants\\n bsp = lambda x: int(numpy.prod(blockShape[x:])) #block shape product returned as an integer\\n const_dict = ({\\\"NV\\\":blockShape[1],'SX':blockShape[2],'SY':blockShape[3],\\\"VARS\\\":bsp(2),\\\"TIMES\\\":bsp(1),\\\"OPS\\\":solver.operating,\\\"ITS\\\":solver.intermediate})\\n solver.GPUArray = mallocGPUArray(blockShape)\\n solver.localGPUArray = numpy.zeros(blockShape)\\n #Building CUDA source code\\n solver.gpu = io.buildGPUSource(solver.gpu)\\n io.copyConstants(solver.gpu,const_dict) #This copys gpu constants not global constants\\n solver.cpu.set_globals(*solver.globals,source_mod=solver.gpu)\\n #Make GPU geometry\\n solver.standard.initializeGPU(solver.gpu.get_function(\\\"Standard\\\"),solver.blocksize,grid)\",\n \"def handle_gpu_compatibility():\\n try:\\n gpus = tf.config.experimental.list_physical_devices(\\\"GPU\\\")\\n for gpu in gpus:\\n tf.config.experimental.set_memory_growth(gpu, True)\\n except Exception as e:\\n print(e)\",\n \"def build_model(self):\\n if self.args.network_type == 'unet':\\n self.shared = models.Unet(self.args)\\n else:\\n raise NotImplementedError(f'Network type '\\n f'`{self.args.network_type}` is not '\\n f'defined')\\n self.controller = models.Controller(self.args)\\n\\n if self.args.num_gpu == 1:\\n self.shared.cuda()\\n self.controller.cuda()\\n elif self.args.num_gpu > 1:\\n raise NotImplementedError('`num_gpu > 1` is in progress')\",\n \"def prepare_device(self):\\n self._get_pairing_status()\\n self._update_system_clock()\\n self._update_system()\\n # Above will block during update process and kill this instance if\\n # new software is installed\\n\\n if self.backend_down:\\n self._notify_backend_down()\\n else:\\n self._display_skill_loading_notification()\\n self.bus.emit(Message('mycroft.internet.connected'))\\n self._ensure_device_is_paired()\\n self._update_device_attributes_on_backend()\",\n \"def to_device(model, device):\\n p = next(model.parameters())\\n if p.device == device:\\n return\\n model.to(device)\",\n \"def test_torch_auto_gpu_to_cpu(ray_start_4_cpus_2_gpus):\\n\\n # Disable GPU on the driver.\\n os.environ[\\\"CUDA_VISIBLE_DEVICES\\\"] = \\\"\\\"\\n\\n num_workers = 2\\n\\n class ValidateCPUCallback(TrainingCallback):\\n def handle_result(self, results, **info):\\n for result in results:\\n model = result[\\\"model\\\"]\\n assert not next(model.parameters()).is_cuda\\n\\n def train_func():\\n model = torch.nn.Linear(1, 1)\\n\\n # Move to GPU device.\\n model = ray.train.torch.prepare_model(model)\\n\\n assert next(model.parameters()).is_cuda\\n\\n ray.train.save_checkpoint(model=model)\\n ray.train.report(model=model)\\n\\n trainer = Trainer(\\\"torch\\\", num_workers=num_workers, use_gpu=True)\\n trainer.start()\\n trainer.run(train_func, callbacks=[ValidateCPUCallback()])\\n model = trainer.latest_checkpoint[\\\"model\\\"]\\n assert not next(model.parameters()).is_cuda\\n trainer.shutdown()\\n\\n # Test the same thing for state dict.\\n\\n class ValidateCPUStateDictCallback(TrainingCallback):\\n def handle_result(self, results, **info):\\n for result in results:\\n state_dict = result[\\\"state_dict\\\"]\\n for tensor in state_dict.values():\\n assert not tensor.is_cuda\\n\\n def train_func():\\n model = torch.nn.Linear(1, 1)\\n\\n # Move to GPU device.\\n model = ray.train.torch.prepare_model(model)\\n\\n assert next(model.parameters()).is_cuda\\n\\n state_dict = model.state_dict()\\n\\n for tensor in state_dict.values():\\n assert tensor.is_cuda\\n\\n ray.train.save_checkpoint(state_dict=state_dict)\\n ray.train.report(state_dict=state_dict)\\n\\n trainer = Trainer(\\\"torch\\\", num_workers=num_workers, use_gpu=True)\\n trainer.start()\\n trainer.run(train_func, callbacks=[ValidateCPUStateDictCallback()])\\n\\n state_dict = trainer.latest_checkpoint[\\\"state_dict\\\"]\\n for tensor in state_dict.values():\\n assert not tensor.is_cuda\\n trainer.shutdown()\\n\\n # Reset the env var.\\n os.environ.pop(\\\"CUDA_VISIBLE_DEVICES\\\")\",\n \"def _copy_to_gpu(self):\\n self.dispatch('on_texture')\",\n \"def load_device():\",\n \"def magma_device_sync():\\n\\n _libmagma.magma_device_sync()\",\n \"def setup_gpu_and_random(config):\\n random.seed(config.general.manualSeed)\\n np.random.seed(config.general.manualSeed)\\n torch.manual_seed(config.general.manualSeed)\\n torch.cuda.manual_seed(config.general.manualSeed)\\n\\n cudnn.benchmark = True\\n cudnn.deterministic = True\\n config.num_gpu = torch.cuda.device_count()\\n\\n if config.num_gpu > 1:\\n print('------ Use multi-GPU setting ------')\\n print('if you stuck too long time with multi-GPU setting, try to set --workers 0')\\n # check multi-GPU issue https://github.com/clovaai/deep-text-recognition-benchmark/issues/1\\n config.workers = config.workers * config.num_gpu\\n config.batch_size = config.batch_size * config.num_gpu\\n\\n \\\"\\\"\\\" previous version\\n print('To equlize batch stats to 1-GPU setting, the batch_size is multiplied with num_gpu and multiplied batch_size is ', opt.batch_size)\\n opt.batch_size = opt.batch_size * opt.num_gpu\\n print('To equalize the number of epochs to 1-GPU setting, num_iter is divided with num_gpu by default.')\\n If you dont care about it, just commnet out these line.)\\n opt.num_iter = int(opt.num_iter / opt.num_gpu)\\n \\\"\\\"\\\"\",\n \"def set_devices(args):\\n global devices\\n if args is not None:\\n devices = [torch.device(i) for i in ast.literal_eval('[' + args + ']')]\\n torch.cuda.set_device(devices[0])\\n else:\\n devices = [torch.device('cpu')]\",\n \"def setup_CL():\\n\\n #Set up openCL platform\\n NAME = 'NVIDIA CUDA'\\n platforms = cl.get_platforms()\\n\\n dev = None\\n for p in platforms:\\n #Easy switching for local vs remote machine\\n if p.name == 'Apple':\\n NAME = 'Apple'\\n if p.name == NAME:\\n dev = p.get_devices()\\n\\n # Command queue, enable GPU profiling\\n ctx = cl.Context(dev)\\n queue = cl.CommandQueue(ctx,properties=cl.command_queue_properties.PROFILING_ENABLE)\\n\\n return [dev,ctx,queue]\",\n \"def cuda(self) -> 'BatchEmbedder':\\n self.is_cuda = True\\n self.embedding_layer = self.embedding_layer.cuda()\\n\\n return self\",\n \"def return_free_GPU():\\r\\n if torch.cuda.is_available():\\r\\n gpu_num = torch.cuda.device_count()\\r\\n device = torch.device('cuda:{}'.format(gpu_num-1))\\r\\n print('Using GPU:[{}]/[{}] for training...'.format(gpu_num-1,gpu_num-1))\\r\\n return device\\r\\n \\r\\n raise ValueError('GPU not available for training. Check CUDA env with function \\\"check_cuda_env\\\"')\",\n \"def test_auto_transfer_correct_device(ray_start_4_cpus_2_gpus):\\n import nvidia_smi\\n\\n nvidia_smi.nvmlInit()\\n\\n def get_gpu_used_mem(i):\\n handle = nvidia_smi.nvmlDeviceGetHandleByIndex(i)\\n info = nvidia_smi.nvmlDeviceGetMemoryInfo(handle)\\n return info.used\\n\\n start_gpu_memory = get_gpu_used_mem(1)\\n\\n device = torch.device(\\\"cuda:1\\\")\\n small_dataloader = [(torch.randn((1024 * 4, 1024 * 4)),) for _ in range(10)]\\n wrapped_dataloader = ( # noqa: F841\\n ray.train.torch.train_loop_utils._WrappedDataLoader(\\n small_dataloader, device, True\\n )\\n )\\n\\n end_gpu_memory = get_gpu_used_mem(1)\\n\\n # Verify GPU memory usage increases on the right cuda device\\n assert end_gpu_memory > start_gpu_memory\",\n \"def set_max_gpu(self):\\r\\n gpu_getter = GPUGetter()\\r\\n gpu = str(gpu_getter.get_free_gpu())\\r\\n\\r\\n if gpu:\\r\\n print(\\\"Using GPU: %s\\\" % gpu)\\r\\n os.environ[\\\"CUDA_DEVICE_ORDER\\\"] = \\\"PCI_BUS_ID\\\" # see issue #152\\r\\n os.environ['CUDA_VISIBLE_DEVICES'] = gpu\\r\\n\\r\\n if not gpu:\\r\\n print('No GPU detected')\",\n \"def OnGPU(gpu_id):\\n device_option = caffe2_pb2.DeviceOption()\\n device_option.device_type = workspace.GpuDeviceType\\n device_option.device_id = gpu_id\\n return device_option\",\n \"def set_gpu(gpu):\\r\\n os.environ['CUDA_VISIBLE_DEVICES'] = gpu\\r\\n tf_config = tf.ConfigProto()\\r\\n tf_config.gpu_options.allow_growth = True\\r\\n return tf_config\",\n \"def device():\\n return torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\",\n \"def do_device(self, args):\\n self.device_command.cmdloop(\\\"Enter to device mode\\\")\",\n \"def test_gpu_cuda_code() -> None:\\n if get_from_environ(\\\"DISABLE_GPU_FOR_TESTING\\\") is not None:\\n print(\\\"GPU payload disabled for testing\\\")\\n return\\n\\n # if the command exists it can run on the hardware below\\n proc = subprocess.Popen([\\\"nvidia-smi\\\"], stdout=subprocess.PIPE)\\n stdout, _ = proc.communicate()\\n str_stdout = stdout.decode()\\n assert \\\"NVIDIA-SMI\\\" in str_stdout, str_stdout\\n assert proc.returncode == 0\\n # search the history for the CUDA implementation\",\n \"def config_training_instance(self):\\n # Compute the average of the gradients main_train_device\\n tower_grads = []\\n\\n # Distribute the model onto available GPUs\\n for i in range(self.num_gpus):\\n with tf.device(\\\"/gpu:{}\\\".format(i)):\\n\\n optimizer = tf.train.AdamOptimizer(\\n learning_rate=self.learning_rate)\\n batch_size_instance = self.batch_size // self.num_gpus\\n\\n # Split data between GPUs\\n inputs_instance = self.inputs[i * batch_size_instance:(i + 1) *\\n batch_size_instance]\\n labels_instance = self.labels[i * batch_size_instance:(i + 1) *\\n batch_size_instance]\\n\\n logits = self.model(inputs_instance)\\n trainable_variables = self.model.trainable_variables\\n model_loss = self.construct_loss(logits=logits,\\n labels=labels_instance)\\n network_regularizers, regularizer_loss, exporter, costs = self.embed_morphnet(\\n input_boundary=[inputs_instance.op],\\n output_boundary=[logits.op],\\n morphnet_regularization_strength=self.\\n morphnet_regularization_strength_placeholder,\\n morphnet_cost_thresholds=self.morphnet_target_cost_thresholds)\\n total_loss = model_loss + regularizer_loss\\n\\n grads = optimizer.compute_gradients(\\n total_loss, var_list=trainable_variables)\\n tower_grads.append(grads)\\n\\n # Usually we would use the first GPU\\n if i == 0:\\n # Evaluate model (with test logits, for dropout to be disabled)\\n self.logits_train_instance = logits\\n self.model_loss_train_instance = model_loss\\n self.probs_train_instance = tf.nn.softmax(logits)\\n self.correct_pred_train_instance = tf.equal(\\n tf.argmax(logits, 1), tf.argmax(labels_instance, 1))\\n self.accuracy_train_instance = tf.reduce_mean(\\n tf.cast(self.correct_pred_train_instance, tf.float32))\\n\\n self.network_regularizer_train_instance = network_regularizers\\n self.regularizer_loss_train_instance = regularizer_loss\\n self.total_loss_train_instance = total_loss\\n self.exporter_train_instance = exporter\\n self.cost_train_instance = costs\\n\\n # Compute the average of the gradients main_train_device\\n with tf.device(self.main_train_device):\\n grads = self.average_gradients(tower_grads)\\n self.train_op = optimizer.apply_gradients(grads, global_step=None)\",\n \"def _minimal_device_test(device: torch.device) -> bool:\\n try:\\n with torch.no_grad():\\n model = torch.nn.Conv2d(1, 1, 1).to(device)\\n x = torch.zeros(1, 1, 1, 1).to(device)\\n y = model(x)\\n del model, x, y\\n except Exception as e:\\n return False\\n\\n return True\",\n \"def device(request):\\n d = request.param()\\n\\n # enable GPU error checking\\n if isinstance(d, hoomd.device.GPU):\\n d.gpu_error_checking = True\\n\\n return d\",\n \"def try_gpu():\\r\\n try:\\r\\n ctx = mx.gpu()\\r\\n _ = nd.array([0], ctx=ctx)\\r\\n except mx.base.MXNetError:\\r\\n ctx = mx.cpu()\\r\\n return ctx\",\n \"def try_gpu():\\n try:\\n ctx = mx.gpu()\\n _ = nd.array([0], ctx=ctx)\\n except:\\n ctx = mx.cpu()\\n return ctx\",\n \"def try_gpu():\\n try:\\n ctx = mx.gpu()\\n _ = nd.array([0], ctx=ctx)\\n except:\\n ctx = mx.cpu()\\n return ctx\",\n \"def set_device(device: Union[str, torch.device]) -> torch.device:\\n err_msg = None\\n if isinstance(device, torch.device):\\n pass\\n elif device == 'auto':\\n cuda = torch.cuda.is_available()\\n device = torch.device('cuda' if cuda else 'cpu')\\n elif device == 'gpu':\\n cuda = torch.cuda.is_available()\\n if cuda:\\n device = torch.device('cuda')\\n else:\\n err_msg = ('Device set to \\\"gpu\\\", but could not access '\\n 'any CUDA-enabled GPU. Please make sure that '\\n 'a GPU is available and CUDA is installed '\\n 'on this machine.')\\n elif device == 'cpu':\\n device = torch.device('cpu')\\n else:\\n err_msg = f'Unknown device \\\"{device}\\\". Try \\\"auto\\\".'\\n if err_msg is not None:\\n logger = get_logger(__name__, verbose=0)\\n logger.error(f'Unknown device \\\"{device}\\\". Try \\\"auto\\\".')\\n import sys\\n sys.exit(1)\\n return device\",\n \"def set_gpu_from_theano():\\r\\n # Transfer the theano gpu binding to pycuda, for consistency\\r\\n if config.device.startswith(\\\"gpu\\\") and len(config.device) > 3:\\r\\n os.environ[\\\"CUDA_DEVICE\\\"] = theano.config.device[3:]\\r\\n elif (config.init_gpu_device.startswith(\\\"gpu\\\") and\\r\\n len(config.init_gpu_device) > 3):\\r\\n os.environ[\\\"CUDA_DEVICE\\\"] = theano.config.init_gpu_device[3:]\",\n \"def mat_device(self): # pylint: disable=C0103\\n if cp is None:\\n raise ModuleNotFoundError(\\\"Could not import cupy -- cannot use GPU!\\\")\\n if self._mat_device is None:\\n gp_device = cp.array(self._gp)\\n object.__setattr__(\\n self,\\n \\\"_mat_device\\\",\\n cp.diag(self._disp_over_m) - gp_device.reshape(-1, 1) * gp_device,\\n )\\n return self._mat_device\",\n \"def gpu(device_id=0):\\n return Context('gpu', device_id)\",\n \"def gpu(device_id=0):\\n return Context('gpu', device_id)\",\n \"def setUp(self):\\n self.setup_model()\\n self.sess = tf.Session(\\n config=tf.ConfigProto(\\n allow_soft_placement=True,\\n gpu_options=tf.GPUOptions(allow_growth=True),\\n log_device_placement=self.params['log_device_placement'],\\n ))\\n\\n # TODO: Determine whether this should be called here or\\n # in dbinterface.initialize()\\n self.sess.run(tf.global_variables_initializer())\\n\\n self.dbinterface = DBInterface(\\n sess=self.sess,\\n params=self.params,\\n cache_dir=self.CACHE_DIR,\\n save_params=self.save_params,\\n load_params=self.load_params)\\n\\n self.step = 0\",\n \"def __init__(self,model,device):\\n self.model = model\\n self.device = device\",\n \"def test_torch_prepare_model(ray_start_4_cpus_2_gpus):\\n\\n def train_fn():\\n model = torch.nn.Linear(1, 1)\\n\\n # Wrap in DDP.\\n model = train.torch.prepare_model(model)\\n\\n # Make sure model is wrapped in DDP.\\n assert isinstance(model, DistributedDataParallel)\\n\\n # Make sure model is on cuda.\\n assert next(model.parameters()).is_cuda\\n\\n trainer = Trainer(\\\"torch\\\", num_workers=2, use_gpu=True)\\n trainer.start()\\n trainer.run(train_fn)\\n trainer.shutdown()\",\n \"def init():\\n\\tN = np.int32(DIM) #prepare for stitching\\n\\t#HII_DIM = np.int32(HII_DIM)\\n\\tf_pixel_factor = DIM/HII_DIM;\\n\\tscale = np.float32(BOX_LEN)/DIM\\n\\tHII_scale = np.float32(BOX_LEN)/HII_DIM\\n\\tshape = (N,N,N)\\n\\t\\n\\tMRGgen = MRG32k3aRandomNumberGenerator(seed_getter=seed_getter_uniform, offset=0)\\n\\n\\tkernel_source = open(cmd_folder+\\\"/initialize.cu\\\").read()\\n\\tkernel_code = kernel_source % {\\n\\n\\t\\t'DELTAK': DELTA_K,\\n\\t\\t'VOLUME': VOLUME,\\n\\t\\t'DIM': DIM\\n\\t}\\n\\tmain_module = nvcc.SourceModule(kernel_code)\\n\\tinit_kernel = main_module.get_function(\\\"init_kernel\\\")\\n\\tHII_filter = main_module.get_function(\\\"HII_filter\\\")\\n\\tadj_complex_conj = main_module.get_function(\\\"adj_complex_conj\\\")\\n\\tsubsample_kernel = main_module.get_function(\\\"subsample\\\")\\n\\tvelocity_kernel = main_module.get_function(\\\"set_velocity\\\")\\n\\tpspec_texture = main_module.get_texref(\\\"pspec\\\")\\n\\n\\tinterpPspec, interpSize = init_pspec() #interpPspec contains both k array and P array\\n\\tinterp_cu = cuda.matrix_to_array(interpPspec, order='F')\\n\\tcuda.bind_array_to_texref(interp_cu, pspec_texture)\\n\\n\\tlargebox_d = gpuarray.zeros(shape, dtype=np.float32)\\n\\tinit_kernel(largebox_d, np.int32(DIM), block=block_size, grid=grid_size)\\n\\n\\t#import IPython; IPython.embed()\\n\\tlargebox_d_imag = gpuarray.zeros(shape, dtype=np.float32)\\n\\tinit_kernel(largebox_d_imag, np.int32(DIM), block=block_size, grid=grid_size)\\n\\n\\tlargebox_d *= MRGgen.gen_normal(shape, dtype=np.float32)\\n\\tlargebox_d_imag *= MRGgen.gen_normal(shape, dtype=np.float32)\\n\\tlargebox_d = largebox_d + np.complex64(1.j) * largebox_d_imag\\n\\n\\t#adj_complex_conj(largebox_d, DIM, block=block_size, grid=grid_size)\\n\\tlargebox = largebox_d.get()\\n\\t#np.save(parent_folder+\\\"/Boxes/deltak_z0.00_{0:d}_{1:.0f}Mpc\\\".format(DIM, BOX_LEN), largebox)\\n\\n\\t#save real space box before smoothing\\n\\tplan = Plan(shape, dtype=np.complex64)\\n\\tplan.execute(largebox_d, inverse=True) #FFT to real space of smoothed box\\n\\tlargebox_d /= scale**3\\n\\tnp.save(parent_folder+\\\"/Boxes/deltax_z0.00_{0:d}_{1:.0f}Mpc\\\".format(DIM, BOX_LEN), largebox_d.real.get_async())\\n\\n\\t#save real space box after smoothing and subsampling\\n\\t# host largebox is still in k space, no need to reload from disk\\n\\tlargebox_d = gpuarray.to_gpu(largebox)\\n\\tsmoothR = np.float32(L_FACTOR*BOX_LEN/HII_DIM)\\n\\tHII_filter(largebox_d, N, ZERO, smoothR, block=block_size, grid=grid_size);\\n\\tplan.execute(largebox_d, inverse=True) #FFT to real space of smoothed box\\n\\tlargebox_d /= scale**3\\n\\tsmallbox_d = gpuarray.zeros(HII_shape, dtype=np.float32)\\n\\tsubsample_kernel(largebox_d.real, smallbox_d, N, HII_DIM, PIXEL_FACTOR, block=block_size, grid=HII_grid_size) #subsample in real space\\n\\tnp.save(parent_folder+\\\"/Boxes/smoothed_deltax_z0.00_{0:d}_{1:.0f}Mpc\\\".format(HII_DIM, BOX_LEN), smallbox_d.get_async())\\n\\n\\t# reload the k-space box for velocity boxes\\n\\tlargebox_d = gpuarray.to_gpu(largebox)\\n\\t\\n\\t#largebox_d /= VOLUME #divide by VOLUME if using fft (vs ifft)\\n\\tsmoothR = np.float32(L_FACTOR*BOX_LEN/HII_DIM)\\n\\tlargevbox_d = gpuarray.zeros((DIM,DIM,DIM), dtype=np.complex64)\\n\\tsmallbox_d = gpuarray.zeros(HII_shape, dtype=np.float32)\\n\\tfor num, mode in enumerate(['x', 'y', 'z']):\\n\\t\\tvelocity_kernel(largebox_d, largevbox_d, DIM, np.int32(num), block=block_size, grid=grid_size)\\n\\t\\tHII_filter(largevbox_d, DIM, ZERO, smoothR, block=block_size, grid=grid_size)\\n\\t\\tplan.execute(largevbox_d, inverse=True)\\n\\t\\tlargevbox_d /= scale**3\\n\\t\\t#import IPython; IPython.embed()\\n\\t\\tsubsample_kernel(largevbox_d.real, smallbox_d, DIM, HII_DIM,PIXEL_FACTOR, block=block_size, grid=HII_grid_size)\\n\\t\\tnp.save(parent_folder+\\\"/Boxes/v{0}overddot_{1:d}_{2:.0f}Mpc\\\".format(mode, HII_DIM, BOX_LEN), smallbox_d.get())\\n\\n\\treturn\",\n \"def load_model(self, gpus=1):\\r\\n\\t\\t\\r\\n\\t\\tif self.model != None:\\r\\n\\t\\t\\treturn\\r\\n\\r\\n\\t\\t## build the model on the CPU if parallelism is targeted\\r\\n\\t\\tif isinstance(gpus, Sequence):\\r\\n\\t\\t\\tif len(gpus) != 1:\\r\\n\\t\\t\\t\\tdevice = \\\"/cpu:0\\\"\\r\\n\\t\\t\\t\\tmultigpu = True\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\tdevice = \\\"/gpu:{:d}\\\".format(gpus[0])\\r\\n\\t\\t\\t\\tmultigpu = False\\r\\n\\t\\telse:\\r\\n\\t\\t\\tif gpus != 1:\\r\\n\\t\\t\\t\\tdevice = \\\"/cpu:0\\\"\\r\\n\\t\\t\\t\\tmultigpu = True\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\tdevice = \\\"/gpu:{:d}\\\".format(gpus)\\r\\n\\t\\t\\t\\tmultigpu = False\\r\\n\\r\\n\\r\\n\\t\\tif self.__prop__(\\\"Resume\\\"):\\r\\n\\t\\t\\tself.model = keras.models.load_model(\\r\\n\\t\\t\\t\\tself.__prop__(\\\"SnapshotDirectory\\\") + self.__prop__(\\\"Prefix\\\") + self.__prop__(\\\"Resume\\\") + '.h5\\\"')\\r\\n\\t\\t\\tself.single_model = self.model\\r\\n\\t\\t\\tif multigpu:\\r\\n\\t\\t\\t\\tself.model = multi_gpu_model(self.model, gpus)\\r\\n\\t\\telse: \\r\\n\\t\\t\\t\\r\\n\\t\\t\\twith tensorflow.device(device):\\r\\n\\t\\t\\t\\tif self.__prop__(\\\"Prefix\\\").startswith(\\\"i3PosNet_VGG16\\\"):\\r\\n\\t\\t\\t\\t\\tself.model = i3PosNetVGG(\\r\\n\\t\\t\\t\\t\\t\\tinput_shape=self.__prop__(\\\"InputShape\\\"), \\r\\n\\t\\t\\t\\t\\t\\tout_number=self.__prop__(\\\"TargetShape\\\"),\\r\\n\\t\\t\\t\\t\\t\\tlayer_count=self.__prop__(\\\"LayerCount\\\"), \\r\\n\\t\\t\\t\\t\\t\\tfc_layer_count=self.__prop__(\\\"FCLayerCount\\\"), \\r\\n\\t\\t\\t\\t\\t\\tfc_reg=self.__prop__(\\\"FCReg\\\"), \\r\\n\\t\\t\\t\\t\\t\\tconv_reg=self.__prop__(\\\"ConvReg\\\"), \\r\\n\\t\\t\\t\\t\\t\\tshrinking=self.__prop__(\\\"Shrinking\\\"),\\r\\n\\t\\t\\t\\t\\t\\tpadding=self.__prop__(\\\"Padding\\\"))\\r\\n\\t\\t\\t\\telse:\\r\\n\\t\\t\\t\\t\\tself.model = i3PosNet(image_shape, out = self.__prop__(\\\"TargetShape\\\"))\\r\\n\\r\\n\\t\\t\\tself.single_model = self.model\\r\\n\\t\\t\\tif multigpu:\\r\\n\\t\\t\\t\\tself.model = multi_gpu_model(self.model, gpus)\\r\\n\\t\\t\\t\\t\\r\\n\\t\\t\\t# clear model\\r\\n\\t\\t\\t# try:\\r\\n\\t\\t\\t\\t# del self.model\\r\\n\\t\\t\\t# except:\\r\\n\\t\\t\\t\\t# pass\\r\\n\\r\\n\\t\\t\\tif self.__prop__(\\\"Optimizer\\\") == \\\"SGD\\\":\\r\\n\\t\\t\\t\\toptimizer = SGD(\\r\\n\\t\\t\\t\\t\\tlr=self.__prop__(\\\"BaseLR\\\"),\\r\\n\\t\\t\\t\\t\\tdecay=self.__prop__(\\\"Gamma\\\") if self.__prop__(\\\"LRPolicy\\\") == \\\"decay\\\" else 0.,\\r\\n\\t\\t\\t\\t\\tmomentum= self.__prop__(\\\"Momentum\\\"),\\r\\n\\t\\t\\t\\t\\tnesterov=True)\\r\\n\\t\\t\\telif self.__prop__(\\\"Optimizer\\\") == \\\"Adam\\\":\\r\\n\\t\\t\\t\\toptimizer = Adam(\\r\\n\\t\\t\\t\\t\\tlr=self.__prop__(\\\"BaseLR\\\"),\\r\\n\\t\\t\\t\\t\\tdecay=self.__prop__(\\\"Gamma\\\") if self.__prop__(\\\"LRPolicy\\\") == \\\"decay\\\" else 0.,\\r\\n\\t\\t\\t\\t\\t# use defaults for these for now (b1 = 0.9, b2 = 0.999, e = 1e-8\\r\\n\\t\\t\\t\\t\\tbeta_1=self.__prop__(\\\"Beta1\\\"),\\r\\n\\t\\t\\t\\t\\tbeta_2=self.__prop__(\\\"Beta2\\\"),\\r\\n\\t\\t\\t\\t\\tepsilon=self.__prop__(\\\"Epsilon\\\")\\r\\n\\t\\t\\t\\t\\t)\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tself.model.compile(loss='mean_squared_error', optimizer=optimizer)\",\n \"def cuda_if_gpu(T):\\n\\n return T.cuda() if use_cuda else T\",\n \"def cudaLoader(model, train_set, val_set):\\n device = torch.device(\\\"cuda:0\\\" if torch.cuda.is_available() else \\\"cpu\\\")\\n # device = ('cpu') # comment/uncomment to use GPU\\n print(\\\"device:\\\\t\\\", device)\\n\\n if torch.cuda.device_count() > 1:\\n print(\\\"Let's use\\\", torch.cuda.device_count(), \\\"GPUs!\\\")\\n # dim = 0 [30, xxx] -> [10, ...], [10, ...], [10, ...] on 3 GPUs\\n model = nn.DataParallel(model)\\n\\n model.to(dtype = torch.double) #typecasting\\n train_set = train_set.to(device)\\n val_set = val_set.to(device)\\n model = model.to(device);\\n return model, train_set, val_set\",\n \"def test_nvidia_driver2():\\r\\n a = numpy.random.rand(10000).astype(\\\"float32\\\")\\r\\n cuda.shared_constructor(a)\\r\\n assert theano.sandbox.cuda.use.device_number is not None\",\n \"def train_on_device(data_dir, dataset_id, model_path, ckpt_path, weight_updates_path):\\r\\n\\r\\n # Store pre-trained model and weights\\r\\n old_model = load_model(model_path)\\r\\n old_model.load_weights(ckpt_path)\\r\\n\\r\\n # Initialize model and checkpoint, which are obtained from server\\r\\n device_model = load_model(model_path)\\r\\n device_model.load_weights(ckpt_path)\\r\\n\\r\\n # print(device_model.summary())\\r\\n\\r\\n # load the vocabulary\\r\\n vocab_filename = os.path.join(data_dir, \\\"vocab.txt\\\")\\r\\n vocab = load_doc(vocab_filename)\\r\\n vocab = vocab.split()\\r\\n vocab = set(vocab)\\r\\n\\r\\n # create the tokenizer\\r\\n tokenizer = Tokenizer()\\r\\n\\r\\n # loading tokenizer from file\\r\\n tokenizer_filename = os.path.join(data_dir, \\\"tokenizer.pickle\\\")\\r\\n with open(tokenizer_filename, \\\"rb\\\") as handle:\\r\\n tokenizer = pickle.load(handle)\\r\\n\\r\\n # Get training data present on device\\r\\n X_train, y_train = get_data(data_dir, dataset_id, vocab, tokenizer, is_train=True)\\r\\n\\r\\n X_test, y_test = get_data(data_dir, dataset_id, vocab, tokenizer, is_train=False)\\r\\n\\r\\n scores = device_model.evaluate(X_test, y_test, verbose=0)\\r\\n print(\\\"Test Accuracy(before training): %.2f%%\\\" % (scores[1] * 100))\\r\\n\\r\\n # Train model\\r\\n device_model.fit(\\r\\n X_train, y_train, epochs=NUM_EPOCHS, batch_size=BATCH_SIZE,\\r\\n )\\r\\n\\r\\n scores = device_model.evaluate(X_test, y_test, verbose=0)\\r\\n print(\\\"Test Accuracy(after training): %.2f%%\\\" % (scores[1] * 100))\\r\\n\\r\\n # Load model to store weight updates\\r\\n weight_updates = load_model(model_path)\\r\\n\\r\\n # Number of batches trained on device\\r\\n num_batches = X_train.shape[0] // BATCH_SIZE\\r\\n\\r\\n # Calculate weight updates\\r\\n for i in range(len(device_model.layers)):\\r\\n\\r\\n # Pre-trained weights\\r\\n old_layer_weights = old_model.layers[i].get_weights()\\r\\n\\r\\n # Post-trained weights\\r\\n new_layer_weights = device_model.layers[i].get_weights()\\r\\n\\r\\n # Weight updates calculation\\r\\n weight_updates.layers[i].set_weights(\\r\\n num_batches\\r\\n * (np.asarray(new_layer_weights) - np.asarray(old_layer_weights)),\\r\\n )\\r\\n\\r\\n # print(\\\"old weights: \\\", old_layer_weights)\\r\\n # print(\\\"new weights: \\\", new_layer_weights)\\r\\n # print(\\\"weight updates: \\\", weight_updates.layers[i].get_weights())\\r\\n\\r\\n # Save weight updates\\r\\n weight_updates.save_weights(weight_updates_path)\\r\\n\\r\\n return (num_batches, weight_updates_path)\",\n \"def __init__(self):\\n \\n self.model = Net()\\n\\n if torch.cuda.is_available():\\n map_location=torch.device('cuda')\\n else:\\n map_location=torch.device('cpu')\\n\\n # load parameters\\n self.model.load_state_dict(torch.load('model.pt',\\n map_location=map_location)) \\n \\n if torch.cuda.is_available():\\n self.model.cuda()\\n else:\\n self.model.cpu()\\n \\n self.model.eval()\",\n \"def EnableCUDA(gpu_id=0, use_cudnn=True):\\n global option\\n option['device'] = 'CUDA'\\n option['device_id'] = gpu_id\\n option['use_cudnn'] = use_cudnn\",\n \"def main():\\n args = arg_parser()\\n if(args.gpu):\\n gpu = args.gpu\\n else:\\n print(\\\"GPU mode not specified, will use the default value - Use GPU\\\")\\n gpu = \\\"Y\\\"\\n # Device setting:\\n device = device_setting(gpu)\\n \\n # Prepare the datasets and dataloaders:\\n print(\\\"\\\\nPreparing dataset for train/valid/test ...\\\")\\n train_loader, valid_loader, test_loader, train_data, valid_data, test_data = load_dataset()\\n \\n # Model architects, criterion and optimizer:\\n print(\\\"\\\\nNetwork archetecture building ...\\\")\\n model, criterion, optimizer = network(device=device,\\n architecture=args.architecture,\\n learning_rate=args.learning_rate,\\n hidden_size=args.hidden_size,\\n dropout=args.dropout,\\n output_size=args.output_size)\\n \\n # Train the model:\\n print(\\\"\\\\n\\\")\\n model = train(model=model,\\n epochs=5,\\n learning_rate=args.learning_rate,\\n criterion=criterion,\\n optimizer=optimizer,\\n train_loader=train_loader,\\n valid_loader=valid_loader,\\n device=device)\\n \\n # Validate the model performance on the test set:\\n print(\\\"\\\\nValidate model performance on test set ...\\\")\\n test(model=model, test_loader=test_loader, device=device)\\n \\n # Save model checkpoint:\\n print(\\\"\\\\nSave model checkpoint ...\\\")\\n save(model=model, train_data=train_data, epochs=args.epochs, architecture=args.architecture)\",\n \"def set_devices_for_ml(sys_device_ids):\\n import os\\n\\n all_ids = []\\n for ids in sys_device_ids:\\n all_ids += ids\\n unique_sys_device_ids = list(set(all_ids))\\n unique_sys_device_ids.sort()\\n if -1 in unique_sys_device_ids:\\n unique_sys_device_ids.remove(-1)\\n\\n # Set the CUDA_VISIBLE_DEVICES environment variable\\n\\n visible_devices = ''\\n for i in unique_sys_device_ids:\\n visible_devices += '{}, '.format(i)\\n os.environ['CUDA_VISIBLE_DEVICES'] = visible_devices\\n\\n # Return wrappers\\n\\n relative_device_ids = []\\n TVTs, TMOs = [], []\\n for ids in sys_device_ids:\\n relative_ids = []\\n for id in ids:\\n if id != -1:\\n id = find_index(unique_sys_device_ids, id)\\n relative_ids.append(id)\\n relative_device_ids.append(relative_ids)\\n\\n # Models and user defined Variables/Tensors would be transferred to the\\n # first device.\\n TVTs.append(TransferVarTensor(relative_ids[0]))\\n TMOs.append(TransferModulesOptims(relative_ids[0]))\\n return TVTs, TMOs, relative_device_ids\",\n \"def try_gpu(i=0): #@save\\n if len(tf.config.experimental.list_physical_devices('GPU')) >= i + 1:\\n return tf.device(f'/GPU:{i}')\\n return tf.device('/CPU:0')\",\n \"def set_cuda(self, is_cuda):\\n self.is_cuda = is_cuda\",\n \"def set_devices(sys_device_ids):\\n # Set the CUDA_VISIBLE_DEVICES environment variable\\n import os\\n visible_devices = ''\\n for i in sys_device_ids:\\n visible_devices += '{}, '.format(i)\\n os.environ['CUDA_VISIBLE_DEVICES'] = visible_devices\\n # Return wrappers.\\n # Models and user defined Variables/Tensors would be transferred to the\\n # first device.\\n device_id = 0 if len(sys_device_ids) > 0 else -1\\n TVT = TransferVarTensor(device_id)\\n TMO = TransferModulesOptims(device_id)\\n return TVT, TMO\",\n \"def get_device(args: dict) -> torch.device:\\n\\n if is_distributed(args):\\n device = torch.device(\\\"cuda\\\", args.local_rank)\\n else:\\n if torch.cuda.is_available():\\n device = torch.device(\\\"cuda\\\", 0)\\n else:\\n device = torch.device(\\\"cpu\\\")\\n return device\",\n \"def get_device(arguments):\\n\\n # Checks if the GPU is available to be used and sets the .\\n if arguments.gpu and torch.cuda.is_available():\\n return torch.device(f\\\"cuda:{torch.cuda.device_count() - 1}\\\")\\n\\n # Sets the device to CPU.\\n else:\\n return torch.device(\\\"cpu\\\")\",\n \"def trainer(current_gpu, args):\\n\\n model_history = train_utils.init_model_history()\\n batch_size = args.batch_size\\n num_epochs = args.num_epochs\\n feature_extract = False\\n\\n model = train_utils.initialize_ft_model(args.model_name, num_classes=args.num_classes, feature_extract=feature_extract)\\n model, args = dist_setting(current_gpu, model, args)\\n logger.info(f\\\"==> Training on rank {args.rank}.\\\")\\n logger.info(args)\\n \\n dataloaders, transforms, train_sampler = train_utils.create_dataloaders(\\n args.train_dir, args.valid_dir, rank=args.rank, \\n world_size=args.world_size, batch_size=batch_size,\\n num_workers=args.num_workers\\n )\\n \\n optimizer = train_utils.initialize_optimizer(model, feature_extract, lr=args.lr*args.world_size, momentum=0.9) \\n criterion = nn.CrossEntropyLoss()\\n\\n since = time.time()\\n val_acc_history = []\\n best_model_wts = copy.deepcopy(model.state_dict())\\n best_acc1 = 0.0\\n num_samples = {k: len(dataloaders[k].dataset) for k, v in dataloaders.items()}\\n num_steps = {k: int(np.ceil(len(dataloaders[k].dataset) / (batch_size*args.world_size))) for k, v in dataloaders.items()}\\n device = torch.device(f'cuda:{current_gpu}') \\n\\n for epoch in range(1, num_epochs+1):\\n \\n batch_time = train_utils.AverageMeter('Time', ':6.3f')\\n data_time = train_utils.AverageMeter('Data', ':6.3f')\\n losses = train_utils.AverageMeter('Loss', ':.4e')\\n top1 = train_utils.AverageMeter('Acc@1', ':6.2f')\\n \\n logger.info('-' * 40)\\n logger.info('[Rank {}, Epoch {}/{}] Processing...'.format(args.rank, epoch, num_epochs))\\n logger.info('-' * 40)\\n\\n # Each epoch has a training and validation phase\\n for phase in ['train', 'valid']: \\n\\n if phase == 'train':\\n model.train() # Set model to training mode\\n if args.multigpus_distributed:\\n dataloaders[phase].sampler.set_epoch(epoch) # Set epoch count for DistributedSampler \\n else:\\n model.eval() # Set model to evaluate mode\\n\\n running_loss = 0.0\\n running_corrects = 0\\n epoch_tic = time.time() \\n tic = time.time()\\n \\n for i, (inputs, labels) in enumerate(dataloaders[phase]):\\n # measure data loading time\\n data_time.update(time.time() - tic) \\n \\n inputs = inputs.to(device)\\n labels = labels.to(device)\\n\\n optimizer.zero_grad()\\n\\n with torch.set_grad_enabled(phase=='train'):\\n outputs = model(inputs)\\n loss = criterion(outputs, labels)\\n probs, preds = torch.max(outputs, 1)\\n \\n # Compute gradient and do stochastic gradient descent\\n if phase == 'train':\\n loss.backward()\\n optimizer.step()\\n \\n running_loss += loss.item() * inputs.size(0)\\n running_corrects += torch.sum(preds == labels.data)\\n acc1 = train_utils.accuracy(outputs, labels, topk=(1,))\\n \\n # Average loss and accuracy across processes for logging\\n if args.multigpus_distributed:\\n reduced_loss = train_utils.reduce_tensor(loss.data, args)\\n reduced_acc1 = train_utils.reduce_tensor(acc1[0], args)\\n else:\\n reduced_loss = loss.data\\n reduced_acc1 = acc1[0]\\n\\n losses.update(train_utils.to_python_float(reduced_loss), inputs.size(0))\\n top1.update(train_utils.to_python_float(reduced_acc1), inputs.size(0))\\n \\n # measure elapsed time\\n batch_time.update(time.time() - tic)\\n tic = time.time()\\n\\n if phase == 'train' and i % args.log_interval == 0:\\n step_loss = running_loss / ((i+1)*batch_size)\\n step_acc = running_corrects.double() / ((i+1)*batch_size)\\n logger.info(f'[Rank {args.rank}, Epoch {epoch}/{num_epochs}, Step {i+1}/{num_steps[phase]}] {phase}-acc: {step_acc:.4f}, '\\n f'{phase}-loss: {step_loss:.4f}, data-time: {data_time.val:.4f}, batch-time: {batch_time.val:.4f}') \\n \\n\\n ## Waiting until finishing operations on GPU (Pytorch default: async)\\n torch.cuda.synchronize()\\n \\n if current_gpu == 0: \\n logger.info(f'[Epoch {epoch}/{num_epochs}] {phase}-acc: {top1.avg:.4f}, '\\n f'{phase}-loss: {losses.val:.4f}, time: {time.time()-epoch_tic:.4f}') \\n \\n model_history['epoch'].append(epoch)\\n model_history['batch_idx'].append(i)\\n model_history['data_time'].append(data_time.val) \\n model_history['batch_time'].append(batch_time.val)\\n model_history['losses'].append(losses.val)\\n model_history['top1'].append(top1.val)\\n\\n if phase == 'valid':\\n is_best = top1.avg > best_acc1\\n best_acc1 = max(top1.avg, best_acc1)\\n \\n if (args.multigpus_distributed and args.rank % args.num_gpus == 0):\\n #train_utils.save_history(os.path.join(args.output_data_dir, 'model_history.p'), model_history) \\n train_utils.save_model({\\n 'epoch': epoch + 1,\\n 'model_name': args.model_name,\\n 'state_dict': model.module.state_dict(),\\n 'optimizer': optimizer.state_dict(),\\n 'best_acc1': best_acc1,\\n 'loss': losses\\n }, is_best, args.model_chkpt_dir, args.model_dir)\\n elif not args.multigpus_distributed:\\n #train_utils.save_history(os.path.join(args.output_data_dir, 'model_history.p'), model_history) \\n train_utils.save_model({\\n 'epoch': epoch + 1,\\n 'model_name': args.model_name,\\n 'state_dict': model.state_dict(),\\n 'optimizer': optimizer.state_dict(),\\n 'best_acc1': best_acc1,\\n 'loss': losses\\n }, is_best, args.model_chkpt_dir, args.model_dir) \\n \\n \\n time_elapsed = time.time() - since\\n if current_gpu == 0:\\n logger.info('Training complete in {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60))\\n logger.info('Best val acc: {:.4f}'.format(best_acc1))\\n \\n if args.multigpus_distributed:\\n dist_cleanup()\",\n \"def config_keras() -> None:\\n config = tf.ConfigProto()\\n config.gpu_options.allow_growth = True\\n kbackend.tensorflow_backend.set_session(tf.Session(config=config))\",\n \"def model_device(model):\\n # Source: https://discuss.pytorch.org/t/how-to-check-if-model-is-on-cuda/180\\n try:\\n return str(next(model.parameters()).device)\\n except StopIteration:\\n # Model has no parameters\\n pass\\n return 'cpu'\",\n \"def __init__(self, *args, **kwargs):\\n super(MadryEtAlMultiGPU, self).__init__(*args, **kwargs)\\n self.structural_kwargs += ['ngpu']\",\n \"def is_gpu_available() -> bool:\\n return torch.cuda.is_available()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7189841","0.6974946","0.68392825","0.68199843","0.67975026","0.6781155","0.67694235","0.6714223","0.6713853","0.6688746","0.66411406","0.66013426","0.6601249","0.65606564","0.6550351","0.6538365","0.6532433","0.6494333","0.6494088","0.6472267","0.6455442","0.63934565","0.6371974","0.6370674","0.6370674","0.63516027","0.6350023","0.6344533","0.63407826","0.63209283","0.6300701","0.6291615","0.62897724","0.62853456","0.62823516","0.6244864","0.62125045","0.6198014","0.6190049","0.6167626","0.61662143","0.61662143","0.61370283","0.61152035","0.61025673","0.6102406","0.6072655","0.6064118","0.6053266","0.6051076","0.60318583","0.60187936","0.6015644","0.60151154","0.6007916","0.6001247","0.5998845","0.5998039","0.5988288","0.59496343","0.5923936","0.5916135","0.59150624","0.59140116","0.58977044","0.58732146","0.58662105","0.5863228","0.58585864","0.5838977","0.5831223","0.5831223","0.5820844","0.5818238","0.5813384","0.5808458","0.5808458","0.5805983","0.5794306","0.5777492","0.57728904","0.57616585","0.5759482","0.574727","0.57444113","0.5719597","0.5718373","0.56856793","0.5679609","0.56648993","0.56607777","0.56518984","0.5651334","0.56426847","0.5630813","0.56269497","0.56208354","0.5620096","0.56093013","0.5606304"],"string":"[\n \"0.7189841\",\n \"0.6974946\",\n \"0.68392825\",\n \"0.68199843\",\n \"0.67975026\",\n \"0.6781155\",\n \"0.67694235\",\n \"0.6714223\",\n \"0.6713853\",\n \"0.6688746\",\n \"0.66411406\",\n \"0.66013426\",\n \"0.6601249\",\n \"0.65606564\",\n \"0.6550351\",\n \"0.6538365\",\n \"0.6532433\",\n \"0.6494333\",\n \"0.6494088\",\n \"0.6472267\",\n \"0.6455442\",\n \"0.63934565\",\n \"0.6371974\",\n \"0.6370674\",\n \"0.6370674\",\n \"0.63516027\",\n \"0.6350023\",\n \"0.6344533\",\n \"0.63407826\",\n \"0.63209283\",\n \"0.6300701\",\n \"0.6291615\",\n \"0.62897724\",\n \"0.62853456\",\n \"0.62823516\",\n \"0.6244864\",\n \"0.62125045\",\n \"0.6198014\",\n \"0.6190049\",\n \"0.6167626\",\n \"0.61662143\",\n \"0.61662143\",\n \"0.61370283\",\n \"0.61152035\",\n \"0.61025673\",\n \"0.6102406\",\n \"0.6072655\",\n \"0.6064118\",\n \"0.6053266\",\n \"0.6051076\",\n \"0.60318583\",\n \"0.60187936\",\n \"0.6015644\",\n \"0.60151154\",\n \"0.6007916\",\n \"0.6001247\",\n \"0.5998845\",\n \"0.5998039\",\n \"0.5988288\",\n \"0.59496343\",\n \"0.5923936\",\n \"0.5916135\",\n \"0.59150624\",\n \"0.59140116\",\n \"0.58977044\",\n \"0.58732146\",\n \"0.58662105\",\n \"0.5863228\",\n \"0.58585864\",\n \"0.5838977\",\n \"0.5831223\",\n \"0.5831223\",\n \"0.5820844\",\n \"0.5818238\",\n \"0.5813384\",\n \"0.5808458\",\n \"0.5808458\",\n \"0.5805983\",\n \"0.5794306\",\n \"0.5777492\",\n \"0.57728904\",\n \"0.57616585\",\n \"0.5759482\",\n \"0.574727\",\n \"0.57444113\",\n \"0.5719597\",\n \"0.5718373\",\n \"0.56856793\",\n \"0.5679609\",\n \"0.56648993\",\n \"0.56607777\",\n \"0.56518984\",\n \"0.5651334\",\n \"0.56426847\",\n \"0.5630813\",\n \"0.56269497\",\n \"0.56208354\",\n \"0.5620096\",\n \"0.56093013\",\n \"0.5606304\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6146334"},"document_rank":{"kind":"string","value":"42"}}},{"rowIdx":22884,"cells":{"query":{"kind":"string","value":"Training logic for an epoch"},"document":{"kind":"string","value":"def _train_epoch(self, epoch):\n raise NotImplementedError"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def train_one_epoch(self):\n raise NotImplementedError","def train(self, training_steps=10):","def train():\n pass","def train_epoch(self, data_loader):\n raise NotImplementedError","def train(self):\n self.epoch = 0\n self.step = 0\n self.start_time = time.time()\n for self.epoch in range(self.num_epochs):\n print(\"EPOHA\")\n self.run_epoch()\n print(\"SAVE MODEL\")\n self.save_model()","def train(self, batch):\n pass","def train():\n # YOUR TRAINING CODE GOES HERE","def train(self, num_batches: int):","def train_epoch(self):\n for batch, targets in self.training_dataloader:\n self.training_step(batch, targets)\n self.calculate_training_loss()\n self.epochs_trained += 1\n LOGGER.info(\n \"Training loss after {} epochs: {}\".format(str(self.epochs_trained), str(self.training_average_loss))\n )","def trainNet():","def train_epoch(self) -> None:\n ct = self.config.training\n total_games = self._get_total_games()\n print(f\"Total Games: {total_games}\")\n train_size = int(0.9 * total_games)\n dataset_wrapper = DatasetWrapper(self.config)\n self.agent.model.fit(\n dataset_wrapper.get_dataset(train_size),\n epochs=ct.epoch_to_checkpoint,\n validation_data=dataset_wrapper.get_dataset(train_size, is_training=False),\n )","def train(self):\n pass","def train(self):\n pass","def train(self):\n pass","def train(self):\n pass","def train(self):\n pass","def _train_epoch(self, epoch):\n self.model.train()\n self.train_metrics.reset()\n for batch_idx, (data, target) in enumerate(self.data_loader):\n data, target = data.to(self.device), target.to(self.device)\n\n self.optimizer.zero_grad()\n\n if self.config[\"amp\"]:\n # AMP!\n with autocast():\n output = self.model(data)\n loss = self.criterion(output, target)\n else:\n output = self.model(data)\n loss = self.criterion(output, target)\n\n loss.backward()\n self.optimizer.step()\n\n self.writer.set_step((epoch - 1) * self.len_epoch + batch_idx)\n self.train_metrics.update(\"loss\", loss.item())\n for met in self.metric_ftns:\n self.train_metrics.update(met.__name__, met(output, target))\n\n if batch_idx % self.log_step == 0:\n self.logger.debug(\n \"Train Epoch: {} {} Loss: {:.6f}\".format(\n epoch, self._progress(batch_idx), loss.item()\n )\n )\n self.writer.add_image(\n \"input\", make_grid(data.cpu(), nrow=8, normalize=True)\n )\n\n if batch_idx == self.len_epoch:\n break\n log = self.train_metrics.result()\n\n if self.do_validation:\n val_log = self._valid_epoch(epoch)\n log.update(**{\"val_\" + k: v for k, v in val_log.items()})\n\n if self.lr_scheduler is not None:\n self.lr_scheduler.step()\n return log","def run_epoch(self):\n self.model_lr_scheduler.step()\n\n print(\"Training\")\n self.set_train()\n\n for batch_idx, inputs in enumerate(self.train_loader):\n\n before_op_time = time.time()\n\n outputs, losses = self.process_batch(inputs)\n\n self.model_optimizer.zero_grad()\n losses[\"loss\"].backward()\n self.model_optimizer.step()\n\n duration = time.time() - before_op_time\n\n # log less frequently after the first 2000 steps to save time & disk space\n early_phase = self.step < 2000\n late_phase = self.step % 2000 == 0\n\n if early_phase or late_phase:\n self.log_time(batch_idx, duration, losses[\"loss\"].cpu().data)\n\n if \"depth_gt\" in inputs:\n self.compute_depth_losses(inputs, outputs, losses)\n\n self.log(\"train\", inputs, outputs, losses)\n self.val()\n\n self.step += 1","def training_phase(self):\r\n self.train_dataloader = self.get_dataloader(\r\n hdf_path=self.train_h5_path,\r\n data_description=\"training set\"\r\n )\r\n self.valid_dataloader = self.get_dataloader(\r\n hdf_path=self.valid_h5_path,\r\n data_description=\"validation set\"\r\n )\r\n\r\n self.get_ts_properties()\r\n\r\n self.initialize_output_files()\r\n\r\n start_epoch, end_epoch = self.define_model_and_optimizer()\r\n\r\n print(\"* Beginning training.\", flush=True)\r\n n_processed_batches = 0\r\n for epoch in range(start_epoch, end_epoch):\r\n\r\n self.current_epoch = epoch\r\n n_processed_batches = self.train_epoch(n_processed_batches=n_processed_batches)\r\n\r\n # evaluate model every `sample_every` epochs (not every epoch)\r\n if epoch % self.C.sample_every == 0:\r\n self.evaluate_model()\r\n else:\r\n util.write_model_status(score=\"NA\") # score not computed\r\n\r\n self.print_time_elapsed()","def run_epoch(model, data, optimizer, epoch):\n traindata, valdata = data\n\n model.train()\n train_bpd = epoch_iter(model, traindata, optimizer, epoch)\n\n model.eval()\n val_bpd = epoch_iter(model, valdata, optimizer, epoch)\n\n return train_bpd, val_bpd","def trainData(self, X, y, NeuralNet, epochs):","def __call__(self, initial_lr, step, epoch):\n\n pass","def train_epoch(model, train_dataloader, optimizer, loss_fn):\n model.train()\n total_training_loss = 0\n for batch_index, batch in enumerate(train_dataloader):\n batch = batch[0].view(-1,1,28,28).float()\n output_batch = model(batch)\n loss = loss_fn(batch, output_batch, model.prev_means, model.prev_vars)\n optimizer.zero_grad()\n loss.backward()\n optimizer.step()\n total_training_loss += loss","def run_epoch(self):\n print(\"Training\")\n self.set_train()\n\n for batch_idx in range(0, self.num_total_batch):\n\n before_op_time = time.time()\n # Choosing the dataloader for training model\n if self.choosing_dataset_to_train_with(batch_idx):\n # Synthetic dataset\n self.syn_or_real = 'syn'\n try:\n inputs = self.syn_train_iter.__next__()\n except StopIteration:\n print('Stopped as the iteration has reached to the END, and reloading the synthetic dataloader')\n self.syn_train_iter = iter(self.syn_train_loader)\n inputs = self.syn_train_iter.__next__()\n else:\n # Real dataset\n self.syn_or_real = 'real'\n try:\n inputs = self.real_train_iter.__next__()\n except StopIteration:\n print('Stopped as the iteration has reached to the END, and reloading the real dataloader')\n self.real_train_iter = iter(self.real_train_loader)\n inputs = self.real_train_iter.__next__()\n\n # Move all available tensors to GPU memory\n for key, ipt in inputs.items():\n if type(key) == tuple or key == \"depth_gt\":\n inputs[key] = ipt.to(self.device)\n\n # log less frequently after the first 2000 steps to save time & disk space\n self.step += 1\n self.early_phase = batch_idx % self.opt.log_frequency == 0\n self.mid_phase = False and self.step % self.opt.save_frequency == 0\n self.late_phase = self.num_total_batch - 1 == batch_idx\n\n outputs, losses = {}, {}\n # Depth estimation\n outputs_d, losses_d = self.process_batch(inputs)\n outputs.update(outputs_d)\n losses.update(losses_d)\n\n # No more if else conditions, just combine all losses based on availability of gradients\n final_loss = torch.tensor(0.).to(self.device)\n for k, v in losses.items():\n if ('d_' not in k) and v.requires_grad and ('/' not in k):\n final_loss += v\n final_loss.backward()\n losses[\"loss\"] = final_loss\n\n if (batch_idx + 1) % 2 == 0:\n self.model_optimizer.step()\n self.model_optimizer.zero_grad()\n self.zero_grad()\n\n duration = time.time() - before_op_time\n self.log_time(batch_idx, duration, losses[\"loss\"].cpu().data)\n\n if \"depth_gt\" in inputs:\n self.compute_depth_losses(inputs, outputs, losses)\n\n if self.early_phase or self.mid_phase or self.late_phase:\n self.log(\"train\", inputs, outputs, losses)\n self.val(\"real\")\n self.val(\"syn\")\n\n if (batch_idx + 1) % 2 == 0:\n current_lr = self.update_learning_rate(self.model_optimizer, self.opt.learning_rate)","def train_epoch(self):\r\n for loader in self.loaders:\r\n if self.epoch % loader.epoch_interval == 0:\r\n self.cycle_dataset(loader)\r\n\r\n self._stats_new_epoch()\r\n self._write_tensorboard()\r\n print('{}th epoch train / eval done!'.format(self.epoch))","def train(self):\n self.epoch = 0\n self.step = 0\n self.start_time = time.time()\n for self.epoch in range(self.opt.num_epochs):\n self.run_epoch()\n if (self.epoch + 1) % self.opt.save_frequency == 0:\n self.save_model()","def _evaluate_during_fit(self, test_loader, epoch):","def _train_epoch(self, model, tqdm_data,\n optimizer_disc=None, optimizer_gen=None):","def Train(self):\n self.init_epoch = self.epoch\n if self.epoch >= self.params.num_epoch:\n WARNING('Num_epoch should be smaller than current epoch. Skip training......\\n')\n else:\n for _ in range(self.epoch, self.params.num_epoch):\n self.epoch += 1\n print('-' * 20 + 'Epoch.' + str(self.epoch) + '-' * 20)\n\n # train one epoch\n self.train_one_epoch()\n\n # should display\n if self.epoch % self.params.display == 0:\n print('\\tTrain loss: %.4f' % self.train_loss[-1])\n\n # should save\n if self.params.should_save:\n if self.epoch % self.params.save_every == 0:\n self.save_checkpoint()\n\n # test every params.test_every epoch\n if self.params.should_val:\n if self.epoch % self.params.val_every == 0:\n self.val_one_epoch()\n print('\\tVal loss: %.4f' % self.val_loss[-1])\n\n # adjust learning rate\n self.adjust_lr()\n self.train_one_epoch_Image_display() \n \n # save the last network state\n if self.params.should_save:\n self.save_checkpoint()\n\n # train visualization\n self.plot_curve()","def train_epoch(model, training_data, optimizer, pred_loss_func, opt):\n\n model.train()\n\n total_event_ll = 0 # cumulative event log-likelihood\n total_time_se = 0 # cumulative time prediction squared-error\n total_time_error = 0 # cumulative time prediction squared-error\n total_time_latitude = 0 # cumulative latitude prediction squared-error\n total_time_longitude = 0 # cumulative longitude prediction squared-error\n total_event_rate = 0 # cumulative number of correct prediction\n total_num_event = 0 # number of total events\n total_num_pred = 0 # number of predictions\n for batch in tqdm(training_data, mininterval=2,\n desc=' - (Training) ', leave=False):\n \"\"\" prepare data \"\"\"\n event_time, time_gap, event_type, latitude, longitude = map(lambda x: x.to(opt.device), batch)\n\n \"\"\" forward \"\"\"\n optimizer.zero_grad()\n\n enc_out, prediction = model(event_type, event_time, latitude, longitude) # change the event_time to time gap\n\n \"\"\" backward \"\"\"\n # negative log-likelihood\n event_ll, non_event_ll = Utils.log_likelihood(model, enc_out, event_time, event_type, latitude, longitude) # change the event_time to time gap\n event_loss = -torch.sum(event_ll - non_event_ll)\n\n # type prediction\n pred_loss, pred_num_event = Utils.type_loss(prediction[0], event_type, pred_loss_func)\n\n # time prediction\n se = Utils.time_loss(prediction[1], event_time) # change the event_time to time gap\n\n # latitude prediction\n le = Utils.time_loss(prediction[2], latitude)\n\n # longitude prediction\n ge = Utils.time_loss(prediction[3], longitude)\n\n # SE is usually large, scale it to stabilize training\n scale_time_loss = 100\n loss = event_loss + pred_loss + se / scale_time_loss + le / scale_time_loss + ge / scale_time_loss\n loss.backward()\n\n \"\"\" update parameters \"\"\"\n optimizer.step()\n\n \"\"\" note keeping \"\"\"\n total_event_ll += -event_loss.item()\n total_time_se += se.item() + le.item() + ge.item()\n total_time_error += se.item()\n total_time_latitude += le.item()\n total_time_longitude += ge.item()\n\n total_event_rate += pred_num_event.item()\n total_num_event += event_type.ne(Constants.PAD).sum().item()\n # we do not predict the first event\n total_num_pred += event_type.ne(Constants.PAD).sum().item() - event_time.shape[0]\n\n total_rmse = np.sqrt(total_time_se / total_num_pred)\n time_rmse = np.sqrt(total_time_error / total_num_pred)\n latitude_rmse = np.sqrt(total_time_latitude / total_num_pred)\n longitude_rmse = np.sqrt(total_time_longitude / total_num_pred)\n print('Time: {:5f} Latitude: {:5f} Longitude: {:5f} Overall: {:5f} '.format(time_rmse, latitude_rmse, longitude_rmse, total_rmse))","def train(self, batch_training=False):\n raise NotImplementedError","def train_epoch(self, train=False):\n # init params\n config = self.config\n writer = self.writer\n train_params = self.get_train_params()\n args = self.args\n # net, net_SP = self.net, self.net_SP\n optimizer, optimizer_SP = self.optimizer, self.optimizer_SP\n\n lr = self.get_learning_rate()\n logging.info(f\"current learning rate: {lr}\")\n\n running_losses = []\n self.save_lists = [\n \"err_q\",\n \"err_t\",\n \"epi_dists\",\n \"relative_poses_cam\",\n \"relative_poses_body\",\n ]\n dict_of_lists_in_train = init_dict_of_lists(config, self.save_lists)\n dict_of_lists_in_val = init_dict_of_lists(config, self.save_lists)\n if_val_in_train_trigger = False\n\n thd_corr = 300\n writer.add_scalar(\"training-lr\", lr, self.n_iter)\n\n # Train one epoch\n for i, sample_train in tqdm(enumerate(self.train_loader)):\n # if training\n if train:\n # eval in training script\n if (\n self.n_iter != 0\n and self.n_iter % config[\"training\"][\"val_interval_in_train\"] == 0\n ):\n if_val_in_train_trigger = True\n if if_val_in_train_trigger:\n logging.info(\n \"+++[Train]+++ Collecting training batch for %s at train step %d\"\n % (args.exper_name, self.n_iter)\n )\n self.net.eval()\n else:\n self.net.train()\n\n # train one batch\n (\n loss_train_out,\n dict_of_lists_in_train,\n clamp_cum,\n ) = self.train_val_batch(\n train_params,\n sample_train,\n True,\n if_val=if_val_in_train_trigger,\n dict_of_lists=dict_of_lists_in_train,\n )\n\n if if_val_in_train_trigger:\n if (\n dict_of_lists_in_train[\"count\"]\n > config[\"training\"][\"val_batches\"]\n ):\n dict_of_lists_in_train = self.flush_dict_of_lists(\n writer, \"training\", self.n_iter, **dict_of_lists_in_train\n )\n if_val_in_train_trigger = False\n else:\n # running_losses.append(loss_train_out)\n print(self.n_iter, \"%.8f\" % loss_train_out)\n self.n_iter += 1\n\n # if testing\n if args.eval and self.n_iter % config[\"training\"][\"val_interval\"] == 0:\n logging.info(\n \"+++[Val]+++ Validating %s at train step %d\"\n % (args.exper_name, self.n_iter)\n )\n self.net.eval()\n assert self.net.training == False\n for j, sample_val in tqdm(enumerate(self.val_loader)):\n # if not self.check_num_of_matches(sample, thd=thd_corr): continue\n logging.info(\"+++[Val]+++ Validating batch %d\" % (j))\n # logging.info(f\"frame_id: {sample_val['frame_ids']}\")\n loss_val_out, dict_of_lists_in_val, _ = self.train_val_batch(\n train_params, sample_val,\n False, if_val=True, dict_of_lists=dict_of_lists_in_val,\n ) ##### check: in order to align val and training\n self.n_iter_val += 1\n if config[\"training\"][\"val_batches\"] != -1 and (\n j > config[\"training\"][\"val_batches\"]\n ): ##### check: how to limit the validation\n break\n print(dict_of_lists_in_val.keys())\n\n ## save valdiation result (dict)\n if len(config[\"exps\"][\"filename\"]) > 3:\n # print(f\"dict_of_lists_in_val: {dict_of_lists_in_val}\")\n def get_dict(key_layer1, key_layer2, dict_of_lists):\n dict_of_array = {}\n for k in key_layer1:\n dict_of_array[k] = np.stack(dict_of_lists[k][key_layer2])\n return dict_of_array\n\n our_name, base_name = (\n config[\"exps\"][\"our_name\"],\n config[\"exps\"][\"base_name\"],\n )\n\n print(f'save dict_of_lists_in_val to {config[\"exps\"][\"filename\"]}')\n # save our results\n dict_of_lists = get_dict(\n self.save_lists, our_name, dict_of_lists_in_val\n )\n dict_of_lists[\"epi_dists\"] = dict_of_lists[\"epi_dists\"][:, :10] ### only take part of it\n np.savez(\n f'{self.save_path[:-11]}/{our_name}_{config[\"exps\"][\"filename\"]}',\n **dict_of_lists,\n )\n # save base_name\n dict_of_lists = get_dict(\n self.save_lists, base_name, dict_of_lists_in_val\n )\n dict_of_lists[\"epi_dists\"] = dict_of_lists[\"epi_dists\"][:, :10] ### only take part of it\n np.savez(\n f'{self.save_path[:-11]}/{base_name}_{config[\"exps\"][\"filename\"]}',\n **dict_of_lists,\n )\n # output then flush\n dict_of_lists_in_val = self.flush_dict_of_lists(\n writer, \"validating\", self.n_iter, **dict_of_lists_in_val\n )\n\n # epoch_loss = np.mean(np.asarray(running_losses))\n\n # training iterations\n self.epoch += 1\n if self.n_iter > config[\"training\"][\"train_iter\"]:\n break\n return 0.0, self.clamp_cum, self.n_iter, self.n_iter_val","def learn(self):\n epochswin = [] # count the number of wins at every epoch of the network against the preceding version\n epochdraw = [] # count the number of draws at every epoch of the network against the preceding version\n epochswingreedy = [] # count the number of wins against greedy at every epoch\n epochswinrandom = [] # count the number of wins against random at every epoch\n epochsdrawgreedy = [] # count the number of draws against greedy at every epoch\n epochsdrawrandom = [] # count the number of wins against random at every epoch\n epochswinminmax = [] # count the number of wins against minmax at every epoch\n epochsdrawminmax = [] # count the number of draws against minmax at every epoch\n\n\n if self.args.load_model == True:\n file = open(self.args.trainExampleCheckpoint + \"graphwins:iter\" + str(self.args.numIters) + \":eps\" + str(\n self.args.numEps) + \":dim\" + str(self.game.n) + \".txt\", \"r+\")\n lines = file.readlines()\n for index, line in enumerate(lines):\n for word in line.split():\n if index == 0:\n epochswin.append(word)\n elif index == 1:\n epochdraw.append(word)\n file.close()\n\n file = open(self.args.trainExampleCheckpoint + \"graphwins:iter\" + str(self.args.numIters) + \":eps\" + str(\n self.args.numEps) + \":dim\" + str(self.game.n) + \":greedyrandom.txt\", \"r+\")\n lines = file.readlines()\n for index, line in enumerate(lines):\n for word in line.split():\n if index == 0:\n epochswingreedy.append(word)\n elif index == 1:\n epochsdrawgreedy.append(word)\n elif index == 2:\n epochswinrandom.append(word)\n elif index == 3:\n epochsdrawrandom.append(word)\n elif index == 4:\n epochswinminmax.append(word)\n elif index == 5:\n epochsdrawminmax.append(word)\n file.close()\n self.loadTrainExamples()\n\n for i in range(1, self.args.numIters + 1):\n # bookkeeping\n print('------ITER ' + str(i) + '------')\n # examples of the iteration\n iterationTrainExamples = deque([], maxlen=self.args.maxlenOfQueue)\n\n eps_time = AverageMeter()\n bar = Bar('Self Play', max=self.args.numEps)\n end = time.time()\n\n for eps in range(self.args.numEps):\n iterationTrainExamples += self.executeEpisode()\n\n # bookkeeping + plot progress\n eps_time.update(time.time() - end)\n end = time.time()\n bar.suffix = '({eps}/{maxeps}) Eps Time: {et:.3f}s | Total: {total:} | ETA: {eta:}'.format(eps=eps + 1,\n maxeps=self.args.numEps,\n et=eps_time.avg,\n total=bar.elapsed_td,\n eta=bar.eta_td)\n bar.next()\n bar.finish()\n\n # save the iteration examples to the history\n self.trainExamplesHistory.append(iterationTrainExamples)\n\n if len(self.trainExamplesHistory) > self.args.numItersForTrainExamplesHistory:\n print(\"len(trainExamplesHistory) =\", len(self.trainExamplesHistory),\n \" => remove the oldest trainExamples\")\n self.trainExamplesHistory.pop(0)\n # backup history to a file\n # NB! the examples were collected using the model from the previous iteration, so (i-1)\n self.saveTrainExamples(i - 1)\n\n # shuffle examlpes before training\n trainExamples = []\n for e in self.trainExamplesHistory:\n trainExamples.extend(e)\n shuffle(trainExamples)\n\n # training new network, keeping a copy of the old one\n\n filename = \"curent\"+str(i)+\"temp:iter\" + str(self.args.numIters) + \":eps\" + str(self.args.numEps) + \":dim\" + str(\n self.game.n) + \".pth.tar\"\n filenameBest = \"best\" + str(self.args.numIters) + \":eps\" + str(self.args.numEps) + \":dim\" + str(\n self.game.n) + \".pth.tar\"\n\n self.nnet.save_checkpoint(folder=self.args.checkpoint, filename=filename)\n exists = os.path.isfile(filenameBest)\n if exists:\n self.pnet.load_checkpoint(folder=self.args.checkpoint, filename=filenameBest)\n else:\n self.pnet.load_checkpoint(folder=self.args.checkpoint, filename=filename)\n pmcts = MCTS(self.game, self.pnet, self.args)\n\n self.nnet.train(trainExamples)\n nmcts = MCTS(self.game, self.nnet, self.args)\n\n print('PITTING AGAINST PREVIOUS VERSION')\n arena = Arena(lambda x: np.argmax(pmcts.getActionProb(x, temp=0)),\n lambda x: np.argmax(nmcts.getActionProb(x, temp=0)), self.game,nmcts,pmcts,evaluate=True)\n\n pwins, nwins, draws = arena.playGames(self.args.arenaCompare, False)\n\n pmcts.clear()\n nmcts.clear()\n del pmcts\n del nmcts\n\n print(' ')\n print('NEW/PREV WINS : %d / %d ; DRAWS : %d' % (nwins, pwins, draws))\n if i == 1:\n epochswin.append(pwins)\n epochdraw.append(0)\n\n epochswin.append(nwins)\n epochdraw.append(draws)\n self.writeLogsToFile(epochswin, epochdraw)\n\n ''' Get all the players and then pit them against the network. You need to modify here if you implement \n more players\n '''\n (gp, rp, mp) = self.decidePlayers()\n\n if self.args.parallel == 0:\n\n\n nmcts1 = MCTS(self.game, self.nnet, self.args)\n nmcts2 = MCTS(self.game, self.nnet, self.args)\n nmcts3 = MCTS(self.game, self.nnet, self.args)\n\n arenagreedy = Arena(lambda x: np.argmax(nmcts1.getActionProb(x, temp=0)), gp, self.game,nmcts1)\n arenarandom = Arena(lambda x: np.argmax(nmcts2.getActionProb(x, temp=0)), rp, self.game,nmcts2)\n arenaminmax = Arena(lambda x: np.argmax(nmcts3.getActionProb(x, temp=0)), mp, self.game,nmcts3,evaluate=True)\n\n pwinsminmax, nwinsminmax, drawsminmax = arenaminmax.playGames(self.args.arenaCompare)\n print(\"minmax - \"+str(pwinsminmax)+\" \"+str(nwinsminmax)+\" \"+str(drawsminmax))\n pwinsgreedy, nwinsgreedy, drawsgreedy = arenagreedy.playGames(self.args.arenaCompare)\n print(\"greedy - \"+str(pwinsgreedy)+\" \"+str(nwinsgreedy)+\" \"+str(drawsgreedy))\n pwinsreandom, nwinsrandom, drawsrandom = arenarandom.playGames(self.args.arenaCompare)\n print(\"random - \"+str(pwinsreandom)+\" \"+str(nwinsrandom)+\" \"+str(drawsrandom))\n\n nmcts1.clear()\n nmcts2.clear()\n nmcts3.clear()\n del nmcts1\n del nmcts2\n del nmcts3\n\n else:\n '''\n This will be used if you want to evaluate the network against the benchmarks in a parallel way\n '''\n\n self.args.update({'index': str(i)})\n\n p = self.parallel(self.args.arenaCompare)\n (pwinsminmax, nwinsminmax, drawsminmax) = p[0] # self.parallel(\"minmax\", self.args.arenaCompare)\n (pwinsgreedy, nwinsgreedy, drawsgreedy) = p[1] # self.parallel(\"greedy\",self.args.arenaCompare)\n (pwinsreandom, nwinsrandom, drawsrandom) = p[2] # self.parallel(\"random\",self.args.arenaCompare)\n\n epochsdrawgreedy.append(drawsgreedy)\n epochsdrawrandom.append(drawsrandom)\n epochswinrandom.append(pwinsreandom)\n epochswingreedy.append(pwinsgreedy)\n epochswinminmax.append(pwinsminmax)\n epochsdrawminmax.append(drawsminmax)\n\n self.writeLogsToFile(epochswingreedy, epochsdrawgreedy, epochswinrandom, epochsdrawrandom, epochswinminmax,\n epochsdrawminmax, training=False)\n\n if pwins + nwins == 0 or float(nwins) / (pwins + nwins) <= self.args.updateThreshold:\n print('REJECTING NEW MODEL')\n filename = \"curent\"+str(i)+\"temp:iter\" + str(self.args.numIters) + \":eps\" + str(self.args.numEps) + \":dim\" + str(\n self.game.n) + \".pth.tar\"\n filenameBest = \"best\" + str(self.args.numIters) + \":eps\" + str(self.args.numEps) + \":dim\" + str(\n self.game.n) + \".pth.tar\"\n exists = os.path.isfile(filenameBest)\n if exists:\n self.nnet.load_checkpoint(folder=self.args.checkpoint, filename=filenameBest)\n else:\n self.nnet.load_checkpoint(folder=self.args.checkpoint, filename=filename)\n\n else:\n print('ACCEPTING NEW MODEL')\n\n filename = \"best\" + str(self.args.numIters) + \":eps\" + str(self.args.numEps) + \":dim\" + str(\n self.game.n) + \".pth.tar\"\n self.nnet.save_checkpoint(folder=self.args.checkpoint, filename=self.getCheckpointFile(i))\n self.nnet.save_checkpoint(folder=self.args.checkpoint, filename=filename)\n self.mcts.clear()\n del self.mcts\n self.mcts = MCTS(self.game, self.nnet, self.args, mcts=True) # reset search tree\n print(self.tracker.print_diff())\n self.writeLogsToFile(epochswin, epochdraw, training=True)","def train_epoch(args, loss_func, pbar, train_loader, model, optimizer,\n train_bpd, train_recon_error , train_perplexity):\n model.train()\n # Loop data in epoch\n for x, _ in train_loader:\n\n # This break used for debugging\n if args.max_iterations is not None:\n if args.global_it > args.max_iterations:\n break\n\n x = x.to(args.device)\n\n # Get reconstruction and vector quantization loss\n # `x_prime`: reconstruction of `input`\n # `vq_loss`: MSE(encoded embeddings, nearest emb in codebooks)\n x_prime, vq_loss, perplexity = model(x)\n\n loss, log_pxz, bpd = loss_func(args, x_prime, x, vq_loss, model)\n\n optimizer.zero_grad()\n loss.backward()\n optimizer.step()\n\n train_bpd.append((-1)*bpd.item())\n train_recon_error.append((-1)*log_pxz.item())\n train_perplexity.append(perplexity.item())\n\n # Print Average every 100 steps\n if (args.global_it+1) % 100 == 0:\n av_bpd = np.mean(train_bpd[-100:])\n av_rec_err = np.mean(train_recon_error[-100:])\n av_ppl = np.mean(train_perplexity[-100:])\n if args.model == 'vqvae':\n pbar.print_train(bpd=float(av_bpd), rec_err=float(av_rec_err),\n increment=100)\n elif args.model == 'diffvqvae':\n pbar.print_train(bpd=float(av_bpd), temp=float(model.temp),\n increment=100)\n args.global_it += 1","def train(self):\n raise NotImplementedError","def train(self, epoch=50):\n # self.history = self.model.fit(self.train_images,\n # self.train_labels,\n # epochs=epoch,\n # validation_data=(self.test_images, self.test_labels))\n datagen = ImageDataGenerator(width_shift_range=0.1, height_shift_range=0.1,\n horizontal_flip=True)\n # prepare iterator\n it_train = datagen.flow(self.train_images, self.train_labels, batch_size=64)\n # fit model\n steps = int(self.train_images.shape[0] / 64)\n self.history = self.model.fit_generator(it_train, steps_per_epoch=steps,\n epochs=epoch,\n validation_data=(self.test_images,\n self.test_labels),\n verbose=1)\n # evaluate model\n _, acc = self.model.evaluate(self.test_images, self.test_labels, verbose=0)\n LOGGER.info('> %.3f' % (acc * 100.0))\n self.summarize_diagnostics()","def run_epoch(model, data, optimizer):\n traindata, valdata = data\n\n model.train()\n train_elbo = epoch_iter(model, traindata, optimizer)\n\n model.eval()\n val_elbo = epoch_iter(model, valdata, optimizer)\n\n return train_elbo, val_elbo","def run_epoch(model, data, optimizer):\n traindata, valdata = data\n\n model.train()\n train_elbo = epoch_iter(model, traindata, optimizer)\n\n model.eval()\n val_elbo = epoch_iter(model, valdata, optimizer)\n\n return train_elbo, val_elbo","def train_step(self):\n pass","def train_model_epoch(self, epoch_idx, tuning=False):\n acc_loss = 0\n\n num_batch = self.model.config.kg_meta.tot_train_triples // self.config.batch_size if not self.debug else 10\n \n metrics_names = ['acc_loss', 'loss'] \n progress_bar = tf.keras.utils.Progbar(num_batch, stateful_metrics=metrics_names)\n\n for batch_idx in range(num_batch):\n data = list(next(self.generator))\n \n if self.training_strategy == \"projection_based\":\n h = tf.convert_to_tensor(data[0], dtype=tf.int32)\n r = tf.convert_to_tensor(data[1], dtype=tf.int32)\n t = tf.convert_to_tensor(data[2], dtype=tf.int32)\n hr_t = data[3] # tf.convert_to_tensor(data[3], dtype=tf.float32)\n rt_h = data[4] # tf.convert_to_tensor(data[4], dtype=tf.float32)\n loss = self.train_step_projection(h, r, t, hr_t, rt_h)\n elif self.training_strategy == \"pointwise_based\":\n h = tf.convert_to_tensor(data[0], dtype=tf.int32)\n r = tf.convert_to_tensor(data[1], dtype=tf.int32)\n t = tf.convert_to_tensor(data[2], dtype=tf.int32)\n y = tf.convert_to_tensor(data[3], dtype=tf.float32)\n loss = self.train_step_pointwise(h, r, t, y)\n else:\n ph = tf.convert_to_tensor(data[0], dtype=tf.int32)\n pr = tf.convert_to_tensor(data[1], dtype=tf.int32)\n pt = tf.convert_to_tensor(data[2], dtype=tf.int32)\n nh = tf.convert_to_tensor(data[3], dtype=tf.int32)\n nr = tf.convert_to_tensor(data[4], dtype=tf.int32)\n nt = tf.convert_to_tensor(data[5], dtype=tf.int32)\n loss = self.train_step(ph, pr, pt, nh, nr, nt)\n\n acc_loss += loss\n\n if not tuning:\n progress_bar.add(1, values=[('acc_loss', acc_loss), ('loss', loss)])\n\n self.training_results.append([epoch_idx, acc_loss.numpy()])\n\n return acc_loss","def train(self, training_data):\n pass","def train(self):\n\t\traise NotImplementedError","def training(self):\n \n best_valid_loss = np.inf\n c = 0\n \n self.train_loader, self.test_loader = self.get_train_test_loaders()\n \n print('Training the {} model with the following architecture:'.format(self.model_name))\n print(summary(self.model, (3, self.image_width, self.image_height)))\n print('*'*100)\n print('Starting the training...')\n print('*'*100)\n \n # Create the model save dir if it already doesn't exist\n if not os.path.exists(self.model_save_dir):\n os.makedirs(self.model_save_dir)\n \n for epoch in range(self.n_epochs):\n\n print(f'Epoch: {epoch+1:02}')\n\n start_time = time.time()\n\n train_loss = self.train(self.train_loader)\n valid_loss = self.evaluate(self.test_loader)\n\n epoch_mins, epoch_secs = self.epoch_time(start_time, time.time())\n\n c+=1\n if valid_loss < best_valid_loss:\n best_valid_loss = valid_loss\n torch.save(self.model.state_dict(), os.path.join(self.model_save_dir, '{}_trained.pt'.format(self.model_name)))\n c=0\n\n if c>4:\n #decrease lr if loss does not decrease after 5 steps\n self.scheduler.step()\n c=0\n\n print(f'Time: {epoch_mins}m {epoch_secs}s') \n print(f'Train Loss: {train_loss:.3f}')\n print(f'Val Loss: {valid_loss:.3f}')\n print('-'*60)\n print('The best validation loss is', best_valid_loss)\n print('*'*100)","def step(self, epoch):\n\n self.train(epoch)\n self.test(epoch)","def train_epoch(self, epoch):\n t1 = time()\n output = {'tp': [], 'fp': [], 'fn': [], 'tn': [], 'loss': [], 'preds': [], 'true': 0, 'ttotal': []}\n self.acc_NA.clear()\n self.acc_not_NA.clear()\n self.acc_total.clear()\n\n self.model.train()\n # 多个batch的数据\n train_iter = self.iterator(self.data['train'], batch_size=self.params['batch'],\n shuffle_=self.params['shuffle_data'])\n\n for batch_idx, batch in enumerate(train_iter):\n # print(\"batch_idx\", batch_idx)\n batch = self.convert_batch(batch, istrain=True)\n\n # with autograd.detect_anomaly():\n self.optimizer.zero_grad()\n loss, stats, predictions, select, pred_pairs, multi_truths, mask, relation_label = self.model(batch)\n pred_pairs = torch.sigmoid(pred_pairs)\n # self.optimizer.zero_grad()\n loss.backward() # backward computation\n\n nn.utils.clip_grad_norm_(self.model.parameters(), self.gc) # gradient clipping\n self.optimizer.step() # update\n if self.scheduler!=None:\n self.scheduler.step()\n\n relation_label = relation_label.to('cpu').data.numpy()\n predictions = predictions.to('cpu').data.numpy()\n # batches\n output['loss'] += [float(loss.item())]\n output['tp'] += [stats['tp'].to('cpu').data.numpy()]\n output['fp'] += [stats['fp'].to('cpu').data.numpy()]\n output['fn'] += [stats['fn'].to('cpu').data.numpy()]\n output['tn'] += [stats['tn'].to('cpu').data.numpy()]\n output['preds'] += [predictions]\n output['ttotal'] += [stats['ttotal']]\n\n for i in range(predictions.shape[0]):\n label = relation_label[i]\n if label < 0:\n break\n if label == self.loader.label2ignore:\n self.acc_NA.add(predictions[i] == label)\n else:\n self.acc_not_NA.add(predictions[i] == label)\n self.acc_total.add(predictions[i] == label)\n # 一个epoch\n total_loss, scores = self.performance(output)\n t2 = time()\n\n self.train_res['loss'] += [total_loss]\n self.train_res['score'] += [scores[self.primary_metric]]\n self.train_res['p'] += [scores['micro_p']]\n self.train_res['r'] += [scores['micro_r']]\n\n print('Epoch: {:02d} | TRAIN | LOSS = {:.05f}, | NA acc: {:4.2f} | not NA acc: {:4.2f} | tot acc: {:4.2f}'.\n format(epoch, total_loss, self.acc_NA.get(), self.acc_not_NA.get(), self.acc_total.get()), end=\"\")\n print_results(scores, [], False, t2 - t1)\n print(\"TTotal\\t\", sum(output['ttotal']))\n return scores['micro_f']","def _train_epoch(self, epoch):\n self.model.train()\n self.train_metrics.reset()\n for batch_idx, (data, target_seg, target_class) in enumerate(self.data_loader):\n data, target_seg, target_class = data.to(self.device), target_seg.to(self.device), target_class.to(self.device)\n\n self.optimizer.zero_grad()\n output_seg, output_class = self.model(data)\n loss = self.criterion((output_seg, output_class), target_seg, target_class, epoch)\n loss.backward()\n self.optimizer.step()\n\n self.writer.set_step((epoch - 1) * self.len_epoch + batch_idx)\n self.train_metrics.update('loss', loss.item())\n for met in self.metric_ftns:\n if met.__name__ == \"accuracy\":\n self.train_metrics.update(met.__name__, met(output_class, target_class))\n else:\n self.train_metrics.update(met.__name__, met(output_seg, target_seg))\n\n if batch_idx % self.log_step == 0:\n self.logger.debug('Train Epoch: {} {} Loss: {:.6f}'.format(\n epoch,\n self._progress(batch_idx),\n loss.item()))\n\n self._visualize_input(data.cpu())\n\n if batch_idx == self.len_epoch:\n break\n log = self.train_metrics.result()\n\n if self.do_validation:\n val_log = self._valid_epoch(epoch)\n log.update(**{'val_'+k : v for k, v in val_log.items()})\n\n if self.lr_scheduler is not None:\n self.lr_scheduler.step()\n\n return log","def training(self) -> None:\n self.compile_model()\n self.train_epoch()\n self.agent.save()","def train_one_epoch(self):\n\t\tself.model.train()\n\t\ttrain_loss = 0\n\n\t\tfor batch_idx, data in enumerate(self.data_loader.train_loader):\n\t\t\tInput = data[0].float().to(self.device)\n\t\t\tOutput = data[1].float().to(self.device)\n\n\t\t\tself.optimizer.zero_grad()\n\t\t\tloss = self.loss(self.model(Input)[:,0],Output)\n\t\t\ttrain_loss += loss.item()\n\t\t\tloss.backward()\n\t\t\tself.optimizer.step()\n\t\t\tself.current_iteration += 1\n\n\t\tself.summary_writer.add_scalar('training/loss', loss.item(), self.current_epoch)","def run_epoch( self ):\n # --- Init Epoch ----\n total_epoch_loss = 0.0\n epoch_batches = self.dataset.dataloader( self.config.neuron.epoch_length )\n progress_bar = qqdm(enumerate(epoch_batches), total=len(epoch_batches), desc=format_str('blue', f'Epoch Progress'))\n for iteration, (inputs) in progress_bar:\n\n # ---- Forward / Backward ----\n prev_mechanism_weights = self.mechanism_weights.tolist()\n output = self.train ( batch = { 'inputs': inputs } )\n next_mechanism_weights = self.mechanism_weights.tolist()\n total_epoch_loss += output.local_target_loss.item()\n\n # ---- Logs ----\n self.epoch_logs (\n progress_bar,\n iteration = iteration,\n output = output,\n prev_mechanism_weights = prev_mechanism_weights,\n next_mechanism_weights = next_mechanism_weights\n )\n self.global_step += 1\n\n self.epoch_loss = total_epoch_loss / self.config.neuron.epoch_length\n self.epoch += 1","def train_epoch(self, epoch, evaluator, optimizer, perf_path, perf_trace, state_fpath, writer_tensorboard):\n\n # Train an epoch\n self.model.train()\n print('Start epoch', epoch)\n train_itr = iter(self.loader_train)\n total_err = 0\n total_acc = 0\n\n for index, (data_pixel, data_labels) in enumerate(train_itr):\n\n # compute\n input_data = data_pixel.float().cuda()\n data_labels = data_labels.cuda()\n\n # Use the model the produce the classification\n grapheme_logits, vowel_logits, consonant_logits = self.model(input_data)\n\n # produce evaluator results\n eval_result = evaluator(grapheme_logits, vowel_logits, consonant_logits, data_labels)\n\n # set optimizer to zero.\n optimizer.zero_grad()\n\n # back propogate the evaluation results.\n eval_result['loss'].backward()\n\n # optimizer take step forward.\n optimizer.step()\n\n # tabulate the steps from the evaluation\n eval_result = {k: eval_result[k].item() for k in eval_result}\n\n # update every hundreds' of\n if index % 100 == 0:\n print(index, eval_result['loss'], eval_result['acc'])\n train_result = evaluator.evalulate_on_cache()\n train_total_err = train_result['loss']\n writer_tensorboard.add_scalar('Loss/Train', train_total_err, global_step=epoch)\n # log_metric('loss', train_total_err)\n train_total_acc = train_result['acc']\n writer_tensorboard.add_scalar('Accuracy/Train', train_total_acc, global_step=epoch)\n # log_metric('acc', train_total_acc)\n train_kaggle_score = train_result['kaggle_score']\n writer_tensorboard.add_scalar('Kaggle_Score/Train', train_kaggle_score, global_step=epoch)\n # log_metric('kaggle_score', train_kaggle_score)\n dict_metrics_train = {\n 'Loss/Train': train_total_err,\n 'Accuracy/Train': train_total_acc,\n 'Kaggle_Score/Train': train_kaggle_score,\n }\n log_metrics(dict_metrics_train, step=epoch)\n print(f\"Epoch {epoch} Training, Loss {train_total_err}, Acc {train_total_acc}\")\n evaluator.clear_cache()\n # compute validation error\n self.model.eval()\n val_itr = iter(self.loader_val)\n with torch.no_grad():\n for index, (data_pixel, data_labels) in enumerate(val_itr):\n input_data = data_pixel.float().cuda()\n data_labels = data_labels.cuda()\n grapheme_logits, vowel_logits, consonant_logits = self.model(input_data)\n eval_result = evaluator(grapheme_logits, vowel_logits, consonant_logits, data_labels)\n eval_result = {k: eval_result[k].item() for k in eval_result}\n total_err += eval_result['loss']\n total_acc += eval_result['acc']\n # print(total_err / (1 + input_index), total_acc / (1 + input_index))\n val_result = evaluator.evalulate_on_cache()\n val_total_err = val_result['loss']\n writer_tensorboard.add_scalar('Loss/Val', val_total_err, global_step=epoch)\n val_total_acc = val_result['acc']\n writer_tensorboard.add_scalar('Accuracy/Val', val_total_acc, global_step=epoch)\n val_kaggle_score = val_result['kaggle_score']\n writer_tensorboard.add_scalar('Kaggle_Score/Val', val_kaggle_score, global_step=epoch)\n dict_metrics_val = {\n 'Loss/Validation': val_total_err,\n 'Accuracy/Validation': val_total_acc,\n 'Kaggle_Score/Validation': val_kaggle_score,\n }\n log_metrics(dict_metrics_val, step=epoch)\n # Write to disk.\n writer_tensorboard.flush()\n print(f\"Epoch {epoch} Eval, Loss {val_total_err}, Acc {val_total_acc}\")\n evaluator.clear_cache()\n print(\"Saving the model (epoch %d)\" % epoch)\n torch.save({\n \"epoch\": epoch + 1,\n \"model_state\": self.model.state_dict(),\n \"optimizer_state\": optimizer.state_dict(),\n }, state_fpath)\n print(f\"Making a backup (step {epoch})\")\n backup_fpath = os.path.join(self.backup_dir, f\"model_bak_{epoch}.pt\")\n torch.save({\n \"epoch\": epoch + 1,\n \"model_state\": self.model.state_dict(),\n \"optimizer_state\": optimizer.state_dict(),\n }, backup_fpath)\n # Dump the traces\n perf_trace.append(\n {\n 'epoch': epoch,\n 'train_err': train_total_err,\n 'train_acc': train_total_acc,\n 'train_kaggle_score': train_kaggle_score,\n 'val_err': val_total_err,\n 'val_acc': val_total_acc,\n 'val_kaggle_score': val_kaggle_score\n }\n )\n pickle.dump(perf_trace, open(perf_path, 'wb'))\n # store epoch full result separately\n epoch_result = {\n 'epoch': epoch,\n 'train_result': train_result,\n 'val_result': val_result\n }\n pickle.dump(epoch_result, open(os.path.join(self.results_dir, 'result_epoch_{0}.p'.format(epoch)), 'wb'))","def _train(self):\n step = 0\n for epoch in range(self.opts.num_epochs):\n self.hub.publish(Topic.EPOCH, epoch)\n for i, data in enumerate(self.loader):\n # Compute loss ...\n # NOTE(ycho): if one of the callbacks require training loss,\n # e.g. for logging, simply register a hook to the loss module\n # rather than trying to extract them here.\n loss = self.loss_fn(self.model, data)\n self.hub.publish(Topic.TRAIN_LOSS, loss)\n\n # Backprop + Optimize ...\n self.optim.zero_grad()\n loss[\"total\"].backward()\n self.optim.step()\n\n # Emit `step` event.\n # == logging, saving, evaluation\n self.hub.publish(Topic.STEP, step)\n step += 1\n\n if step >= self.opts.train_steps:\n return","def train(self, ):\n raise NotImplementedError","def train(self):\n self.training = True","def _train_epoch(self, epoch):\n\t\tstart = time.time()\n\t\tself.model.train()\n\t\tfor batch_idx, (images, labels) in enumerate(self.train_loader):\n\n\t\t\timages, labels = images.to(self.config.DEVICE), labels.to(self.config.DEVICE)\n\n\t\t\tself.optimizer.zero_grad()\n\t\t\toutput = self.model(images)\n\t\t\tloss = self.criterion(output, labels)\n\t\t\tloss.backward()\n\t\t\tself.optimizer.step()\n\n\t\t\tn_iter = (epoch - 1) * len(self.train_loader) + batch_idx + 1\n\n\t\t\tlast_layer = list(self.model.children())[-1]\n\t\t\tfor name, para in last_layer.named_parameters():\n\t\t\t\tif 'weight' in name:\n\t\t\t\t\tself.logger_setup['writer'].add_scalar('LastLayerGradients/grad_norm2_weights', para.grad.norm(), n_iter)\n\t\t\t\tif 'bias' in name:\n\t\t\t\t\tself.logger_setup['writer'].add_scalar('LastLayerGradients/grad_norm2_bias', para.grad.norm(), n_iter)\n\n\t\t\tprint('Training Epoch: {epoch} [{trained_samples}/{total_samples}]\\tLoss: {:0.4f}\\tLR: {:0.6f}'.format(\n\t\t\t\tloss.item(),\n\t\t\t\tself.optimizer.param_groups[0]['lr'],\n\t\t\t\tepoch=epoch,\n\t\t\t\ttrained_samples=self.config.loader_params['bs']*(batch_idx + 1),\n\t\t\t\ttotal_samples=self.total_train_samples))\n\t\t\n\t\t\t#update training loss for each iteration\n\t\t\tself.logger_setup['writer'].add_scalar('Train/loss', loss.item(), n_iter)\n\t\t\t\n\t\t\tif self.config.WARM_UP and (epoch <= self.config.WARM_EPOCH):\n\t\t\t\tself.warmup_scheduler.step()\n\n\t\tfor name, param in self.model.named_parameters():\n\t\t\tlayer, attr = os.path.splitext(name)\n\t\t\tattr = attr[1:]\n\t\t\tself.logger_setup['writer'].add_histogram(\"{}/{}\".format(layer, attr), param, epoch)\n\n\t\tfinish = time.time()\n\t\tprint('epoch {} training time consumed: {:.2f}s'.format(epoch, finish - start))","def train(self):\r\n \r\n args = self.args\r\n model = self.model\r\n dataset = self.dataset\r\n train_state = self.train_state\r\n optimizer = self.optimizer\r\n scheduler = self.scheduler\r\n train_bar = self.train_bar\r\n val_bar = self.val_bar\r\n epoch_bar = self.epoch_bar\r\n \r\n for epoch_index in range(args.num_epochs):\r\n train_state['epoch_index'] = epoch_index\r\n \r\n # Iterate over training dataset\r\n \r\n running_loss,running_acc = self.train_loop(epoch_index, args, \r\n model, dataset, \r\n optimizer, train_bar)\r\n \r\n train_state['train_loss'].append(running_loss)\r\n train_state['train_acc'].append(running_acc)\r\n \r\n running_loss,running_acc = self.val_loop(epoch_index, args, model, \r\n dataset, optimizer, val_bar)\r\n \r\n \r\n train_state['val_loss'].append(running_loss)\r\n train_state['val_acc'].append(running_acc)\r\n \r\n print(\"Epoch \"+str(epoch_index+1)+\": Running loss=\"+ \\\r\n str(running_loss)+\", Running Acc=\"+str(running_acc))\r\n \r\n train_state = update_train_state(args=args, model=model, \r\n train_state=train_state)\r\n \r\n scheduler.step(train_state['val_loss'][-1])\r\n \r\n if train_state['stop_early']:\r\n break\r\n \r\n train_bar.n = 0\r\n val_bar.n = 0\r\n epoch_bar.set_postfix(best_val=train_state['early_stopping_best_val'] )\r\n epoch_bar.update()\r\n \r\n state_dict = torch.load(train_state['model_filename'])\r\n model.load_state_dict(state_dict)\r\n return model","def _train_epoch(self, epoch):\n self.model.train()\n total_loss = 0\n\n self.logger.info('Train Epoch: {}'.format(epoch))\n\n for batch_idx, (data) in enumerate(self.train_loader):\n start_it = time()\n data = data.to(self.device)\n\n self.optimizer.zero_grad()\n output = self.model(data)\n if isinstance(output, tuple):\n loss = self.model.loss(data, *output)\n else:\n loss = self.model.loss(data, output)\n loss.backward()\n self.optimizer.step()\n\n step = epoch * len(self.train_loader) + batch_idx\n self.tb_writer.add_scalar('train/loss', loss.item(), step)\n # self.comet_writer.log_metric('loss', loss.item(), step)\n\n total_loss += loss.item()\n\n end_it = time()\n time_it = end_it - start_it\n if batch_idx % self.log_step == 0:\n self.logger.info(\n ' > [{}/{} ({:.0f}%), {:.2f}s] Loss: {:.6f} '.format(\n batch_idx * self.train_loader.batch_size + data.size(\n 0),\n len(self.train_loader.dataset),\n 100.0 * batch_idx / len(self.train_loader),\n time_it * (len(self.train_loader) - batch_idx),\n loss.item()))\n # grid = make_grid(data.cpu(), nrow=8, normalize=True)\n # self.tb_writer.add_image('input', grid, step)\n\n self.logger.info(' > Total loss: {:.6f}'.format(\n total_loss / len(self.train_loader)\n ))\n\n return total_loss / len(self.train_loader)","def train(self, X, y, batch_size=5, num_epochs=10, alpha=0.1, gamma=0.9, learning=\"Delta\"):\n rem = int(np.ceil(len(X[0])/batch_size))\n for epoch in range(num_epochs):\n art = 0;\n for sample in range(rem):\n end = art + batch_size\n\n # Get a sample (column from X and Y) where the size of the sample is given by the batch size\n sampleX = X[:, art : end]\n sampleY = y[:, art : end]\n #print (sampleX)\n\n # Get the prediction\n results = self.predict(sampleX)\n art += batch_size\n\n if learning == \"Delta\" or learning == \"delta\":\n # Calculate e\n e = np.subtract(sampleY, results)\n\n # Calculate e dot p, where p is the input matrix\n ep = np.dot(e, np.transpose(sampleX))\n\n # Multiply this new matrix by the scalar alpha\n aep = np.multiply(alpha, ep)\n\n # Calculate the new weights along with the bias\n self.weights = np.add(self.weights, aep)\n \n elif learning == \"Filtered\" or learning == \"filtered\":\n\n # Calculate e dot p, where p is the input matrix\n ep = np.dot(sampleY, np.transpose(sampleX))\n\n # Multiply this new matrix by the scalar alpha\n aep = np.multiply(alpha, ep)\n\n # Multiply the old weights by some scalar gamma\n gw = np.multiply(1 - gamma, self.weights)\n\n self.weights = np.add(gw, aep)\n\n elif learning == \"Unsupervised_hebb\" or learning == \"unsupervised_hebb\":\n # Add a row of one's to the top of the input matrix\n #newX = np.vstack((np.array([1 for column in range(sampleX.shape[1])]), sampleX))\n\n # Calculate e dot p, where p is the input matrix\n ep = np.dot(results, np.transpose(sampleX))\n\n # Multiply this new matrix by the scalar alpha\n aep = np.multiply(alpha, ep)\n\n # Calculate the new weights along with the bias\n self.weights = np.add(self.weights, aep)","def train(self)->None:","def train_epoch(self, epoch):\n device_mapper = self.device_mapper\n self.model.train()\n self.train_metrics.reset()\n for batch_idx, data in enumerate(self.data_loader):\n data = device_mapper.map_modules(data, non_blocking=True)\n\n self.optimizer.zero_grad()\n output = self.model(data)\n loss = self.loss(output, data)\n loss.backward()\n self.optimizer.step()\n\n self.writer.set_step((epoch - 1) * self.len_epoch + batch_idx)\n self.train_metrics.update('loss', loss.item(), batch_size=output.size(0))\n for met in self.metrics:\n self.train_metrics.update(met.name(), met(output, data), batch_size=output.size(0))\n\n if batch_idx % self.log_step == 0:\n self.logger.debug('Train Epoch: %d %s Loss: %.6f', epoch, self._progress(batch_idx), loss.item())\n\n if batch_idx == self.len_epoch:\n break\n log = self.train_metrics.result()\n\n if self.do_validation:\n val_log = self.valid_epoch(epoch)\n log.update(**{'val_' + k: v for k, v in val_log.items()})\n\n if self.lr_scheduler is not None:\n if isinstance(self.lr_scheduler, torch.optim.lr_scheduler.ReduceLROnPlateau):\n self.lr_scheduler.step(log[\"val_roc_auc\"])\n else:\n self.lr_scheduler.step()\n return log","def train(self):\n\t\tself.model.fit(self.training_data, self.training_labels)","def _train(self):\r\n lr, hr = self.sess.run(self.val_batch)\r\n res = self.sess.run(\r\n [self.train, self.merged,\r\n self.GAN.g_loss, self.GAN.mse_loss, self.GAN.g_gan_loss,\r\n self.GAN.d_loss, self.GAN.d_loss_real, self.GAN.d_loss_fake],\r\n feed_dict={\r\n self.GAN.g_images: lr,\r\n self.GAN.d_images: hr,\r\n self.GAN.is_training: True\r\n })\r\n\r\n return res[1:]","def train(self, epochs):\n print('Starting training...')\n print('\\n{:13} '\n '{:>17} '\n '{:^38}'\n ''.format('', '--- Training ---', '--- Validation ---'))\n print('{:4} {:>8} '\n '{:>8} {:>8} '\n '{:>8} {:>8} {:>8} {:>8}'\n ''.format('', '', 'Loss', 'Acc', 'Loss', 'Prc', 'Rec', 'Acc'))\n training_time = 0\n for epoch in range(1, epochs + 1):\n start_time = time.time()\n trn_stats = self.__progress(self.training, self.__train_fn)\n val_stats = self.__progress(self.validation, self.__val_fn)\n elapsed_time = time.time() - start_time\n training_time += elapsed_time\n print('{:>4} {:>7.2f}s '\n '{:>8.3f} {:>8.1%} '\n '{:>8.3f} {:>8.1%} {:>8.1%} {:>8.1%}'\n ''.format(epoch, elapsed_time,\n trn_stats[0], trn_stats[-1],\n *val_stats))\n self.history.append([epoch] + list(trn_stats) + list(val_stats))\n self.report['epochs'] = epochs\n self.report['time_per_epoch'] = training_time / epochs","def train(self):\n return","def fit(self):\n for i in range(self.current_epoch, self.max_epoch):\n self.current_epoch += 1\n # train\n train_dataloader = self.data_module.get_train_dataloader(\n batch_size=self.train_batch_size, \n shuffle=self.train_dataloader_shuffle, \n num_workers=self.dataloader_num_workers,\n pin_memory=True\n )\n neptune.log_metric(\"learning_rate_vs_epoch\", self.optimizer.param_groups[0]['lr'])\n self.train_one_epoch(train_dataloader)\n\n # validate \n if self.validate_after == 'epoch' and self.train_on_all_data == False and self.run_lr_range_test == False:\n validation_dataloader = self.data_module.get_valid_dataloader(\n batch_size=self.valid_batch_size, \n shuffle=self.train_dataloader_shuffle, \n num_workers=self.dataloader_num_workers, \n pin_memory=True\n )\n self.validate_one_epoch(validation_dataloader)\n\n if self.scheduler:\n if self.step_scheduler_after == 'epoch': \n if self.step_scheduler_metric == 'val_auc':\n self.scheduler.step(self.metrics['valid'][-1]['auc_score'])\n else:\n self.scheduler.step()\n\n if self.run_lr_range_test:\n neptune.log_metric('validation_epoch_end_AUC_vs_LR', \n self.scheduler.get_last_lr()[0], y=self.metrics['valid'][-1]['auc_score'])\n\n # checkpoint model for resuming model\n if (self.current_epoch % self.checkpoint_epochs) == 0:\n self.save_checkpoint()\n\n # sleep the training process\n if self.current_epoch % self.sleep_in_epochs == 0:\n print(f\"SLEEPING FOR {self.sleep_time} at epoch={self.current_epoch}\")\n for i in range(int(self.sleep_time/30)):\n time.sleep(i)\n neptune.log_metric(\"sleeping_status\", y=1)\n\n stop_training = self.stopping_criteria()\n if stop_training:\n if self.fp16:\n self.scaler.step(self.optimizer)\n self.scaler.update()\n self.optimizer.zero_grad()\n else:\n self.optimizer.step()\n self.optimizer.zero_grad()\n # backward all the accumulate gradients\n print(f\"stopped training at {self.current_epoch} epoch\")\n break","def train_epoch(self):\n\n if self._train_data_set is not None and self._train_data_set is not None:\n self._model.fit_num_epochs(self._train_data_set, self._test_data_set)\n else:\n raise RuntimeError(\"[Triggerbot]: No training or test set available\")","def __epoch_train(self, data_loader, writer):\n self.model.train()\n for i, encode in enumerate(data_loader, 1):\n # update model\n encode = {k: v.to(self.device) for k, v in encode.items()}\n self.optimizer.zero_grad()\n loss = self.model(**encode)[0]\n if self.n_gpu > 1:\n loss = loss.mean()\n if self.args.fp16:\n with self.scale_loss(loss, self.optimizer) as scaled_loss:\n scaled_loss.backward()\n else:\n loss.backward()\n # optimizer and scheduler step\n self.optimizer.step()\n self.scheduler.step()\n # log instantaneous accuracy, loss, and learning rate\n inst_loss = loss.cpu().detach().item()\n inst_lr = self.optimizer.param_groups[0]['lr']\n writer.add_scalar('train/loss', inst_loss, self.__step)\n writer.add_scalar('train/learning_rate', inst_lr, self.__step)\n if self.__step % PROGRESS_INTERVAL == 0:\n LOGGER.info('[epoch %i] * (training step %i) loss: %.3f, lr: %0.8f'\n % (self.__epoch, self.__step, inst_loss, inst_lr))\n self.__step += 1\n # break\n if self.__step >= self.args.total_step:\n LOGGER.info('reached maximum step')\n return True\n return False","def train(dataset, epochs, discriminator, generator, generatorOptimizer, discriminatorOptimizer, seed, checkpoint, checkpoint_prefix):\n for epoch in range(epochs):\n start = time.time()\n\n for image_batch in tqdm(dataset):\n train_step(image_batch, generator, discriminator, generatorOptimizer, discriminatorOptimizer)\n #2nd for()\n\n #Produce images for the GIF\n display.clear_output(wait=True)\n generate_and_save_images(generator, epoch + 1, seed)\n\n #save model every 5 epochs\n if (epoch + 1) % 5 == 0:\n print(\"Saving checkpoint.\")\n checkpoint.save(file_prefix = checkpoint_prefix)\n #if() \n\n print(\"time for epoch {} is {} sec\".format(epoch + 1, time.time()-start))\n #1st for\n \n #Generate after final epoch\n display.clear_output(wait=True)\n generator.save(\"CatGeneratorColor.model\")\n discriminator.save(\"CatDiscriminatorColor.model\")","def on_epoch(self, e):\n\n dataloader = self.datasetManager.get_dataloader()\n length_dataloader = len(dataloader)\n print(\"Epoch %i\"%e)\n print(\"-\"*15)\n for i, batch in tqdm.tqdm(enumerate(dataloader)):\n index = e*length_dataloader+i\n batch = self.to_device(batch)\n img = batch[0]\n gts = batch[1]\n\n #add filter here !\n\n out = self.network(img)\n loss = self.loss(out, gts)\n \n self.tb_writer.add_scalar('Training Loss', loss, index)\n\n if index % self.config['Validation']['validation_step'] == 0:\n \"\"\"\n Validation and saving of the model\n \"\"\"\n # self.tb_writer.add_scalar('Training loss', loss.item(), index)\n with torch.no_grad():\n valid_loss = self.validate(index)\n if valid_loss < self.best_valid_loss:\n self.best_valid_loss = valid_loss\n filename = 'trained_model_iter_%i_loss_%.4f.pth'%(index, valid_loss)\n filename = os.path.join(self.output_dir, 'trained_model', filename)\n self.network.save_model(filename, optimizers=self.opt)\n\n self.backward_and_step(loss) #On appel la backpropagation","def train(self, data_dict, label_dict):\n loaders = self.init_loaders(data_dict, label_dict)\n best_performance = 1e18\n loss_dict = self.init_loss_dict()\n performance_dict = self.init_performance_dict()\n\n for epoch in range(self.config_dict[\"num_epochs\"]):\n print(\"Epoch {}/{}\".format(epoch, self.config_dict[\"num_epochs\"] - 1))\n print(\"-\" * 10)\n\n if self.scheduler is not None:\n self.scheduler.step()\n\n for phase in [\"train\", \"val\"]:\n self.model.train(phase == \"train\")\n running_loss_dict = self.init_running_loss_dict(\n list(loss_dict[phase].keys())\n )\n output_dict = self.init_output_dict()\n i = 0\n for the_data in loaders[phase]:\n i += 1\n batch_loss_dict = {}\n inputs, labels = self.transform_batch(the_data)\n\n # zero parameter gradients\n self.optimizer.zero_grad()\n\n # forward\n outputs = self.model(inputs)\n\n output_dict = self.update_output_dict(output_dict, outputs, labels)\n\n batch_loss_dict[\"loss\"] = self.criterion(outputs, labels)\n if phase == \"train\":\n batch_loss_dict[\"loss\"].backward()\n self.optimizer.step()\n\n for key in batch_loss_dict.keys():\n running_loss_dict[key] += batch_loss_dict[key].item()\n\n # Compute epoch losses and update loss dict\n epoch_loss_dict = {\n key: running_loss_dict[key] / i for key in running_loss_dict.keys()\n }\n loss_dict[phase] = self.update_metric_dict(\n loss_dict[phase], epoch_loss_dict\n )\n\n # Compute epoch performance and update performance dict\n epoch_statistics = self.compute_epoch_statistics(output_dict)\n performance_dict[phase] = self.update_metric_dict(\n performance_dict[phase], epoch_statistics\n )\n\n print(\"Phase: {}:\".format(phase))\n self.print_metric_dict(epoch_loss_dict)\n self.print_metric_dict(epoch_statistics)\n\n if phase == \"val\":\n best_model_condition = epoch_loss_dict[\"loss\"] < best_performance\n if best_model_condition:\n print(\"Best model updated\")\n best_performance = epoch_loss_dict[\"loss\"]\n best_model_wts = copy.deepcopy(self.model.state_dict())\n\n print(\"Best val performance: {:4f}\".format(best_performance))\n self.model.load_state_dict(best_model_wts)\n result_dict = {\n phase: {**performance_dict[phase], **loss_dict[phase]}\n for phase in performance_dict.keys()\n }\n return result_dict","def train_an_epoch(self, train_loader, epoch_id):\n assert hasattr(self, \"model\"), \"Please specify the exact model !\"\n self.model.train()\n total_loss = 0\n kl_loss = 0\n rec_loss = 0\n # with autograd.detect_anomaly():\n for batch_id, sample in enumerate(train_loader):\n assert isinstance(sample, torch.Tensor)\n pos_u = torch.tensor(\n [triple[0] for triple in sample],\n dtype=torch.int64,\n device=self.device,\n )\n pos_i_1 = torch.tensor(\n [triple[1] for triple in sample],\n dtype=torch.int64,\n device=self.device,\n )\n pos_i_2 = torch.tensor(\n [triple[2] for triple in sample],\n dtype=torch.int64,\n device=self.device,\n )\n neg_u = torch.tensor(\n self.data.user_sampler.sample(\n self.config[\"model\"][\"n_neg\"], len(sample)\n ),\n dtype=torch.int64,\n device=self.device,\n )\n neg_i_1 = torch.tensor(\n self.data.item_sampler.sample(\n self.config[\"model\"][\"n_neg\"], len(sample)\n ),\n dtype=torch.int64,\n device=self.device,\n )\n neg_i_2 = torch.tensor(\n self.data.item_sampler.sample(\n self.config[\"model\"][\"n_neg\"], len(sample)\n ),\n dtype=torch.int64,\n device=self.device,\n )\n batch_data = (pos_u, pos_i_1, pos_i_2, neg_u, neg_i_1, neg_i_2)\n loss = self.train_single_batch(batch_data)\n total_loss += loss\n kl_loss += self.model.kl_loss\n rec_loss += self.model.rec_loss\n total_loss = total_loss / self.config[\"model\"][\"batch_size\"]\n rec_loss = rec_loss / self.config[\"model\"][\"batch_size\"]\n kl_loss = kl_loss / self.config[\"model\"][\"batch_size\"]\n print(\n \"[Training Epoch {}], log_like_loss {} kl_loss: {} alpha: {} lr: {}\".format(\n epoch_id,\n rec_loss,\n kl_loss,\n self.model.alpha,\n self.config[\"model\"][\"lr\"],\n )\n )\n self.writer.add_scalars(\n \"model/loss\",\n {\n \"total_loss\": total_loss,\n \"rec_loss\": total_loss - kl_loss,\n \"kl_loss\": kl_loss,\n },\n epoch_id,\n )","def train_model(self):\n ### Early Stop Mechanism\n loss = previous_loss = float(\"inf\")\n patience_left = self.config.patience\n ### Early Stop Mechanism\n\n self.generator = Generator(self.model.config, training_strategy=self.training_strategy)\n self.evaluator = Evaluator(model=self.model, data_type=self.teston, debug=self.debug)\n\n if self.config.loadFromData:\n self.load_model()\n \n for cur_epoch_idx in range(self.config.epochs):\n print(\"Epoch[%d/%d]\"%(cur_epoch_idx,self.config.epochs))\n loss = self.train_model_epoch(cur_epoch_idx)\n self.test(cur_epoch_idx)\n\n ### Early Stop Mechanism\n ### start to check if the loss is still decreasing after an interval. \n ### Example, if early_stop_epoch == 50, the trainer will check loss every 50 epoche.\n ### TODO: change to support different metrics.\n if ((cur_epoch_idx + 1) % self.config.early_stop_epoch) == 0: \n if patience_left > 0 and previous_loss <= loss:\n patience_left -= 1\n print('%s more chances before the trainer stops the training. (prev_loss, curr_loss): (%.f, %.f)' % \\\n (patience_left, previous_loss, loss))\n\n elif patience_left == 0 and previous_loss <= loss:\n self.evaluator.result_queue.put(Evaluator.TEST_BATCH_EARLY_STOP)\n break\n else:\n patience_left = self.config.patience\n\n previous_loss = loss\n ### Early Stop Mechanism\n\n self.generator.stop()\n self.evaluator.save_training_result(self.training_results)\n self.evaluator.stop()\n\n if self.config.save_model:\n self.save_model()\n\n if self.config.disp_result:\n self.display()\n\n if self.config.disp_summary:\n self.config.summary()\n self.config.summary_hyperparameter(self.model.model_name)\n\n self.export_embeddings()\n\n return loss","def train(self):\n self.dataGenerator.printDataStatistics()\n sE = len(self.dataGenerator.ids[\"train\"])// 32\n sV = len(self.dataGenerator.ids[\"validation\"])// 32\n self.model.fit_generator(\n generator=self.dataGenerator.trainingGenerator,\n steps_per_epoch= sE,\n epochs=2,\n validation_data=self.dataGenerator.validationGenerator,\n validation_steps=sV,\n # use_multiprocessing=True,\n # workers=2,\n )","def train_epoch(training_input, training_target):\n permutation = torch.randperm(training_input.shape[0])\n\n epoch_training_losses = []\n net.train()\n # logger.info(\"-----------------------------0---------------------------------\")\n # for i in range(0, batch_size):\n # for i in range(10):\n\n optimizer.zero_grad()\n logger.info(\"-----------------------------1---------------------------------\")\n # indices = permutation[i:i + batch_size]\n X_batch, y_batch = training_input, training_target\n current_X_batch = X_batch.to(device=args.device)\n current_y_batch = y_batch.to(device=args.device)\n # logger.info(\"-----------------------------2---------------------------------\")\n out = net(A_wave, current_X_batch)\n loss = loss_criterion(out, current_y_batch)\n # logger.info(f'{i}/{training_input.shape[0]}: step loss:{loss.item()}')\n # print(f'{i}/{training_input.shape[0]}: step loss:{loss.item()}')\n logger.info(f'2--------------------out:{out},current_y_batch:{current_y_batch}')\n loss.backward()\n logger.info(f'3--------------------loss:{loss}')\n # logger.info(\"-----------------------------4---------------------------------\")\n optimizer.step()\n logger.info(f'4--------------------loss:{loss}')\n # logger.info(\"-----------------------------5---------------------------------\")\n # epoch_training_losses.append(loss.clone().detach().cpu().numpy())\n # logger.info(\"-----------------------------6---------------------------------\")\n # return sum(epoch_training_losses)/len(epoch_training_losses)\n return loss","def train(self):\n raise NotImplementedError()","def __init__(self, \n training_epochs):\n self.training_epochs = training_epochs","def train_epoch(self, epoch_num: int) -> float:\n self.model.train()\n epoch_loss = 0.0\n # hidden_start = torch.zeros(self.batch_size, self.rnn_size)\n # for batch_num, (x, y) in enumerate(make_batches(self.train_data,\n # self.batch_size,\n # self.max_len)):\n\n for batch_num, batch_tuple in enumerate(self.train_data):\n print('batch: ', batch_num)\n # reset gradients in train epoch\n self.optimizer.zero_grad()\n x = len(batch_tuple[0])\n y = len(batch_tuple[0][0])\n # compute hidden states\n # batch x timesteps x hidden_size\n x, y = batch_tuple\n # x = x.to(self.device)\n # y = y.to(self.device)\n hidden_states = self.model(x)\n # compute unnormalized probabilities\n # batch x timesteps x vocab_size\n # logits = self.model.get_logits(hidden_states)\n\n # compute loss\n # scalar\n batch_loss = self.model.get_loss(hidden_states, y)\n epoch_loss += batch_loss.item()\n\n # backpropagation (gradient of loss wrt parameters)\n batch_loss.backward()\n\n # clip gradients if they get too large\n torch.nn.utils.clip_grad_norm_(list(self.model.parameters()),\n self.max_grad_norm)\n\n # update parameters\n self.optimizer.step()\n\n # we use a stateful RNN, which means the first hidden state for the\n # next batch is the last hidden state of the current batch\n # hidden_states.detach_()\n # hidden_start = hidden_states[:,-1,:] # add comment\n if batch_num % 100 == 0:\n print(\"epoch %d, %d/%d examples, batch loss = %f\"\n % (epoch_num, (batch_num + 1) * self.batch_size,\n self.num_train_examples, batch_loss.item()))\n epoch_loss /= (batch_num + 1)\n\n return epoch_loss","def train(self, verbose=True):\n\n\n learned = False\n iteration = 0\n\n from util.loss_functions import DifferentError\n loss = DifferentError()\n\n\n\n\n\n # Train for some epochs if the error is not 0\n while not learned:\n # x ist ein Bild bestehend aus einem Label (erster Eintrag) und 784 Pixeln\n # t ist das Zielergebnis von x (überprüfbar mit dem Label)\n # o ist der tatsächliche Ergebnis von x\n # w ist der Gewichtsvektor\n # Als Aktivierungsfunktion verwenden wir die Sigmoid Funktion\n # Das Training wird dann beendet, sobald das Fehlerkriterium konvergiert\n\n totalError = 0\n\n output = []\n labels = self.trainingSet.label\n inputs = self.trainingSet.input\n\n # iteriere für jede Instanz im Trainingsset x € X\n for input in inputs:\n # Ermittle O_x = sig(w*x)\n output.append(self.fire(input))\n\n # Ermittle Fehler AE = tx - ox\n error = loss.calculateError(np.array(labels), np.array(output))\n\n # grad = [0]\n grad = np.zeros(len(self.trainingSet.input[0]))\n grad2 = np.zeros(len(self.trainingSet.input[0]))\n\n for e, input, out in zip(error, inputs, output):\n activationPrime = Activation.getDerivative(activationName)(np.dot(np.array(input), self.weight))\n #grad += np.multiply( np.multiply( input, e), activationPrime)\n grad += np.multiply( input, e)\n\n # Update grad = grad + errorPrime * x * activationPrime\n\n\n\n # print grad - grad2\n #print \"Error: \" + str(error) + \" Grad: \" + str(grad)\n\n # update w: w <- w + n*grad\n self.updateWeights(grad)\n\n\n iteration += 1\n totalError = error.sum()\n\n if verbose:\n logging.info(\"Epoch: %i; Error: %i\", iteration, totalError)\n\n if abs(totalError) < 0.01 or iteration >= self.epochs:\n # stop criteria is reached\n learned = True\n\n pass","def _train_epoch(self, train_batches, data, max_metric_value, metric_save, patience, step_pbar):\n evaluate = True\n exit_tag = False\n num_steps = self.args.num_steps\n check_point, batch_size = self.args.check_point, self.args.batch_size\n save_dir, save_prefix = self.args.save_dir, self.args.algo\n\n for bitx, batch in enumerate(train_batches):\n if evaluate and self.global_step % self.eval_freq == 0:\n if data.dev_set is not None:\n dev_batches = data.gen_mini_batches('dev', 31928, shuffle=False)\n dev_loss, dev_perplexity, dev_perplexity_at_rank = self.evaluate(dev_batches, data)\n #print('dev loss=%s' % dev_loss, 'dev ppl=%s' % dev_perplexity, 'dev ppl at rank=', dev_perplexity_at_rank)\n\n test_batches = data.gen_mini_batches('test', 41405, shuffle=False)\n test_loss, test_perplexity, test_perplexity_at_rank = self.evaluate(test_batches, data)\n #print('test loss=%s' % test_loss, 'dev ppl=%s' % test_perplexity, 'dev ppl at rank=' , test_perplexity_at_rank)\n\n self.writer.add_scalar(\"dev/loss\", dev_loss, self.global_step)\n self.writer.add_scalar(\"dev/perplexity\", dev_perplexity, self.global_step)\n self.writer.add_scalar(\"test/loss\", test_loss, self.global_step)\n self.writer.add_scalar(\"test/perplexity\", test_perplexity, self.global_step)\n\n for trunc_level in self.trunc_levels:\n ndcg_version1, ndcg_version2 = self.relevance_estimator.evaluate(self, data, self.relevance_queries, trunc_level)\n self.writer.add_scalar(\"NDCG_version1/{}\".format(trunc_level), ndcg_version1, self.global_step)\n self.writer.add_scalar(\"NDCG_version2/{}\".format(trunc_level), ndcg_version2, self.global_step)\n\n if dev_loss < metric_save:\n metric_save = dev_loss\n patience = 0\n else:\n patience += 1\n # Trick: do not decay d_lr help convergence\n if patience >= self.patience:\n #self.adjust_learning_rate(self.discrim_optimizer, self.args.lr_decay)\n self.adjust_learning_rate(self.policy_optimizer, self.args.lr_decay)\n self.g_lr *= self.args.lr_decay\n #self.d_lr *= self.args.lr_decay\n self.writer.add_scalar('train/g_lr', self.g_lr, self.global_step)\n #self.writer.add_scalar('train/d_lr', self.d_lr, self.global_step)\n metric_save = dev_loss\n patience = 0\n self.patience += 1\n else:\n self.logger.warning('No dev set is loaded for evaluation in the dataset!')\n\n self.global_step += 1\n step_pbar.update(1)\n QIDS = Variable(torch.from_numpy(np.array(batch['qids'], dtype=np.int64)))\n UIDS = Variable(torch.from_numpy(np.array(batch['uids'], dtype=np.int64)))\n VIDS = Variable(torch.from_numpy(np.array(batch['vids'], dtype=np.int64)))\n PRE_CLICKS = Variable(torch.from_numpy(np.array(batch['clicks'], dtype=np.int64)[:, :-1]))\n CLICKS = Variable(torch.from_numpy(np.array(batch['clicks'], dtype=np.int64)[:, 1:]))\n\n # generate trajectories\n for __ in range(self.args.d_step):\n actor_rnn_state = Variable(torch.zeros(1, QIDS.shape[0], self.gru_hidden_size))\n critic_rnn_state = Variable(torch.zeros(1, QIDS.shape[0], self.gru_hidden_size))\n CLICK_ = torch.zeros(QIDS.shape[0], 1, dtype=CLICKS.dtype)\n logits = torch.zeros(QIDS.shape[0], 0, 2)\n values = torch.zeros(QIDS.shape[0], 0)\n CLICKS_ = Variable(torch.zeros((QIDS.shape[0], 0), dtype=CLICKS.dtype))\n if self.use_cuda:\n QIDS, UIDS, VIDS, PRE_CLICKS, CLICKS = QIDS.cuda(), UIDS.cuda(), VIDS.cuda(), PRE_CLICKS.cuda(), CLICKS.cuda()\n actor_rnn_state, critic_rnn_state, CLICK_ = actor_rnn_state.cuda(), critic_rnn_state.cuda(), CLICK_.cuda()\n logits, values, CLICKS_ = logits.cuda(), values.cuda(), CLICKS_.cuda()\n self.policy.eval()\n for i in range(self.max_d_num + 1):\n logit, value, actor_rnn_state, critic_rnn_state = self.policy(QIDS[:, i:i+1], \n UIDS[:, i:i+1], \n VIDS[:, i:i+1], \n CLICK_, \n actor_rnn_state, \n critic_rnn_state)\n if i > 0:\n CLICK_ = torch.distributions.Categorical(logit).sample()\n logits = torch.cat([logits, logit], dim=1)\n values = torch.cat([values, value], dim=1)\n CLICKS_ = torch.cat([CLICKS_, CLICK_], dim=1)\n\n if self.use_cuda:\n CLICKS_ = torch.cat((torch.zeros((CLICKS_.shape[0], 1), dtype=CLICKS_.dtype, device=torch.device('cuda')), CLICKS_), dim=1)\n else:\n CLICKS_ = torch.cat((torch.zeros((CLICKS_.shape[0], 1), dtype=CLICKS_.dtype), CLICKS_), dim=1)\n\n '''update discriminator'''\n for _ in range(self.args.k):\n self.discrim.train()\n self.discrim_optimizer.zero_grad()\n g_o, _ = self.discrim(QIDS, UIDS, VIDS, CLICKS_)\n g_o_target = torch.ones((QIDS.shape[0], g_o.shape[1]))\n e_o, _ = self.discrim(QIDS, UIDS, VIDS, CLICKS)\n e_o_target = torch.zeros((QIDS.shape[0], e_o.shape[1]))\n if self.use_cuda:\n g_o_target, e_o_target = g_o_target.cuda(), e_o_target.cuda()\n \n discrim_loss = self.discrim_criterion(g_o, g_o_target) + self.discrim_criterion(e_o, e_o_target)\n discrim_loss.backward()\n self.discrim_optimizer.step()\n self.writer.add_scalar('train/d_loss', discrim_loss.data, self.global_step)\n\n '''estimate advantage'''\n with torch.no_grad():\n self.discrim.eval()\n rewards = -torch.log(self.discrim(QIDS, UIDS, VIDS, CLICKS_)[0])\n # print(rewards.shape, values.shape)\n #print(tensor_type)\n #exit(0)\n deltas = torch.zeros(rewards.shape)\n advantages = torch.zeros(rewards.shape)\n prev_value = torch.zeros(rewards.shape[0])\n prev_advantage = torch.zeros(rewards.shape[0])\n if self.use_cuda:\n deltas, advantages = deltas.cuda(), advantages.cuda()\n prev_value, prev_advantage = prev_value.cuda(), prev_advantage.cuda()\n '''print(deltas)\n print(advantages)\n print(prev_value)\n print(prev_advantage)\n exit(0)'''\n\n for i in reversed(range(rewards.size(1))):\n deltas[:, i] = rewards[:, i] + self.gamma * prev_value - values[:, i]\n advantages[:, i] = deltas[:, i] + self.gamma * self.tau * prev_advantage\n prev_value = values[:, i]\n prev_advantage = advantages[:, i]\n\n returns = values + advantages\n advantages = (advantages - advantages.mean()) / (advantages.std() + MINF)\n # advantages = (returns - returns.mean())/returns.std()\n\n fixed_log_probs = torch.distributions.Categorical(logits).log_prob(CLICKS_[:, 1:])\n\n '''PPO update'''\n self.policy.train()\n optim_batchsize = 512\n optim_iter_num = int(math.ceil(QIDS.shape[0] / optim_batchsize))\n if self.use_cuda:\n CLICKS_ = torch.cat((torch.zeros((CLICKS_.shape[0], 1), dtype=CLICKS_.dtype, device=torch.device('cuda')), CLICKS_), dim=1)\n else:\n CLICKS_ = torch.cat((torch.zeros((CLICKS_.shape[0], 1), dtype=CLICKS_.dtype), CLICKS_), dim=1)\n for _ in range(self.args.g_step):\n perm = np.arange(QIDS.shape[0])\n np.random.shuffle(perm)\n\n QIDS, UIDS, VIDS, PRE_CLICKS, CLICKS, CLICKS_, advantages, returns, fixed_log_probs = \\\n QIDS[perm].clone(), UIDS[perm].clone(), VIDS[perm].clone(), PRE_CLICKS[perm].clone(), \\\n CLICKS[perm].clone(), CLICKS_[perm].clone(), advantages[perm].clone(), returns[perm].clone(), fixed_log_probs[perm].clone()\n\n #print(QIDS)\n #exit(0)\n\n for i in range(optim_iter_num):\n ind = slice(i * optim_batchsize, min((i + 1) * optim_batchsize, QIDS.shape[0]))\n qids_b, uids_b, vids_b, pclicks_b, clicks_b, clicks__b, advantage_b, returns_b, fixed_log_probs_b = \\\n QIDS[ind], UIDS[ind], VIDS[ind], CLICKS_[ind, :-1], CLICKS[ind], CLICKS_[ind, 2:], \\\n advantages[ind], returns[ind], fixed_log_probs[ind]\n\n logits, values_pred, _, _ = self.policy(qids_b, uids_b, vids_b, pclicks_b)\n dist = torch.distributions.Categorical(logits)\n\n\n '''update critic'''\n value_loss = (values_pred - returns_b).pow(2).mean()\n '''optimizer policy'''\n log_probs_b = dist.log_prob(clicks__b)\n ratio = torch.exp(log_probs_b - fixed_log_probs_b)\n surr1 = ratio * advantage_b\n surr2 = torch.clamp(ratio, 1.0 - self.clip_epsilon, 1.0 + self.clip_epsilon) * advantage_b\n policy_surr = -torch.min(surr1, surr2).mean()\n pe = dist.entropy().mean()\n loss = value_loss + self.alpha * policy_surr - self.beta * pe\n\n self.policy_optimizer.zero_grad()\n loss.backward()\n torch.nn.utils.clip_grad_norm_(self.policy.parameters(), 40)\n self.policy_optimizer.step()\n g_loss, _ = self.compute_loss(logits, clicks_b)\n\n self.writer.add_scalar('train/g_loss', g_loss.data, self.global_step)\n self.writer.add_scalar('train/g_valueloss', value_loss.data, self.global_step)\n self.writer.add_scalar('train/g_policysurr', policy_surr.data, self.global_step)\n self.writer.add_scalar('train/g_entropy', pe.data, self.global_step)\n\n if check_point > 0 and self.global_step % check_point == 0:\n self.save_model(save_dir, save_prefix)\n if self.global_step >= num_steps:\n exit_tag = True\n\n return max_metric_value, exit_tag, metric_save, patience","def train(x_train, y_train, x_valid, y_valid, config):\n train_acc = []\n valid_acc = []\n train_loss = []\n valid_loss = []\n best_model = None\n NUM_EPOCH = config['epochs']\n EARLY_STOP = config['early_stop']\n EARLY_STOP_EPOCH = config['early_stop_epoch']\n BATCH_SIZE = config['batch_size']\n model = NeuralNetwork(config=config)\n loss = float('inf')\n best_loss = float('inf')\n best_accuracy = 0\n patience = 0\n\n\n\n for i in range (NUM_EPOCH):\n\n x_train, y_train = shuffle(x_train, y_train)\n x_train = np.asarray(x_train)\n y_train = np.asarray(y_train)\n\n for j in range (0, len(x_train), BATCH_SIZE):\n start = j\n end = j + BATCH_SIZE\n if (end > len(x_train)):\n end = len(x_train)\n\n x = x_train[start:end]\n y = y_train[start:end]\n\n model.forward(x, y) \n model.backward()\n\n train_epoch_loss = model.forward(x_train, y_train)\n \n train_predict = np.zeros_like(model.y)\n train_predict[np.arange(len(model.y)), model.y.argmax(1)] = 1\n\n train_accuracy = sum([1 if all(train_predict[i] == y_train[i]) else 0 for i in range(len(y_train))])/len(y_train)\n\n train_loss.append(train_epoch_loss)\n train_acc.append(train_accuracy)\n \n valid_epoch_loss = model.forward(x_valid, y_valid)\n valid_predict = np.zeros_like(model.y)\n valid_predict[np.arange(len(model.y)), model.y.argmax(1)] = 1\n\n valid_accuracy = sum([1 if all(valid_predict[i] == y_valid[i]) else 0 for i in range(len(y_valid))])/len(y_valid)\n\n valid_loss.append(valid_epoch_loss)\n valid_acc.append(valid_accuracy)\n\n\n print(\"Epoch:\", i, \"Train Accuracy|Loss:\", train_accuracy,\"| \", train_epoch_loss, \"~|~ Valid: \", valid_accuracy, \" | \", valid_epoch_loss)\n if EARLY_STOP:\n if valid_epoch_loss > best_loss and patience >= EARLY_STOP_EPOCH:\n return train_acc, valid_acc, train_loss, valid_loss, best_model\n elif valid_epoch_loss > best_loss and patience < EARLY_STOP_EPOCH:\n patience += 1\n else:\n patience = 0\n if valid_epoch_loss < best_loss:\n best_loss = valid_epoch_loss\n best_accuracy = valid_accuracy\n best_model = copy.deepcopy(model)\n\n loss = valid_epoch_loss\n\n \n best_model = model \n return train_acc, valid_acc, train_loss, valid_loss, best_model","def train_one_epoch(self):\n self.model.train()\n for batch_idx, (imgs, labels) in enumerate(self.tr_loader):\n imgs, labels = imgs.to(self.device), labels.to(self.device)\n self.optimizer.zero_grad()\n\n outputs, aux_outputs = self.model(imgs).values()\n loss1 = self.criterion(outputs, labels)\n loss2 = self.criterion(aux_outputs, labels)\n self.loss = loss1 + 0.3*loss2\n\n _, preds = torch.max(outputs, 1)\n acc = preds.eq(labels.view_as(preds)).sum().item() / self.cfg.bs\n\n self.loss.backward()\n self.optimizer.step()\n \n self.summary_writer.add_scalars('scalar_group', \n { 'loss_end' : loss1.item(),\n 'loss_aux' : loss2.item(),\n 'loss_total' : self.loss.item(),\n 'accuracy' : acc},\n self.current_iteration)\n\n if batch_idx % self.cfg.log_interval == 0:\n info_1 = 'Epochs {} [{}/{} ({:.0f}%)] | Loss: {:.6f}' .format(\n self.current_epoch, \n batch_idx * len(imgs), \n len(self.tr_loader.dataset), \n 100. * batch_idx / len(self.tr_loader),\n self.loss.item())\n info_2 = 'Batch Accuracy : {:.2f}'.format(acc)\n self.logger.info('{} | {}'.format(info_1, info_2))\n self.save_checkpoint('{}_epoch{}_iter{}.pt'.format(\n self.cfg.exp_name,\n self.current_epoch, \n self.current_iteration)\n )\n self.current_iteration += 1","def train_epoch(self, train_loader, model, loss_function, criterion,\n optimizer, epoch, writer_train, train_on_textures):\n losses = AverageMeter()\n model.train()\n\n if train_on_textures:\n input_name = \"texture\"\n else:\n input_name = \"image\"\n for i, data in enumerate(train_loader):\n # switch to train mode\n model.train()\n input_var = data[input_name].float().to(self._device)\n if \"hierarchical\" in self._model_name:\n input_rep = self.generate_little_vae_encoding(input_var)\n latent_rep, mean, logvar = model(input_rep)\n output = self.generate_little_vae_decoding(latent_rep[0:1])\n loss = criterion(latent_rep, input_rep, mean, logvar, epoch)\n else:\n output, mean, logvar = model(input_var)\n loss = criterion(output, input_var, mean, logvar, epoch)\n\n # compute gradient and do optimization step\n optimizer.zero_grad()\n loss[\"loss\"].backward()\n optimizer.step()\n loss[\"loss\"]/=input_var.shape[0]\n losses.update(loss[\"loss\"].item(), 1)\n \n cur_iter = i + len(train_loader) * epoch\n for key in loss: \n writer_train.add_scalar('data/{}'.format(key), loss[key].item(), cur_iter)\n print(\"Epoch: [{0}][{1}/{2}]\\t Loss {loss.last_val:.4f} \"\n \"({loss.avg:.4f})\\t\".format(\n epoch, i, len(train_loader), loss=losses))\n if i % 10 == 0:\n writer_train.add_image('imgs/input', input_var[0], cur_iter)\n if \"hierarchical\" in self._model_name:\n writer_train.add_image('imgs/hierarchical_output', output[0], cur_iter)\n writer_train.add_image('imgs/little_vae_output', self.generate_little_vae_decoding(input_rep[0:1])[0], cur_iter)\n else:\n writer_train.add_image('imgs/output', output[0], cur_iter)","def _train_epoch(self, epoch):\n self.model.train()\n\n\n total_loss = 0\n total_metrics = np.zeros(len(self.metrics))\n length = len(self.data_loader)\n total_pm25_loss = 0\n total_pm10_loss = 0\n pm25_loss = 0\n pm10_loss = 0\n\n for batch_idx, (data, target) in enumerate(self.data_loader):\n data, target = data.to(self.device), target.to(self.device)\n\n self.optimizer.zero_grad()\n output = self.model(data)\n # print(output.shape, target.shape)\n target = target.squeeze()\n model_loss = self.loss(output, target)\n\n # print(output.shape, target.shape)\n # pm25_predict, pm10_predict = torch.chunk(output, 2, dim=1)\n # pm25_target, pm10_target = torch.chunk(target, 2, dim=1)\n # pm25_loss = self.loss(pm25_predict, pm25_target)\n # pm10_loss = self.loss(pm10_predict, pm10_target)\n # total_pm25_loss += pm25_loss.item()\n # total_pm10_loss += pm10_loss.item()\n\n l2_reg = torch.tensor(0.0).to(self.device)\n if self.config['trainer']['l2_regularization']:\n for param in self.model.parameters():\n l2_reg += torch.norm(param, p=2)\n loss = model_loss + self.config['trainer']['l2_lambda'] * l2_reg\n else:\n loss = model_loss\n\n loss.backward()\n # torch.nn.utils.clip_grad_norm(self.model.parameters(), 1)\n self.optimizer.step()\n\n self.writer.set_step((epoch - 1) * self.len_epoch + batch_idx)\n self.writer.add_scalar('loss', loss.item())\n total_loss += loss.item()\n # total_metrics += self._eval_metrics(output, target)\n\n if batch_idx % self.log_step == 0:\n self.logger.debug('Train Epoch: {} {} Loss: {:.6f} model_loss: {:.6f} pm25_loss {:.6f} pm10_loss {:.6f} l2_loss: {:.6f}'.format(\n epoch,\n self._progress(batch_idx),\n loss.item(),\n model_loss.item(),\n pm25_loss,\n pm10_loss,\n l2_reg.item()))\n\n if batch_idx == self.len_epoch:\n break\n\n log = {\n 'loss': total_loss / length,\n 'rmse_pm25_loss': np.sqrt(total_pm25_loss / length),\n 'rmse_pm10_loss': np.sqrt(total_pm10_loss / length)\n }\n\n\n val_log = self._valid_epoch(epoch)\n log.update(val_log)\n\n if self.lr_scheduler is not None:\n self.lr_scheduler.step(val_log['val_loss'])\n\n return log","def _train_internal(self, opts):\n\n batches_num = self._data.num_points / opts['batch_size']\n train_size = self._data.num_points\n num_plot = 320\n sample_prev = np.zeros([num_plot] + list(self._data.data_shape))\n l2s = []\n\n counter = 0\n decay = 1.\n logging.error('Training VAE')\n for _epoch in xrange(opts[\"gan_epoch_num\"]):\n\n if opts['decay_schedule'] == \"manual\":\n if _epoch == 30:\n decay = decay / 2.\n if _epoch == 50:\n decay = decay / 5.\n if _epoch == 100:\n decay = decay / 10.\n\n if _epoch > 0 and _epoch % opts['save_every_epoch'] == 0:\n os.path.join(opts['work_dir'], opts['ckpt_dir'])\n self._saver.save(self._session,\n os.path.join(opts['work_dir'],\n opts['ckpt_dir'],\n 'trained-pot'),\n global_step=counter)\n\n for _idx in xrange(batches_num):\n # logging.error('Step %d of %d' % (_idx, batches_num ) )\n data_ids = np.random.choice(train_size, opts['batch_size'],\n replace=False, p=self._data_weights)\n batch_images = self._data.data[data_ids].astype(np.float)\n batch_noise = utils.generate_noise(opts, opts['batch_size'])\n _, loss, loss_kl, loss_reconstruct = self._session.run(\n [self._optim, self._loss, self._loss_kl,\n self._loss_reconstruct],\n feed_dict={self._real_points_ph: batch_images,\n self._noise_ph: batch_noise,\n self._lr_decay_ph: decay,\n self._is_training_ph: True})\n counter += 1\n\n if opts['verbose'] and counter % opts['plot_every'] == 0:\n debug_str = 'Epoch: %d/%d, batch:%d/%d' % (\n _epoch+1, opts['gan_epoch_num'], _idx+1, batches_num)\n debug_str += ' [L=%.2g, Recon=%.2g, KLQ=%.2g]' % (\n loss, loss_reconstruct, loss_kl)\n logging.error(debug_str)\n\n if opts['verbose'] and counter % opts['plot_every'] == 0:\n metrics = Metrics()\n points_to_plot = self._run_batch(\n opts, self._generated, self._noise_ph,\n self._noise_for_plots[0:num_plot],\n self._is_training_ph, False)\n l2s.append(np.sum((points_to_plot - sample_prev)**2))\n metrics.l2s = l2s[:]\n metrics.make_plots(\n opts,\n counter,\n None,\n points_to_plot,\n prefix='sample_e%04d_mb%05d_' % (_epoch, _idx))\n reconstructed = self._session.run(\n self._reconstruct_x,\n feed_dict={self._real_points_ph: batch_images,\n self._is_training_ph: False})\n metrics.l2s = None\n metrics.make_plots(\n opts,\n counter,\n None,\n reconstructed,\n prefix='reconstr_e%04d_mb%05d_' % (_epoch, _idx))\n if opts['early_stop'] > 0 and counter > opts['early_stop']:\n break\n if _epoch > 0:\n os.path.join(opts['work_dir'], opts['ckpt_dir'])\n self._saver.save(self._session,\n os.path.join(opts['work_dir'],\n opts['ckpt_dir'],\n 'trained-pot-final'),\n global_step=counter)","def _train_epoch(X_train, y_train, model, criterion, optimizer, batch_size, iterations):\n #this function is inspired by an EECS 445 project done by Justin Weilbach\n\n #I found online that people do this but I don't think it did anything\n model = model.train()\n\n #create batch size for sgd\n num_train = X_train.shape[0]\n batch_mask = np.random.choice(num_train, batch_size)\n train_batch = X_train[batch_mask]\n #lmao why is that not already an np array\n y_train = np.array(y_train)\n batch_labels = np.asarray(y_train[batch_mask])\n\n for it in range(0, iterations):\n for i, image in enumerate(train_batch):\n label = batch_labels[i]\n label = torch.from_numpy(np.asarray(label))\n label = label.type(torch.LongTensor)\n label = torch.tensor([label])\n\n image = torch.from_numpy(image)\n image = image.type(torch.FloatTensor)\n image = image.unsqueeze(0)\n\n optimizer.zero_grad()\n output = model(image)\n\n loss = criterion(output, label)\n loss.backward()\n optimizer.step()","def train(self, training, epochs, group):\n for epoch in range(epochs):\n self.input_matrix={}\n self.back_propagation_learning(training)\n acc = accuracy(self, group)\n print(\"Accuracy on epoch {} is {} \".format(epoch, acc))","def _train_epoch(self, epoch: int) -> Dict[str, float]:\n logger.info(\"Epoch %d/%d\", epoch, self._num_epochs - 1)\n peak_cpu_usage = peak_memory_mb()\n logger.info(f\"Peak CPU memory usage MB: {peak_cpu_usage}\")\n gpu_usage = []\n for gpu, memory in gpu_memory_mb().items():\n gpu_usage.append((gpu, memory))\n logger.info(f\"GPU {gpu} memory usage MB: {memory}\")\n\n train_loss = 0.0\n # Set the model to \"train\" mode.\n self.model.train()\n\n num_gpus = len(self._cuda_devices)\n\n # Get tqdm for the training batches\n raw_train_generator = self.iterator(self.train_data,\n num_epochs=1,\n shuffle=self.shuffle)\n train_generator = lazy_groups_of(raw_train_generator, num_gpus)\n num_training_batches = math.ceil(self.iterator.get_num_batches(self.train_data)/num_gpus)\n self._last_log = time.time()\n last_save_time = time.time()\n\n batches_this_epoch = 0\n if self._batch_num_total is None:\n self._batch_num_total = 0\n\n histogram_parameters = set(self.model.get_parameters_for_histogram_tensorboard_logging())\n\n logger.info(\"Training\")\n train_generator_tqdm = Tqdm.tqdm(train_generator,\n total=num_training_batches)\n cumulative_batch_size = 0\n for batch_group in train_generator_tqdm:\n batches_this_epoch += 1\n self._batch_num_total += 1\n batch_num_total = self._batch_num_total\n\n self.optimizer.zero_grad()\n\n output_dict = self.get_output_dict(batch_group, for_training=True)\n loss = self.get_batch_loss(output_dict, for_training=True)\n\n if torch.isnan(loss):\n raise ValueError(\"nan loss encountered\")\n\n loss.backward()\n\n train_loss += loss.item()\n\n batch_grad_norm = self.rescale_gradients()\n\n # This does nothing if batch_num_total is None or you are using a\n # scheduler which doesn't update per batch.\n if self._learning_rate_scheduler:\n self._learning_rate_scheduler.step_batch(batch_num_total)\n if self._momentum_scheduler:\n self._momentum_scheduler.step_batch(batch_num_total)\n\n if self._tensorboard.should_log_histograms_this_batch():\n # get the magnitude of parameter updates for logging\n # We need a copy of current parameters to compute magnitude of updates,\n # and copy them to CPU so large models won't go OOM on the GPU.\n param_updates = {name: param.detach().cpu().clone()\n for name, param in self.model.named_parameters()}\n self.optimizer.step()\n for name, param in self.model.named_parameters():\n param_updates[name].sub_(param.detach().cpu())\n update_norm = torch.norm(param_updates[name].view(-1, ))\n param_norm = torch.norm(param.view(-1, )).cpu()\n self._tensorboard.add_train_scalar(\"gradient_update/\" + name,\n update_norm / (param_norm + 1e-7))\n else:\n self.optimizer.step()\n\n # Update moving averages\n if self._moving_average is not None:\n self._moving_average.apply(batch_num_total)\n\n # Update the description with the latest metrics\n metrics = training_util.get_metrics(self.model, train_loss, batches_this_epoch)\n description = training_util.description_from_metrics(metrics)\n\n train_generator_tqdm.set_description(description, refresh=False)\n\n # Log parameter values to Tensorboard\n if self._tensorboard.should_log_this_batch():\n self._tensorboard.log_parameter_and_gradient_statistics(self.model, batch_grad_norm)\n self._tensorboard.log_learning_rates(self.model, self.optimizer)\n\n self._tensorboard.add_train_scalar(\"loss/loss_train\", metrics[\"loss\"])\n self._tensorboard.log_metrics({\"epoch_metrics/\" + k: v for k, v in metrics.items()})\n\n if self.tensorboard_log_batch_callback:\n self.tensorboard_log_batch_callback(output_dict, self._tensorboard)\n\n if self._tensorboard.should_log_histograms_this_batch():\n self._tensorboard.log_histograms(self.model, histogram_parameters)\n\n if self._log_batch_size_period:\n cur_batch = sum([training_util.get_batch_size(batch) for batch in batch_group])\n cumulative_batch_size += cur_batch\n if (batches_this_epoch - 1) % self._log_batch_size_period == 0:\n average = cumulative_batch_size/batches_this_epoch\n logger.info(f\"current batch size: {cur_batch} mean batch size: {average}\")\n self._tensorboard.add_train_scalar(\"current_batch_size\", cur_batch)\n self._tensorboard.add_train_scalar(\"mean_batch_size\", average)\n\n # Save model if needed.\n if self._model_save_interval is not None and (\n time.time() - last_save_time > self._model_save_interval\n ):\n last_save_time = time.time()\n self._save_checkpoint(\n '{0}.{1}'.format(epoch, training_util.time_to_str(int(last_save_time)))\n )\n metrics = training_util.get_metrics(self.model, train_loss, batches_this_epoch, reset=True)\n metrics['cpu_memory_MB'] = peak_cpu_usage\n for (gpu_num, memory) in gpu_usage:\n metrics['gpu_'+str(gpu_num)+'_memory_MB'] = memory\n return metrics","def train_network(self):\n if self.trainData:\n if self.verbose:\n print('Started training...')\n\n for epoch in range(135):\n pass\n # save the model\n else:\n if self.verbose:\n print('No train data available')","def train_network(self, batch_size, epochs):\n\n if self.eq_train: self.model.fit([self.X_train_high_level, self.X_train_low_level], self.y_train, epochs=epochs, batch_size=batch_size, sample_weight=self.train_weights_eq) \n else: self.model.fit([self.X_train_high_level, self.X_train_low_level], self.y_train, epochs=epochs, batch_size=batch_size, sample_weight=self.train_weights)","def train(self, x_train, y_train, x_val, y_val):\n pass","def validation_epoch(self):\n self.model.eval()\n\n # Compute for training set\n train_loss, train_acc = compute_loss_and_accuracy(\n self.dataloader_train, self.model, self.loss_criterion\n )\n self.TRAIN_ACC.append(train_acc)\n self.TRAIN_LOSS.append(train_loss)\n\n # Compute for validation set\n validation_loss, validation_acc = compute_loss_and_accuracy(\n self.dataloader_val, self.model, self.loss_criterion\n )\n self.VALIDATION_ACC.append(validation_acc)\n self.VALIDATION_LOSS.append(validation_loss)\n print(\"Current validation loss:\", validation_loss, \" Accuracy:\", validation_acc)\n # Compute for testing set\n test_loss, test_acc = compute_loss_and_accuracy(\n self.dataloader_test, self.model, self.loss_criterion\n )\n self.TEST_ACC.append(test_acc)\n self.TEST_LOSS.append(test_loss)\n\n self.model.train()","def start_training(self):\n self.training = True","def train_step(self):\r\n batch_images = next(self.data_loader.next_batch())\r\n _, loss, summary, ea = self.sess.run([self.model.train_op, self.model.total_loss, self.model.merged, self.model.euclidean_a_p],\r\n feed_dict={self.model.input: batch_images, self.model.is_training: True})\r\n \r\n return loss, summary","def train_epoch(model, optimizer, train_loader, criterion, device):\n\n model.train()\n \n for batch_train, batch_answers in train_loader:\n batch_train = batch_train.to(device)\n batch_answers = batch_answers.to(device)\n \n optimizer.zero_grad()\n model_answers = model(batch_train)\n criterion(model_answers[0], batch_answers)\n\n\n new_loss = criterion(model_answers[0], batch_answers) + criterion(model_answers[1], batch_answers) \n new_loss.backward()\n optimizer.step()","def compile_train(self, epochs):\n self.model.compile(\n optimizer=Adam(0.001),\n loss=SparseCategoricalCrossentropy(from_logits=True),\n metrics='accuracy'\n )\n\n self.model.fit(\n train_x,\n train_y,\n batch_size=50,\n epochs=epochs,\n validation_data=(val_x, val_y),\n verbose=1\n )","def train(self, sess): \n\n logging.info(\"////////////////////////////\")\n logging.info(\"///// BEGIN TRAINING /////\")\n logging.info(\"////////////////////////////\")\n\n # for TensorBoard\n summaryWriter = tf.summary.FileWriter(\n \"./checkpoints/\", \n sess.graph)\n\n # Initialize iterator\n sess.run(self.train_iter.initializer)\n\n # Print initial model predictions\n emaTrainLoss = self.get_loss(sess, dSet=\"train\")\n emaTrainAccr = self.get_accuracy(sess, dSet=\"train\")\n valLoss = self.get_loss(sess, dSet=\"val\")\n valAccr = self.get_accuracy(sess, dSet=\"val\")\n logging.info(\"Initial training Loss / Accuracy: %f / %f)\" % (emaTrainLoss, emaTrainAccr))\n logging.info(\"Initial validation Loss / Accuracy: %f / %f)\" % (valLoss, valAccr))\n\n randomRatio = 1.0\n epoch = 0\n best_val_loss = None\n best_val_acc = None\n\n\n ###### Loop over epochs #####\n while (self.FLAGS.Nepochs is 0) or (epoch <= self.FLAGS.Nepochs):\n epoch += 1\n epoch_tic = time.time()\n\n # Evaluate test and validation data\n trnLoss = self.get_loss(sess, dSet=\"train\")\n trnAccr = self.get_accuracy(sess, dSet=\"train\")\n valLoss = self.get_loss(sess, dSet=\"val\")\n valAccr = self.get_accuracy(sess, dSet=\"val\")\n\n print_info = \"Full Sets\\tTraining %.5f / %.5f \\tValidation %.5f / %.5f\" %\\\n (trnLoss, trnAccr, valLoss, valAccr)\n logging.info(\"\\n\\n///// Begin Epoch {} /////\\n\".format(epoch)\n + print_info)\n\n\n # Initialize iterator\n sess.run(self.train_iter.initializer)\n\n ##### Loop over mini batches #####\n while True:\n\n # Perform training step\n try :\n tstep_tic = time.time()\n curLoss, curAccr, global_step = self.run_train_step(sess, summaryWriter)\n tstep_toc = time.time()\n tstep_time = tstep_toc - tstep_tic\n except tf.errors.OutOfRangeError:\n break\n\n # Update training history parameters\n emaTrainLoss = curLoss*(1-self.FLAGS.train_variable_decay)\\\n + emaTrainLoss*self.FLAGS.train_variable_decay \n emaTrainAccr = curAccr*(1-self.FLAGS.train_variable_decay)\\\n + emaTrainAccr*self.FLAGS.train_variable_decay \n\n ### Evaluate model ###\n if global_step % self.FLAGS.eval_every == 0:\n\n # Save training data measurements\n self.writeSummary(emaTrainLoss, \"train/loss\", summaryWriter, global_step)\n self.writeSummary(emaTrainAccr, \"train/acc\", summaryWriter, global_step)\n self.history[\"step\"].append(global_step)\n self.history[\"trainLoss\"].append(emaTrainLoss)\n self.history[\"trainAccr\"].append(emaTrainAccr)\n\n # Evaluate validation data\n valLoss = self.get_loss(sess, dSet=\"val\")\n valAccr = self.get_accuracy(sess, dSet=\"val\")\n\n self.writeSummary(valLoss, \"val/loss\", summaryWriter, global_step)\n self.writeSummary(valAccr, \"val/acc\", summaryWriter, global_step)\n self.history[\"validLoss\"].append(valLoss)\n self.history[\"validAccr\"].append(valAccr)\n\n # Logging results\n print_info = \"%i\\tTraining %.5f / %.5f \\tValidation %.5f / %.5f\" %\\\n (global_step, emaTrainLoss, emaTrainAccr, valLoss, valAccr)\n logging.info(print_info)\n\n # plot training progress\n self.plot_results()\n\n\n # Save model\n if global_step % self.FLAGS.save_every == 0:\n logging.info(\"Saving model at iteration {} to {}\".format(\n global_step, self.FLAGS.checkpoint_path))\n self.saver.save(sess, \n self.FLAGS.checkpoint_path + \"/\" + self.FLAGS.experiment_name, \n global_step=global_step)\n self.saveTrainingHistory(\n fileName=self.FLAGS.checkpoint_path + \"/\" + self.FLAGS.experiment_name, \n global_step=global_step)\n\n\n # Evaluate validation data\n valLoss = self.get_loss(sess, dSet=\"val\")\n valAccs = self.get_accuracy(sess, dSet=\"val\")\n\n # Save best models\n if (best_val_loss is None) or (valLoss < best_val_loss):\n logging.info(\"Saving best loss model at iteration {} in {}\".format(\n global_step, self.FLAGS.bestModel_loss_ckpt_path))\n best_val_loss = valLoss\n self.bestLossSaver.save(sess, \n self.FLAGS.bestModel_loss_ckpt_path + \"/\" + self.FLAGS.experiment_name, \n global_step=global_step)\n self.saveTrainingHistory(\n fileName=self.FLAGS.bestModel_loss_ckpt_path + \"/\" + self.FLAGS.experiment_name, \n global_step=global_step)\n if (best_val_acc is None) or (valAccs > best_val_acc):\n logging.info(\"Saving best accuracy model at iteration {} in {}\".format(\n global_step, self.FLAGS.bestModel_acc_ckpt_path))\n best_val_acc = valAccs\n self.bestAccSaver.save(sess, \n self.FLAGS.bestModel_acc_ckpt_path + \"/\" + self.FLAGS.experiment_name, \n global_step=global_step)\n self.saveTrainingHistory(\n fileName=self.FLAGS.bestModel_acc_ckpt_path + \"/\" + self.FLAGS.experiment_name, \n global_step=global_step)\n\n\n loss_train = self.get_loss(sess, dSet=\"train\")\n acc_train = self.get_accuracy(sess, dSet=\"train\")\n\n loss_val = self.get_loss(sess, dSet=\"val\")\n acc_val = self.get_accuracy(sess, dSet=\"val\")\n\n print(loss_train, acc_train)\n if self.FLAGS.verbose:\n print(\"\\n\\n\")\n print(\"###########################\")\n print(\"##### Final Results #####\")\n print(\"###########################\")\n print(\"\\nTraining [ Loss: %f\\t Accuracy: %f]\" \\\n % (loss_train, acc_train))\n print(\"Validation [ Loss: %f\\t Accuracy: %f]\" \\\n % (loss_val, acc_val))\n \n self.hasTrained = True","def train_an_epoch(self, train_loader, epoch_id):\n assert hasattr(self, \"model\"), \"Please specify the exact model !\"\n self.model.train()\n total_loss = 0.0\n\n for batch_data in train_loader:\n loss = self.train_single_batch(batch_data)\n total_loss += loss\n print(\"[Training Epoch {}], Loss {}\".format(epoch_id, loss))\n self.writer.add_scalar(\"model/loss\", total_loss, epoch_id)","def train_one_epoch(self):\n print('Training......')\n\n # set mode train\n self.network.train()\n\n # prepare data\n train_loss = 0\n transform = transforms.Compose([Rescale(params.rescale_size),\n RandomCrop(params.image_size),\n RandomHorizontalFlip(),\n ToTensor()\n ])\n\n\n\n dataset = Cityscapes(params.dataset_root, mode='train', transforms = transform)\n\n train_loader = DataLoader(dataset,\n batch_size=params.train_batch,\n shuffle=params.shuffle,\n num_workers=params.dataloader_workers)\n \n train_size = 1896\n if train_size % self.params.train_batch != 0:\n total_batch = train_size // self.params.train_batch + 1\n else:\n total_batch = train_size // self.params.train_batch\n recal = 0\n precision = 0\n F_one = 0\n IOU = 0\n accuracy_new = 0 \n # train through dataset\n for batch_idx, batch in enumerate(train_loader):\n self.pb.click(batch_idx, total_batch)\n image, label = batch['image'], batch['label']\n image_cuda, label_cuda = image.cuda(), label.cuda()\n\n # checkpoint split\n if self.params.should_split:\n image_cuda.requires_grad_()\n out = checkpoint_sequential(self.network, self.params.split, image_cuda)\n else:\n out = self.network(image_cuda)\n\n\n loss = self.loss_fn(out, label_cuda)\n \n #display_image(out, label_cuda)\n TP, FP, TN, FN = confusion(out, label_cuda)\n recal = recal+TP\n precision = precision+FP\n F_one = F_one + TN\n IOU = IOU+ FN \n accuracy_final = accuracy(out, label_cuda)\n accuracy_new = accuracy_new + accuracy_final\n\n # optimize\n self.opt.zero_grad()\n loss.backward()\n self.opt.step()\n\n # accumulate\n train_loss += loss.item()\n\n # record first loss\n if self.train_loss == []:\n self.train_loss.append(train_loss)\n self.summary_writer.add_scalar('loss/train_loss', train_loss, 0)\n \n print(\"\\t\")\n print(recal/total_batch, precision/ total_batch, F_one/ total_batch, IOU/ total_batch)\n print(accuracy_new/total_batch)\n \n self.pb.close()\n train_loss /= total_batch\n self.train_loss.append(train_loss)\n\n # add to summary\n self.summary_writer.add_scalar('loss/train_loss', train_loss, self.epoch)"],"string":"[\n \"def train_one_epoch(self):\\n raise NotImplementedError\",\n \"def train(self, training_steps=10):\",\n \"def train():\\n pass\",\n \"def train_epoch(self, data_loader):\\n raise NotImplementedError\",\n \"def train(self):\\n self.epoch = 0\\n self.step = 0\\n self.start_time = time.time()\\n for self.epoch in range(self.num_epochs):\\n print(\\\"EPOHA\\\")\\n self.run_epoch()\\n print(\\\"SAVE MODEL\\\")\\n self.save_model()\",\n \"def train(self, batch):\\n pass\",\n \"def train():\\n # YOUR TRAINING CODE GOES HERE\",\n \"def train(self, num_batches: int):\",\n \"def train_epoch(self):\\n for batch, targets in self.training_dataloader:\\n self.training_step(batch, targets)\\n self.calculate_training_loss()\\n self.epochs_trained += 1\\n LOGGER.info(\\n \\\"Training loss after {} epochs: {}\\\".format(str(self.epochs_trained), str(self.training_average_loss))\\n )\",\n \"def trainNet():\",\n \"def train_epoch(self) -> None:\\n ct = self.config.training\\n total_games = self._get_total_games()\\n print(f\\\"Total Games: {total_games}\\\")\\n train_size = int(0.9 * total_games)\\n dataset_wrapper = DatasetWrapper(self.config)\\n self.agent.model.fit(\\n dataset_wrapper.get_dataset(train_size),\\n epochs=ct.epoch_to_checkpoint,\\n validation_data=dataset_wrapper.get_dataset(train_size, is_training=False),\\n )\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def _train_epoch(self, epoch):\\n self.model.train()\\n self.train_metrics.reset()\\n for batch_idx, (data, target) in enumerate(self.data_loader):\\n data, target = data.to(self.device), target.to(self.device)\\n\\n self.optimizer.zero_grad()\\n\\n if self.config[\\\"amp\\\"]:\\n # AMP!\\n with autocast():\\n output = self.model(data)\\n loss = self.criterion(output, target)\\n else:\\n output = self.model(data)\\n loss = self.criterion(output, target)\\n\\n loss.backward()\\n self.optimizer.step()\\n\\n self.writer.set_step((epoch - 1) * self.len_epoch + batch_idx)\\n self.train_metrics.update(\\\"loss\\\", loss.item())\\n for met in self.metric_ftns:\\n self.train_metrics.update(met.__name__, met(output, target))\\n\\n if batch_idx % self.log_step == 0:\\n self.logger.debug(\\n \\\"Train Epoch: {} {} Loss: {:.6f}\\\".format(\\n epoch, self._progress(batch_idx), loss.item()\\n )\\n )\\n self.writer.add_image(\\n \\\"input\\\", make_grid(data.cpu(), nrow=8, normalize=True)\\n )\\n\\n if batch_idx == self.len_epoch:\\n break\\n log = self.train_metrics.result()\\n\\n if self.do_validation:\\n val_log = self._valid_epoch(epoch)\\n log.update(**{\\\"val_\\\" + k: v for k, v in val_log.items()})\\n\\n if self.lr_scheduler is not None:\\n self.lr_scheduler.step()\\n return log\",\n \"def run_epoch(self):\\n self.model_lr_scheduler.step()\\n\\n print(\\\"Training\\\")\\n self.set_train()\\n\\n for batch_idx, inputs in enumerate(self.train_loader):\\n\\n before_op_time = time.time()\\n\\n outputs, losses = self.process_batch(inputs)\\n\\n self.model_optimizer.zero_grad()\\n losses[\\\"loss\\\"].backward()\\n self.model_optimizer.step()\\n\\n duration = time.time() - before_op_time\\n\\n # log less frequently after the first 2000 steps to save time & disk space\\n early_phase = self.step < 2000\\n late_phase = self.step % 2000 == 0\\n\\n if early_phase or late_phase:\\n self.log_time(batch_idx, duration, losses[\\\"loss\\\"].cpu().data)\\n\\n if \\\"depth_gt\\\" in inputs:\\n self.compute_depth_losses(inputs, outputs, losses)\\n\\n self.log(\\\"train\\\", inputs, outputs, losses)\\n self.val()\\n\\n self.step += 1\",\n \"def training_phase(self):\\r\\n self.train_dataloader = self.get_dataloader(\\r\\n hdf_path=self.train_h5_path,\\r\\n data_description=\\\"training set\\\"\\r\\n )\\r\\n self.valid_dataloader = self.get_dataloader(\\r\\n hdf_path=self.valid_h5_path,\\r\\n data_description=\\\"validation set\\\"\\r\\n )\\r\\n\\r\\n self.get_ts_properties()\\r\\n\\r\\n self.initialize_output_files()\\r\\n\\r\\n start_epoch, end_epoch = self.define_model_and_optimizer()\\r\\n\\r\\n print(\\\"* Beginning training.\\\", flush=True)\\r\\n n_processed_batches = 0\\r\\n for epoch in range(start_epoch, end_epoch):\\r\\n\\r\\n self.current_epoch = epoch\\r\\n n_processed_batches = self.train_epoch(n_processed_batches=n_processed_batches)\\r\\n\\r\\n # evaluate model every `sample_every` epochs (not every epoch)\\r\\n if epoch % self.C.sample_every == 0:\\r\\n self.evaluate_model()\\r\\n else:\\r\\n util.write_model_status(score=\\\"NA\\\") # score not computed\\r\\n\\r\\n self.print_time_elapsed()\",\n \"def run_epoch(model, data, optimizer, epoch):\\n traindata, valdata = data\\n\\n model.train()\\n train_bpd = epoch_iter(model, traindata, optimizer, epoch)\\n\\n model.eval()\\n val_bpd = epoch_iter(model, valdata, optimizer, epoch)\\n\\n return train_bpd, val_bpd\",\n \"def trainData(self, X, y, NeuralNet, epochs):\",\n \"def __call__(self, initial_lr, step, epoch):\\n\\n pass\",\n \"def train_epoch(model, train_dataloader, optimizer, loss_fn):\\n model.train()\\n total_training_loss = 0\\n for batch_index, batch in enumerate(train_dataloader):\\n batch = batch[0].view(-1,1,28,28).float()\\n output_batch = model(batch)\\n loss = loss_fn(batch, output_batch, model.prev_means, model.prev_vars)\\n optimizer.zero_grad()\\n loss.backward()\\n optimizer.step()\\n total_training_loss += loss\",\n \"def run_epoch(self):\\n print(\\\"Training\\\")\\n self.set_train()\\n\\n for batch_idx in range(0, self.num_total_batch):\\n\\n before_op_time = time.time()\\n # Choosing the dataloader for training model\\n if self.choosing_dataset_to_train_with(batch_idx):\\n # Synthetic dataset\\n self.syn_or_real = 'syn'\\n try:\\n inputs = self.syn_train_iter.__next__()\\n except StopIteration:\\n print('Stopped as the iteration has reached to the END, and reloading the synthetic dataloader')\\n self.syn_train_iter = iter(self.syn_train_loader)\\n inputs = self.syn_train_iter.__next__()\\n else:\\n # Real dataset\\n self.syn_or_real = 'real'\\n try:\\n inputs = self.real_train_iter.__next__()\\n except StopIteration:\\n print('Stopped as the iteration has reached to the END, and reloading the real dataloader')\\n self.real_train_iter = iter(self.real_train_loader)\\n inputs = self.real_train_iter.__next__()\\n\\n # Move all available tensors to GPU memory\\n for key, ipt in inputs.items():\\n if type(key) == tuple or key == \\\"depth_gt\\\":\\n inputs[key] = ipt.to(self.device)\\n\\n # log less frequently after the first 2000 steps to save time & disk space\\n self.step += 1\\n self.early_phase = batch_idx % self.opt.log_frequency == 0\\n self.mid_phase = False and self.step % self.opt.save_frequency == 0\\n self.late_phase = self.num_total_batch - 1 == batch_idx\\n\\n outputs, losses = {}, {}\\n # Depth estimation\\n outputs_d, losses_d = self.process_batch(inputs)\\n outputs.update(outputs_d)\\n losses.update(losses_d)\\n\\n # No more if else conditions, just combine all losses based on availability of gradients\\n final_loss = torch.tensor(0.).to(self.device)\\n for k, v in losses.items():\\n if ('d_' not in k) and v.requires_grad and ('/' not in k):\\n final_loss += v\\n final_loss.backward()\\n losses[\\\"loss\\\"] = final_loss\\n\\n if (batch_idx + 1) % 2 == 0:\\n self.model_optimizer.step()\\n self.model_optimizer.zero_grad()\\n self.zero_grad()\\n\\n duration = time.time() - before_op_time\\n self.log_time(batch_idx, duration, losses[\\\"loss\\\"].cpu().data)\\n\\n if \\\"depth_gt\\\" in inputs:\\n self.compute_depth_losses(inputs, outputs, losses)\\n\\n if self.early_phase or self.mid_phase or self.late_phase:\\n self.log(\\\"train\\\", inputs, outputs, losses)\\n self.val(\\\"real\\\")\\n self.val(\\\"syn\\\")\\n\\n if (batch_idx + 1) % 2 == 0:\\n current_lr = self.update_learning_rate(self.model_optimizer, self.opt.learning_rate)\",\n \"def train_epoch(self):\\r\\n for loader in self.loaders:\\r\\n if self.epoch % loader.epoch_interval == 0:\\r\\n self.cycle_dataset(loader)\\r\\n\\r\\n self._stats_new_epoch()\\r\\n self._write_tensorboard()\\r\\n print('{}th epoch train / eval done!'.format(self.epoch))\",\n \"def train(self):\\n self.epoch = 0\\n self.step = 0\\n self.start_time = time.time()\\n for self.epoch in range(self.opt.num_epochs):\\n self.run_epoch()\\n if (self.epoch + 1) % self.opt.save_frequency == 0:\\n self.save_model()\",\n \"def _evaluate_during_fit(self, test_loader, epoch):\",\n \"def _train_epoch(self, model, tqdm_data,\\n optimizer_disc=None, optimizer_gen=None):\",\n \"def Train(self):\\n self.init_epoch = self.epoch\\n if self.epoch >= self.params.num_epoch:\\n WARNING('Num_epoch should be smaller than current epoch. Skip training......\\\\n')\\n else:\\n for _ in range(self.epoch, self.params.num_epoch):\\n self.epoch += 1\\n print('-' * 20 + 'Epoch.' + str(self.epoch) + '-' * 20)\\n\\n # train one epoch\\n self.train_one_epoch()\\n\\n # should display\\n if self.epoch % self.params.display == 0:\\n print('\\\\tTrain loss: %.4f' % self.train_loss[-1])\\n\\n # should save\\n if self.params.should_save:\\n if self.epoch % self.params.save_every == 0:\\n self.save_checkpoint()\\n\\n # test every params.test_every epoch\\n if self.params.should_val:\\n if self.epoch % self.params.val_every == 0:\\n self.val_one_epoch()\\n print('\\\\tVal loss: %.4f' % self.val_loss[-1])\\n\\n # adjust learning rate\\n self.adjust_lr()\\n self.train_one_epoch_Image_display() \\n \\n # save the last network state\\n if self.params.should_save:\\n self.save_checkpoint()\\n\\n # train visualization\\n self.plot_curve()\",\n \"def train_epoch(model, training_data, optimizer, pred_loss_func, opt):\\n\\n model.train()\\n\\n total_event_ll = 0 # cumulative event log-likelihood\\n total_time_se = 0 # cumulative time prediction squared-error\\n total_time_error = 0 # cumulative time prediction squared-error\\n total_time_latitude = 0 # cumulative latitude prediction squared-error\\n total_time_longitude = 0 # cumulative longitude prediction squared-error\\n total_event_rate = 0 # cumulative number of correct prediction\\n total_num_event = 0 # number of total events\\n total_num_pred = 0 # number of predictions\\n for batch in tqdm(training_data, mininterval=2,\\n desc=' - (Training) ', leave=False):\\n \\\"\\\"\\\" prepare data \\\"\\\"\\\"\\n event_time, time_gap, event_type, latitude, longitude = map(lambda x: x.to(opt.device), batch)\\n\\n \\\"\\\"\\\" forward \\\"\\\"\\\"\\n optimizer.zero_grad()\\n\\n enc_out, prediction = model(event_type, event_time, latitude, longitude) # change the event_time to time gap\\n\\n \\\"\\\"\\\" backward \\\"\\\"\\\"\\n # negative log-likelihood\\n event_ll, non_event_ll = Utils.log_likelihood(model, enc_out, event_time, event_type, latitude, longitude) # change the event_time to time gap\\n event_loss = -torch.sum(event_ll - non_event_ll)\\n\\n # type prediction\\n pred_loss, pred_num_event = Utils.type_loss(prediction[0], event_type, pred_loss_func)\\n\\n # time prediction\\n se = Utils.time_loss(prediction[1], event_time) # change the event_time to time gap\\n\\n # latitude prediction\\n le = Utils.time_loss(prediction[2], latitude)\\n\\n # longitude prediction\\n ge = Utils.time_loss(prediction[3], longitude)\\n\\n # SE is usually large, scale it to stabilize training\\n scale_time_loss = 100\\n loss = event_loss + pred_loss + se / scale_time_loss + le / scale_time_loss + ge / scale_time_loss\\n loss.backward()\\n\\n \\\"\\\"\\\" update parameters \\\"\\\"\\\"\\n optimizer.step()\\n\\n \\\"\\\"\\\" note keeping \\\"\\\"\\\"\\n total_event_ll += -event_loss.item()\\n total_time_se += se.item() + le.item() + ge.item()\\n total_time_error += se.item()\\n total_time_latitude += le.item()\\n total_time_longitude += ge.item()\\n\\n total_event_rate += pred_num_event.item()\\n total_num_event += event_type.ne(Constants.PAD).sum().item()\\n # we do not predict the first event\\n total_num_pred += event_type.ne(Constants.PAD).sum().item() - event_time.shape[0]\\n\\n total_rmse = np.sqrt(total_time_se / total_num_pred)\\n time_rmse = np.sqrt(total_time_error / total_num_pred)\\n latitude_rmse = np.sqrt(total_time_latitude / total_num_pred)\\n longitude_rmse = np.sqrt(total_time_longitude / total_num_pred)\\n print('Time: {:5f} Latitude: {:5f} Longitude: {:5f} Overall: {:5f} '.format(time_rmse, latitude_rmse, longitude_rmse, total_rmse))\",\n \"def train(self, batch_training=False):\\n raise NotImplementedError\",\n \"def train_epoch(self, train=False):\\n # init params\\n config = self.config\\n writer = self.writer\\n train_params = self.get_train_params()\\n args = self.args\\n # net, net_SP = self.net, self.net_SP\\n optimizer, optimizer_SP = self.optimizer, self.optimizer_SP\\n\\n lr = self.get_learning_rate()\\n logging.info(f\\\"current learning rate: {lr}\\\")\\n\\n running_losses = []\\n self.save_lists = [\\n \\\"err_q\\\",\\n \\\"err_t\\\",\\n \\\"epi_dists\\\",\\n \\\"relative_poses_cam\\\",\\n \\\"relative_poses_body\\\",\\n ]\\n dict_of_lists_in_train = init_dict_of_lists(config, self.save_lists)\\n dict_of_lists_in_val = init_dict_of_lists(config, self.save_lists)\\n if_val_in_train_trigger = False\\n\\n thd_corr = 300\\n writer.add_scalar(\\\"training-lr\\\", lr, self.n_iter)\\n\\n # Train one epoch\\n for i, sample_train in tqdm(enumerate(self.train_loader)):\\n # if training\\n if train:\\n # eval in training script\\n if (\\n self.n_iter != 0\\n and self.n_iter % config[\\\"training\\\"][\\\"val_interval_in_train\\\"] == 0\\n ):\\n if_val_in_train_trigger = True\\n if if_val_in_train_trigger:\\n logging.info(\\n \\\"+++[Train]+++ Collecting training batch for %s at train step %d\\\"\\n % (args.exper_name, self.n_iter)\\n )\\n self.net.eval()\\n else:\\n self.net.train()\\n\\n # train one batch\\n (\\n loss_train_out,\\n dict_of_lists_in_train,\\n clamp_cum,\\n ) = self.train_val_batch(\\n train_params,\\n sample_train,\\n True,\\n if_val=if_val_in_train_trigger,\\n dict_of_lists=dict_of_lists_in_train,\\n )\\n\\n if if_val_in_train_trigger:\\n if (\\n dict_of_lists_in_train[\\\"count\\\"]\\n > config[\\\"training\\\"][\\\"val_batches\\\"]\\n ):\\n dict_of_lists_in_train = self.flush_dict_of_lists(\\n writer, \\\"training\\\", self.n_iter, **dict_of_lists_in_train\\n )\\n if_val_in_train_trigger = False\\n else:\\n # running_losses.append(loss_train_out)\\n print(self.n_iter, \\\"%.8f\\\" % loss_train_out)\\n self.n_iter += 1\\n\\n # if testing\\n if args.eval and self.n_iter % config[\\\"training\\\"][\\\"val_interval\\\"] == 0:\\n logging.info(\\n \\\"+++[Val]+++ Validating %s at train step %d\\\"\\n % (args.exper_name, self.n_iter)\\n )\\n self.net.eval()\\n assert self.net.training == False\\n for j, sample_val in tqdm(enumerate(self.val_loader)):\\n # if not self.check_num_of_matches(sample, thd=thd_corr): continue\\n logging.info(\\\"+++[Val]+++ Validating batch %d\\\" % (j))\\n # logging.info(f\\\"frame_id: {sample_val['frame_ids']}\\\")\\n loss_val_out, dict_of_lists_in_val, _ = self.train_val_batch(\\n train_params, sample_val,\\n False, if_val=True, dict_of_lists=dict_of_lists_in_val,\\n ) ##### check: in order to align val and training\\n self.n_iter_val += 1\\n if config[\\\"training\\\"][\\\"val_batches\\\"] != -1 and (\\n j > config[\\\"training\\\"][\\\"val_batches\\\"]\\n ): ##### check: how to limit the validation\\n break\\n print(dict_of_lists_in_val.keys())\\n\\n ## save valdiation result (dict)\\n if len(config[\\\"exps\\\"][\\\"filename\\\"]) > 3:\\n # print(f\\\"dict_of_lists_in_val: {dict_of_lists_in_val}\\\")\\n def get_dict(key_layer1, key_layer2, dict_of_lists):\\n dict_of_array = {}\\n for k in key_layer1:\\n dict_of_array[k] = np.stack(dict_of_lists[k][key_layer2])\\n return dict_of_array\\n\\n our_name, base_name = (\\n config[\\\"exps\\\"][\\\"our_name\\\"],\\n config[\\\"exps\\\"][\\\"base_name\\\"],\\n )\\n\\n print(f'save dict_of_lists_in_val to {config[\\\"exps\\\"][\\\"filename\\\"]}')\\n # save our results\\n dict_of_lists = get_dict(\\n self.save_lists, our_name, dict_of_lists_in_val\\n )\\n dict_of_lists[\\\"epi_dists\\\"] = dict_of_lists[\\\"epi_dists\\\"][:, :10] ### only take part of it\\n np.savez(\\n f'{self.save_path[:-11]}/{our_name}_{config[\\\"exps\\\"][\\\"filename\\\"]}',\\n **dict_of_lists,\\n )\\n # save base_name\\n dict_of_lists = get_dict(\\n self.save_lists, base_name, dict_of_lists_in_val\\n )\\n dict_of_lists[\\\"epi_dists\\\"] = dict_of_lists[\\\"epi_dists\\\"][:, :10] ### only take part of it\\n np.savez(\\n f'{self.save_path[:-11]}/{base_name}_{config[\\\"exps\\\"][\\\"filename\\\"]}',\\n **dict_of_lists,\\n )\\n # output then flush\\n dict_of_lists_in_val = self.flush_dict_of_lists(\\n writer, \\\"validating\\\", self.n_iter, **dict_of_lists_in_val\\n )\\n\\n # epoch_loss = np.mean(np.asarray(running_losses))\\n\\n # training iterations\\n self.epoch += 1\\n if self.n_iter > config[\\\"training\\\"][\\\"train_iter\\\"]:\\n break\\n return 0.0, self.clamp_cum, self.n_iter, self.n_iter_val\",\n \"def learn(self):\\n epochswin = [] # count the number of wins at every epoch of the network against the preceding version\\n epochdraw = [] # count the number of draws at every epoch of the network against the preceding version\\n epochswingreedy = [] # count the number of wins against greedy at every epoch\\n epochswinrandom = [] # count the number of wins against random at every epoch\\n epochsdrawgreedy = [] # count the number of draws against greedy at every epoch\\n epochsdrawrandom = [] # count the number of wins against random at every epoch\\n epochswinminmax = [] # count the number of wins against minmax at every epoch\\n epochsdrawminmax = [] # count the number of draws against minmax at every epoch\\n\\n\\n if self.args.load_model == True:\\n file = open(self.args.trainExampleCheckpoint + \\\"graphwins:iter\\\" + str(self.args.numIters) + \\\":eps\\\" + str(\\n self.args.numEps) + \\\":dim\\\" + str(self.game.n) + \\\".txt\\\", \\\"r+\\\")\\n lines = file.readlines()\\n for index, line in enumerate(lines):\\n for word in line.split():\\n if index == 0:\\n epochswin.append(word)\\n elif index == 1:\\n epochdraw.append(word)\\n file.close()\\n\\n file = open(self.args.trainExampleCheckpoint + \\\"graphwins:iter\\\" + str(self.args.numIters) + \\\":eps\\\" + str(\\n self.args.numEps) + \\\":dim\\\" + str(self.game.n) + \\\":greedyrandom.txt\\\", \\\"r+\\\")\\n lines = file.readlines()\\n for index, line in enumerate(lines):\\n for word in line.split():\\n if index == 0:\\n epochswingreedy.append(word)\\n elif index == 1:\\n epochsdrawgreedy.append(word)\\n elif index == 2:\\n epochswinrandom.append(word)\\n elif index == 3:\\n epochsdrawrandom.append(word)\\n elif index == 4:\\n epochswinminmax.append(word)\\n elif index == 5:\\n epochsdrawminmax.append(word)\\n file.close()\\n self.loadTrainExamples()\\n\\n for i in range(1, self.args.numIters + 1):\\n # bookkeeping\\n print('------ITER ' + str(i) + '------')\\n # examples of the iteration\\n iterationTrainExamples = deque([], maxlen=self.args.maxlenOfQueue)\\n\\n eps_time = AverageMeter()\\n bar = Bar('Self Play', max=self.args.numEps)\\n end = time.time()\\n\\n for eps in range(self.args.numEps):\\n iterationTrainExamples += self.executeEpisode()\\n\\n # bookkeeping + plot progress\\n eps_time.update(time.time() - end)\\n end = time.time()\\n bar.suffix = '({eps}/{maxeps}) Eps Time: {et:.3f}s | Total: {total:} | ETA: {eta:}'.format(eps=eps + 1,\\n maxeps=self.args.numEps,\\n et=eps_time.avg,\\n total=bar.elapsed_td,\\n eta=bar.eta_td)\\n bar.next()\\n bar.finish()\\n\\n # save the iteration examples to the history\\n self.trainExamplesHistory.append(iterationTrainExamples)\\n\\n if len(self.trainExamplesHistory) > self.args.numItersForTrainExamplesHistory:\\n print(\\\"len(trainExamplesHistory) =\\\", len(self.trainExamplesHistory),\\n \\\" => remove the oldest trainExamples\\\")\\n self.trainExamplesHistory.pop(0)\\n # backup history to a file\\n # NB! the examples were collected using the model from the previous iteration, so (i-1)\\n self.saveTrainExamples(i - 1)\\n\\n # shuffle examlpes before training\\n trainExamples = []\\n for e in self.trainExamplesHistory:\\n trainExamples.extend(e)\\n shuffle(trainExamples)\\n\\n # training new network, keeping a copy of the old one\\n\\n filename = \\\"curent\\\"+str(i)+\\\"temp:iter\\\" + str(self.args.numIters) + \\\":eps\\\" + str(self.args.numEps) + \\\":dim\\\" + str(\\n self.game.n) + \\\".pth.tar\\\"\\n filenameBest = \\\"best\\\" + str(self.args.numIters) + \\\":eps\\\" + str(self.args.numEps) + \\\":dim\\\" + str(\\n self.game.n) + \\\".pth.tar\\\"\\n\\n self.nnet.save_checkpoint(folder=self.args.checkpoint, filename=filename)\\n exists = os.path.isfile(filenameBest)\\n if exists:\\n self.pnet.load_checkpoint(folder=self.args.checkpoint, filename=filenameBest)\\n else:\\n self.pnet.load_checkpoint(folder=self.args.checkpoint, filename=filename)\\n pmcts = MCTS(self.game, self.pnet, self.args)\\n\\n self.nnet.train(trainExamples)\\n nmcts = MCTS(self.game, self.nnet, self.args)\\n\\n print('PITTING AGAINST PREVIOUS VERSION')\\n arena = Arena(lambda x: np.argmax(pmcts.getActionProb(x, temp=0)),\\n lambda x: np.argmax(nmcts.getActionProb(x, temp=0)), self.game,nmcts,pmcts,evaluate=True)\\n\\n pwins, nwins, draws = arena.playGames(self.args.arenaCompare, False)\\n\\n pmcts.clear()\\n nmcts.clear()\\n del pmcts\\n del nmcts\\n\\n print(' ')\\n print('NEW/PREV WINS : %d / %d ; DRAWS : %d' % (nwins, pwins, draws))\\n if i == 1:\\n epochswin.append(pwins)\\n epochdraw.append(0)\\n\\n epochswin.append(nwins)\\n epochdraw.append(draws)\\n self.writeLogsToFile(epochswin, epochdraw)\\n\\n ''' Get all the players and then pit them against the network. You need to modify here if you implement \\n more players\\n '''\\n (gp, rp, mp) = self.decidePlayers()\\n\\n if self.args.parallel == 0:\\n\\n\\n nmcts1 = MCTS(self.game, self.nnet, self.args)\\n nmcts2 = MCTS(self.game, self.nnet, self.args)\\n nmcts3 = MCTS(self.game, self.nnet, self.args)\\n\\n arenagreedy = Arena(lambda x: np.argmax(nmcts1.getActionProb(x, temp=0)), gp, self.game,nmcts1)\\n arenarandom = Arena(lambda x: np.argmax(nmcts2.getActionProb(x, temp=0)), rp, self.game,nmcts2)\\n arenaminmax = Arena(lambda x: np.argmax(nmcts3.getActionProb(x, temp=0)), mp, self.game,nmcts3,evaluate=True)\\n\\n pwinsminmax, nwinsminmax, drawsminmax = arenaminmax.playGames(self.args.arenaCompare)\\n print(\\\"minmax - \\\"+str(pwinsminmax)+\\\" \\\"+str(nwinsminmax)+\\\" \\\"+str(drawsminmax))\\n pwinsgreedy, nwinsgreedy, drawsgreedy = arenagreedy.playGames(self.args.arenaCompare)\\n print(\\\"greedy - \\\"+str(pwinsgreedy)+\\\" \\\"+str(nwinsgreedy)+\\\" \\\"+str(drawsgreedy))\\n pwinsreandom, nwinsrandom, drawsrandom = arenarandom.playGames(self.args.arenaCompare)\\n print(\\\"random - \\\"+str(pwinsreandom)+\\\" \\\"+str(nwinsrandom)+\\\" \\\"+str(drawsrandom))\\n\\n nmcts1.clear()\\n nmcts2.clear()\\n nmcts3.clear()\\n del nmcts1\\n del nmcts2\\n del nmcts3\\n\\n else:\\n '''\\n This will be used if you want to evaluate the network against the benchmarks in a parallel way\\n '''\\n\\n self.args.update({'index': str(i)})\\n\\n p = self.parallel(self.args.arenaCompare)\\n (pwinsminmax, nwinsminmax, drawsminmax) = p[0] # self.parallel(\\\"minmax\\\", self.args.arenaCompare)\\n (pwinsgreedy, nwinsgreedy, drawsgreedy) = p[1] # self.parallel(\\\"greedy\\\",self.args.arenaCompare)\\n (pwinsreandom, nwinsrandom, drawsrandom) = p[2] # self.parallel(\\\"random\\\",self.args.arenaCompare)\\n\\n epochsdrawgreedy.append(drawsgreedy)\\n epochsdrawrandom.append(drawsrandom)\\n epochswinrandom.append(pwinsreandom)\\n epochswingreedy.append(pwinsgreedy)\\n epochswinminmax.append(pwinsminmax)\\n epochsdrawminmax.append(drawsminmax)\\n\\n self.writeLogsToFile(epochswingreedy, epochsdrawgreedy, epochswinrandom, epochsdrawrandom, epochswinminmax,\\n epochsdrawminmax, training=False)\\n\\n if pwins + nwins == 0 or float(nwins) / (pwins + nwins) <= self.args.updateThreshold:\\n print('REJECTING NEW MODEL')\\n filename = \\\"curent\\\"+str(i)+\\\"temp:iter\\\" + str(self.args.numIters) + \\\":eps\\\" + str(self.args.numEps) + \\\":dim\\\" + str(\\n self.game.n) + \\\".pth.tar\\\"\\n filenameBest = \\\"best\\\" + str(self.args.numIters) + \\\":eps\\\" + str(self.args.numEps) + \\\":dim\\\" + str(\\n self.game.n) + \\\".pth.tar\\\"\\n exists = os.path.isfile(filenameBest)\\n if exists:\\n self.nnet.load_checkpoint(folder=self.args.checkpoint, filename=filenameBest)\\n else:\\n self.nnet.load_checkpoint(folder=self.args.checkpoint, filename=filename)\\n\\n else:\\n print('ACCEPTING NEW MODEL')\\n\\n filename = \\\"best\\\" + str(self.args.numIters) + \\\":eps\\\" + str(self.args.numEps) + \\\":dim\\\" + str(\\n self.game.n) + \\\".pth.tar\\\"\\n self.nnet.save_checkpoint(folder=self.args.checkpoint, filename=self.getCheckpointFile(i))\\n self.nnet.save_checkpoint(folder=self.args.checkpoint, filename=filename)\\n self.mcts.clear()\\n del self.mcts\\n self.mcts = MCTS(self.game, self.nnet, self.args, mcts=True) # reset search tree\\n print(self.tracker.print_diff())\\n self.writeLogsToFile(epochswin, epochdraw, training=True)\",\n \"def train_epoch(args, loss_func, pbar, train_loader, model, optimizer,\\n train_bpd, train_recon_error , train_perplexity):\\n model.train()\\n # Loop data in epoch\\n for x, _ in train_loader:\\n\\n # This break used for debugging\\n if args.max_iterations is not None:\\n if args.global_it > args.max_iterations:\\n break\\n\\n x = x.to(args.device)\\n\\n # Get reconstruction and vector quantization loss\\n # `x_prime`: reconstruction of `input`\\n # `vq_loss`: MSE(encoded embeddings, nearest emb in codebooks)\\n x_prime, vq_loss, perplexity = model(x)\\n\\n loss, log_pxz, bpd = loss_func(args, x_prime, x, vq_loss, model)\\n\\n optimizer.zero_grad()\\n loss.backward()\\n optimizer.step()\\n\\n train_bpd.append((-1)*bpd.item())\\n train_recon_error.append((-1)*log_pxz.item())\\n train_perplexity.append(perplexity.item())\\n\\n # Print Average every 100 steps\\n if (args.global_it+1) % 100 == 0:\\n av_bpd = np.mean(train_bpd[-100:])\\n av_rec_err = np.mean(train_recon_error[-100:])\\n av_ppl = np.mean(train_perplexity[-100:])\\n if args.model == 'vqvae':\\n pbar.print_train(bpd=float(av_bpd), rec_err=float(av_rec_err),\\n increment=100)\\n elif args.model == 'diffvqvae':\\n pbar.print_train(bpd=float(av_bpd), temp=float(model.temp),\\n increment=100)\\n args.global_it += 1\",\n \"def train(self):\\n raise NotImplementedError\",\n \"def train(self, epoch=50):\\n # self.history = self.model.fit(self.train_images,\\n # self.train_labels,\\n # epochs=epoch,\\n # validation_data=(self.test_images, self.test_labels))\\n datagen = ImageDataGenerator(width_shift_range=0.1, height_shift_range=0.1,\\n horizontal_flip=True)\\n # prepare iterator\\n it_train = datagen.flow(self.train_images, self.train_labels, batch_size=64)\\n # fit model\\n steps = int(self.train_images.shape[0] / 64)\\n self.history = self.model.fit_generator(it_train, steps_per_epoch=steps,\\n epochs=epoch,\\n validation_data=(self.test_images,\\n self.test_labels),\\n verbose=1)\\n # evaluate model\\n _, acc = self.model.evaluate(self.test_images, self.test_labels, verbose=0)\\n LOGGER.info('> %.3f' % (acc * 100.0))\\n self.summarize_diagnostics()\",\n \"def run_epoch(model, data, optimizer):\\n traindata, valdata = data\\n\\n model.train()\\n train_elbo = epoch_iter(model, traindata, optimizer)\\n\\n model.eval()\\n val_elbo = epoch_iter(model, valdata, optimizer)\\n\\n return train_elbo, val_elbo\",\n \"def run_epoch(model, data, optimizer):\\n traindata, valdata = data\\n\\n model.train()\\n train_elbo = epoch_iter(model, traindata, optimizer)\\n\\n model.eval()\\n val_elbo = epoch_iter(model, valdata, optimizer)\\n\\n return train_elbo, val_elbo\",\n \"def train_step(self):\\n pass\",\n \"def train_model_epoch(self, epoch_idx, tuning=False):\\n acc_loss = 0\\n\\n num_batch = self.model.config.kg_meta.tot_train_triples // self.config.batch_size if not self.debug else 10\\n \\n metrics_names = ['acc_loss', 'loss'] \\n progress_bar = tf.keras.utils.Progbar(num_batch, stateful_metrics=metrics_names)\\n\\n for batch_idx in range(num_batch):\\n data = list(next(self.generator))\\n \\n if self.training_strategy == \\\"projection_based\\\":\\n h = tf.convert_to_tensor(data[0], dtype=tf.int32)\\n r = tf.convert_to_tensor(data[1], dtype=tf.int32)\\n t = tf.convert_to_tensor(data[2], dtype=tf.int32)\\n hr_t = data[3] # tf.convert_to_tensor(data[3], dtype=tf.float32)\\n rt_h = data[4] # tf.convert_to_tensor(data[4], dtype=tf.float32)\\n loss = self.train_step_projection(h, r, t, hr_t, rt_h)\\n elif self.training_strategy == \\\"pointwise_based\\\":\\n h = tf.convert_to_tensor(data[0], dtype=tf.int32)\\n r = tf.convert_to_tensor(data[1], dtype=tf.int32)\\n t = tf.convert_to_tensor(data[2], dtype=tf.int32)\\n y = tf.convert_to_tensor(data[3], dtype=tf.float32)\\n loss = self.train_step_pointwise(h, r, t, y)\\n else:\\n ph = tf.convert_to_tensor(data[0], dtype=tf.int32)\\n pr = tf.convert_to_tensor(data[1], dtype=tf.int32)\\n pt = tf.convert_to_tensor(data[2], dtype=tf.int32)\\n nh = tf.convert_to_tensor(data[3], dtype=tf.int32)\\n nr = tf.convert_to_tensor(data[4], dtype=tf.int32)\\n nt = tf.convert_to_tensor(data[5], dtype=tf.int32)\\n loss = self.train_step(ph, pr, pt, nh, nr, nt)\\n\\n acc_loss += loss\\n\\n if not tuning:\\n progress_bar.add(1, values=[('acc_loss', acc_loss), ('loss', loss)])\\n\\n self.training_results.append([epoch_idx, acc_loss.numpy()])\\n\\n return acc_loss\",\n \"def train(self, training_data):\\n pass\",\n \"def train(self):\\n\\t\\traise NotImplementedError\",\n \"def training(self):\\n \\n best_valid_loss = np.inf\\n c = 0\\n \\n self.train_loader, self.test_loader = self.get_train_test_loaders()\\n \\n print('Training the {} model with the following architecture:'.format(self.model_name))\\n print(summary(self.model, (3, self.image_width, self.image_height)))\\n print('*'*100)\\n print('Starting the training...')\\n print('*'*100)\\n \\n # Create the model save dir if it already doesn't exist\\n if not os.path.exists(self.model_save_dir):\\n os.makedirs(self.model_save_dir)\\n \\n for epoch in range(self.n_epochs):\\n\\n print(f'Epoch: {epoch+1:02}')\\n\\n start_time = time.time()\\n\\n train_loss = self.train(self.train_loader)\\n valid_loss = self.evaluate(self.test_loader)\\n\\n epoch_mins, epoch_secs = self.epoch_time(start_time, time.time())\\n\\n c+=1\\n if valid_loss < best_valid_loss:\\n best_valid_loss = valid_loss\\n torch.save(self.model.state_dict(), os.path.join(self.model_save_dir, '{}_trained.pt'.format(self.model_name)))\\n c=0\\n\\n if c>4:\\n #decrease lr if loss does not decrease after 5 steps\\n self.scheduler.step()\\n c=0\\n\\n print(f'Time: {epoch_mins}m {epoch_secs}s') \\n print(f'Train Loss: {train_loss:.3f}')\\n print(f'Val Loss: {valid_loss:.3f}')\\n print('-'*60)\\n print('The best validation loss is', best_valid_loss)\\n print('*'*100)\",\n \"def step(self, epoch):\\n\\n self.train(epoch)\\n self.test(epoch)\",\n \"def train_epoch(self, epoch):\\n t1 = time()\\n output = {'tp': [], 'fp': [], 'fn': [], 'tn': [], 'loss': [], 'preds': [], 'true': 0, 'ttotal': []}\\n self.acc_NA.clear()\\n self.acc_not_NA.clear()\\n self.acc_total.clear()\\n\\n self.model.train()\\n # 多个batch的数据\\n train_iter = self.iterator(self.data['train'], batch_size=self.params['batch'],\\n shuffle_=self.params['shuffle_data'])\\n\\n for batch_idx, batch in enumerate(train_iter):\\n # print(\\\"batch_idx\\\", batch_idx)\\n batch = self.convert_batch(batch, istrain=True)\\n\\n # with autograd.detect_anomaly():\\n self.optimizer.zero_grad()\\n loss, stats, predictions, select, pred_pairs, multi_truths, mask, relation_label = self.model(batch)\\n pred_pairs = torch.sigmoid(pred_pairs)\\n # self.optimizer.zero_grad()\\n loss.backward() # backward computation\\n\\n nn.utils.clip_grad_norm_(self.model.parameters(), self.gc) # gradient clipping\\n self.optimizer.step() # update\\n if self.scheduler!=None:\\n self.scheduler.step()\\n\\n relation_label = relation_label.to('cpu').data.numpy()\\n predictions = predictions.to('cpu').data.numpy()\\n # batches\\n output['loss'] += [float(loss.item())]\\n output['tp'] += [stats['tp'].to('cpu').data.numpy()]\\n output['fp'] += [stats['fp'].to('cpu').data.numpy()]\\n output['fn'] += [stats['fn'].to('cpu').data.numpy()]\\n output['tn'] += [stats['tn'].to('cpu').data.numpy()]\\n output['preds'] += [predictions]\\n output['ttotal'] += [stats['ttotal']]\\n\\n for i in range(predictions.shape[0]):\\n label = relation_label[i]\\n if label < 0:\\n break\\n if label == self.loader.label2ignore:\\n self.acc_NA.add(predictions[i] == label)\\n else:\\n self.acc_not_NA.add(predictions[i] == label)\\n self.acc_total.add(predictions[i] == label)\\n # 一个epoch\\n total_loss, scores = self.performance(output)\\n t2 = time()\\n\\n self.train_res['loss'] += [total_loss]\\n self.train_res['score'] += [scores[self.primary_metric]]\\n self.train_res['p'] += [scores['micro_p']]\\n self.train_res['r'] += [scores['micro_r']]\\n\\n print('Epoch: {:02d} | TRAIN | LOSS = {:.05f}, | NA acc: {:4.2f} | not NA acc: {:4.2f} | tot acc: {:4.2f}'.\\n format(epoch, total_loss, self.acc_NA.get(), self.acc_not_NA.get(), self.acc_total.get()), end=\\\"\\\")\\n print_results(scores, [], False, t2 - t1)\\n print(\\\"TTotal\\\\t\\\", sum(output['ttotal']))\\n return scores['micro_f']\",\n \"def _train_epoch(self, epoch):\\n self.model.train()\\n self.train_metrics.reset()\\n for batch_idx, (data, target_seg, target_class) in enumerate(self.data_loader):\\n data, target_seg, target_class = data.to(self.device), target_seg.to(self.device), target_class.to(self.device)\\n\\n self.optimizer.zero_grad()\\n output_seg, output_class = self.model(data)\\n loss = self.criterion((output_seg, output_class), target_seg, target_class, epoch)\\n loss.backward()\\n self.optimizer.step()\\n\\n self.writer.set_step((epoch - 1) * self.len_epoch + batch_idx)\\n self.train_metrics.update('loss', loss.item())\\n for met in self.metric_ftns:\\n if met.__name__ == \\\"accuracy\\\":\\n self.train_metrics.update(met.__name__, met(output_class, target_class))\\n else:\\n self.train_metrics.update(met.__name__, met(output_seg, target_seg))\\n\\n if batch_idx % self.log_step == 0:\\n self.logger.debug('Train Epoch: {} {} Loss: {:.6f}'.format(\\n epoch,\\n self._progress(batch_idx),\\n loss.item()))\\n\\n self._visualize_input(data.cpu())\\n\\n if batch_idx == self.len_epoch:\\n break\\n log = self.train_metrics.result()\\n\\n if self.do_validation:\\n val_log = self._valid_epoch(epoch)\\n log.update(**{'val_'+k : v for k, v in val_log.items()})\\n\\n if self.lr_scheduler is not None:\\n self.lr_scheduler.step()\\n\\n return log\",\n \"def training(self) -> None:\\n self.compile_model()\\n self.train_epoch()\\n self.agent.save()\",\n \"def train_one_epoch(self):\\n\\t\\tself.model.train()\\n\\t\\ttrain_loss = 0\\n\\n\\t\\tfor batch_idx, data in enumerate(self.data_loader.train_loader):\\n\\t\\t\\tInput = data[0].float().to(self.device)\\n\\t\\t\\tOutput = data[1].float().to(self.device)\\n\\n\\t\\t\\tself.optimizer.zero_grad()\\n\\t\\t\\tloss = self.loss(self.model(Input)[:,0],Output)\\n\\t\\t\\ttrain_loss += loss.item()\\n\\t\\t\\tloss.backward()\\n\\t\\t\\tself.optimizer.step()\\n\\t\\t\\tself.current_iteration += 1\\n\\n\\t\\tself.summary_writer.add_scalar('training/loss', loss.item(), self.current_epoch)\",\n \"def run_epoch( self ):\\n # --- Init Epoch ----\\n total_epoch_loss = 0.0\\n epoch_batches = self.dataset.dataloader( self.config.neuron.epoch_length )\\n progress_bar = qqdm(enumerate(epoch_batches), total=len(epoch_batches), desc=format_str('blue', f'Epoch Progress'))\\n for iteration, (inputs) in progress_bar:\\n\\n # ---- Forward / Backward ----\\n prev_mechanism_weights = self.mechanism_weights.tolist()\\n output = self.train ( batch = { 'inputs': inputs } )\\n next_mechanism_weights = self.mechanism_weights.tolist()\\n total_epoch_loss += output.local_target_loss.item()\\n\\n # ---- Logs ----\\n self.epoch_logs (\\n progress_bar,\\n iteration = iteration,\\n output = output,\\n prev_mechanism_weights = prev_mechanism_weights,\\n next_mechanism_weights = next_mechanism_weights\\n )\\n self.global_step += 1\\n\\n self.epoch_loss = total_epoch_loss / self.config.neuron.epoch_length\\n self.epoch += 1\",\n \"def train_epoch(self, epoch, evaluator, optimizer, perf_path, perf_trace, state_fpath, writer_tensorboard):\\n\\n # Train an epoch\\n self.model.train()\\n print('Start epoch', epoch)\\n train_itr = iter(self.loader_train)\\n total_err = 0\\n total_acc = 0\\n\\n for index, (data_pixel, data_labels) in enumerate(train_itr):\\n\\n # compute\\n input_data = data_pixel.float().cuda()\\n data_labels = data_labels.cuda()\\n\\n # Use the model the produce the classification\\n grapheme_logits, vowel_logits, consonant_logits = self.model(input_data)\\n\\n # produce evaluator results\\n eval_result = evaluator(grapheme_logits, vowel_logits, consonant_logits, data_labels)\\n\\n # set optimizer to zero.\\n optimizer.zero_grad()\\n\\n # back propogate the evaluation results.\\n eval_result['loss'].backward()\\n\\n # optimizer take step forward.\\n optimizer.step()\\n\\n # tabulate the steps from the evaluation\\n eval_result = {k: eval_result[k].item() for k in eval_result}\\n\\n # update every hundreds' of\\n if index % 100 == 0:\\n print(index, eval_result['loss'], eval_result['acc'])\\n train_result = evaluator.evalulate_on_cache()\\n train_total_err = train_result['loss']\\n writer_tensorboard.add_scalar('Loss/Train', train_total_err, global_step=epoch)\\n # log_metric('loss', train_total_err)\\n train_total_acc = train_result['acc']\\n writer_tensorboard.add_scalar('Accuracy/Train', train_total_acc, global_step=epoch)\\n # log_metric('acc', train_total_acc)\\n train_kaggle_score = train_result['kaggle_score']\\n writer_tensorboard.add_scalar('Kaggle_Score/Train', train_kaggle_score, global_step=epoch)\\n # log_metric('kaggle_score', train_kaggle_score)\\n dict_metrics_train = {\\n 'Loss/Train': train_total_err,\\n 'Accuracy/Train': train_total_acc,\\n 'Kaggle_Score/Train': train_kaggle_score,\\n }\\n log_metrics(dict_metrics_train, step=epoch)\\n print(f\\\"Epoch {epoch} Training, Loss {train_total_err}, Acc {train_total_acc}\\\")\\n evaluator.clear_cache()\\n # compute validation error\\n self.model.eval()\\n val_itr = iter(self.loader_val)\\n with torch.no_grad():\\n for index, (data_pixel, data_labels) in enumerate(val_itr):\\n input_data = data_pixel.float().cuda()\\n data_labels = data_labels.cuda()\\n grapheme_logits, vowel_logits, consonant_logits = self.model(input_data)\\n eval_result = evaluator(grapheme_logits, vowel_logits, consonant_logits, data_labels)\\n eval_result = {k: eval_result[k].item() for k in eval_result}\\n total_err += eval_result['loss']\\n total_acc += eval_result['acc']\\n # print(total_err / (1 + input_index), total_acc / (1 + input_index))\\n val_result = evaluator.evalulate_on_cache()\\n val_total_err = val_result['loss']\\n writer_tensorboard.add_scalar('Loss/Val', val_total_err, global_step=epoch)\\n val_total_acc = val_result['acc']\\n writer_tensorboard.add_scalar('Accuracy/Val', val_total_acc, global_step=epoch)\\n val_kaggle_score = val_result['kaggle_score']\\n writer_tensorboard.add_scalar('Kaggle_Score/Val', val_kaggle_score, global_step=epoch)\\n dict_metrics_val = {\\n 'Loss/Validation': val_total_err,\\n 'Accuracy/Validation': val_total_acc,\\n 'Kaggle_Score/Validation': val_kaggle_score,\\n }\\n log_metrics(dict_metrics_val, step=epoch)\\n # Write to disk.\\n writer_tensorboard.flush()\\n print(f\\\"Epoch {epoch} Eval, Loss {val_total_err}, Acc {val_total_acc}\\\")\\n evaluator.clear_cache()\\n print(\\\"Saving the model (epoch %d)\\\" % epoch)\\n torch.save({\\n \\\"epoch\\\": epoch + 1,\\n \\\"model_state\\\": self.model.state_dict(),\\n \\\"optimizer_state\\\": optimizer.state_dict(),\\n }, state_fpath)\\n print(f\\\"Making a backup (step {epoch})\\\")\\n backup_fpath = os.path.join(self.backup_dir, f\\\"model_bak_{epoch}.pt\\\")\\n torch.save({\\n \\\"epoch\\\": epoch + 1,\\n \\\"model_state\\\": self.model.state_dict(),\\n \\\"optimizer_state\\\": optimizer.state_dict(),\\n }, backup_fpath)\\n # Dump the traces\\n perf_trace.append(\\n {\\n 'epoch': epoch,\\n 'train_err': train_total_err,\\n 'train_acc': train_total_acc,\\n 'train_kaggle_score': train_kaggle_score,\\n 'val_err': val_total_err,\\n 'val_acc': val_total_acc,\\n 'val_kaggle_score': val_kaggle_score\\n }\\n )\\n pickle.dump(perf_trace, open(perf_path, 'wb'))\\n # store epoch full result separately\\n epoch_result = {\\n 'epoch': epoch,\\n 'train_result': train_result,\\n 'val_result': val_result\\n }\\n pickle.dump(epoch_result, open(os.path.join(self.results_dir, 'result_epoch_{0}.p'.format(epoch)), 'wb'))\",\n \"def _train(self):\\n step = 0\\n for epoch in range(self.opts.num_epochs):\\n self.hub.publish(Topic.EPOCH, epoch)\\n for i, data in enumerate(self.loader):\\n # Compute loss ...\\n # NOTE(ycho): if one of the callbacks require training loss,\\n # e.g. for logging, simply register a hook to the loss module\\n # rather than trying to extract them here.\\n loss = self.loss_fn(self.model, data)\\n self.hub.publish(Topic.TRAIN_LOSS, loss)\\n\\n # Backprop + Optimize ...\\n self.optim.zero_grad()\\n loss[\\\"total\\\"].backward()\\n self.optim.step()\\n\\n # Emit `step` event.\\n # == logging, saving, evaluation\\n self.hub.publish(Topic.STEP, step)\\n step += 1\\n\\n if step >= self.opts.train_steps:\\n return\",\n \"def train(self, ):\\n raise NotImplementedError\",\n \"def train(self):\\n self.training = True\",\n \"def _train_epoch(self, epoch):\\n\\t\\tstart = time.time()\\n\\t\\tself.model.train()\\n\\t\\tfor batch_idx, (images, labels) in enumerate(self.train_loader):\\n\\n\\t\\t\\timages, labels = images.to(self.config.DEVICE), labels.to(self.config.DEVICE)\\n\\n\\t\\t\\tself.optimizer.zero_grad()\\n\\t\\t\\toutput = self.model(images)\\n\\t\\t\\tloss = self.criterion(output, labels)\\n\\t\\t\\tloss.backward()\\n\\t\\t\\tself.optimizer.step()\\n\\n\\t\\t\\tn_iter = (epoch - 1) * len(self.train_loader) + batch_idx + 1\\n\\n\\t\\t\\tlast_layer = list(self.model.children())[-1]\\n\\t\\t\\tfor name, para in last_layer.named_parameters():\\n\\t\\t\\t\\tif 'weight' in name:\\n\\t\\t\\t\\t\\tself.logger_setup['writer'].add_scalar('LastLayerGradients/grad_norm2_weights', para.grad.norm(), n_iter)\\n\\t\\t\\t\\tif 'bias' in name:\\n\\t\\t\\t\\t\\tself.logger_setup['writer'].add_scalar('LastLayerGradients/grad_norm2_bias', para.grad.norm(), n_iter)\\n\\n\\t\\t\\tprint('Training Epoch: {epoch} [{trained_samples}/{total_samples}]\\\\tLoss: {:0.4f}\\\\tLR: {:0.6f}'.format(\\n\\t\\t\\t\\tloss.item(),\\n\\t\\t\\t\\tself.optimizer.param_groups[0]['lr'],\\n\\t\\t\\t\\tepoch=epoch,\\n\\t\\t\\t\\ttrained_samples=self.config.loader_params['bs']*(batch_idx + 1),\\n\\t\\t\\t\\ttotal_samples=self.total_train_samples))\\n\\t\\t\\n\\t\\t\\t#update training loss for each iteration\\n\\t\\t\\tself.logger_setup['writer'].add_scalar('Train/loss', loss.item(), n_iter)\\n\\t\\t\\t\\n\\t\\t\\tif self.config.WARM_UP and (epoch <= self.config.WARM_EPOCH):\\n\\t\\t\\t\\tself.warmup_scheduler.step()\\n\\n\\t\\tfor name, param in self.model.named_parameters():\\n\\t\\t\\tlayer, attr = os.path.splitext(name)\\n\\t\\t\\tattr = attr[1:]\\n\\t\\t\\tself.logger_setup['writer'].add_histogram(\\\"{}/{}\\\".format(layer, attr), param, epoch)\\n\\n\\t\\tfinish = time.time()\\n\\t\\tprint('epoch {} training time consumed: {:.2f}s'.format(epoch, finish - start))\",\n \"def train(self):\\r\\n \\r\\n args = self.args\\r\\n model = self.model\\r\\n dataset = self.dataset\\r\\n train_state = self.train_state\\r\\n optimizer = self.optimizer\\r\\n scheduler = self.scheduler\\r\\n train_bar = self.train_bar\\r\\n val_bar = self.val_bar\\r\\n epoch_bar = self.epoch_bar\\r\\n \\r\\n for epoch_index in range(args.num_epochs):\\r\\n train_state['epoch_index'] = epoch_index\\r\\n \\r\\n # Iterate over training dataset\\r\\n \\r\\n running_loss,running_acc = self.train_loop(epoch_index, args, \\r\\n model, dataset, \\r\\n optimizer, train_bar)\\r\\n \\r\\n train_state['train_loss'].append(running_loss)\\r\\n train_state['train_acc'].append(running_acc)\\r\\n \\r\\n running_loss,running_acc = self.val_loop(epoch_index, args, model, \\r\\n dataset, optimizer, val_bar)\\r\\n \\r\\n \\r\\n train_state['val_loss'].append(running_loss)\\r\\n train_state['val_acc'].append(running_acc)\\r\\n \\r\\n print(\\\"Epoch \\\"+str(epoch_index+1)+\\\": Running loss=\\\"+ \\\\\\r\\n str(running_loss)+\\\", Running Acc=\\\"+str(running_acc))\\r\\n \\r\\n train_state = update_train_state(args=args, model=model, \\r\\n train_state=train_state)\\r\\n \\r\\n scheduler.step(train_state['val_loss'][-1])\\r\\n \\r\\n if train_state['stop_early']:\\r\\n break\\r\\n \\r\\n train_bar.n = 0\\r\\n val_bar.n = 0\\r\\n epoch_bar.set_postfix(best_val=train_state['early_stopping_best_val'] )\\r\\n epoch_bar.update()\\r\\n \\r\\n state_dict = torch.load(train_state['model_filename'])\\r\\n model.load_state_dict(state_dict)\\r\\n return model\",\n \"def _train_epoch(self, epoch):\\n self.model.train()\\n total_loss = 0\\n\\n self.logger.info('Train Epoch: {}'.format(epoch))\\n\\n for batch_idx, (data) in enumerate(self.train_loader):\\n start_it = time()\\n data = data.to(self.device)\\n\\n self.optimizer.zero_grad()\\n output = self.model(data)\\n if isinstance(output, tuple):\\n loss = self.model.loss(data, *output)\\n else:\\n loss = self.model.loss(data, output)\\n loss.backward()\\n self.optimizer.step()\\n\\n step = epoch * len(self.train_loader) + batch_idx\\n self.tb_writer.add_scalar('train/loss', loss.item(), step)\\n # self.comet_writer.log_metric('loss', loss.item(), step)\\n\\n total_loss += loss.item()\\n\\n end_it = time()\\n time_it = end_it - start_it\\n if batch_idx % self.log_step == 0:\\n self.logger.info(\\n ' > [{}/{} ({:.0f}%), {:.2f}s] Loss: {:.6f} '.format(\\n batch_idx * self.train_loader.batch_size + data.size(\\n 0),\\n len(self.train_loader.dataset),\\n 100.0 * batch_idx / len(self.train_loader),\\n time_it * (len(self.train_loader) - batch_idx),\\n loss.item()))\\n # grid = make_grid(data.cpu(), nrow=8, normalize=True)\\n # self.tb_writer.add_image('input', grid, step)\\n\\n self.logger.info(' > Total loss: {:.6f}'.format(\\n total_loss / len(self.train_loader)\\n ))\\n\\n return total_loss / len(self.train_loader)\",\n \"def train(self, X, y, batch_size=5, num_epochs=10, alpha=0.1, gamma=0.9, learning=\\\"Delta\\\"):\\n rem = int(np.ceil(len(X[0])/batch_size))\\n for epoch in range(num_epochs):\\n art = 0;\\n for sample in range(rem):\\n end = art + batch_size\\n\\n # Get a sample (column from X and Y) where the size of the sample is given by the batch size\\n sampleX = X[:, art : end]\\n sampleY = y[:, art : end]\\n #print (sampleX)\\n\\n # Get the prediction\\n results = self.predict(sampleX)\\n art += batch_size\\n\\n if learning == \\\"Delta\\\" or learning == \\\"delta\\\":\\n # Calculate e\\n e = np.subtract(sampleY, results)\\n\\n # Calculate e dot p, where p is the input matrix\\n ep = np.dot(e, np.transpose(sampleX))\\n\\n # Multiply this new matrix by the scalar alpha\\n aep = np.multiply(alpha, ep)\\n\\n # Calculate the new weights along with the bias\\n self.weights = np.add(self.weights, aep)\\n \\n elif learning == \\\"Filtered\\\" or learning == \\\"filtered\\\":\\n\\n # Calculate e dot p, where p is the input matrix\\n ep = np.dot(sampleY, np.transpose(sampleX))\\n\\n # Multiply this new matrix by the scalar alpha\\n aep = np.multiply(alpha, ep)\\n\\n # Multiply the old weights by some scalar gamma\\n gw = np.multiply(1 - gamma, self.weights)\\n\\n self.weights = np.add(gw, aep)\\n\\n elif learning == \\\"Unsupervised_hebb\\\" or learning == \\\"unsupervised_hebb\\\":\\n # Add a row of one's to the top of the input matrix\\n #newX = np.vstack((np.array([1 for column in range(sampleX.shape[1])]), sampleX))\\n\\n # Calculate e dot p, where p is the input matrix\\n ep = np.dot(results, np.transpose(sampleX))\\n\\n # Multiply this new matrix by the scalar alpha\\n aep = np.multiply(alpha, ep)\\n\\n # Calculate the new weights along with the bias\\n self.weights = np.add(self.weights, aep)\",\n \"def train(self)->None:\",\n \"def train_epoch(self, epoch):\\n device_mapper = self.device_mapper\\n self.model.train()\\n self.train_metrics.reset()\\n for batch_idx, data in enumerate(self.data_loader):\\n data = device_mapper.map_modules(data, non_blocking=True)\\n\\n self.optimizer.zero_grad()\\n output = self.model(data)\\n loss = self.loss(output, data)\\n loss.backward()\\n self.optimizer.step()\\n\\n self.writer.set_step((epoch - 1) * self.len_epoch + batch_idx)\\n self.train_metrics.update('loss', loss.item(), batch_size=output.size(0))\\n for met in self.metrics:\\n self.train_metrics.update(met.name(), met(output, data), batch_size=output.size(0))\\n\\n if batch_idx % self.log_step == 0:\\n self.logger.debug('Train Epoch: %d %s Loss: %.6f', epoch, self._progress(batch_idx), loss.item())\\n\\n if batch_idx == self.len_epoch:\\n break\\n log = self.train_metrics.result()\\n\\n if self.do_validation:\\n val_log = self.valid_epoch(epoch)\\n log.update(**{'val_' + k: v for k, v in val_log.items()})\\n\\n if self.lr_scheduler is not None:\\n if isinstance(self.lr_scheduler, torch.optim.lr_scheduler.ReduceLROnPlateau):\\n self.lr_scheduler.step(log[\\\"val_roc_auc\\\"])\\n else:\\n self.lr_scheduler.step()\\n return log\",\n \"def train(self):\\n\\t\\tself.model.fit(self.training_data, self.training_labels)\",\n \"def _train(self):\\r\\n lr, hr = self.sess.run(self.val_batch)\\r\\n res = self.sess.run(\\r\\n [self.train, self.merged,\\r\\n self.GAN.g_loss, self.GAN.mse_loss, self.GAN.g_gan_loss,\\r\\n self.GAN.d_loss, self.GAN.d_loss_real, self.GAN.d_loss_fake],\\r\\n feed_dict={\\r\\n self.GAN.g_images: lr,\\r\\n self.GAN.d_images: hr,\\r\\n self.GAN.is_training: True\\r\\n })\\r\\n\\r\\n return res[1:]\",\n \"def train(self, epochs):\\n print('Starting training...')\\n print('\\\\n{:13} '\\n '{:>17} '\\n '{:^38}'\\n ''.format('', '--- Training ---', '--- Validation ---'))\\n print('{:4} {:>8} '\\n '{:>8} {:>8} '\\n '{:>8} {:>8} {:>8} {:>8}'\\n ''.format('', '', 'Loss', 'Acc', 'Loss', 'Prc', 'Rec', 'Acc'))\\n training_time = 0\\n for epoch in range(1, epochs + 1):\\n start_time = time.time()\\n trn_stats = self.__progress(self.training, self.__train_fn)\\n val_stats = self.__progress(self.validation, self.__val_fn)\\n elapsed_time = time.time() - start_time\\n training_time += elapsed_time\\n print('{:>4} {:>7.2f}s '\\n '{:>8.3f} {:>8.1%} '\\n '{:>8.3f} {:>8.1%} {:>8.1%} {:>8.1%}'\\n ''.format(epoch, elapsed_time,\\n trn_stats[0], trn_stats[-1],\\n *val_stats))\\n self.history.append([epoch] + list(trn_stats) + list(val_stats))\\n self.report['epochs'] = epochs\\n self.report['time_per_epoch'] = training_time / epochs\",\n \"def train(self):\\n return\",\n \"def fit(self):\\n for i in range(self.current_epoch, self.max_epoch):\\n self.current_epoch += 1\\n # train\\n train_dataloader = self.data_module.get_train_dataloader(\\n batch_size=self.train_batch_size, \\n shuffle=self.train_dataloader_shuffle, \\n num_workers=self.dataloader_num_workers,\\n pin_memory=True\\n )\\n neptune.log_metric(\\\"learning_rate_vs_epoch\\\", self.optimizer.param_groups[0]['lr'])\\n self.train_one_epoch(train_dataloader)\\n\\n # validate \\n if self.validate_after == 'epoch' and self.train_on_all_data == False and self.run_lr_range_test == False:\\n validation_dataloader = self.data_module.get_valid_dataloader(\\n batch_size=self.valid_batch_size, \\n shuffle=self.train_dataloader_shuffle, \\n num_workers=self.dataloader_num_workers, \\n pin_memory=True\\n )\\n self.validate_one_epoch(validation_dataloader)\\n\\n if self.scheduler:\\n if self.step_scheduler_after == 'epoch': \\n if self.step_scheduler_metric == 'val_auc':\\n self.scheduler.step(self.metrics['valid'][-1]['auc_score'])\\n else:\\n self.scheduler.step()\\n\\n if self.run_lr_range_test:\\n neptune.log_metric('validation_epoch_end_AUC_vs_LR', \\n self.scheduler.get_last_lr()[0], y=self.metrics['valid'][-1]['auc_score'])\\n\\n # checkpoint model for resuming model\\n if (self.current_epoch % self.checkpoint_epochs) == 0:\\n self.save_checkpoint()\\n\\n # sleep the training process\\n if self.current_epoch % self.sleep_in_epochs == 0:\\n print(f\\\"SLEEPING FOR {self.sleep_time} at epoch={self.current_epoch}\\\")\\n for i in range(int(self.sleep_time/30)):\\n time.sleep(i)\\n neptune.log_metric(\\\"sleeping_status\\\", y=1)\\n\\n stop_training = self.stopping_criteria()\\n if stop_training:\\n if self.fp16:\\n self.scaler.step(self.optimizer)\\n self.scaler.update()\\n self.optimizer.zero_grad()\\n else:\\n self.optimizer.step()\\n self.optimizer.zero_grad()\\n # backward all the accumulate gradients\\n print(f\\\"stopped training at {self.current_epoch} epoch\\\")\\n break\",\n \"def train_epoch(self):\\n\\n if self._train_data_set is not None and self._train_data_set is not None:\\n self._model.fit_num_epochs(self._train_data_set, self._test_data_set)\\n else:\\n raise RuntimeError(\\\"[Triggerbot]: No training or test set available\\\")\",\n \"def __epoch_train(self, data_loader, writer):\\n self.model.train()\\n for i, encode in enumerate(data_loader, 1):\\n # update model\\n encode = {k: v.to(self.device) for k, v in encode.items()}\\n self.optimizer.zero_grad()\\n loss = self.model(**encode)[0]\\n if self.n_gpu > 1:\\n loss = loss.mean()\\n if self.args.fp16:\\n with self.scale_loss(loss, self.optimizer) as scaled_loss:\\n scaled_loss.backward()\\n else:\\n loss.backward()\\n # optimizer and scheduler step\\n self.optimizer.step()\\n self.scheduler.step()\\n # log instantaneous accuracy, loss, and learning rate\\n inst_loss = loss.cpu().detach().item()\\n inst_lr = self.optimizer.param_groups[0]['lr']\\n writer.add_scalar('train/loss', inst_loss, self.__step)\\n writer.add_scalar('train/learning_rate', inst_lr, self.__step)\\n if self.__step % PROGRESS_INTERVAL == 0:\\n LOGGER.info('[epoch %i] * (training step %i) loss: %.3f, lr: %0.8f'\\n % (self.__epoch, self.__step, inst_loss, inst_lr))\\n self.__step += 1\\n # break\\n if self.__step >= self.args.total_step:\\n LOGGER.info('reached maximum step')\\n return True\\n return False\",\n \"def train(dataset, epochs, discriminator, generator, generatorOptimizer, discriminatorOptimizer, seed, checkpoint, checkpoint_prefix):\\n for epoch in range(epochs):\\n start = time.time()\\n\\n for image_batch in tqdm(dataset):\\n train_step(image_batch, generator, discriminator, generatorOptimizer, discriminatorOptimizer)\\n #2nd for()\\n\\n #Produce images for the GIF\\n display.clear_output(wait=True)\\n generate_and_save_images(generator, epoch + 1, seed)\\n\\n #save model every 5 epochs\\n if (epoch + 1) % 5 == 0:\\n print(\\\"Saving checkpoint.\\\")\\n checkpoint.save(file_prefix = checkpoint_prefix)\\n #if() \\n\\n print(\\\"time for epoch {} is {} sec\\\".format(epoch + 1, time.time()-start))\\n #1st for\\n \\n #Generate after final epoch\\n display.clear_output(wait=True)\\n generator.save(\\\"CatGeneratorColor.model\\\")\\n discriminator.save(\\\"CatDiscriminatorColor.model\\\")\",\n \"def on_epoch(self, e):\\n\\n dataloader = self.datasetManager.get_dataloader()\\n length_dataloader = len(dataloader)\\n print(\\\"Epoch %i\\\"%e)\\n print(\\\"-\\\"*15)\\n for i, batch in tqdm.tqdm(enumerate(dataloader)):\\n index = e*length_dataloader+i\\n batch = self.to_device(batch)\\n img = batch[0]\\n gts = batch[1]\\n\\n #add filter here !\\n\\n out = self.network(img)\\n loss = self.loss(out, gts)\\n \\n self.tb_writer.add_scalar('Training Loss', loss, index)\\n\\n if index % self.config['Validation']['validation_step'] == 0:\\n \\\"\\\"\\\"\\n Validation and saving of the model\\n \\\"\\\"\\\"\\n # self.tb_writer.add_scalar('Training loss', loss.item(), index)\\n with torch.no_grad():\\n valid_loss = self.validate(index)\\n if valid_loss < self.best_valid_loss:\\n self.best_valid_loss = valid_loss\\n filename = 'trained_model_iter_%i_loss_%.4f.pth'%(index, valid_loss)\\n filename = os.path.join(self.output_dir, 'trained_model', filename)\\n self.network.save_model(filename, optimizers=self.opt)\\n\\n self.backward_and_step(loss) #On appel la backpropagation\",\n \"def train(self, data_dict, label_dict):\\n loaders = self.init_loaders(data_dict, label_dict)\\n best_performance = 1e18\\n loss_dict = self.init_loss_dict()\\n performance_dict = self.init_performance_dict()\\n\\n for epoch in range(self.config_dict[\\\"num_epochs\\\"]):\\n print(\\\"Epoch {}/{}\\\".format(epoch, self.config_dict[\\\"num_epochs\\\"] - 1))\\n print(\\\"-\\\" * 10)\\n\\n if self.scheduler is not None:\\n self.scheduler.step()\\n\\n for phase in [\\\"train\\\", \\\"val\\\"]:\\n self.model.train(phase == \\\"train\\\")\\n running_loss_dict = self.init_running_loss_dict(\\n list(loss_dict[phase].keys())\\n )\\n output_dict = self.init_output_dict()\\n i = 0\\n for the_data in loaders[phase]:\\n i += 1\\n batch_loss_dict = {}\\n inputs, labels = self.transform_batch(the_data)\\n\\n # zero parameter gradients\\n self.optimizer.zero_grad()\\n\\n # forward\\n outputs = self.model(inputs)\\n\\n output_dict = self.update_output_dict(output_dict, outputs, labels)\\n\\n batch_loss_dict[\\\"loss\\\"] = self.criterion(outputs, labels)\\n if phase == \\\"train\\\":\\n batch_loss_dict[\\\"loss\\\"].backward()\\n self.optimizer.step()\\n\\n for key in batch_loss_dict.keys():\\n running_loss_dict[key] += batch_loss_dict[key].item()\\n\\n # Compute epoch losses and update loss dict\\n epoch_loss_dict = {\\n key: running_loss_dict[key] / i for key in running_loss_dict.keys()\\n }\\n loss_dict[phase] = self.update_metric_dict(\\n loss_dict[phase], epoch_loss_dict\\n )\\n\\n # Compute epoch performance and update performance dict\\n epoch_statistics = self.compute_epoch_statistics(output_dict)\\n performance_dict[phase] = self.update_metric_dict(\\n performance_dict[phase], epoch_statistics\\n )\\n\\n print(\\\"Phase: {}:\\\".format(phase))\\n self.print_metric_dict(epoch_loss_dict)\\n self.print_metric_dict(epoch_statistics)\\n\\n if phase == \\\"val\\\":\\n best_model_condition = epoch_loss_dict[\\\"loss\\\"] < best_performance\\n if best_model_condition:\\n print(\\\"Best model updated\\\")\\n best_performance = epoch_loss_dict[\\\"loss\\\"]\\n best_model_wts = copy.deepcopy(self.model.state_dict())\\n\\n print(\\\"Best val performance: {:4f}\\\".format(best_performance))\\n self.model.load_state_dict(best_model_wts)\\n result_dict = {\\n phase: {**performance_dict[phase], **loss_dict[phase]}\\n for phase in performance_dict.keys()\\n }\\n return result_dict\",\n \"def train_an_epoch(self, train_loader, epoch_id):\\n assert hasattr(self, \\\"model\\\"), \\\"Please specify the exact model !\\\"\\n self.model.train()\\n total_loss = 0\\n kl_loss = 0\\n rec_loss = 0\\n # with autograd.detect_anomaly():\\n for batch_id, sample in enumerate(train_loader):\\n assert isinstance(sample, torch.Tensor)\\n pos_u = torch.tensor(\\n [triple[0] for triple in sample],\\n dtype=torch.int64,\\n device=self.device,\\n )\\n pos_i_1 = torch.tensor(\\n [triple[1] for triple in sample],\\n dtype=torch.int64,\\n device=self.device,\\n )\\n pos_i_2 = torch.tensor(\\n [triple[2] for triple in sample],\\n dtype=torch.int64,\\n device=self.device,\\n )\\n neg_u = torch.tensor(\\n self.data.user_sampler.sample(\\n self.config[\\\"model\\\"][\\\"n_neg\\\"], len(sample)\\n ),\\n dtype=torch.int64,\\n device=self.device,\\n )\\n neg_i_1 = torch.tensor(\\n self.data.item_sampler.sample(\\n self.config[\\\"model\\\"][\\\"n_neg\\\"], len(sample)\\n ),\\n dtype=torch.int64,\\n device=self.device,\\n )\\n neg_i_2 = torch.tensor(\\n self.data.item_sampler.sample(\\n self.config[\\\"model\\\"][\\\"n_neg\\\"], len(sample)\\n ),\\n dtype=torch.int64,\\n device=self.device,\\n )\\n batch_data = (pos_u, pos_i_1, pos_i_2, neg_u, neg_i_1, neg_i_2)\\n loss = self.train_single_batch(batch_data)\\n total_loss += loss\\n kl_loss += self.model.kl_loss\\n rec_loss += self.model.rec_loss\\n total_loss = total_loss / self.config[\\\"model\\\"][\\\"batch_size\\\"]\\n rec_loss = rec_loss / self.config[\\\"model\\\"][\\\"batch_size\\\"]\\n kl_loss = kl_loss / self.config[\\\"model\\\"][\\\"batch_size\\\"]\\n print(\\n \\\"[Training Epoch {}], log_like_loss {} kl_loss: {} alpha: {} lr: {}\\\".format(\\n epoch_id,\\n rec_loss,\\n kl_loss,\\n self.model.alpha,\\n self.config[\\\"model\\\"][\\\"lr\\\"],\\n )\\n )\\n self.writer.add_scalars(\\n \\\"model/loss\\\",\\n {\\n \\\"total_loss\\\": total_loss,\\n \\\"rec_loss\\\": total_loss - kl_loss,\\n \\\"kl_loss\\\": kl_loss,\\n },\\n epoch_id,\\n )\",\n \"def train_model(self):\\n ### Early Stop Mechanism\\n loss = previous_loss = float(\\\"inf\\\")\\n patience_left = self.config.patience\\n ### Early Stop Mechanism\\n\\n self.generator = Generator(self.model.config, training_strategy=self.training_strategy)\\n self.evaluator = Evaluator(model=self.model, data_type=self.teston, debug=self.debug)\\n\\n if self.config.loadFromData:\\n self.load_model()\\n \\n for cur_epoch_idx in range(self.config.epochs):\\n print(\\\"Epoch[%d/%d]\\\"%(cur_epoch_idx,self.config.epochs))\\n loss = self.train_model_epoch(cur_epoch_idx)\\n self.test(cur_epoch_idx)\\n\\n ### Early Stop Mechanism\\n ### start to check if the loss is still decreasing after an interval. \\n ### Example, if early_stop_epoch == 50, the trainer will check loss every 50 epoche.\\n ### TODO: change to support different metrics.\\n if ((cur_epoch_idx + 1) % self.config.early_stop_epoch) == 0: \\n if patience_left > 0 and previous_loss <= loss:\\n patience_left -= 1\\n print('%s more chances before the trainer stops the training. (prev_loss, curr_loss): (%.f, %.f)' % \\\\\\n (patience_left, previous_loss, loss))\\n\\n elif patience_left == 0 and previous_loss <= loss:\\n self.evaluator.result_queue.put(Evaluator.TEST_BATCH_EARLY_STOP)\\n break\\n else:\\n patience_left = self.config.patience\\n\\n previous_loss = loss\\n ### Early Stop Mechanism\\n\\n self.generator.stop()\\n self.evaluator.save_training_result(self.training_results)\\n self.evaluator.stop()\\n\\n if self.config.save_model:\\n self.save_model()\\n\\n if self.config.disp_result:\\n self.display()\\n\\n if self.config.disp_summary:\\n self.config.summary()\\n self.config.summary_hyperparameter(self.model.model_name)\\n\\n self.export_embeddings()\\n\\n return loss\",\n \"def train(self):\\n self.dataGenerator.printDataStatistics()\\n sE = len(self.dataGenerator.ids[\\\"train\\\"])// 32\\n sV = len(self.dataGenerator.ids[\\\"validation\\\"])// 32\\n self.model.fit_generator(\\n generator=self.dataGenerator.trainingGenerator,\\n steps_per_epoch= sE,\\n epochs=2,\\n validation_data=self.dataGenerator.validationGenerator,\\n validation_steps=sV,\\n # use_multiprocessing=True,\\n # workers=2,\\n )\",\n \"def train_epoch(training_input, training_target):\\n permutation = torch.randperm(training_input.shape[0])\\n\\n epoch_training_losses = []\\n net.train()\\n # logger.info(\\\"-----------------------------0---------------------------------\\\")\\n # for i in range(0, batch_size):\\n # for i in range(10):\\n\\n optimizer.zero_grad()\\n logger.info(\\\"-----------------------------1---------------------------------\\\")\\n # indices = permutation[i:i + batch_size]\\n X_batch, y_batch = training_input, training_target\\n current_X_batch = X_batch.to(device=args.device)\\n current_y_batch = y_batch.to(device=args.device)\\n # logger.info(\\\"-----------------------------2---------------------------------\\\")\\n out = net(A_wave, current_X_batch)\\n loss = loss_criterion(out, current_y_batch)\\n # logger.info(f'{i}/{training_input.shape[0]}: step loss:{loss.item()}')\\n # print(f'{i}/{training_input.shape[0]}: step loss:{loss.item()}')\\n logger.info(f'2--------------------out:{out},current_y_batch:{current_y_batch}')\\n loss.backward()\\n logger.info(f'3--------------------loss:{loss}')\\n # logger.info(\\\"-----------------------------4---------------------------------\\\")\\n optimizer.step()\\n logger.info(f'4--------------------loss:{loss}')\\n # logger.info(\\\"-----------------------------5---------------------------------\\\")\\n # epoch_training_losses.append(loss.clone().detach().cpu().numpy())\\n # logger.info(\\\"-----------------------------6---------------------------------\\\")\\n # return sum(epoch_training_losses)/len(epoch_training_losses)\\n return loss\",\n \"def train(self):\\n raise NotImplementedError()\",\n \"def __init__(self, \\n training_epochs):\\n self.training_epochs = training_epochs\",\n \"def train_epoch(self, epoch_num: int) -> float:\\n self.model.train()\\n epoch_loss = 0.0\\n # hidden_start = torch.zeros(self.batch_size, self.rnn_size)\\n # for batch_num, (x, y) in enumerate(make_batches(self.train_data,\\n # self.batch_size,\\n # self.max_len)):\\n\\n for batch_num, batch_tuple in enumerate(self.train_data):\\n print('batch: ', batch_num)\\n # reset gradients in train epoch\\n self.optimizer.zero_grad()\\n x = len(batch_tuple[0])\\n y = len(batch_tuple[0][0])\\n # compute hidden states\\n # batch x timesteps x hidden_size\\n x, y = batch_tuple\\n # x = x.to(self.device)\\n # y = y.to(self.device)\\n hidden_states = self.model(x)\\n # compute unnormalized probabilities\\n # batch x timesteps x vocab_size\\n # logits = self.model.get_logits(hidden_states)\\n\\n # compute loss\\n # scalar\\n batch_loss = self.model.get_loss(hidden_states, y)\\n epoch_loss += batch_loss.item()\\n\\n # backpropagation (gradient of loss wrt parameters)\\n batch_loss.backward()\\n\\n # clip gradients if they get too large\\n torch.nn.utils.clip_grad_norm_(list(self.model.parameters()),\\n self.max_grad_norm)\\n\\n # update parameters\\n self.optimizer.step()\\n\\n # we use a stateful RNN, which means the first hidden state for the\\n # next batch is the last hidden state of the current batch\\n # hidden_states.detach_()\\n # hidden_start = hidden_states[:,-1,:] # add comment\\n if batch_num % 100 == 0:\\n print(\\\"epoch %d, %d/%d examples, batch loss = %f\\\"\\n % (epoch_num, (batch_num + 1) * self.batch_size,\\n self.num_train_examples, batch_loss.item()))\\n epoch_loss /= (batch_num + 1)\\n\\n return epoch_loss\",\n \"def train(self, verbose=True):\\n\\n\\n learned = False\\n iteration = 0\\n\\n from util.loss_functions import DifferentError\\n loss = DifferentError()\\n\\n\\n\\n\\n\\n # Train for some epochs if the error is not 0\\n while not learned:\\n # x ist ein Bild bestehend aus einem Label (erster Eintrag) und 784 Pixeln\\n # t ist das Zielergebnis von x (überprüfbar mit dem Label)\\n # o ist der tatsächliche Ergebnis von x\\n # w ist der Gewichtsvektor\\n # Als Aktivierungsfunktion verwenden wir die Sigmoid Funktion\\n # Das Training wird dann beendet, sobald das Fehlerkriterium konvergiert\\n\\n totalError = 0\\n\\n output = []\\n labels = self.trainingSet.label\\n inputs = self.trainingSet.input\\n\\n # iteriere für jede Instanz im Trainingsset x € X\\n for input in inputs:\\n # Ermittle O_x = sig(w*x)\\n output.append(self.fire(input))\\n\\n # Ermittle Fehler AE = tx - ox\\n error = loss.calculateError(np.array(labels), np.array(output))\\n\\n # grad = [0]\\n grad = np.zeros(len(self.trainingSet.input[0]))\\n grad2 = np.zeros(len(self.trainingSet.input[0]))\\n\\n for e, input, out in zip(error, inputs, output):\\n activationPrime = Activation.getDerivative(activationName)(np.dot(np.array(input), self.weight))\\n #grad += np.multiply( np.multiply( input, e), activationPrime)\\n grad += np.multiply( input, e)\\n\\n # Update grad = grad + errorPrime * x * activationPrime\\n\\n\\n\\n # print grad - grad2\\n #print \\\"Error: \\\" + str(error) + \\\" Grad: \\\" + str(grad)\\n\\n # update w: w <- w + n*grad\\n self.updateWeights(grad)\\n\\n\\n iteration += 1\\n totalError = error.sum()\\n\\n if verbose:\\n logging.info(\\\"Epoch: %i; Error: %i\\\", iteration, totalError)\\n\\n if abs(totalError) < 0.01 or iteration >= self.epochs:\\n # stop criteria is reached\\n learned = True\\n\\n pass\",\n \"def _train_epoch(self, train_batches, data, max_metric_value, metric_save, patience, step_pbar):\\n evaluate = True\\n exit_tag = False\\n num_steps = self.args.num_steps\\n check_point, batch_size = self.args.check_point, self.args.batch_size\\n save_dir, save_prefix = self.args.save_dir, self.args.algo\\n\\n for bitx, batch in enumerate(train_batches):\\n if evaluate and self.global_step % self.eval_freq == 0:\\n if data.dev_set is not None:\\n dev_batches = data.gen_mini_batches('dev', 31928, shuffle=False)\\n dev_loss, dev_perplexity, dev_perplexity_at_rank = self.evaluate(dev_batches, data)\\n #print('dev loss=%s' % dev_loss, 'dev ppl=%s' % dev_perplexity, 'dev ppl at rank=', dev_perplexity_at_rank)\\n\\n test_batches = data.gen_mini_batches('test', 41405, shuffle=False)\\n test_loss, test_perplexity, test_perplexity_at_rank = self.evaluate(test_batches, data)\\n #print('test loss=%s' % test_loss, 'dev ppl=%s' % test_perplexity, 'dev ppl at rank=' , test_perplexity_at_rank)\\n\\n self.writer.add_scalar(\\\"dev/loss\\\", dev_loss, self.global_step)\\n self.writer.add_scalar(\\\"dev/perplexity\\\", dev_perplexity, self.global_step)\\n self.writer.add_scalar(\\\"test/loss\\\", test_loss, self.global_step)\\n self.writer.add_scalar(\\\"test/perplexity\\\", test_perplexity, self.global_step)\\n\\n for trunc_level in self.trunc_levels:\\n ndcg_version1, ndcg_version2 = self.relevance_estimator.evaluate(self, data, self.relevance_queries, trunc_level)\\n self.writer.add_scalar(\\\"NDCG_version1/{}\\\".format(trunc_level), ndcg_version1, self.global_step)\\n self.writer.add_scalar(\\\"NDCG_version2/{}\\\".format(trunc_level), ndcg_version2, self.global_step)\\n\\n if dev_loss < metric_save:\\n metric_save = dev_loss\\n patience = 0\\n else:\\n patience += 1\\n # Trick: do not decay d_lr help convergence\\n if patience >= self.patience:\\n #self.adjust_learning_rate(self.discrim_optimizer, self.args.lr_decay)\\n self.adjust_learning_rate(self.policy_optimizer, self.args.lr_decay)\\n self.g_lr *= self.args.lr_decay\\n #self.d_lr *= self.args.lr_decay\\n self.writer.add_scalar('train/g_lr', self.g_lr, self.global_step)\\n #self.writer.add_scalar('train/d_lr', self.d_lr, self.global_step)\\n metric_save = dev_loss\\n patience = 0\\n self.patience += 1\\n else:\\n self.logger.warning('No dev set is loaded for evaluation in the dataset!')\\n\\n self.global_step += 1\\n step_pbar.update(1)\\n QIDS = Variable(torch.from_numpy(np.array(batch['qids'], dtype=np.int64)))\\n UIDS = Variable(torch.from_numpy(np.array(batch['uids'], dtype=np.int64)))\\n VIDS = Variable(torch.from_numpy(np.array(batch['vids'], dtype=np.int64)))\\n PRE_CLICKS = Variable(torch.from_numpy(np.array(batch['clicks'], dtype=np.int64)[:, :-1]))\\n CLICKS = Variable(torch.from_numpy(np.array(batch['clicks'], dtype=np.int64)[:, 1:]))\\n\\n # generate trajectories\\n for __ in range(self.args.d_step):\\n actor_rnn_state = Variable(torch.zeros(1, QIDS.shape[0], self.gru_hidden_size))\\n critic_rnn_state = Variable(torch.zeros(1, QIDS.shape[0], self.gru_hidden_size))\\n CLICK_ = torch.zeros(QIDS.shape[0], 1, dtype=CLICKS.dtype)\\n logits = torch.zeros(QIDS.shape[0], 0, 2)\\n values = torch.zeros(QIDS.shape[0], 0)\\n CLICKS_ = Variable(torch.zeros((QIDS.shape[0], 0), dtype=CLICKS.dtype))\\n if self.use_cuda:\\n QIDS, UIDS, VIDS, PRE_CLICKS, CLICKS = QIDS.cuda(), UIDS.cuda(), VIDS.cuda(), PRE_CLICKS.cuda(), CLICKS.cuda()\\n actor_rnn_state, critic_rnn_state, CLICK_ = actor_rnn_state.cuda(), critic_rnn_state.cuda(), CLICK_.cuda()\\n logits, values, CLICKS_ = logits.cuda(), values.cuda(), CLICKS_.cuda()\\n self.policy.eval()\\n for i in range(self.max_d_num + 1):\\n logit, value, actor_rnn_state, critic_rnn_state = self.policy(QIDS[:, i:i+1], \\n UIDS[:, i:i+1], \\n VIDS[:, i:i+1], \\n CLICK_, \\n actor_rnn_state, \\n critic_rnn_state)\\n if i > 0:\\n CLICK_ = torch.distributions.Categorical(logit).sample()\\n logits = torch.cat([logits, logit], dim=1)\\n values = torch.cat([values, value], dim=1)\\n CLICKS_ = torch.cat([CLICKS_, CLICK_], dim=1)\\n\\n if self.use_cuda:\\n CLICKS_ = torch.cat((torch.zeros((CLICKS_.shape[0], 1), dtype=CLICKS_.dtype, device=torch.device('cuda')), CLICKS_), dim=1)\\n else:\\n CLICKS_ = torch.cat((torch.zeros((CLICKS_.shape[0], 1), dtype=CLICKS_.dtype), CLICKS_), dim=1)\\n\\n '''update discriminator'''\\n for _ in range(self.args.k):\\n self.discrim.train()\\n self.discrim_optimizer.zero_grad()\\n g_o, _ = self.discrim(QIDS, UIDS, VIDS, CLICKS_)\\n g_o_target = torch.ones((QIDS.shape[0], g_o.shape[1]))\\n e_o, _ = self.discrim(QIDS, UIDS, VIDS, CLICKS)\\n e_o_target = torch.zeros((QIDS.shape[0], e_o.shape[1]))\\n if self.use_cuda:\\n g_o_target, e_o_target = g_o_target.cuda(), e_o_target.cuda()\\n \\n discrim_loss = self.discrim_criterion(g_o, g_o_target) + self.discrim_criterion(e_o, e_o_target)\\n discrim_loss.backward()\\n self.discrim_optimizer.step()\\n self.writer.add_scalar('train/d_loss', discrim_loss.data, self.global_step)\\n\\n '''estimate advantage'''\\n with torch.no_grad():\\n self.discrim.eval()\\n rewards = -torch.log(self.discrim(QIDS, UIDS, VIDS, CLICKS_)[0])\\n # print(rewards.shape, values.shape)\\n #print(tensor_type)\\n #exit(0)\\n deltas = torch.zeros(rewards.shape)\\n advantages = torch.zeros(rewards.shape)\\n prev_value = torch.zeros(rewards.shape[0])\\n prev_advantage = torch.zeros(rewards.shape[0])\\n if self.use_cuda:\\n deltas, advantages = deltas.cuda(), advantages.cuda()\\n prev_value, prev_advantage = prev_value.cuda(), prev_advantage.cuda()\\n '''print(deltas)\\n print(advantages)\\n print(prev_value)\\n print(prev_advantage)\\n exit(0)'''\\n\\n for i in reversed(range(rewards.size(1))):\\n deltas[:, i] = rewards[:, i] + self.gamma * prev_value - values[:, i]\\n advantages[:, i] = deltas[:, i] + self.gamma * self.tau * prev_advantage\\n prev_value = values[:, i]\\n prev_advantage = advantages[:, i]\\n\\n returns = values + advantages\\n advantages = (advantages - advantages.mean()) / (advantages.std() + MINF)\\n # advantages = (returns - returns.mean())/returns.std()\\n\\n fixed_log_probs = torch.distributions.Categorical(logits).log_prob(CLICKS_[:, 1:])\\n\\n '''PPO update'''\\n self.policy.train()\\n optim_batchsize = 512\\n optim_iter_num = int(math.ceil(QIDS.shape[0] / optim_batchsize))\\n if self.use_cuda:\\n CLICKS_ = torch.cat((torch.zeros((CLICKS_.shape[0], 1), dtype=CLICKS_.dtype, device=torch.device('cuda')), CLICKS_), dim=1)\\n else:\\n CLICKS_ = torch.cat((torch.zeros((CLICKS_.shape[0], 1), dtype=CLICKS_.dtype), CLICKS_), dim=1)\\n for _ in range(self.args.g_step):\\n perm = np.arange(QIDS.shape[0])\\n np.random.shuffle(perm)\\n\\n QIDS, UIDS, VIDS, PRE_CLICKS, CLICKS, CLICKS_, advantages, returns, fixed_log_probs = \\\\\\n QIDS[perm].clone(), UIDS[perm].clone(), VIDS[perm].clone(), PRE_CLICKS[perm].clone(), \\\\\\n CLICKS[perm].clone(), CLICKS_[perm].clone(), advantages[perm].clone(), returns[perm].clone(), fixed_log_probs[perm].clone()\\n\\n #print(QIDS)\\n #exit(0)\\n\\n for i in range(optim_iter_num):\\n ind = slice(i * optim_batchsize, min((i + 1) * optim_batchsize, QIDS.shape[0]))\\n qids_b, uids_b, vids_b, pclicks_b, clicks_b, clicks__b, advantage_b, returns_b, fixed_log_probs_b = \\\\\\n QIDS[ind], UIDS[ind], VIDS[ind], CLICKS_[ind, :-1], CLICKS[ind], CLICKS_[ind, 2:], \\\\\\n advantages[ind], returns[ind], fixed_log_probs[ind]\\n\\n logits, values_pred, _, _ = self.policy(qids_b, uids_b, vids_b, pclicks_b)\\n dist = torch.distributions.Categorical(logits)\\n\\n\\n '''update critic'''\\n value_loss = (values_pred - returns_b).pow(2).mean()\\n '''optimizer policy'''\\n log_probs_b = dist.log_prob(clicks__b)\\n ratio = torch.exp(log_probs_b - fixed_log_probs_b)\\n surr1 = ratio * advantage_b\\n surr2 = torch.clamp(ratio, 1.0 - self.clip_epsilon, 1.0 + self.clip_epsilon) * advantage_b\\n policy_surr = -torch.min(surr1, surr2).mean()\\n pe = dist.entropy().mean()\\n loss = value_loss + self.alpha * policy_surr - self.beta * pe\\n\\n self.policy_optimizer.zero_grad()\\n loss.backward()\\n torch.nn.utils.clip_grad_norm_(self.policy.parameters(), 40)\\n self.policy_optimizer.step()\\n g_loss, _ = self.compute_loss(logits, clicks_b)\\n\\n self.writer.add_scalar('train/g_loss', g_loss.data, self.global_step)\\n self.writer.add_scalar('train/g_valueloss', value_loss.data, self.global_step)\\n self.writer.add_scalar('train/g_policysurr', policy_surr.data, self.global_step)\\n self.writer.add_scalar('train/g_entropy', pe.data, self.global_step)\\n\\n if check_point > 0 and self.global_step % check_point == 0:\\n self.save_model(save_dir, save_prefix)\\n if self.global_step >= num_steps:\\n exit_tag = True\\n\\n return max_metric_value, exit_tag, metric_save, patience\",\n \"def train(x_train, y_train, x_valid, y_valid, config):\\n train_acc = []\\n valid_acc = []\\n train_loss = []\\n valid_loss = []\\n best_model = None\\n NUM_EPOCH = config['epochs']\\n EARLY_STOP = config['early_stop']\\n EARLY_STOP_EPOCH = config['early_stop_epoch']\\n BATCH_SIZE = config['batch_size']\\n model = NeuralNetwork(config=config)\\n loss = float('inf')\\n best_loss = float('inf')\\n best_accuracy = 0\\n patience = 0\\n\\n\\n\\n for i in range (NUM_EPOCH):\\n\\n x_train, y_train = shuffle(x_train, y_train)\\n x_train = np.asarray(x_train)\\n y_train = np.asarray(y_train)\\n\\n for j in range (0, len(x_train), BATCH_SIZE):\\n start = j\\n end = j + BATCH_SIZE\\n if (end > len(x_train)):\\n end = len(x_train)\\n\\n x = x_train[start:end]\\n y = y_train[start:end]\\n\\n model.forward(x, y) \\n model.backward()\\n\\n train_epoch_loss = model.forward(x_train, y_train)\\n \\n train_predict = np.zeros_like(model.y)\\n train_predict[np.arange(len(model.y)), model.y.argmax(1)] = 1\\n\\n train_accuracy = sum([1 if all(train_predict[i] == y_train[i]) else 0 for i in range(len(y_train))])/len(y_train)\\n\\n train_loss.append(train_epoch_loss)\\n train_acc.append(train_accuracy)\\n \\n valid_epoch_loss = model.forward(x_valid, y_valid)\\n valid_predict = np.zeros_like(model.y)\\n valid_predict[np.arange(len(model.y)), model.y.argmax(1)] = 1\\n\\n valid_accuracy = sum([1 if all(valid_predict[i] == y_valid[i]) else 0 for i in range(len(y_valid))])/len(y_valid)\\n\\n valid_loss.append(valid_epoch_loss)\\n valid_acc.append(valid_accuracy)\\n\\n\\n print(\\\"Epoch:\\\", i, \\\"Train Accuracy|Loss:\\\", train_accuracy,\\\"| \\\", train_epoch_loss, \\\"~|~ Valid: \\\", valid_accuracy, \\\" | \\\", valid_epoch_loss)\\n if EARLY_STOP:\\n if valid_epoch_loss > best_loss and patience >= EARLY_STOP_EPOCH:\\n return train_acc, valid_acc, train_loss, valid_loss, best_model\\n elif valid_epoch_loss > best_loss and patience < EARLY_STOP_EPOCH:\\n patience += 1\\n else:\\n patience = 0\\n if valid_epoch_loss < best_loss:\\n best_loss = valid_epoch_loss\\n best_accuracy = valid_accuracy\\n best_model = copy.deepcopy(model)\\n\\n loss = valid_epoch_loss\\n\\n \\n best_model = model \\n return train_acc, valid_acc, train_loss, valid_loss, best_model\",\n \"def train_one_epoch(self):\\n self.model.train()\\n for batch_idx, (imgs, labels) in enumerate(self.tr_loader):\\n imgs, labels = imgs.to(self.device), labels.to(self.device)\\n self.optimizer.zero_grad()\\n\\n outputs, aux_outputs = self.model(imgs).values()\\n loss1 = self.criterion(outputs, labels)\\n loss2 = self.criterion(aux_outputs, labels)\\n self.loss = loss1 + 0.3*loss2\\n\\n _, preds = torch.max(outputs, 1)\\n acc = preds.eq(labels.view_as(preds)).sum().item() / self.cfg.bs\\n\\n self.loss.backward()\\n self.optimizer.step()\\n \\n self.summary_writer.add_scalars('scalar_group', \\n { 'loss_end' : loss1.item(),\\n 'loss_aux' : loss2.item(),\\n 'loss_total' : self.loss.item(),\\n 'accuracy' : acc},\\n self.current_iteration)\\n\\n if batch_idx % self.cfg.log_interval == 0:\\n info_1 = 'Epochs {} [{}/{} ({:.0f}%)] | Loss: {:.6f}' .format(\\n self.current_epoch, \\n batch_idx * len(imgs), \\n len(self.tr_loader.dataset), \\n 100. * batch_idx / len(self.tr_loader),\\n self.loss.item())\\n info_2 = 'Batch Accuracy : {:.2f}'.format(acc)\\n self.logger.info('{} | {}'.format(info_1, info_2))\\n self.save_checkpoint('{}_epoch{}_iter{}.pt'.format(\\n self.cfg.exp_name,\\n self.current_epoch, \\n self.current_iteration)\\n )\\n self.current_iteration += 1\",\n \"def train_epoch(self, train_loader, model, loss_function, criterion,\\n optimizer, epoch, writer_train, train_on_textures):\\n losses = AverageMeter()\\n model.train()\\n\\n if train_on_textures:\\n input_name = \\\"texture\\\"\\n else:\\n input_name = \\\"image\\\"\\n for i, data in enumerate(train_loader):\\n # switch to train mode\\n model.train()\\n input_var = data[input_name].float().to(self._device)\\n if \\\"hierarchical\\\" in self._model_name:\\n input_rep = self.generate_little_vae_encoding(input_var)\\n latent_rep, mean, logvar = model(input_rep)\\n output = self.generate_little_vae_decoding(latent_rep[0:1])\\n loss = criterion(latent_rep, input_rep, mean, logvar, epoch)\\n else:\\n output, mean, logvar = model(input_var)\\n loss = criterion(output, input_var, mean, logvar, epoch)\\n\\n # compute gradient and do optimization step\\n optimizer.zero_grad()\\n loss[\\\"loss\\\"].backward()\\n optimizer.step()\\n loss[\\\"loss\\\"]/=input_var.shape[0]\\n losses.update(loss[\\\"loss\\\"].item(), 1)\\n \\n cur_iter = i + len(train_loader) * epoch\\n for key in loss: \\n writer_train.add_scalar('data/{}'.format(key), loss[key].item(), cur_iter)\\n print(\\\"Epoch: [{0}][{1}/{2}]\\\\t Loss {loss.last_val:.4f} \\\"\\n \\\"({loss.avg:.4f})\\\\t\\\".format(\\n epoch, i, len(train_loader), loss=losses))\\n if i % 10 == 0:\\n writer_train.add_image('imgs/input', input_var[0], cur_iter)\\n if \\\"hierarchical\\\" in self._model_name:\\n writer_train.add_image('imgs/hierarchical_output', output[0], cur_iter)\\n writer_train.add_image('imgs/little_vae_output', self.generate_little_vae_decoding(input_rep[0:1])[0], cur_iter)\\n else:\\n writer_train.add_image('imgs/output', output[0], cur_iter)\",\n \"def _train_epoch(self, epoch):\\n self.model.train()\\n\\n\\n total_loss = 0\\n total_metrics = np.zeros(len(self.metrics))\\n length = len(self.data_loader)\\n total_pm25_loss = 0\\n total_pm10_loss = 0\\n pm25_loss = 0\\n pm10_loss = 0\\n\\n for batch_idx, (data, target) in enumerate(self.data_loader):\\n data, target = data.to(self.device), target.to(self.device)\\n\\n self.optimizer.zero_grad()\\n output = self.model(data)\\n # print(output.shape, target.shape)\\n target = target.squeeze()\\n model_loss = self.loss(output, target)\\n\\n # print(output.shape, target.shape)\\n # pm25_predict, pm10_predict = torch.chunk(output, 2, dim=1)\\n # pm25_target, pm10_target = torch.chunk(target, 2, dim=1)\\n # pm25_loss = self.loss(pm25_predict, pm25_target)\\n # pm10_loss = self.loss(pm10_predict, pm10_target)\\n # total_pm25_loss += pm25_loss.item()\\n # total_pm10_loss += pm10_loss.item()\\n\\n l2_reg = torch.tensor(0.0).to(self.device)\\n if self.config['trainer']['l2_regularization']:\\n for param in self.model.parameters():\\n l2_reg += torch.norm(param, p=2)\\n loss = model_loss + self.config['trainer']['l2_lambda'] * l2_reg\\n else:\\n loss = model_loss\\n\\n loss.backward()\\n # torch.nn.utils.clip_grad_norm(self.model.parameters(), 1)\\n self.optimizer.step()\\n\\n self.writer.set_step((epoch - 1) * self.len_epoch + batch_idx)\\n self.writer.add_scalar('loss', loss.item())\\n total_loss += loss.item()\\n # total_metrics += self._eval_metrics(output, target)\\n\\n if batch_idx % self.log_step == 0:\\n self.logger.debug('Train Epoch: {} {} Loss: {:.6f} model_loss: {:.6f} pm25_loss {:.6f} pm10_loss {:.6f} l2_loss: {:.6f}'.format(\\n epoch,\\n self._progress(batch_idx),\\n loss.item(),\\n model_loss.item(),\\n pm25_loss,\\n pm10_loss,\\n l2_reg.item()))\\n\\n if batch_idx == self.len_epoch:\\n break\\n\\n log = {\\n 'loss': total_loss / length,\\n 'rmse_pm25_loss': np.sqrt(total_pm25_loss / length),\\n 'rmse_pm10_loss': np.sqrt(total_pm10_loss / length)\\n }\\n\\n\\n val_log = self._valid_epoch(epoch)\\n log.update(val_log)\\n\\n if self.lr_scheduler is not None:\\n self.lr_scheduler.step(val_log['val_loss'])\\n\\n return log\",\n \"def _train_internal(self, opts):\\n\\n batches_num = self._data.num_points / opts['batch_size']\\n train_size = self._data.num_points\\n num_plot = 320\\n sample_prev = np.zeros([num_plot] + list(self._data.data_shape))\\n l2s = []\\n\\n counter = 0\\n decay = 1.\\n logging.error('Training VAE')\\n for _epoch in xrange(opts[\\\"gan_epoch_num\\\"]):\\n\\n if opts['decay_schedule'] == \\\"manual\\\":\\n if _epoch == 30:\\n decay = decay / 2.\\n if _epoch == 50:\\n decay = decay / 5.\\n if _epoch == 100:\\n decay = decay / 10.\\n\\n if _epoch > 0 and _epoch % opts['save_every_epoch'] == 0:\\n os.path.join(opts['work_dir'], opts['ckpt_dir'])\\n self._saver.save(self._session,\\n os.path.join(opts['work_dir'],\\n opts['ckpt_dir'],\\n 'trained-pot'),\\n global_step=counter)\\n\\n for _idx in xrange(batches_num):\\n # logging.error('Step %d of %d' % (_idx, batches_num ) )\\n data_ids = np.random.choice(train_size, opts['batch_size'],\\n replace=False, p=self._data_weights)\\n batch_images = self._data.data[data_ids].astype(np.float)\\n batch_noise = utils.generate_noise(opts, opts['batch_size'])\\n _, loss, loss_kl, loss_reconstruct = self._session.run(\\n [self._optim, self._loss, self._loss_kl,\\n self._loss_reconstruct],\\n feed_dict={self._real_points_ph: batch_images,\\n self._noise_ph: batch_noise,\\n self._lr_decay_ph: decay,\\n self._is_training_ph: True})\\n counter += 1\\n\\n if opts['verbose'] and counter % opts['plot_every'] == 0:\\n debug_str = 'Epoch: %d/%d, batch:%d/%d' % (\\n _epoch+1, opts['gan_epoch_num'], _idx+1, batches_num)\\n debug_str += ' [L=%.2g, Recon=%.2g, KLQ=%.2g]' % (\\n loss, loss_reconstruct, loss_kl)\\n logging.error(debug_str)\\n\\n if opts['verbose'] and counter % opts['plot_every'] == 0:\\n metrics = Metrics()\\n points_to_plot = self._run_batch(\\n opts, self._generated, self._noise_ph,\\n self._noise_for_plots[0:num_plot],\\n self._is_training_ph, False)\\n l2s.append(np.sum((points_to_plot - sample_prev)**2))\\n metrics.l2s = l2s[:]\\n metrics.make_plots(\\n opts,\\n counter,\\n None,\\n points_to_plot,\\n prefix='sample_e%04d_mb%05d_' % (_epoch, _idx))\\n reconstructed = self._session.run(\\n self._reconstruct_x,\\n feed_dict={self._real_points_ph: batch_images,\\n self._is_training_ph: False})\\n metrics.l2s = None\\n metrics.make_plots(\\n opts,\\n counter,\\n None,\\n reconstructed,\\n prefix='reconstr_e%04d_mb%05d_' % (_epoch, _idx))\\n if opts['early_stop'] > 0 and counter > opts['early_stop']:\\n break\\n if _epoch > 0:\\n os.path.join(opts['work_dir'], opts['ckpt_dir'])\\n self._saver.save(self._session,\\n os.path.join(opts['work_dir'],\\n opts['ckpt_dir'],\\n 'trained-pot-final'),\\n global_step=counter)\",\n \"def _train_epoch(X_train, y_train, model, criterion, optimizer, batch_size, iterations):\\n #this function is inspired by an EECS 445 project done by Justin Weilbach\\n\\n #I found online that people do this but I don't think it did anything\\n model = model.train()\\n\\n #create batch size for sgd\\n num_train = X_train.shape[0]\\n batch_mask = np.random.choice(num_train, batch_size)\\n train_batch = X_train[batch_mask]\\n #lmao why is that not already an np array\\n y_train = np.array(y_train)\\n batch_labels = np.asarray(y_train[batch_mask])\\n\\n for it in range(0, iterations):\\n for i, image in enumerate(train_batch):\\n label = batch_labels[i]\\n label = torch.from_numpy(np.asarray(label))\\n label = label.type(torch.LongTensor)\\n label = torch.tensor([label])\\n\\n image = torch.from_numpy(image)\\n image = image.type(torch.FloatTensor)\\n image = image.unsqueeze(0)\\n\\n optimizer.zero_grad()\\n output = model(image)\\n\\n loss = criterion(output, label)\\n loss.backward()\\n optimizer.step()\",\n \"def train(self, training, epochs, group):\\n for epoch in range(epochs):\\n self.input_matrix={}\\n self.back_propagation_learning(training)\\n acc = accuracy(self, group)\\n print(\\\"Accuracy on epoch {} is {} \\\".format(epoch, acc))\",\n \"def _train_epoch(self, epoch: int) -> Dict[str, float]:\\n logger.info(\\\"Epoch %d/%d\\\", epoch, self._num_epochs - 1)\\n peak_cpu_usage = peak_memory_mb()\\n logger.info(f\\\"Peak CPU memory usage MB: {peak_cpu_usage}\\\")\\n gpu_usage = []\\n for gpu, memory in gpu_memory_mb().items():\\n gpu_usage.append((gpu, memory))\\n logger.info(f\\\"GPU {gpu} memory usage MB: {memory}\\\")\\n\\n train_loss = 0.0\\n # Set the model to \\\"train\\\" mode.\\n self.model.train()\\n\\n num_gpus = len(self._cuda_devices)\\n\\n # Get tqdm for the training batches\\n raw_train_generator = self.iterator(self.train_data,\\n num_epochs=1,\\n shuffle=self.shuffle)\\n train_generator = lazy_groups_of(raw_train_generator, num_gpus)\\n num_training_batches = math.ceil(self.iterator.get_num_batches(self.train_data)/num_gpus)\\n self._last_log = time.time()\\n last_save_time = time.time()\\n\\n batches_this_epoch = 0\\n if self._batch_num_total is None:\\n self._batch_num_total = 0\\n\\n histogram_parameters = set(self.model.get_parameters_for_histogram_tensorboard_logging())\\n\\n logger.info(\\\"Training\\\")\\n train_generator_tqdm = Tqdm.tqdm(train_generator,\\n total=num_training_batches)\\n cumulative_batch_size = 0\\n for batch_group in train_generator_tqdm:\\n batches_this_epoch += 1\\n self._batch_num_total += 1\\n batch_num_total = self._batch_num_total\\n\\n self.optimizer.zero_grad()\\n\\n output_dict = self.get_output_dict(batch_group, for_training=True)\\n loss = self.get_batch_loss(output_dict, for_training=True)\\n\\n if torch.isnan(loss):\\n raise ValueError(\\\"nan loss encountered\\\")\\n\\n loss.backward()\\n\\n train_loss += loss.item()\\n\\n batch_grad_norm = self.rescale_gradients()\\n\\n # This does nothing if batch_num_total is None or you are using a\\n # scheduler which doesn't update per batch.\\n if self._learning_rate_scheduler:\\n self._learning_rate_scheduler.step_batch(batch_num_total)\\n if self._momentum_scheduler:\\n self._momentum_scheduler.step_batch(batch_num_total)\\n\\n if self._tensorboard.should_log_histograms_this_batch():\\n # get the magnitude of parameter updates for logging\\n # We need a copy of current parameters to compute magnitude of updates,\\n # and copy them to CPU so large models won't go OOM on the GPU.\\n param_updates = {name: param.detach().cpu().clone()\\n for name, param in self.model.named_parameters()}\\n self.optimizer.step()\\n for name, param in self.model.named_parameters():\\n param_updates[name].sub_(param.detach().cpu())\\n update_norm = torch.norm(param_updates[name].view(-1, ))\\n param_norm = torch.norm(param.view(-1, )).cpu()\\n self._tensorboard.add_train_scalar(\\\"gradient_update/\\\" + name,\\n update_norm / (param_norm + 1e-7))\\n else:\\n self.optimizer.step()\\n\\n # Update moving averages\\n if self._moving_average is not None:\\n self._moving_average.apply(batch_num_total)\\n\\n # Update the description with the latest metrics\\n metrics = training_util.get_metrics(self.model, train_loss, batches_this_epoch)\\n description = training_util.description_from_metrics(metrics)\\n\\n train_generator_tqdm.set_description(description, refresh=False)\\n\\n # Log parameter values to Tensorboard\\n if self._tensorboard.should_log_this_batch():\\n self._tensorboard.log_parameter_and_gradient_statistics(self.model, batch_grad_norm)\\n self._tensorboard.log_learning_rates(self.model, self.optimizer)\\n\\n self._tensorboard.add_train_scalar(\\\"loss/loss_train\\\", metrics[\\\"loss\\\"])\\n self._tensorboard.log_metrics({\\\"epoch_metrics/\\\" + k: v for k, v in metrics.items()})\\n\\n if self.tensorboard_log_batch_callback:\\n self.tensorboard_log_batch_callback(output_dict, self._tensorboard)\\n\\n if self._tensorboard.should_log_histograms_this_batch():\\n self._tensorboard.log_histograms(self.model, histogram_parameters)\\n\\n if self._log_batch_size_period:\\n cur_batch = sum([training_util.get_batch_size(batch) for batch in batch_group])\\n cumulative_batch_size += cur_batch\\n if (batches_this_epoch - 1) % self._log_batch_size_period == 0:\\n average = cumulative_batch_size/batches_this_epoch\\n logger.info(f\\\"current batch size: {cur_batch} mean batch size: {average}\\\")\\n self._tensorboard.add_train_scalar(\\\"current_batch_size\\\", cur_batch)\\n self._tensorboard.add_train_scalar(\\\"mean_batch_size\\\", average)\\n\\n # Save model if needed.\\n if self._model_save_interval is not None and (\\n time.time() - last_save_time > self._model_save_interval\\n ):\\n last_save_time = time.time()\\n self._save_checkpoint(\\n '{0}.{1}'.format(epoch, training_util.time_to_str(int(last_save_time)))\\n )\\n metrics = training_util.get_metrics(self.model, train_loss, batches_this_epoch, reset=True)\\n metrics['cpu_memory_MB'] = peak_cpu_usage\\n for (gpu_num, memory) in gpu_usage:\\n metrics['gpu_'+str(gpu_num)+'_memory_MB'] = memory\\n return metrics\",\n \"def train_network(self):\\n if self.trainData:\\n if self.verbose:\\n print('Started training...')\\n\\n for epoch in range(135):\\n pass\\n # save the model\\n else:\\n if self.verbose:\\n print('No train data available')\",\n \"def train_network(self, batch_size, epochs):\\n\\n if self.eq_train: self.model.fit([self.X_train_high_level, self.X_train_low_level], self.y_train, epochs=epochs, batch_size=batch_size, sample_weight=self.train_weights_eq) \\n else: self.model.fit([self.X_train_high_level, self.X_train_low_level], self.y_train, epochs=epochs, batch_size=batch_size, sample_weight=self.train_weights)\",\n \"def train(self, x_train, y_train, x_val, y_val):\\n pass\",\n \"def validation_epoch(self):\\n self.model.eval()\\n\\n # Compute for training set\\n train_loss, train_acc = compute_loss_and_accuracy(\\n self.dataloader_train, self.model, self.loss_criterion\\n )\\n self.TRAIN_ACC.append(train_acc)\\n self.TRAIN_LOSS.append(train_loss)\\n\\n # Compute for validation set\\n validation_loss, validation_acc = compute_loss_and_accuracy(\\n self.dataloader_val, self.model, self.loss_criterion\\n )\\n self.VALIDATION_ACC.append(validation_acc)\\n self.VALIDATION_LOSS.append(validation_loss)\\n print(\\\"Current validation loss:\\\", validation_loss, \\\" Accuracy:\\\", validation_acc)\\n # Compute for testing set\\n test_loss, test_acc = compute_loss_and_accuracy(\\n self.dataloader_test, self.model, self.loss_criterion\\n )\\n self.TEST_ACC.append(test_acc)\\n self.TEST_LOSS.append(test_loss)\\n\\n self.model.train()\",\n \"def start_training(self):\\n self.training = True\",\n \"def train_step(self):\\r\\n batch_images = next(self.data_loader.next_batch())\\r\\n _, loss, summary, ea = self.sess.run([self.model.train_op, self.model.total_loss, self.model.merged, self.model.euclidean_a_p],\\r\\n feed_dict={self.model.input: batch_images, self.model.is_training: True})\\r\\n \\r\\n return loss, summary\",\n \"def train_epoch(model, optimizer, train_loader, criterion, device):\\n\\n model.train()\\n \\n for batch_train, batch_answers in train_loader:\\n batch_train = batch_train.to(device)\\n batch_answers = batch_answers.to(device)\\n \\n optimizer.zero_grad()\\n model_answers = model(batch_train)\\n criterion(model_answers[0], batch_answers)\\n\\n\\n new_loss = criterion(model_answers[0], batch_answers) + criterion(model_answers[1], batch_answers) \\n new_loss.backward()\\n optimizer.step()\",\n \"def compile_train(self, epochs):\\n self.model.compile(\\n optimizer=Adam(0.001),\\n loss=SparseCategoricalCrossentropy(from_logits=True),\\n metrics='accuracy'\\n )\\n\\n self.model.fit(\\n train_x,\\n train_y,\\n batch_size=50,\\n epochs=epochs,\\n validation_data=(val_x, val_y),\\n verbose=1\\n )\",\n \"def train(self, sess): \\n\\n logging.info(\\\"////////////////////////////\\\")\\n logging.info(\\\"///// BEGIN TRAINING /////\\\")\\n logging.info(\\\"////////////////////////////\\\")\\n\\n # for TensorBoard\\n summaryWriter = tf.summary.FileWriter(\\n \\\"./checkpoints/\\\", \\n sess.graph)\\n\\n # Initialize iterator\\n sess.run(self.train_iter.initializer)\\n\\n # Print initial model predictions\\n emaTrainLoss = self.get_loss(sess, dSet=\\\"train\\\")\\n emaTrainAccr = self.get_accuracy(sess, dSet=\\\"train\\\")\\n valLoss = self.get_loss(sess, dSet=\\\"val\\\")\\n valAccr = self.get_accuracy(sess, dSet=\\\"val\\\")\\n logging.info(\\\"Initial training Loss / Accuracy: %f / %f)\\\" % (emaTrainLoss, emaTrainAccr))\\n logging.info(\\\"Initial validation Loss / Accuracy: %f / %f)\\\" % (valLoss, valAccr))\\n\\n randomRatio = 1.0\\n epoch = 0\\n best_val_loss = None\\n best_val_acc = None\\n\\n\\n ###### Loop over epochs #####\\n while (self.FLAGS.Nepochs is 0) or (epoch <= self.FLAGS.Nepochs):\\n epoch += 1\\n epoch_tic = time.time()\\n\\n # Evaluate test and validation data\\n trnLoss = self.get_loss(sess, dSet=\\\"train\\\")\\n trnAccr = self.get_accuracy(sess, dSet=\\\"train\\\")\\n valLoss = self.get_loss(sess, dSet=\\\"val\\\")\\n valAccr = self.get_accuracy(sess, dSet=\\\"val\\\")\\n\\n print_info = \\\"Full Sets\\\\tTraining %.5f / %.5f \\\\tValidation %.5f / %.5f\\\" %\\\\\\n (trnLoss, trnAccr, valLoss, valAccr)\\n logging.info(\\\"\\\\n\\\\n///// Begin Epoch {} /////\\\\n\\\".format(epoch)\\n + print_info)\\n\\n\\n # Initialize iterator\\n sess.run(self.train_iter.initializer)\\n\\n ##### Loop over mini batches #####\\n while True:\\n\\n # Perform training step\\n try :\\n tstep_tic = time.time()\\n curLoss, curAccr, global_step = self.run_train_step(sess, summaryWriter)\\n tstep_toc = time.time()\\n tstep_time = tstep_toc - tstep_tic\\n except tf.errors.OutOfRangeError:\\n break\\n\\n # Update training history parameters\\n emaTrainLoss = curLoss*(1-self.FLAGS.train_variable_decay)\\\\\\n + emaTrainLoss*self.FLAGS.train_variable_decay \\n emaTrainAccr = curAccr*(1-self.FLAGS.train_variable_decay)\\\\\\n + emaTrainAccr*self.FLAGS.train_variable_decay \\n\\n ### Evaluate model ###\\n if global_step % self.FLAGS.eval_every == 0:\\n\\n # Save training data measurements\\n self.writeSummary(emaTrainLoss, \\\"train/loss\\\", summaryWriter, global_step)\\n self.writeSummary(emaTrainAccr, \\\"train/acc\\\", summaryWriter, global_step)\\n self.history[\\\"step\\\"].append(global_step)\\n self.history[\\\"trainLoss\\\"].append(emaTrainLoss)\\n self.history[\\\"trainAccr\\\"].append(emaTrainAccr)\\n\\n # Evaluate validation data\\n valLoss = self.get_loss(sess, dSet=\\\"val\\\")\\n valAccr = self.get_accuracy(sess, dSet=\\\"val\\\")\\n\\n self.writeSummary(valLoss, \\\"val/loss\\\", summaryWriter, global_step)\\n self.writeSummary(valAccr, \\\"val/acc\\\", summaryWriter, global_step)\\n self.history[\\\"validLoss\\\"].append(valLoss)\\n self.history[\\\"validAccr\\\"].append(valAccr)\\n\\n # Logging results\\n print_info = \\\"%i\\\\tTraining %.5f / %.5f \\\\tValidation %.5f / %.5f\\\" %\\\\\\n (global_step, emaTrainLoss, emaTrainAccr, valLoss, valAccr)\\n logging.info(print_info)\\n\\n # plot training progress\\n self.plot_results()\\n\\n\\n # Save model\\n if global_step % self.FLAGS.save_every == 0:\\n logging.info(\\\"Saving model at iteration {} to {}\\\".format(\\n global_step, self.FLAGS.checkpoint_path))\\n self.saver.save(sess, \\n self.FLAGS.checkpoint_path + \\\"/\\\" + self.FLAGS.experiment_name, \\n global_step=global_step)\\n self.saveTrainingHistory(\\n fileName=self.FLAGS.checkpoint_path + \\\"/\\\" + self.FLAGS.experiment_name, \\n global_step=global_step)\\n\\n\\n # Evaluate validation data\\n valLoss = self.get_loss(sess, dSet=\\\"val\\\")\\n valAccs = self.get_accuracy(sess, dSet=\\\"val\\\")\\n\\n # Save best models\\n if (best_val_loss is None) or (valLoss < best_val_loss):\\n logging.info(\\\"Saving best loss model at iteration {} in {}\\\".format(\\n global_step, self.FLAGS.bestModel_loss_ckpt_path))\\n best_val_loss = valLoss\\n self.bestLossSaver.save(sess, \\n self.FLAGS.bestModel_loss_ckpt_path + \\\"/\\\" + self.FLAGS.experiment_name, \\n global_step=global_step)\\n self.saveTrainingHistory(\\n fileName=self.FLAGS.bestModel_loss_ckpt_path + \\\"/\\\" + self.FLAGS.experiment_name, \\n global_step=global_step)\\n if (best_val_acc is None) or (valAccs > best_val_acc):\\n logging.info(\\\"Saving best accuracy model at iteration {} in {}\\\".format(\\n global_step, self.FLAGS.bestModel_acc_ckpt_path))\\n best_val_acc = valAccs\\n self.bestAccSaver.save(sess, \\n self.FLAGS.bestModel_acc_ckpt_path + \\\"/\\\" + self.FLAGS.experiment_name, \\n global_step=global_step)\\n self.saveTrainingHistory(\\n fileName=self.FLAGS.bestModel_acc_ckpt_path + \\\"/\\\" + self.FLAGS.experiment_name, \\n global_step=global_step)\\n\\n\\n loss_train = self.get_loss(sess, dSet=\\\"train\\\")\\n acc_train = self.get_accuracy(sess, dSet=\\\"train\\\")\\n\\n loss_val = self.get_loss(sess, dSet=\\\"val\\\")\\n acc_val = self.get_accuracy(sess, dSet=\\\"val\\\")\\n\\n print(loss_train, acc_train)\\n if self.FLAGS.verbose:\\n print(\\\"\\\\n\\\\n\\\")\\n print(\\\"###########################\\\")\\n print(\\\"##### Final Results #####\\\")\\n print(\\\"###########################\\\")\\n print(\\\"\\\\nTraining [ Loss: %f\\\\t Accuracy: %f]\\\" \\\\\\n % (loss_train, acc_train))\\n print(\\\"Validation [ Loss: %f\\\\t Accuracy: %f]\\\" \\\\\\n % (loss_val, acc_val))\\n \\n self.hasTrained = True\",\n \"def train_an_epoch(self, train_loader, epoch_id):\\n assert hasattr(self, \\\"model\\\"), \\\"Please specify the exact model !\\\"\\n self.model.train()\\n total_loss = 0.0\\n\\n for batch_data in train_loader:\\n loss = self.train_single_batch(batch_data)\\n total_loss += loss\\n print(\\\"[Training Epoch {}], Loss {}\\\".format(epoch_id, loss))\\n self.writer.add_scalar(\\\"model/loss\\\", total_loss, epoch_id)\",\n \"def train_one_epoch(self):\\n print('Training......')\\n\\n # set mode train\\n self.network.train()\\n\\n # prepare data\\n train_loss = 0\\n transform = transforms.Compose([Rescale(params.rescale_size),\\n RandomCrop(params.image_size),\\n RandomHorizontalFlip(),\\n ToTensor()\\n ])\\n\\n\\n\\n dataset = Cityscapes(params.dataset_root, mode='train', transforms = transform)\\n\\n train_loader = DataLoader(dataset,\\n batch_size=params.train_batch,\\n shuffle=params.shuffle,\\n num_workers=params.dataloader_workers)\\n \\n train_size = 1896\\n if train_size % self.params.train_batch != 0:\\n total_batch = train_size // self.params.train_batch + 1\\n else:\\n total_batch = train_size // self.params.train_batch\\n recal = 0\\n precision = 0\\n F_one = 0\\n IOU = 0\\n accuracy_new = 0 \\n # train through dataset\\n for batch_idx, batch in enumerate(train_loader):\\n self.pb.click(batch_idx, total_batch)\\n image, label = batch['image'], batch['label']\\n image_cuda, label_cuda = image.cuda(), label.cuda()\\n\\n # checkpoint split\\n if self.params.should_split:\\n image_cuda.requires_grad_()\\n out = checkpoint_sequential(self.network, self.params.split, image_cuda)\\n else:\\n out = self.network(image_cuda)\\n\\n\\n loss = self.loss_fn(out, label_cuda)\\n \\n #display_image(out, label_cuda)\\n TP, FP, TN, FN = confusion(out, label_cuda)\\n recal = recal+TP\\n precision = precision+FP\\n F_one = F_one + TN\\n IOU = IOU+ FN \\n accuracy_final = accuracy(out, label_cuda)\\n accuracy_new = accuracy_new + accuracy_final\\n\\n # optimize\\n self.opt.zero_grad()\\n loss.backward()\\n self.opt.step()\\n\\n # accumulate\\n train_loss += loss.item()\\n\\n # record first loss\\n if self.train_loss == []:\\n self.train_loss.append(train_loss)\\n self.summary_writer.add_scalar('loss/train_loss', train_loss, 0)\\n \\n print(\\\"\\\\t\\\")\\n print(recal/total_batch, precision/ total_batch, F_one/ total_batch, IOU/ total_batch)\\n print(accuracy_new/total_batch)\\n \\n self.pb.close()\\n train_loss /= total_batch\\n self.train_loss.append(train_loss)\\n\\n # add to summary\\n self.summary_writer.add_scalar('loss/train_loss', train_loss, self.epoch)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.81284416","0.8044275","0.795282","0.7818035","0.7789884","0.7776823","0.7748766","0.7745458","0.77287894","0.7725468","0.76904434","0.7620618","0.7620618","0.7620618","0.7620618","0.7620618","0.76109827","0.75628734","0.7556383","0.7547646","0.7536899","0.7535087","0.75316215","0.7526072","0.7516032","0.7515835","0.7512943","0.7512445","0.7495484","0.7494166","0.7493588","0.74922335","0.7486698","0.74862283","0.7476469","0.74758005","0.7447605","0.7447605","0.74454474","0.7431674","0.7425271","0.7420993","0.7416986","0.74160194","0.74159336","0.7407834","0.74069","0.7386779","0.7373453","0.7373193","0.73584795","0.7354355","0.7328128","0.73137033","0.7311355","0.731059","0.7295994","0.7293598","0.728794","0.7287468","0.7285376","0.7280058","0.72798276","0.72733015","0.7271079","0.7256508","0.7255253","0.72509676","0.7248821","0.72473663","0.7243537","0.7241543","0.7222613","0.72225505","0.7205655","0.7203486","0.7200225","0.71717954","0.7170395","0.71700996","0.71672237","0.716515","0.7163513","0.71624935","0.71611255","0.7157403","0.71518314","0.7150311","0.71470964","0.71443003","0.7142204","0.71373814","0.71333885","0.7128135","0.7115114","0.7111967","0.7091414"],"string":"[\n \"0.81284416\",\n \"0.8044275\",\n \"0.795282\",\n \"0.7818035\",\n \"0.7789884\",\n \"0.7776823\",\n \"0.7748766\",\n \"0.7745458\",\n \"0.77287894\",\n \"0.7725468\",\n \"0.76904434\",\n \"0.7620618\",\n \"0.7620618\",\n \"0.7620618\",\n \"0.7620618\",\n \"0.7620618\",\n \"0.76109827\",\n \"0.75628734\",\n \"0.7556383\",\n \"0.7547646\",\n \"0.7536899\",\n \"0.7535087\",\n \"0.75316215\",\n \"0.7526072\",\n \"0.7516032\",\n \"0.7515835\",\n \"0.7512943\",\n \"0.7512445\",\n \"0.7495484\",\n \"0.7494166\",\n \"0.7493588\",\n \"0.74922335\",\n \"0.7486698\",\n \"0.74862283\",\n \"0.7476469\",\n \"0.74758005\",\n \"0.7447605\",\n \"0.7447605\",\n \"0.74454474\",\n \"0.7431674\",\n \"0.7425271\",\n \"0.7420993\",\n \"0.7416986\",\n \"0.74160194\",\n \"0.74159336\",\n \"0.7407834\",\n \"0.74069\",\n \"0.7386779\",\n \"0.7373453\",\n \"0.7373193\",\n \"0.73584795\",\n \"0.7354355\",\n \"0.7328128\",\n \"0.73137033\",\n \"0.7311355\",\n \"0.731059\",\n \"0.7295994\",\n \"0.7293598\",\n \"0.728794\",\n \"0.7287468\",\n \"0.7285376\",\n \"0.7280058\",\n \"0.72798276\",\n \"0.72733015\",\n \"0.7271079\",\n \"0.7256508\",\n \"0.7255253\",\n \"0.72509676\",\n \"0.7248821\",\n \"0.72473663\",\n \"0.7243537\",\n \"0.7241543\",\n \"0.7222613\",\n \"0.72225505\",\n \"0.7205655\",\n \"0.7203486\",\n \"0.7200225\",\n \"0.71717954\",\n \"0.7170395\",\n \"0.71700996\",\n \"0.71672237\",\n \"0.716515\",\n \"0.7163513\",\n \"0.71624935\",\n \"0.71611255\",\n \"0.7157403\",\n \"0.71518314\",\n \"0.7150311\",\n \"0.71470964\",\n \"0.71443003\",\n \"0.7142204\",\n \"0.71373814\",\n \"0.71333885\",\n \"0.7128135\",\n \"0.7115114\",\n \"0.7111967\",\n \"0.7091414\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.84083605"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":22885,"cells":{"query":{"kind":"string","value":"Resume from saved checkpoints"},"document":{"kind":"string","value":"def _resume_checkpoint(self, resume_path):\n self.logger.info(\"Loading checkpoint: {} ...\".format(resume_path))\n checkpoint = torch.load(resume_path)\n self.start_epoch = checkpoint['epoch'] + 1\n self.mnt_best = checkpoint['monitor_best']\n\n # load model params from checkpoint.\n if checkpoint['config']['name'] != self.config['name']:\n self.logger.warning(\n 'Warning: Architecture configuration given in config file is different from that of checkpoint. ' + \\\n 'This may yield an exception while state_dict is being loaded.')\n self.model.load_state_dict(checkpoint['model_state_dict'])\n\n # load optimizer state from checkpoint only when optimizer type is not changed. \n if checkpoint['config']['optimizer']['type'] != self.config['optimizer']['type']:\n self.logger.warning('Warning: Optimizer type given in config file is different from that of checkpoint. ' + \\\n 'Optimizer parameters not being resumed.')\n self.optimizer.load_state_dict(checkpoint['model_optimizer'])\n\n # load scheduler state from checkpoint only when scheduler type is not changed\n if checkpoint['config']['scheduler']['type'] != self.config['scheduler']['type']:\n self.logger.warning('Warning: Scheduler type given in config file is different from that of checkpoint. ' + \\\n 'Scheduler parameters not being resumed.')\n self.scheduler.load_state_dict(checkpoint['model_scheduler'])\n\n self.train_logger = checkpoint['logger']\n self.logger.info(\"Checkpoint '{}' (epoch {}) loaded\".format(resume_path, self.start_epoch))"},"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 resume(self, checkpoint):\n model_dict = paddle.load(checkpoint)\n self.model.set_state_dict(model_dict)","def _resume_checkpoint(self, resume_path):\n self.logger.info(\"Loading checkpoint: {} ...\".format(resume_path))\n checkpoint = torch.load(resume_path)\n self.start_epoch = checkpoint['epoch'] + 1\n self.monitor_best = checkpoint['monitor_best']\n self.model.load_state_dict(checkpoint['state_dict'])\n self.optimizer.load_state_dict(checkpoint['optimizer'])\n self.train_logger = checkpoint['logger']\n self.logger.info(\"Checkpoint '{}' (epoch {}) loaded\".format(resume_path, self.start_epoch))","def _resume_checkpoint(self, resume_path):\n resume_path = str(resume_path)\n self.logger.info(\"Loading checkpoint: {} ...\".format(resume_path))\n checkpoint = torch.load(resume_path)\n self.start_epoch = checkpoint['epoch'] + 1\n\n # load architecture params from checkpoint.\n if checkpoint['config']['model'] != self.config['model']:\n self.logger.warning(\"Warning: Architecture configuration given in config file is different from that of \"\n \"checkpoint. This may yield an exception while state_dict is being loaded.\")\n self.model.load_state_dict(checkpoint['state_dict'])\n\n # load optimizer state from checkpoint only when optimizer type is not changed.\n if checkpoint['config']['trainer']['optimizer']['type'] != self.config['trainer']['optimizer']['type']:\n self.logger.warning(\"Warning: Optimizer type given in config file is different from that of checkpoint. \"\n \"Optimizer parameters not being resumed.\")\n else:\n self.optimizer.load_state_dict(checkpoint['optimizer'])\n\n self.logger.info(\"Checkpoint loaded. Resume from epoch {}\".format(self.start_epoch))","def _resume_checkpoint(self, resume_path):\n self.logger.info(\"Loading checkpoint: {} ...\".format(resume_path))\n checkpoint = torch.load(resume_path)\n self.start_epoch = checkpoint['epoch'] + 1\n self.monitor_best = checkpoint['monitor_best']\n self.model.load_state_dict(checkpoint['state_dict'])\n self.optimizer.load_state_dict(checkpoint['optimizer'])\n if self.with_cuda:\n for state in self.optimizer.state.values():\n for k, v in state.items():\n if isinstance(v, torch.Tensor):\n state[k] = v.cuda(torch.device('cuda'))\n self.train_logger = checkpoint['logger']\n #self.config = checkpoint['config']\n self.logger.info(\"Checkpoint '{}' (epoch {}) loaded\".format(resume_path, self.start_epoch))","def _resume(self):\n\n if self.resume_file is None:\n return None\n assert os.path.isfile(self.resume_file)\n logger.info(f'=> loading checkpoint {self.resume_file}')\n checkpoint = torch.load(self.resume_file)\n self.cur_epoch = checkpoint['epoch']\n self.model.load_state_dict(checkpoint['state_dict'])\n self.optimizer.load_state_dict(checkpoint['optimizer'])\n self.scheduler.load_state_dict(checkpoint['scheduler'])\n self.best_rho = checkpoint['best_rho']\n self.best_nmse = checkpoint['best_nmse']\n self.cur_epoch += 1 # start from the next epoch\n\n logger.info(f'=> successfully loaded checkpoint {self.resume_file} '\n f'from epoch {checkpoint[\"epoch\"]}.\\n')","def resume_model(self, resume_path):\n if resume_path:\n resume_path = f'{self.model_dir}/{resume_path}.pth.tar'\n if os.path.isfile(resume_path):\n print(f\"=> loading checkpoint '{resume_path}'\")\n checkpoint = torch.load(resume_path, map_location=self.device)\n self.best_acc = checkpoint['best_acc']\n self.model.load_state_dict(checkpoint['state_dict'])\n print(f\"=> loaded checkpoint '{resume_path}' (Round {checkpoint['rnd']})\")\n del checkpoint\n else:\n print(f\"=> no checkpoint found at '{resume_path}'\")","def _resume_checkpoint(self, resume_path):\n self.logger.info(\"Loading checkpoint: {} ...\".format(resume_path))\n checkpoint = torch.load(resume_path)\n self.start_epoch = checkpoint['epoch'] + 1\n self.monitor_best = checkpoint['monitor_best']\n self.model.load_state_dict(checkpoint['state_dict'])\n self.optimizer.load_state_dict(checkpoint['optimizer'])\n # 将参数全部放入GPU\n if self.with_cuda:\n for state in self.optimizer.state.values():\n for k, v in state.items():\n if isinstance(v, torch.Tensor):\n state[k] = v.cuda(self.device)\n self.train_logger = checkpoint['logger']\n self.config = checkpoint['config']\n self.logger.info(\"Checkpoint '{}' (epoch {}) loaded\".format(resume_path, self.start_epoch))","def _resume_checkpoint(self, resume_path, model, optimizer):\n if not resume_path:\n return model, optimizer\n\n self.logger.info(f'Loading checkpoint: {resume_path}')\n checkpoint = torch.load(resume_path)\n model.load_state_dict(checkpoint['state_dict'])\n\n # load optimizer state from checkpoint only when optimizer type is not changed.\n if checkpoint['config']['optimizer']['type'] != self.config['optimizer']['type']:\n self.logger.warning(\"Warning: Optimizer type given in config file is different from \"\n \"that of checkpoint. Optimizer parameters not being resumed.\")\n else:\n optimizer.load_state_dict(checkpoint['optimizer'])\n\n self.logger.info(f'Checkpoint \"{resume_path}\" loaded')\n return model, optimizer","def resume(self):\n pass","def resume(self):\n pass","def resume(self):\n pass","def resume(self):\n\t\tpass","def restore(self, checkpoint):\n raise NotImplementedError","def resume_training(self, train_data, model_path, valid_data=None):\n restore_state = self.checkpointer.restore(model_path)\n loss_fn = self._get_loss_fn()\n self.train()\n self._train_model(\n train_data=train_data,\n loss_fn=loss_fn,\n valid_data=valid_data,\n restore_state=restore_state,\n )","def resume(cls, workdir):\n drover = cls._restore_drover(workdir)\n drover._continue()","def resume(model, optimizer, gpu, filepath='./saves/checkpoint.pth.tar'):\n assert isinstance(filepath, str)\n\n if gpu:\n f = torch.load(filepath)\n else:\n f = torch.load(filepath, map_location=lambda storage, loc: storage)\n epoch = f['epoch']\n losses = f['losses']\n seq_len = f['seq_len']\n\n model.load_state_dict(f['state_dict'])\n optimizer.load_state_dict(f['optimizer'])\n return model, optimizer, epoch, losses, seq_len","def _resume_from_checkpoint(model: tf.keras.Model,\n model_dir: str,\n train_steps: int) -> int:\n logging.info('Load from checkpoint is enabled.')\n latest_checkpoint = tf.train.latest_checkpoint(model_dir)\n logging.info('latest_checkpoint: %s', latest_checkpoint)\n if not latest_checkpoint:\n logging.info('No checkpoint detected.')\n return 0\n\n logging.info('Checkpoint file %s found and restoring from '\n 'checkpoint', latest_checkpoint)\n model.load_weights(latest_checkpoint)\n initial_epoch = model.optimizer.iterations // train_steps\n logging.info('Completed loading from checkpoint.')\n logging.info('Resuming from epoch %d', initial_epoch)\n return int(initial_epoch)","def restore_model(self, resume_iters):\n if self.resume_iters:\n checkpoint_dir = os.path.join(self.checkpoint_dir, self.model_dir)\n print('Loading the trained models from step {}...'.format(resume_iters))\n G_path = os.path.join(checkpoint_dir, '{}-G.ckpt'.format(resume_iters))\n self.G.load_state_dict(torch.load(G_path, map_location=lambda storage, loc: storage))","def resume(self, save_path: str, train_data: BaseDataManager,\n val_data: BaseDataManager = None,\n params: Parameters = None, **kwargs):\n return self.run(\n train_data=train_data,\n val_data=val_data,\n params=params,\n save_path=save_path,\n **kwargs)","def _restore_training_state(self, restore_state):\n self.load_state_dict(restore_state[\"model\"])\n self.optimizer.load_state_dict(restore_state[\"optimizer\"])\n self.lr_scheduler.load_state_dict(restore_state[\"lr_scheduler\"])\n start_iteration = restore_state[\"iteration\"] + 1\n if self.config[\"verbose\"]:\n print(f\"Restored checkpoint to iteration {start_iteration}.\")\n\n if restore_state[\"best_model_found\"]:\n # Update checkpointer with appropriate information about best model\n # Note that the best model found so far may not be the model in the\n # checkpoint that is currently being loaded.\n self.checkpointer.best_model_found = True\n self.checkpointer.best_iteration = restore_state[\"best_iteration\"]\n self.checkpointer.best_score = restore_state[\"best_score\"]\n if self.config[\"verbose\"]:\n print(\n f\"Updated checkpointer: \"\n f\"best_score={self.checkpointer.best_score:.3f}, \"\n f\"best_iteration={self.checkpointer.best_iteration}\"\n )\n return start_iteration","def resume(self):\n self._paused = False","def load_checkpoint(self):\n if self.params.resume_from is not None and os.path.exists(self.params.resume_from):\n try:\n LOG('Loading Checkpoint at %s' % self.params.resume_from)\n ckpt = torch.load(self.params.resume_from)\n self.epoch = ckpt['epoch']\n try:\n self.train_loss = ckpt['train_loss']\n self.val_loss = ckpt['val_loss']\n except:\n self.train_loss = []\n self.val_loss = []\n self.network.load_state_dict(ckpt['state_dict'])\n self.opt.load_state_dict(ckpt['optimizer'])\n LOG('Checkpoint Loaded!')\n LOG('Current Epoch: %d' % self.epoch)\n self.ckpt_flag = True\n except:\n WARNING('Cannot load checkpoint from %s. Start loading pre-trained model......' % self.params.resume_from)\n else:\n WARNING('Checkpoint do not exists. Start loading pre-trained model......')","def restore_model(self, resume_iters):\n print('Loading the trained models from step {}...'.format(resume_iters))\n G_path = os.path.join(self.model_save_dir, '{}-G.ckpt'.format(resume_iters))\n self.G.load_state_dict(torch.load(G_path, map_location=lambda storage, loc: storage))","def resume(self):\n\n self.shm_command.write({'cmd': 'resume', 'data': {}})","def resume(self):\n self.is_paused = False","def resume(self):\n raise NotImplementedError()","def resume(self):\n raise NotImplementedError()","def resume(self):\n self.check_state('resume')\n try:\n self.newportxps.resume_all()\n except Exception:\n pass","def restore(self, checkpoint_path: str):\r\n raise NotImplementedError","def restore(self, checkpoint_data):\n\n self.iteration = checkpoint_data['iteration']\n self.action_requests = checkpoint_data['action_requests']\n\n self.experience = deque()\n for episode in checkpoint_data['experience']:\n ep = []\n for transition in episode:\n ep.append(tuple(transition))\n\n self.experience.append(ep)","def checkpoint():","def restore(self):\n\n self.brain.restore_checkpoint()","def restore_model(self, resume_iters):\n print('Loading the trained models from step {}...'.format(resume_iters))\n G_path = os.path.join(self.model_save_dir, '{}-G.ckpt'.format(resume_iters))\n D_path = os.path.join(self.model_save_dir, '{}-D.ckpt'.format(resume_iters))\n self.G.load_state_dict(torch.load(G_path, map_location=lambda storage, loc: storage))\n self.D.load_state_dict(torch.load(D_path, map_location=lambda storage, loc: storage))","def resume_workflow(self):\n self._gdb_interface.resume_workflow()","def _restore(self):\n\n output_path = self.output_path + '/checkpoints/'\n checkpoint = tf.train.latest_checkpoint(output_path)\n if checkpoint:\n self.saver.restore(self.session, save_path=checkpoint)\n restored_step = int(checkpoint.split('-')[-1]) # Robust enough?\n return restored_step\n logging.info('Starting training from scratch.')\n return 0","def resume(self):\n\t\treturn Job(SDK.PrlVm_Resume(self.handle)[0])","def resume(self):\n self.Game=Game(self.Display)\n try:\n pickle_in=open('.\\\\2048.txt','rb')\n except:\n return\n a=pickle.load(pickle_in)\n self.Game.GameBoard.restore(a)\n pickle_in.close()","def resume_training(args: argparse.Namespace, hp: HParams, tier: int, model: Tier,\n optimizer: torch.optim.Optimizer, logger: logging.Logger) \\\n -> Tuple[Tier, torch.optim.Optimizer]:\n if not Path(args.checkpoint_path).exists():\n logger.error(f\"Path for resuming training {args.checkpoint_path} does not exist.\")\n raise Exception(f\"Path for resuming training {args.checkpoint_path} does not exist.\")\n\n logger.info(f\"Resuming training with weights from: {args.checkpoint_path}\")\n checkpoint = torch.load(args.checkpoint_path)\n hp_chkpt = checkpoint[\"hp\"]\n\n # Check if current hyperparameters and the ones from saved model are the same\n if hp_chkpt.audio != hp.audio:\n logger.warning(\"New params for audio are different from checkpoint. \"\n \"It will use new params.\")\n\n if hp_chkpt.network != hp.network:\n logger.error(\"New params for network structure are different from checkpoint.\")\n raise Exception(\"New params for network structure are different from checkpoint.\")\n\n if checkpoint[\"tier_idx\"] != tier:\n logger.error(\n f\"New tier to train ({tier}) is different from checkpoint ({checkpoint['tier']}).\")\n raise Exception(\n f\"New tier to train ({tier}) is different from checkpoint ({checkpoint['tier']}).\")\n\n if hp_chkpt.data != hp.data:\n logger.warning(\"New params for dataset are different from checkpoint. \"\n \"It will use new params.\")\n\n if hp_chkpt.training != hp.training:\n logger.warning(\"New params for training are different from checkpoint. \"\n \"It will use new params.\")\n\n # epoch_chkpt = checkpoint[\"epoch\"]\n # iterations_chkpt = checkpoint[\"iterations\"]\n # total_iterations_chkpt = checkpoint[\"total_iterations\"]\n model.load_state_dict(checkpoint[\"tier\"])\n optimizer.load_state_dict(checkpoint[\"optimizer\"])\n\n return model, optimizer","def resume(self, tag=\"current\"):\n\n if not self.is_resumable(tag):\n logging.warning(\"This exeriment is not resumable!\")\n self.force_restart(tag)\n\n else:\n logging.info(\"Loading the experiment from {}\".format(self._dir_name))\n\n save_dir = os.path.join(self._dir_name, tag)\n\n if self._model is not None:\n self._model.load(save_dir)\n\n if self._config is not None:\n file_name = os.path.join(save_dir, \"config.p\")\n self._config.load(file_name)\n\n if self._logger is not None:\n file_name = os.path.join(save_dir, \"logger\")\n self._logger.load(file_name)\n\n if self._train_statistics is not None:\n file_name = os.path.join(save_dir, \"train_statistics.p\")\n self._train_statistics.load(file_name)\n\n if self._data_iterator is not None:\n file_name = os.path.join(save_dir, \"data_iterator.p\")\n self._data_iterator.load(file_name)","def checkpoint(self):\n self.logger.info('Checkpointing Sampler')\n with open(self.resume_file, \"wb\") as f:\n pickle.dump(self, f)","def resume_workflow(self):\n with self._driver.session() as session:\n session.write_transaction(tx.set_workflow_state, state='RESUME')","def restore(self, checkpoint_path):\n start_time = time.time()\n latest_checkpoint = train_util.get_latest_chekpoint(checkpoint_path)\n if latest_checkpoint is not None:\n checkpoint = tf.train.Checkpoint(model=self)\n checkpoint.restore(latest_checkpoint).expect_partial()\n logging.info('Loaded checkpoint %s', latest_checkpoint)\n logging.info('Loading model took %.1f seconds', time.time() - start_time)\n else:\n logging.info('Could not find checkpoint to load at %s, skipping.',\n checkpoint_path)","def restore_model(self, resume_iters):\n \n print('Loading the trained models from step {}...'.format(resume_iters))\n encoder_path = os.path.join(self.model_save_dir, '{}-encoder.ckpt'.format(resume_iters))\n decoder_path = os.path.join(self.model_save_dir, '{}-decoder.ckpt'.format(resume_iters))\n D_path = os.path.join(self.model_save_dir, '{}-D.ckpt'.format(resume_iters))\n self.encoder.load_state_dict(torch.load(encoder_path, map_location=lambda storage, loc: storage))\n self.decoder.load_state_dict(torch.load(decoder_path, map_location=lambda storage, loc: storage))\n self.D.load_state_dict(torch.load(D_path, map_location=lambda storage, loc: storage))","def restore(self):\n # For multi-worker training, it should not restore a model in certain\n # worker setting (e.g. non-chief worker in ParameterServerStrategy).\n # pylint: disable=protected-access\n if self._model._in_multi_worker_mode() and not multi_worker_util.should_load_checkpoint():\n return\n self.read_checkpoint_manager.restore_or_initialize()","def on_resume(self):\r\n store = get_store()\r\n self.sm.current = str(store.get('pause')[\"value\"])","def __resume_log(self, log_tag, model):\r\n if log_tag == self.LOG_TAG_LAST:\r\n start_checkpoint_path = self.checkpoint_path_last\r\n elif log_tag == self.LOG_TAG_BEST_EER:\r\n start_checkpoint_path = self.checkpoint_path_best_eer\r\n else:\r\n raise Exception('wrong log_tag')\r\n errmsg = str(start_checkpoint_path) + ' should exists as dir'\r\n assert os.path.isdir(start_checkpoint_path), errmsg\r\n self.checkpoints_info_load()\r\n start_ep = self.checkpoints_info[log_tag]['ep']\r\n start_b_gl = self.checkpoints_info[log_tag]['batch']\r\n self.__resume_custom(start_checkpoint_path, start_ep, start_b_gl, model=model)","def restore(self, sess: tf.Session) -> None:\n super().restore(sess)\n BaseModel._restore_checkpoint(self.pretrained_saver, sess, path=FLAGS.pretrained_checkpoint)","def __resume_custom(self, start_checkpoint_path=None, start_ep=0, start_b_gl=0, eval_val_before_trn: bool = True, model: tf.Module = None):\r\n self.__init_model(start_checkpoint_path, model)\r\n # TODO clear extra steps on plots\r\n assert is_any_int(start_ep)\r\n assert start_ep >= 0\r\n assert is_any_int(start_b_gl)\r\n assert start_b_gl >= 0\r\n self.ep = start_ep\r\n self.ep_last = self.ep - int(eval_val_before_trn)\r\n self.b_gl = start_b_gl","def restore(self):\n if self._restored_model:\n return\n with self.eval_graph.graph.as_default():\n last_checkpoint = self._find_last_checkpoint()\n # TODO(rbharath): Is setting train=False right here?\n saver = tf.train.Saver()\n saver.restore(self._get_shared_session(train=False), last_checkpoint)\n self._restored_model = True","def resume(self) -> int:\n last_epoch = -1\n latest_file_path = self._fetch_latest_checkpt()\n if latest_file_path and os.path.exists(latest_file_path):\n self.load_params(latest_file_path)\n _, self.checkpt_dir, filename = latest_file_path.rsplit(os.path.sep, 2)\n # fetch the last epoch from the filename\n last_epoch = int(filename.split(\"_\", 1)[0])\n return last_epoch + 1","def resume(self):\n if self.paused:\n pause_time = time.time() - self.paused_time\n self.start_time = self.start_time + pause_time\n self.paused = False","def resume(self) -> None:\n self._running.set()","def _restore_checkpoint(self, checkpoint_path):\n self.logger.info(\"Loading checkpoint: {} ...\".format(checkpoint_path))\n checkpoint = torch.load(checkpoint_path)\n pretrained_dict = checkpoint['state_dict'] # 预训练模型的state_dict\n model_dict = self.model.state_dict() # 当前用来训练的模型的state_dict\n \n if pretrained_dict.keys() != model_dict.keys(): # 需要进行参数的适配\n print('Parameters are inconsistant, adapting model parameters ...')\n # 在合并前(update),需要去除pretrained_dict一些不需要的参数\n # 只含有识别分支的预训练模型参数字典中键'0', '1'对应全模型参数字典中键'2', '3'\n pretrained_dict['2'] = transfer_state_dict(pretrained_dict['0'], model_dict['2'])\n pretrained_dict['3'] = transfer_state_dict(pretrained_dict['1'], model_dict['3'])\n del pretrained_dict['0'] # 把原本预训练模型中的键值对删掉，以免错误地更新当前模型中的键值对\n del pretrained_dict['1']\n model_dict.update(pretrained_dict) # 更新(合并)模型的参数\n self.model.load_state_dict(model_dict)\n else:\n print('Parameters are consistant, load state dict directly ...')\n self.model.load_state_dict(checkpoint['state_dict'])\n # self.optimizer.load_state_dict(checkpoint['optimizer'])\n # if self.with_cuda:\n # for state in self.optimizer.state.values():\n # for k, v in state.items():\n # if isinstance(v, torch.Tensor):\n # state[k] = v.cuda(self.device)","def resume(self, **kwargs):\r\n self.enc_seen = kwargs['enc_seen']\r\n # TODO: say why the game ended, via constants file probably\r","def resume(self, name=None):\n raise NotImplementedError","def resume():\n if checkIfAllFixed():\n disableTaskControls()\n globs.ERREVENT.set()\n globs.DISP_SCREEN.updateScreen(globs.DISP_SCREEN.progress)\n else:\n globs.CONTROLLER.taskMonitor.errorBox.append(\"WARNING! Fix All Errors Before Resuming\")\n globs.CONTROLLER.taskMonitor.errorBox.append(\"\")","def restore(self,\n sess,\n ckpt_file,\n ckpt_type):\n if ckpt_file is None:\n raise FileNotFoundError(\"checkpoint file doesn't exist\")\n \n if ckpt_type == \"debug\":\n self.ckpt_debug_saver.restore(sess, ckpt_file)\n elif ckpt_type == \"epoch\":\n self.ckpt_epoch_saver.restore(sess, ckpt_file)\n else:\n raise ValueError(\"unsupported checkpoint type {0}\".format(ckpt_type))","def restore_resume_state(self, key):\n new_state = self.statedb.get(key)\n if new_state is None:\n return False\n if \"_rev\" in self.value:\n backup_key = self.backup_resume_state(self.value)\n if backup_key is None:\n return False\n log.info(\"restoring iteration state: %s\", new_state)\n self.itr._save_state_json(new_state)\n return True","def load_checkpoint(self, session, model_dir):\n assert self.params.cp_load == True, (\"cp_load must be set to true to load a checkpoint\")\n self.loader.restore(session, model_dir)","def resume(vm='', env=''):\n local( main_dir + '/vagrant/bin/vm.sh resume ' + str(vm) + ' ' + str(env) )","def load_checkpoint(args, trainer, epoch_itr):\n os.makedirs(os.path.join(args.save_dir, 'checkpoints'), exist_ok=True)\n checkpoint_path = os.path.join(args.save_dir, 'checkpoints', args.restore_file)\n if os.path.isfile(checkpoint_path):\n extra_state = trainer.load_checkpoint(checkpoint_path)\n if extra_state is not None:\n # replay train iterator to match checkpoint\n epoch_itr.load_state_dict(extra_state['train_iterator'])\n\n print('| loaded checkpoint {} (epoch {} @ {} updates)'.format(\n checkpoint_path, epoch_itr.epoch, trainer.get_num_updates()))\n\n trainer.lr_step(epoch_itr.epoch)\n trainer.lr_step_update(trainer.get_num_updates())\n if 'best' in extra_state:\n save_checkpoint.best = extra_state['best']","def resume(self):\n self.background_scheduler.resume()","def checkpoint(self):\n save()","def LoadProgramState(self, restored_checkpoint_path=None, sess=None):\n pass","async def resume(self):\n await self.send({\n \"op\": 6,\n \"d\" : {\n \"token\" : self.client.token,\n \"session_id\": self.session_id,\n \"seq\" : self.last_event_id\n }\n })","def restore_checkpoint(model, checkpoint_dir, cuda=False, force=False, pretrain=False):\n try:\n cp_files = [\n file_\n for file_ in os.listdir(checkpoint_dir)\n if file_.startswith(\"epoch=\") and file_.endswith(\".checkpoint.pth.tar\")\n ]\n except FileNotFoundError:\n cp_files = None\n os.makedirs(checkpoint_dir)\n if not cp_files:\n print(\"No saved model parameters found\")\n if force:\n raise Exception(\"Checkpoint not found\")\n else:\n return model, 0, []\n\n # Find latest epoch\n for i in itertools.count(1):\n if \"epoch={}.checkpoint.pth.tar\".format(i) in cp_files:\n epoch = i\n else:\n break\n\n if not force:\n print(\n \"Which epoch to load from? Choose in range [0, {}].\".format(epoch),\n \"Enter 0 to train from scratch.\",\n )\n print(\">> \", end=\"\")\n inp_epoch = int(input())\n if inp_epoch not in range(epoch + 1):\n raise Exception(\"Invalid epoch number\")\n if inp_epoch == 0:\n print(\"Checkpoint not loaded\")\n clear_checkpoint(checkpoint_dir)\n return model, 0, []\n else:\n print(\"Which epoch to load from? Choose in range [1, {}].\".format(epoch))\n inp_epoch = int(input())\n if inp_epoch not in range(1, epoch + 1):\n raise Exception(\"Invalid epoch number\")\n\n filename = os.path.join(\n checkpoint_dir, \"epoch={}.checkpoint.pth.tar\".format(inp_epoch)\n )\n\n print(\"Loading from checkpoint {}?\".format(filename))\n\n if cuda:\n checkpoint = torch.load(filename)\n else:\n # Load GPU model on CPU\n checkpoint = torch.load(filename, map_location=lambda storage, loc: storage)\n\n try:\n start_epoch = checkpoint[\"epoch\"]\n stats = checkpoint[\"stats\"]\n if pretrain:\n model.load_state_dict(checkpoint[\"state_dict\"], strict=False)\n else:\n model.load_state_dict(checkpoint[\"state_dict\"])\n print(\n \"=> Successfully restored checkpoint (trained for {} epochs)\".format(\n checkpoint[\"epoch\"]\n )\n )\n except:\n print(\"=> Checkpoint not successfully restored\")\n raise\n\n return model, inp_epoch, stats","def load_checkpoints(args, model): \n print('Loading the model checkpoints from iter {}...'.format(args.resume_iter))\n checkpoint_path = os.path.join(config.checkpoint_path, args.model_type)\n\n gen_g_path = os.path.join(checkpoint_path, '{}-Gen_g.ckpt'.format(args.resume_iter))\n gen_f_path = os.path.join(checkpoint_path, '{}-Gen_f.ckpt'.format(args.resume_iter))\n model.gen_g.load_state_dict(torch.load(gen_g_path, map_location=lambda storage, loc: storage))\n model.gen_f.load_state_dict(torch.load(gen_f_path, map_location=lambda storage, loc: storage))\n\n if args.train:\n dis_c_path = os.path.join(checkpoint_path, '{}-Dis_c.ckpt'.format(args.resume_iter))\n dis_t_path = os.path.join(checkpoint_path, '{}-Dis_t.ckpt'.format(args.resume_iter))\n model.dis_c.load_state_dict(torch.load(dis_c_path, map_location=lambda storage, loc: storage))\n model.dis_t.load_state_dict(torch.load(dis_t_path, map_location=lambda storage, loc: storage))","def resume(cls, resume_file, manager, model):\n with open(resume_file, \"rb\") as f:\n obj = pickle.load(f)\n obj.model = model\n obj.manager = manager\n obj.logLmin = obj.manager.logLmin\n obj.logLmax = obj.manager.logLmax\n obj.logger = logging.getLogger(\"cpnest.sample.Sampler\")\n obj.producer_pipe , obj.thread_id = obj.manager.connect_producer()\n obj.logger.info('Resuming Sampler from ' + resume_file)\n obj.last_checkpoint_time = time.time()\n return obj","def _restore(self, checkpoint):\n checkpoint_path = os.path.join(checkpoint, \"model_weights\")\n self.model.load_weights(checkpoint_path)","def on_resume(self, userdata):\n pass","def resume():\n cache.set('is_paused', 'False')\n socketio.emit('resume', {})","async def resume_behaviors(self) -> None:","def resumeJob(_id, client):\n return tryAgainJob(_id)","def restore_fn(flags):\n # if flags.tf_initial_checkpoint is None:\n # return None\n\n # Warn the user if a checkpoint exists in the train_dir. Then ignore.\n # if tf.train.latest_checkpoint(flags.train_dir):\n # tf.logging.info(\n # 'Ignoring --checkpoint_path because a checkpoint already exists in %s'\n # % flags.train_dir)\n # return None\n\n exclusions = []\n if flags.checkpoint_exclude_scopes:\n exclusions = [scope.strip()\n for scope in flags.checkpoint_exclude_scopes.split(',')]\n\n variables_to_restore = []\n for var in slim.get_model_variables():\n excluded = False\n for exclusion in exclusions:\n if var.op.name.startswith(exclusion):\n excluded = True\n break\n if not excluded:\n variables_to_restore.append(var)\n # Change model scope if necessary.\n if flags.checkpoint_model_scope is not None:\n variables_to_restore = \\\n {var.op.name.replace(flags.model_name,\n flags.checkpoint_model_scope): var\n for var in variables_to_restore}\n\n tf.compat.v1.logging.info('++++++++++++++++++++')\n tf.compat.v1.logging.info('Fine-tuning from %s. Ignoring missing vars: %s' %\n (flags.pre_trained_checkpoint, flags.ignore_missing_vars))\n slim.assign_from_checkpoint_fn(flags.pre_trained_checkpoint,\n variables_to_restore,\n ignore_missing_vars=flags.ignore_missing_vars)","def resume(instance):\n if instance.state == STOPPED:\n return\n\n Queue.objects.add(function=\"resume\", instance=instance)","def load_checkpoint(self, checkpoint_path, continue_from_epoch=True):\n print(\"Loading checkpoint: {}\".format(checkpoint_path))\n state = torch.load(checkpoint_path)\n self.model.load_state_dict(state['state_dict'])\n self.optimizer.load_state_dict(state['optim_dict'])\n\n if continue_from_epoch:\n self.epoch = state['epoch']","def reload_checkpoint(self):\n checkpoint_path = os.path.join(self.params.dump_path, 'checkpoint.pth')\n if not os.path.isfile(checkpoint_path):\n if self.params.reload_checkpoint == '':\n return\n else:\n checkpoint_path = self.params.reload_checkpoint\n assert os.path.isfile(checkpoint_path)\n logger.warning(\"Reloading checkpoint from %s ...\" % checkpoint_path)\n data = torch.load(checkpoint_path, map_location='cpu')\n\n # reload model parameters\n for name in self.MODEL_NAMES:\n getattr(self, name).load_state_dict(data[name])\n\n # reload optimizers\n for name in self.optimizers.keys():\n if False: # AMP checkpoint reloading is buggy, we cannot do that - TODO: fix - https://github.com/NVIDIA/apex/issues/250\n logger.warning(\"Reloading checkpoint optimizer %s ...\" % name)\n else: # instead, we only reload current iterations / learning rates\n logger.warning(\"Not reloading checkpoint optimizer %s.\" % name)\n for group_id, param_group in enumerate(self.optimizers[name].param_groups):\n if 'num_updates' not in param_group:\n logger.warning(\"No 'num_updates' for optimizer %s.\" % name)\n continue\n logger.warning(\"Reloading 'num_updates' and 'lr' for optimizer %s.\" % name)\n param_group['num_updates'] = data['%s_optimizer' % name]['param_groups'][group_id]['num_updates']\n param_group['lr'] = self.optimizers[name].get_lr_for_step(param_group['num_updates'])\n\n # reload main metrics\n self.epoch = data['epoch'] + 1\n self.n_total_iter = data['n_total_iter']\n self.best_metrics = data['best_metrics']\n self.best_stopping_criterion = data['best_stopping_criterion']\n logger.warning(\"Checkpoint reloaded. Resuming at epoch %i / iteration %i ...\" % (self.epoch, self.n_total_iter))","def resume(self, instance, callback):\n self._start(instance['id'])","def resume_model(filename, args):\n checkpoint = torch.load(filename)\n clf = CNN()\n clf.load_state_dict(checkpoint['clf'])\n \n if args.cuda:\n clf = clf.cuda()\n\n opt = torch.optim.Adam(clf.parameters(), lr=1e-3)\n opt.load_state_dict(checkpoint['opt'])\n\n return clf, opt","def resume(self, job_id):\n job = Job.get_job_by_id(job_id)\n self.access_handler.check_resume(job)\n self.master.resume_job(job)","def on_resume_toggled(self, _):\n if not self.resume.get_active():\n self._previous_force_recheck = self.force_recheck.get_active()\n self.force_recheck.set_sensitive(False)\n self.force_recheck.set_active(True)\n else:\n self.force_recheck.set_active(self._previous_force_recheck)\n self.force_recheck.set_sensitive(True)","def on_resume(self, event):\n self.pre_check(event)\n if self.get_player(event.guild.id).paused:\n self.get_player(event.guild.id).resume()","def before_train(self, runner) -> None:\n if runner._resume:\n for action_epoch, recipe in self.schedule.items():\n if action_epoch >= runner.epoch + 1:\n break\n self._do_switch(runner, recipe,\n f' (resume recipe of epoch {action_epoch})')","def restore(self, PATH):\n self._saver.restore(self._sess, PATH)","def test_resume_restore(self):\n if not self.backupset.resume:\n self.fail(\"Resume must be True for this test\")\n gen = BlobGenerator(\"ent-backup\", \"ent-backup-\", self.value_size, end=self.num_items)\n self._load_all_buckets(self.master, gen, \"create\", 0)\n self.backup_create()\n self.backup_cluster_validate()\n self.log.info(\"Start to flush bucket\")\n self._all_buckets_flush()\n restore_result = self.cluster.async_restore_cluster(backupset=self.backupset,\n objstore_provider=self.objstore_provider,\n no_progress_bar=self.no_progress_bar,\n cli_command_location=self.cli_command_location,\n cb_version=self.cb_version,\n force_updates=self.backupset.force_updates,\n no_resume=True)\n state = \"\"\n while state not in (\"FINISHED\", \"EXECUTING\"):\n state = restore_result.state\n self._kill_cbbackupmgr()\n self.assertFalse(self._check_output(\"success\", restore_result.result()))\n self.backup_restore_validate(compare_uuid=False, seqno_compare_function=\">=\")","def restore(self, ds_crossval):\n t = datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n print(\"[INFO] {} - Restoring from latest checkpoint ...\".format(t))\n self.ckpt_handle.restore(\n tf.train.latest_checkpoint(self.ckpt_dir)).expect_partial()\n self._eval_step(ds_crossval.data.values,\n ds_crossval.labels_onehot.values)\n self.best_accuracy = float(self.eval_accuracy.result())\n template = \"{} model restored after {} epoch(s) - \" \\\n \"Cross-vall accuracy = {:.9f}\"\n print(template.format(self.name, int(self.ckpt_handle.step),\n self.best_accuracy))","def resume(self):\n\n Console.info(\"Resuming session...\")\n\n for project in self.__projects:\n project.resume()","def checkpoint(self, epoch: int):\n if self.exp.scheduler_stepper is not None:\n torch.save(\n {\n \"model_state_dict\": self.exp.model.state_dict(),\n \"optimizer_state_dict\": self.exp.optimizer.state_dict(),\n \"scheduler_state_dict\": self.exp.scheduler_stepper.scheduler.state_dict(),\n \"Epoch\": epoch,\n },\n self.exp.path,\n )\n else:\n torch.save(\n {\n \"model_state_dict\": self.exp.model.state_dict(),\n \"optimizer_state_dict\": self.exp.optimizer.state_dict(),\n \"Epoch\": epoch,\n },\n self.exp.path,\n )","def resume(cls):\n\n cls._set_mode_running()\n TimeDisplay.start_time()\n for callback in cls.resume_callback:\n callback()","def load(loadname, checkpoint=None):\n ckpt_dir = \"./models/tf_ckpt_\" + loadname + \"/\"\n if checkpoint is not None:\n status = checkpoint.restore(tf.train.latest_checkpoint(ckpt_dir))\n status.assert_consumed()\n print(\"Loaded checkpoint\")\n else:\n print(\"Not Loading any checkpoint\")\n print(\"Starting training from initial configuration\")","def restore_checkpoint(self, checkpoint_id, name, path=''):\n\n\t\tself.log.debug(\"restoring Notebook %s from checkpoint %s\", name, checkpoint_id)\n\t\tnb_path = self._get_os_path(name, path)\n\t\tcp_path = self.get_checkpoint_path(checkpoint_id, name, path)\n\n\t\tif not key_exists(self.bucket, cp_path):\n\t\t\tself.log.debug(\"checkpoint file does not exist: %s\", cp_path)\n\t\t\traise web.HTTPError(404,\n\t\t\t\tu'Notebook checkpoint does not exist: %s-%s' % (name, checkpoint_id)\n\t\t\t)\n\t\t# ensure notebook is readable (never restore from an unreadable notebook)\n\t\tkey = self.bucket.get_key(cp_path)\n\t\tnb = current.reads(key.get_contents_as_string(), u'json')\n\t\tself._copy(cp_path, nb_path)\n\t\tself.log.debug(\"copying %s -> %s\", cp_path, nb_path)","def warm_start_training(self, sess): \n ckpt = tf.train.latest_checkpoint(self.train_dir)\n if ckpt:\n # the global_step will restore sa well\n saver = tf.train.Saver(tf.global_variables(), max_to_keep=100)\n saver.restore(sess, ckpt)\n print('restore from the checkpoint{0}'.format(ckpt))\n return\n \n if self.checkpoint_path is None:\n return None\n \n exclusions = []\n if self.checkpoint_exclude_scopes:\n exclusions = [scope.strip()\n for scope in self.checkpoint_exclude_scopes.split(',')]\n # TODO(sguada) variables.filter_variables()\n variables_to_restore = []\n all_variables = slim.get_model_variables()\n if tf.gfile.IsDirectory(self.checkpoint_path):\n global_step = slim.get_or_create_global_step()\n all_variables.append(global_step)\n checkpoint_path = tf.train.latest_checkpoint(self.checkpoint_path)\n else:\n checkpoint_path = self.checkpoint_path\n \n for var in all_variables:\n excluded = False\n \n for exclusion in exclusions:\n if var.op.name.startswith(exclusion):\n excluded = True\n break\n if not excluded:\n variables_to_restore.append(var)\n \n# tf.logging.info('Fine-tuning from %s' % checkpoint_path)\n \n slim.assign_from_checkpoint_fn(\n checkpoint_path,\n variables_to_restore)(sess)\n return","def restore_session(self, dir_model):\n self.logger.info(\"Reloading the latest trained model...\")\n self.saver.restore(self.sess, dir_model)","def resume(self):\n raise TaskError(\"Task %s: subclass should override resume() method!\" % (\n self))","def restore(self, sess, path=None, var_list=None):\n\n saver = tf.train.Saver(var_list)\n if path is None:\n path = tf.train.latest_checkpoint(os.path.dirname(self.config.CHECKPOINTS_PATH))\n saver.restore(sess, path)\n print(\"model restored from %s\" % path)","def restore_session(self, dir_model):\r\n self.logger.info(\"Reloading the latest trained model...\")\r\n self.saver.restore(self.sess, tf.train.latest_checkpoint(dir_model))","def restore_session(saver, sess, model_dir):\n checkpoint = tf.train.get_checkpoint_state(model_dir)\n if checkpoint and checkpoint.model_checkpoint_path:\n saver.restore(sess, checkpoint.model_checkpoint_path)\n print(\"checkpoint loaded:\", checkpoint.model_checkpoint_path)\n tokens = checkpoint.model_checkpoint_path.split(\"-\")\n # set global step\n global_t = int(tokens[2])\n n_episode = int(tokens[1])\n print(\">>> global step set: \", global_t)\n else:\n print(\"Could not find old checkpoint\")\n global_t = 0\n n_episode = 0\n return global_t, n_episode","def resume(self):\n self._is_paused = False\n for lobby in self._lobby_list:\n lobby.resume()","def restore_session(self, dir_model):\n self.logger.info(\"Reloading the latest trained model...\")\n self.saver.restore(self.session, dir_model)","def restore_state(model, optimizer, latest_snapshot):\n\n checkpoint = torch.load(latest_snapshot,\n map_location=lambda storage, loc: storage.cuda(args[\"local_rank\"]))\n\n model.load_state_dict(checkpoint['state_dict'])\n optimizer.load_state_dict(checkpoint['optimizer'])\n return checkpoint['seen_images'], checkpoint['epochs']"],"string":"[\n \"def resume(self, checkpoint):\\n model_dict = paddle.load(checkpoint)\\n self.model.set_state_dict(model_dict)\",\n \"def _resume_checkpoint(self, resume_path):\\n self.logger.info(\\\"Loading checkpoint: {} ...\\\".format(resume_path))\\n checkpoint = torch.load(resume_path)\\n self.start_epoch = checkpoint['epoch'] + 1\\n self.monitor_best = checkpoint['monitor_best']\\n self.model.load_state_dict(checkpoint['state_dict'])\\n self.optimizer.load_state_dict(checkpoint['optimizer'])\\n self.train_logger = checkpoint['logger']\\n self.logger.info(\\\"Checkpoint '{}' (epoch {}) loaded\\\".format(resume_path, self.start_epoch))\",\n \"def _resume_checkpoint(self, resume_path):\\n resume_path = str(resume_path)\\n self.logger.info(\\\"Loading checkpoint: {} ...\\\".format(resume_path))\\n checkpoint = torch.load(resume_path)\\n self.start_epoch = checkpoint['epoch'] + 1\\n\\n # load architecture params from checkpoint.\\n if checkpoint['config']['model'] != self.config['model']:\\n self.logger.warning(\\\"Warning: Architecture configuration given in config file is different from that of \\\"\\n \\\"checkpoint. This may yield an exception while state_dict is being loaded.\\\")\\n self.model.load_state_dict(checkpoint['state_dict'])\\n\\n # load optimizer state from checkpoint only when optimizer type is not changed.\\n if checkpoint['config']['trainer']['optimizer']['type'] != self.config['trainer']['optimizer']['type']:\\n self.logger.warning(\\\"Warning: Optimizer type given in config file is different from that of checkpoint. \\\"\\n \\\"Optimizer parameters not being resumed.\\\")\\n else:\\n self.optimizer.load_state_dict(checkpoint['optimizer'])\\n\\n self.logger.info(\\\"Checkpoint loaded. Resume from epoch {}\\\".format(self.start_epoch))\",\n \"def _resume_checkpoint(self, resume_path):\\n self.logger.info(\\\"Loading checkpoint: {} ...\\\".format(resume_path))\\n checkpoint = torch.load(resume_path)\\n self.start_epoch = checkpoint['epoch'] + 1\\n self.monitor_best = checkpoint['monitor_best']\\n self.model.load_state_dict(checkpoint['state_dict'])\\n self.optimizer.load_state_dict(checkpoint['optimizer'])\\n if self.with_cuda:\\n for state in self.optimizer.state.values():\\n for k, v in state.items():\\n if isinstance(v, torch.Tensor):\\n state[k] = v.cuda(torch.device('cuda'))\\n self.train_logger = checkpoint['logger']\\n #self.config = checkpoint['config']\\n self.logger.info(\\\"Checkpoint '{}' (epoch {}) loaded\\\".format(resume_path, self.start_epoch))\",\n \"def _resume(self):\\n\\n if self.resume_file is None:\\n return None\\n assert os.path.isfile(self.resume_file)\\n logger.info(f'=> loading checkpoint {self.resume_file}')\\n checkpoint = torch.load(self.resume_file)\\n self.cur_epoch = checkpoint['epoch']\\n self.model.load_state_dict(checkpoint['state_dict'])\\n self.optimizer.load_state_dict(checkpoint['optimizer'])\\n self.scheduler.load_state_dict(checkpoint['scheduler'])\\n self.best_rho = checkpoint['best_rho']\\n self.best_nmse = checkpoint['best_nmse']\\n self.cur_epoch += 1 # start from the next epoch\\n\\n logger.info(f'=> successfully loaded checkpoint {self.resume_file} '\\n f'from epoch {checkpoint[\\\"epoch\\\"]}.\\\\n')\",\n \"def resume_model(self, resume_path):\\n if resume_path:\\n resume_path = f'{self.model_dir}/{resume_path}.pth.tar'\\n if os.path.isfile(resume_path):\\n print(f\\\"=> loading checkpoint '{resume_path}'\\\")\\n checkpoint = torch.load(resume_path, map_location=self.device)\\n self.best_acc = checkpoint['best_acc']\\n self.model.load_state_dict(checkpoint['state_dict'])\\n print(f\\\"=> loaded checkpoint '{resume_path}' (Round {checkpoint['rnd']})\\\")\\n del checkpoint\\n else:\\n print(f\\\"=> no checkpoint found at '{resume_path}'\\\")\",\n \"def _resume_checkpoint(self, resume_path):\\n self.logger.info(\\\"Loading checkpoint: {} ...\\\".format(resume_path))\\n checkpoint = torch.load(resume_path)\\n self.start_epoch = checkpoint['epoch'] + 1\\n self.monitor_best = checkpoint['monitor_best']\\n self.model.load_state_dict(checkpoint['state_dict'])\\n self.optimizer.load_state_dict(checkpoint['optimizer'])\\n # 将参数全部放入GPU\\n if self.with_cuda:\\n for state in self.optimizer.state.values():\\n for k, v in state.items():\\n if isinstance(v, torch.Tensor):\\n state[k] = v.cuda(self.device)\\n self.train_logger = checkpoint['logger']\\n self.config = checkpoint['config']\\n self.logger.info(\\\"Checkpoint '{}' (epoch {}) loaded\\\".format(resume_path, self.start_epoch))\",\n \"def _resume_checkpoint(self, resume_path, model, optimizer):\\n if not resume_path:\\n return model, optimizer\\n\\n self.logger.info(f'Loading checkpoint: {resume_path}')\\n checkpoint = torch.load(resume_path)\\n model.load_state_dict(checkpoint['state_dict'])\\n\\n # load optimizer state from checkpoint only when optimizer type is not changed.\\n if checkpoint['config']['optimizer']['type'] != self.config['optimizer']['type']:\\n self.logger.warning(\\\"Warning: Optimizer type given in config file is different from \\\"\\n \\\"that of checkpoint. Optimizer parameters not being resumed.\\\")\\n else:\\n optimizer.load_state_dict(checkpoint['optimizer'])\\n\\n self.logger.info(f'Checkpoint \\\"{resume_path}\\\" loaded')\\n return model, optimizer\",\n \"def resume(self):\\n pass\",\n \"def resume(self):\\n pass\",\n \"def resume(self):\\n pass\",\n \"def resume(self):\\n\\t\\tpass\",\n \"def restore(self, checkpoint):\\n raise NotImplementedError\",\n \"def resume_training(self, train_data, model_path, valid_data=None):\\n restore_state = self.checkpointer.restore(model_path)\\n loss_fn = self._get_loss_fn()\\n self.train()\\n self._train_model(\\n train_data=train_data,\\n loss_fn=loss_fn,\\n valid_data=valid_data,\\n restore_state=restore_state,\\n )\",\n \"def resume(cls, workdir):\\n drover = cls._restore_drover(workdir)\\n drover._continue()\",\n \"def resume(model, optimizer, gpu, filepath='./saves/checkpoint.pth.tar'):\\n assert isinstance(filepath, str)\\n\\n if gpu:\\n f = torch.load(filepath)\\n else:\\n f = torch.load(filepath, map_location=lambda storage, loc: storage)\\n epoch = f['epoch']\\n losses = f['losses']\\n seq_len = f['seq_len']\\n\\n model.load_state_dict(f['state_dict'])\\n optimizer.load_state_dict(f['optimizer'])\\n return model, optimizer, epoch, losses, seq_len\",\n \"def _resume_from_checkpoint(model: tf.keras.Model,\\n model_dir: str,\\n train_steps: int) -> int:\\n logging.info('Load from checkpoint is enabled.')\\n latest_checkpoint = tf.train.latest_checkpoint(model_dir)\\n logging.info('latest_checkpoint: %s', latest_checkpoint)\\n if not latest_checkpoint:\\n logging.info('No checkpoint detected.')\\n return 0\\n\\n logging.info('Checkpoint file %s found and restoring from '\\n 'checkpoint', latest_checkpoint)\\n model.load_weights(latest_checkpoint)\\n initial_epoch = model.optimizer.iterations // train_steps\\n logging.info('Completed loading from checkpoint.')\\n logging.info('Resuming from epoch %d', initial_epoch)\\n return int(initial_epoch)\",\n \"def restore_model(self, resume_iters):\\n if self.resume_iters:\\n checkpoint_dir = os.path.join(self.checkpoint_dir, self.model_dir)\\n print('Loading the trained models from step {}...'.format(resume_iters))\\n G_path = os.path.join(checkpoint_dir, '{}-G.ckpt'.format(resume_iters))\\n self.G.load_state_dict(torch.load(G_path, map_location=lambda storage, loc: storage))\",\n \"def resume(self, save_path: str, train_data: BaseDataManager,\\n val_data: BaseDataManager = None,\\n params: Parameters = None, **kwargs):\\n return self.run(\\n train_data=train_data,\\n val_data=val_data,\\n params=params,\\n save_path=save_path,\\n **kwargs)\",\n \"def _restore_training_state(self, restore_state):\\n self.load_state_dict(restore_state[\\\"model\\\"])\\n self.optimizer.load_state_dict(restore_state[\\\"optimizer\\\"])\\n self.lr_scheduler.load_state_dict(restore_state[\\\"lr_scheduler\\\"])\\n start_iteration = restore_state[\\\"iteration\\\"] + 1\\n if self.config[\\\"verbose\\\"]:\\n print(f\\\"Restored checkpoint to iteration {start_iteration}.\\\")\\n\\n if restore_state[\\\"best_model_found\\\"]:\\n # Update checkpointer with appropriate information about best model\\n # Note that the best model found so far may not be the model in the\\n # checkpoint that is currently being loaded.\\n self.checkpointer.best_model_found = True\\n self.checkpointer.best_iteration = restore_state[\\\"best_iteration\\\"]\\n self.checkpointer.best_score = restore_state[\\\"best_score\\\"]\\n if self.config[\\\"verbose\\\"]:\\n print(\\n f\\\"Updated checkpointer: \\\"\\n f\\\"best_score={self.checkpointer.best_score:.3f}, \\\"\\n f\\\"best_iteration={self.checkpointer.best_iteration}\\\"\\n )\\n return start_iteration\",\n \"def resume(self):\\n self._paused = False\",\n \"def load_checkpoint(self):\\n if self.params.resume_from is not None and os.path.exists(self.params.resume_from):\\n try:\\n LOG('Loading Checkpoint at %s' % self.params.resume_from)\\n ckpt = torch.load(self.params.resume_from)\\n self.epoch = ckpt['epoch']\\n try:\\n self.train_loss = ckpt['train_loss']\\n self.val_loss = ckpt['val_loss']\\n except:\\n self.train_loss = []\\n self.val_loss = []\\n self.network.load_state_dict(ckpt['state_dict'])\\n self.opt.load_state_dict(ckpt['optimizer'])\\n LOG('Checkpoint Loaded!')\\n LOG('Current Epoch: %d' % self.epoch)\\n self.ckpt_flag = True\\n except:\\n WARNING('Cannot load checkpoint from %s. Start loading pre-trained model......' % self.params.resume_from)\\n else:\\n WARNING('Checkpoint do not exists. Start loading pre-trained model......')\",\n \"def restore_model(self, resume_iters):\\n print('Loading the trained models from step {}...'.format(resume_iters))\\n G_path = os.path.join(self.model_save_dir, '{}-G.ckpt'.format(resume_iters))\\n self.G.load_state_dict(torch.load(G_path, map_location=lambda storage, loc: storage))\",\n \"def resume(self):\\n\\n self.shm_command.write({'cmd': 'resume', 'data': {}})\",\n \"def resume(self):\\n self.is_paused = False\",\n \"def resume(self):\\n raise NotImplementedError()\",\n \"def resume(self):\\n raise NotImplementedError()\",\n \"def resume(self):\\n self.check_state('resume')\\n try:\\n self.newportxps.resume_all()\\n except Exception:\\n pass\",\n \"def restore(self, checkpoint_path: str):\\r\\n raise NotImplementedError\",\n \"def restore(self, checkpoint_data):\\n\\n self.iteration = checkpoint_data['iteration']\\n self.action_requests = checkpoint_data['action_requests']\\n\\n self.experience = deque()\\n for episode in checkpoint_data['experience']:\\n ep = []\\n for transition in episode:\\n ep.append(tuple(transition))\\n\\n self.experience.append(ep)\",\n \"def checkpoint():\",\n \"def restore(self):\\n\\n self.brain.restore_checkpoint()\",\n \"def restore_model(self, resume_iters):\\n print('Loading the trained models from step {}...'.format(resume_iters))\\n G_path = os.path.join(self.model_save_dir, '{}-G.ckpt'.format(resume_iters))\\n D_path = os.path.join(self.model_save_dir, '{}-D.ckpt'.format(resume_iters))\\n self.G.load_state_dict(torch.load(G_path, map_location=lambda storage, loc: storage))\\n self.D.load_state_dict(torch.load(D_path, map_location=lambda storage, loc: storage))\",\n \"def resume_workflow(self):\\n self._gdb_interface.resume_workflow()\",\n \"def _restore(self):\\n\\n output_path = self.output_path + '/checkpoints/'\\n checkpoint = tf.train.latest_checkpoint(output_path)\\n if checkpoint:\\n self.saver.restore(self.session, save_path=checkpoint)\\n restored_step = int(checkpoint.split('-')[-1]) # Robust enough?\\n return restored_step\\n logging.info('Starting training from scratch.')\\n return 0\",\n \"def resume(self):\\n\\t\\treturn Job(SDK.PrlVm_Resume(self.handle)[0])\",\n \"def resume(self):\\n self.Game=Game(self.Display)\\n try:\\n pickle_in=open('.\\\\\\\\2048.txt','rb')\\n except:\\n return\\n a=pickle.load(pickle_in)\\n self.Game.GameBoard.restore(a)\\n pickle_in.close()\",\n \"def resume_training(args: argparse.Namespace, hp: HParams, tier: int, model: Tier,\\n optimizer: torch.optim.Optimizer, logger: logging.Logger) \\\\\\n -> Tuple[Tier, torch.optim.Optimizer]:\\n if not Path(args.checkpoint_path).exists():\\n logger.error(f\\\"Path for resuming training {args.checkpoint_path} does not exist.\\\")\\n raise Exception(f\\\"Path for resuming training {args.checkpoint_path} does not exist.\\\")\\n\\n logger.info(f\\\"Resuming training with weights from: {args.checkpoint_path}\\\")\\n checkpoint = torch.load(args.checkpoint_path)\\n hp_chkpt = checkpoint[\\\"hp\\\"]\\n\\n # Check if current hyperparameters and the ones from saved model are the same\\n if hp_chkpt.audio != hp.audio:\\n logger.warning(\\\"New params for audio are different from checkpoint. \\\"\\n \\\"It will use new params.\\\")\\n\\n if hp_chkpt.network != hp.network:\\n logger.error(\\\"New params for network structure are different from checkpoint.\\\")\\n raise Exception(\\\"New params for network structure are different from checkpoint.\\\")\\n\\n if checkpoint[\\\"tier_idx\\\"] != tier:\\n logger.error(\\n f\\\"New tier to train ({tier}) is different from checkpoint ({checkpoint['tier']}).\\\")\\n raise Exception(\\n f\\\"New tier to train ({tier}) is different from checkpoint ({checkpoint['tier']}).\\\")\\n\\n if hp_chkpt.data != hp.data:\\n logger.warning(\\\"New params for dataset are different from checkpoint. \\\"\\n \\\"It will use new params.\\\")\\n\\n if hp_chkpt.training != hp.training:\\n logger.warning(\\\"New params for training are different from checkpoint. \\\"\\n \\\"It will use new params.\\\")\\n\\n # epoch_chkpt = checkpoint[\\\"epoch\\\"]\\n # iterations_chkpt = checkpoint[\\\"iterations\\\"]\\n # total_iterations_chkpt = checkpoint[\\\"total_iterations\\\"]\\n model.load_state_dict(checkpoint[\\\"tier\\\"])\\n optimizer.load_state_dict(checkpoint[\\\"optimizer\\\"])\\n\\n return model, optimizer\",\n \"def resume(self, tag=\\\"current\\\"):\\n\\n if not self.is_resumable(tag):\\n logging.warning(\\\"This exeriment is not resumable!\\\")\\n self.force_restart(tag)\\n\\n else:\\n logging.info(\\\"Loading the experiment from {}\\\".format(self._dir_name))\\n\\n save_dir = os.path.join(self._dir_name, tag)\\n\\n if self._model is not None:\\n self._model.load(save_dir)\\n\\n if self._config is not None:\\n file_name = os.path.join(save_dir, \\\"config.p\\\")\\n self._config.load(file_name)\\n\\n if self._logger is not None:\\n file_name = os.path.join(save_dir, \\\"logger\\\")\\n self._logger.load(file_name)\\n\\n if self._train_statistics is not None:\\n file_name = os.path.join(save_dir, \\\"train_statistics.p\\\")\\n self._train_statistics.load(file_name)\\n\\n if self._data_iterator is not None:\\n file_name = os.path.join(save_dir, \\\"data_iterator.p\\\")\\n self._data_iterator.load(file_name)\",\n \"def checkpoint(self):\\n self.logger.info('Checkpointing Sampler')\\n with open(self.resume_file, \\\"wb\\\") as f:\\n pickle.dump(self, f)\",\n \"def resume_workflow(self):\\n with self._driver.session() as session:\\n session.write_transaction(tx.set_workflow_state, state='RESUME')\",\n \"def restore(self, checkpoint_path):\\n start_time = time.time()\\n latest_checkpoint = train_util.get_latest_chekpoint(checkpoint_path)\\n if latest_checkpoint is not None:\\n checkpoint = tf.train.Checkpoint(model=self)\\n checkpoint.restore(latest_checkpoint).expect_partial()\\n logging.info('Loaded checkpoint %s', latest_checkpoint)\\n logging.info('Loading model took %.1f seconds', time.time() - start_time)\\n else:\\n logging.info('Could not find checkpoint to load at %s, skipping.',\\n checkpoint_path)\",\n \"def restore_model(self, resume_iters):\\n \\n print('Loading the trained models from step {}...'.format(resume_iters))\\n encoder_path = os.path.join(self.model_save_dir, '{}-encoder.ckpt'.format(resume_iters))\\n decoder_path = os.path.join(self.model_save_dir, '{}-decoder.ckpt'.format(resume_iters))\\n D_path = os.path.join(self.model_save_dir, '{}-D.ckpt'.format(resume_iters))\\n self.encoder.load_state_dict(torch.load(encoder_path, map_location=lambda storage, loc: storage))\\n self.decoder.load_state_dict(torch.load(decoder_path, map_location=lambda storage, loc: storage))\\n self.D.load_state_dict(torch.load(D_path, map_location=lambda storage, loc: storage))\",\n \"def restore(self):\\n # For multi-worker training, it should not restore a model in certain\\n # worker setting (e.g. non-chief worker in ParameterServerStrategy).\\n # pylint: disable=protected-access\\n if self._model._in_multi_worker_mode() and not multi_worker_util.should_load_checkpoint():\\n return\\n self.read_checkpoint_manager.restore_or_initialize()\",\n \"def on_resume(self):\\r\\n store = get_store()\\r\\n self.sm.current = str(store.get('pause')[\\\"value\\\"])\",\n \"def __resume_log(self, log_tag, model):\\r\\n if log_tag == self.LOG_TAG_LAST:\\r\\n start_checkpoint_path = self.checkpoint_path_last\\r\\n elif log_tag == self.LOG_TAG_BEST_EER:\\r\\n start_checkpoint_path = self.checkpoint_path_best_eer\\r\\n else:\\r\\n raise Exception('wrong log_tag')\\r\\n errmsg = str(start_checkpoint_path) + ' should exists as dir'\\r\\n assert os.path.isdir(start_checkpoint_path), errmsg\\r\\n self.checkpoints_info_load()\\r\\n start_ep = self.checkpoints_info[log_tag]['ep']\\r\\n start_b_gl = self.checkpoints_info[log_tag]['batch']\\r\\n self.__resume_custom(start_checkpoint_path, start_ep, start_b_gl, model=model)\",\n \"def restore(self, sess: tf.Session) -> None:\\n super().restore(sess)\\n BaseModel._restore_checkpoint(self.pretrained_saver, sess, path=FLAGS.pretrained_checkpoint)\",\n \"def __resume_custom(self, start_checkpoint_path=None, start_ep=0, start_b_gl=0, eval_val_before_trn: bool = True, model: tf.Module = None):\\r\\n self.__init_model(start_checkpoint_path, model)\\r\\n # TODO clear extra steps on plots\\r\\n assert is_any_int(start_ep)\\r\\n assert start_ep >= 0\\r\\n assert is_any_int(start_b_gl)\\r\\n assert start_b_gl >= 0\\r\\n self.ep = start_ep\\r\\n self.ep_last = self.ep - int(eval_val_before_trn)\\r\\n self.b_gl = start_b_gl\",\n \"def restore(self):\\n if self._restored_model:\\n return\\n with self.eval_graph.graph.as_default():\\n last_checkpoint = self._find_last_checkpoint()\\n # TODO(rbharath): Is setting train=False right here?\\n saver = tf.train.Saver()\\n saver.restore(self._get_shared_session(train=False), last_checkpoint)\\n self._restored_model = True\",\n \"def resume(self) -> int:\\n last_epoch = -1\\n latest_file_path = self._fetch_latest_checkpt()\\n if latest_file_path and os.path.exists(latest_file_path):\\n self.load_params(latest_file_path)\\n _, self.checkpt_dir, filename = latest_file_path.rsplit(os.path.sep, 2)\\n # fetch the last epoch from the filename\\n last_epoch = int(filename.split(\\\"_\\\", 1)[0])\\n return last_epoch + 1\",\n \"def resume(self):\\n if self.paused:\\n pause_time = time.time() - self.paused_time\\n self.start_time = self.start_time + pause_time\\n self.paused = False\",\n \"def resume(self) -> None:\\n self._running.set()\",\n \"def _restore_checkpoint(self, checkpoint_path):\\n self.logger.info(\\\"Loading checkpoint: {} ...\\\".format(checkpoint_path))\\n checkpoint = torch.load(checkpoint_path)\\n pretrained_dict = checkpoint['state_dict'] # 预训练模型的state_dict\\n model_dict = self.model.state_dict() # 当前用来训练的模型的state_dict\\n \\n if pretrained_dict.keys() != model_dict.keys(): # 需要进行参数的适配\\n print('Parameters are inconsistant, adapting model parameters ...')\\n # 在合并前(update),需要去除pretrained_dict一些不需要的参数\\n # 只含有识别分支的预训练模型参数字典中键'0', '1'对应全模型参数字典中键'2', '3'\\n pretrained_dict['2'] = transfer_state_dict(pretrained_dict['0'], model_dict['2'])\\n pretrained_dict['3'] = transfer_state_dict(pretrained_dict['1'], model_dict['3'])\\n del pretrained_dict['0'] # 把原本预训练模型中的键值对删掉，以免错误地更新当前模型中的键值对\\n del pretrained_dict['1']\\n model_dict.update(pretrained_dict) # 更新(合并)模型的参数\\n self.model.load_state_dict(model_dict)\\n else:\\n print('Parameters are consistant, load state dict directly ...')\\n self.model.load_state_dict(checkpoint['state_dict'])\\n # self.optimizer.load_state_dict(checkpoint['optimizer'])\\n # if self.with_cuda:\\n # for state in self.optimizer.state.values():\\n # for k, v in state.items():\\n # if isinstance(v, torch.Tensor):\\n # state[k] = v.cuda(self.device)\",\n \"def resume(self, **kwargs):\\r\\n self.enc_seen = kwargs['enc_seen']\\r\\n # TODO: say why the game ended, via constants file probably\\r\",\n \"def resume(self, name=None):\\n raise NotImplementedError\",\n \"def resume():\\n if checkIfAllFixed():\\n disableTaskControls()\\n globs.ERREVENT.set()\\n globs.DISP_SCREEN.updateScreen(globs.DISP_SCREEN.progress)\\n else:\\n globs.CONTROLLER.taskMonitor.errorBox.append(\\\"WARNING! Fix All Errors Before Resuming\\\")\\n globs.CONTROLLER.taskMonitor.errorBox.append(\\\"\\\")\",\n \"def restore(self,\\n sess,\\n ckpt_file,\\n ckpt_type):\\n if ckpt_file is None:\\n raise FileNotFoundError(\\\"checkpoint file doesn't exist\\\")\\n \\n if ckpt_type == \\\"debug\\\":\\n self.ckpt_debug_saver.restore(sess, ckpt_file)\\n elif ckpt_type == \\\"epoch\\\":\\n self.ckpt_epoch_saver.restore(sess, ckpt_file)\\n else:\\n raise ValueError(\\\"unsupported checkpoint type {0}\\\".format(ckpt_type))\",\n \"def restore_resume_state(self, key):\\n new_state = self.statedb.get(key)\\n if new_state is None:\\n return False\\n if \\\"_rev\\\" in self.value:\\n backup_key = self.backup_resume_state(self.value)\\n if backup_key is None:\\n return False\\n log.info(\\\"restoring iteration state: %s\\\", new_state)\\n self.itr._save_state_json(new_state)\\n return True\",\n \"def load_checkpoint(self, session, model_dir):\\n assert self.params.cp_load == True, (\\\"cp_load must be set to true to load a checkpoint\\\")\\n self.loader.restore(session, model_dir)\",\n \"def resume(vm='', env=''):\\n local( main_dir + '/vagrant/bin/vm.sh resume ' + str(vm) + ' ' + str(env) )\",\n \"def load_checkpoint(args, trainer, epoch_itr):\\n os.makedirs(os.path.join(args.save_dir, 'checkpoints'), exist_ok=True)\\n checkpoint_path = os.path.join(args.save_dir, 'checkpoints', args.restore_file)\\n if os.path.isfile(checkpoint_path):\\n extra_state = trainer.load_checkpoint(checkpoint_path)\\n if extra_state is not None:\\n # replay train iterator to match checkpoint\\n epoch_itr.load_state_dict(extra_state['train_iterator'])\\n\\n print('| loaded checkpoint {} (epoch {} @ {} updates)'.format(\\n checkpoint_path, epoch_itr.epoch, trainer.get_num_updates()))\\n\\n trainer.lr_step(epoch_itr.epoch)\\n trainer.lr_step_update(trainer.get_num_updates())\\n if 'best' in extra_state:\\n save_checkpoint.best = extra_state['best']\",\n \"def resume(self):\\n self.background_scheduler.resume()\",\n \"def checkpoint(self):\\n save()\",\n \"def LoadProgramState(self, restored_checkpoint_path=None, sess=None):\\n pass\",\n \"async def resume(self):\\n await self.send({\\n \\\"op\\\": 6,\\n \\\"d\\\" : {\\n \\\"token\\\" : self.client.token,\\n \\\"session_id\\\": self.session_id,\\n \\\"seq\\\" : self.last_event_id\\n }\\n })\",\n \"def restore_checkpoint(model, checkpoint_dir, cuda=False, force=False, pretrain=False):\\n try:\\n cp_files = [\\n file_\\n for file_ in os.listdir(checkpoint_dir)\\n if file_.startswith(\\\"epoch=\\\") and file_.endswith(\\\".checkpoint.pth.tar\\\")\\n ]\\n except FileNotFoundError:\\n cp_files = None\\n os.makedirs(checkpoint_dir)\\n if not cp_files:\\n print(\\\"No saved model parameters found\\\")\\n if force:\\n raise Exception(\\\"Checkpoint not found\\\")\\n else:\\n return model, 0, []\\n\\n # Find latest epoch\\n for i in itertools.count(1):\\n if \\\"epoch={}.checkpoint.pth.tar\\\".format(i) in cp_files:\\n epoch = i\\n else:\\n break\\n\\n if not force:\\n print(\\n \\\"Which epoch to load from? Choose in range [0, {}].\\\".format(epoch),\\n \\\"Enter 0 to train from scratch.\\\",\\n )\\n print(\\\">> \\\", end=\\\"\\\")\\n inp_epoch = int(input())\\n if inp_epoch not in range(epoch + 1):\\n raise Exception(\\\"Invalid epoch number\\\")\\n if inp_epoch == 0:\\n print(\\\"Checkpoint not loaded\\\")\\n clear_checkpoint(checkpoint_dir)\\n return model, 0, []\\n else:\\n print(\\\"Which epoch to load from? Choose in range [1, {}].\\\".format(epoch))\\n inp_epoch = int(input())\\n if inp_epoch not in range(1, epoch + 1):\\n raise Exception(\\\"Invalid epoch number\\\")\\n\\n filename = os.path.join(\\n checkpoint_dir, \\\"epoch={}.checkpoint.pth.tar\\\".format(inp_epoch)\\n )\\n\\n print(\\\"Loading from checkpoint {}?\\\".format(filename))\\n\\n if cuda:\\n checkpoint = torch.load(filename)\\n else:\\n # Load GPU model on CPU\\n checkpoint = torch.load(filename, map_location=lambda storage, loc: storage)\\n\\n try:\\n start_epoch = checkpoint[\\\"epoch\\\"]\\n stats = checkpoint[\\\"stats\\\"]\\n if pretrain:\\n model.load_state_dict(checkpoint[\\\"state_dict\\\"], strict=False)\\n else:\\n model.load_state_dict(checkpoint[\\\"state_dict\\\"])\\n print(\\n \\\"=> Successfully restored checkpoint (trained for {} epochs)\\\".format(\\n checkpoint[\\\"epoch\\\"]\\n )\\n )\\n except:\\n print(\\\"=> Checkpoint not successfully restored\\\")\\n raise\\n\\n return model, inp_epoch, stats\",\n \"def load_checkpoints(args, model): \\n print('Loading the model checkpoints from iter {}...'.format(args.resume_iter))\\n checkpoint_path = os.path.join(config.checkpoint_path, args.model_type)\\n\\n gen_g_path = os.path.join(checkpoint_path, '{}-Gen_g.ckpt'.format(args.resume_iter))\\n gen_f_path = os.path.join(checkpoint_path, '{}-Gen_f.ckpt'.format(args.resume_iter))\\n model.gen_g.load_state_dict(torch.load(gen_g_path, map_location=lambda storage, loc: storage))\\n model.gen_f.load_state_dict(torch.load(gen_f_path, map_location=lambda storage, loc: storage))\\n\\n if args.train:\\n dis_c_path = os.path.join(checkpoint_path, '{}-Dis_c.ckpt'.format(args.resume_iter))\\n dis_t_path = os.path.join(checkpoint_path, '{}-Dis_t.ckpt'.format(args.resume_iter))\\n model.dis_c.load_state_dict(torch.load(dis_c_path, map_location=lambda storage, loc: storage))\\n model.dis_t.load_state_dict(torch.load(dis_t_path, map_location=lambda storage, loc: storage))\",\n \"def resume(cls, resume_file, manager, model):\\n with open(resume_file, \\\"rb\\\") as f:\\n obj = pickle.load(f)\\n obj.model = model\\n obj.manager = manager\\n obj.logLmin = obj.manager.logLmin\\n obj.logLmax = obj.manager.logLmax\\n obj.logger = logging.getLogger(\\\"cpnest.sample.Sampler\\\")\\n obj.producer_pipe , obj.thread_id = obj.manager.connect_producer()\\n obj.logger.info('Resuming Sampler from ' + resume_file)\\n obj.last_checkpoint_time = time.time()\\n return obj\",\n \"def _restore(self, checkpoint):\\n checkpoint_path = os.path.join(checkpoint, \\\"model_weights\\\")\\n self.model.load_weights(checkpoint_path)\",\n \"def on_resume(self, userdata):\\n pass\",\n \"def resume():\\n cache.set('is_paused', 'False')\\n socketio.emit('resume', {})\",\n \"async def resume_behaviors(self) -> None:\",\n \"def resumeJob(_id, client):\\n return tryAgainJob(_id)\",\n \"def restore_fn(flags):\\n # if flags.tf_initial_checkpoint is None:\\n # return None\\n\\n # Warn the user if a checkpoint exists in the train_dir. Then ignore.\\n # if tf.train.latest_checkpoint(flags.train_dir):\\n # tf.logging.info(\\n # 'Ignoring --checkpoint_path because a checkpoint already exists in %s'\\n # % flags.train_dir)\\n # return None\\n\\n exclusions = []\\n if flags.checkpoint_exclude_scopes:\\n exclusions = [scope.strip()\\n for scope in flags.checkpoint_exclude_scopes.split(',')]\\n\\n variables_to_restore = []\\n for var in slim.get_model_variables():\\n excluded = False\\n for exclusion in exclusions:\\n if var.op.name.startswith(exclusion):\\n excluded = True\\n break\\n if not excluded:\\n variables_to_restore.append(var)\\n # Change model scope if necessary.\\n if flags.checkpoint_model_scope is not None:\\n variables_to_restore = \\\\\\n {var.op.name.replace(flags.model_name,\\n flags.checkpoint_model_scope): var\\n for var in variables_to_restore}\\n\\n tf.compat.v1.logging.info('++++++++++++++++++++')\\n tf.compat.v1.logging.info('Fine-tuning from %s. Ignoring missing vars: %s' %\\n (flags.pre_trained_checkpoint, flags.ignore_missing_vars))\\n slim.assign_from_checkpoint_fn(flags.pre_trained_checkpoint,\\n variables_to_restore,\\n ignore_missing_vars=flags.ignore_missing_vars)\",\n \"def resume(instance):\\n if instance.state == STOPPED:\\n return\\n\\n Queue.objects.add(function=\\\"resume\\\", instance=instance)\",\n \"def load_checkpoint(self, checkpoint_path, continue_from_epoch=True):\\n print(\\\"Loading checkpoint: {}\\\".format(checkpoint_path))\\n state = torch.load(checkpoint_path)\\n self.model.load_state_dict(state['state_dict'])\\n self.optimizer.load_state_dict(state['optim_dict'])\\n\\n if continue_from_epoch:\\n self.epoch = state['epoch']\",\n \"def reload_checkpoint(self):\\n checkpoint_path = os.path.join(self.params.dump_path, 'checkpoint.pth')\\n if not os.path.isfile(checkpoint_path):\\n if self.params.reload_checkpoint == '':\\n return\\n else:\\n checkpoint_path = self.params.reload_checkpoint\\n assert os.path.isfile(checkpoint_path)\\n logger.warning(\\\"Reloading checkpoint from %s ...\\\" % checkpoint_path)\\n data = torch.load(checkpoint_path, map_location='cpu')\\n\\n # reload model parameters\\n for name in self.MODEL_NAMES:\\n getattr(self, name).load_state_dict(data[name])\\n\\n # reload optimizers\\n for name in self.optimizers.keys():\\n if False: # AMP checkpoint reloading is buggy, we cannot do that - TODO: fix - https://github.com/NVIDIA/apex/issues/250\\n logger.warning(\\\"Reloading checkpoint optimizer %s ...\\\" % name)\\n else: # instead, we only reload current iterations / learning rates\\n logger.warning(\\\"Not reloading checkpoint optimizer %s.\\\" % name)\\n for group_id, param_group in enumerate(self.optimizers[name].param_groups):\\n if 'num_updates' not in param_group:\\n logger.warning(\\\"No 'num_updates' for optimizer %s.\\\" % name)\\n continue\\n logger.warning(\\\"Reloading 'num_updates' and 'lr' for optimizer %s.\\\" % name)\\n param_group['num_updates'] = data['%s_optimizer' % name]['param_groups'][group_id]['num_updates']\\n param_group['lr'] = self.optimizers[name].get_lr_for_step(param_group['num_updates'])\\n\\n # reload main metrics\\n self.epoch = data['epoch'] + 1\\n self.n_total_iter = data['n_total_iter']\\n self.best_metrics = data['best_metrics']\\n self.best_stopping_criterion = data['best_stopping_criterion']\\n logger.warning(\\\"Checkpoint reloaded. Resuming at epoch %i / iteration %i ...\\\" % (self.epoch, self.n_total_iter))\",\n \"def resume(self, instance, callback):\\n self._start(instance['id'])\",\n \"def resume_model(filename, args):\\n checkpoint = torch.load(filename)\\n clf = CNN()\\n clf.load_state_dict(checkpoint['clf'])\\n \\n if args.cuda:\\n clf = clf.cuda()\\n\\n opt = torch.optim.Adam(clf.parameters(), lr=1e-3)\\n opt.load_state_dict(checkpoint['opt'])\\n\\n return clf, opt\",\n \"def resume(self, job_id):\\n job = Job.get_job_by_id(job_id)\\n self.access_handler.check_resume(job)\\n self.master.resume_job(job)\",\n \"def on_resume_toggled(self, _):\\n if not self.resume.get_active():\\n self._previous_force_recheck = self.force_recheck.get_active()\\n self.force_recheck.set_sensitive(False)\\n self.force_recheck.set_active(True)\\n else:\\n self.force_recheck.set_active(self._previous_force_recheck)\\n self.force_recheck.set_sensitive(True)\",\n \"def on_resume(self, event):\\n self.pre_check(event)\\n if self.get_player(event.guild.id).paused:\\n self.get_player(event.guild.id).resume()\",\n \"def before_train(self, runner) -> None:\\n if runner._resume:\\n for action_epoch, recipe in self.schedule.items():\\n if action_epoch >= runner.epoch + 1:\\n break\\n self._do_switch(runner, recipe,\\n f' (resume recipe of epoch {action_epoch})')\",\n \"def restore(self, PATH):\\n self._saver.restore(self._sess, PATH)\",\n \"def test_resume_restore(self):\\n if not self.backupset.resume:\\n self.fail(\\\"Resume must be True for this test\\\")\\n gen = BlobGenerator(\\\"ent-backup\\\", \\\"ent-backup-\\\", self.value_size, end=self.num_items)\\n self._load_all_buckets(self.master, gen, \\\"create\\\", 0)\\n self.backup_create()\\n self.backup_cluster_validate()\\n self.log.info(\\\"Start to flush bucket\\\")\\n self._all_buckets_flush()\\n restore_result = self.cluster.async_restore_cluster(backupset=self.backupset,\\n objstore_provider=self.objstore_provider,\\n no_progress_bar=self.no_progress_bar,\\n cli_command_location=self.cli_command_location,\\n cb_version=self.cb_version,\\n force_updates=self.backupset.force_updates,\\n no_resume=True)\\n state = \\\"\\\"\\n while state not in (\\\"FINISHED\\\", \\\"EXECUTING\\\"):\\n state = restore_result.state\\n self._kill_cbbackupmgr()\\n self.assertFalse(self._check_output(\\\"success\\\", restore_result.result()))\\n self.backup_restore_validate(compare_uuid=False, seqno_compare_function=\\\">=\\\")\",\n \"def restore(self, ds_crossval):\\n t = datetime.now().strftime(\\\"%Y-%m-%d %H:%M:%S\\\")\\n print(\\\"[INFO] {} - Restoring from latest checkpoint ...\\\".format(t))\\n self.ckpt_handle.restore(\\n tf.train.latest_checkpoint(self.ckpt_dir)).expect_partial()\\n self._eval_step(ds_crossval.data.values,\\n ds_crossval.labels_onehot.values)\\n self.best_accuracy = float(self.eval_accuracy.result())\\n template = \\\"{} model restored after {} epoch(s) - \\\" \\\\\\n \\\"Cross-vall accuracy = {:.9f}\\\"\\n print(template.format(self.name, int(self.ckpt_handle.step),\\n self.best_accuracy))\",\n \"def resume(self):\\n\\n Console.info(\\\"Resuming session...\\\")\\n\\n for project in self.__projects:\\n project.resume()\",\n \"def checkpoint(self, epoch: int):\\n if self.exp.scheduler_stepper is not None:\\n torch.save(\\n {\\n \\\"model_state_dict\\\": self.exp.model.state_dict(),\\n \\\"optimizer_state_dict\\\": self.exp.optimizer.state_dict(),\\n \\\"scheduler_state_dict\\\": self.exp.scheduler_stepper.scheduler.state_dict(),\\n \\\"Epoch\\\": epoch,\\n },\\n self.exp.path,\\n )\\n else:\\n torch.save(\\n {\\n \\\"model_state_dict\\\": self.exp.model.state_dict(),\\n \\\"optimizer_state_dict\\\": self.exp.optimizer.state_dict(),\\n \\\"Epoch\\\": epoch,\\n },\\n self.exp.path,\\n )\",\n \"def resume(cls):\\n\\n cls._set_mode_running()\\n TimeDisplay.start_time()\\n for callback in cls.resume_callback:\\n callback()\",\n \"def load(loadname, checkpoint=None):\\n ckpt_dir = \\\"./models/tf_ckpt_\\\" + loadname + \\\"/\\\"\\n if checkpoint is not None:\\n status = checkpoint.restore(tf.train.latest_checkpoint(ckpt_dir))\\n status.assert_consumed()\\n print(\\\"Loaded checkpoint\\\")\\n else:\\n print(\\\"Not Loading any checkpoint\\\")\\n print(\\\"Starting training from initial configuration\\\")\",\n \"def restore_checkpoint(self, checkpoint_id, name, path=''):\\n\\n\\t\\tself.log.debug(\\\"restoring Notebook %s from checkpoint %s\\\", name, checkpoint_id)\\n\\t\\tnb_path = self._get_os_path(name, path)\\n\\t\\tcp_path = self.get_checkpoint_path(checkpoint_id, name, path)\\n\\n\\t\\tif not key_exists(self.bucket, cp_path):\\n\\t\\t\\tself.log.debug(\\\"checkpoint file does not exist: %s\\\", cp_path)\\n\\t\\t\\traise web.HTTPError(404,\\n\\t\\t\\t\\tu'Notebook checkpoint does not exist: %s-%s' % (name, checkpoint_id)\\n\\t\\t\\t)\\n\\t\\t# ensure notebook is readable (never restore from an unreadable notebook)\\n\\t\\tkey = self.bucket.get_key(cp_path)\\n\\t\\tnb = current.reads(key.get_contents_as_string(), u'json')\\n\\t\\tself._copy(cp_path, nb_path)\\n\\t\\tself.log.debug(\\\"copying %s -> %s\\\", cp_path, nb_path)\",\n \"def warm_start_training(self, sess): \\n ckpt = tf.train.latest_checkpoint(self.train_dir)\\n if ckpt:\\n # the global_step will restore sa well\\n saver = tf.train.Saver(tf.global_variables(), max_to_keep=100)\\n saver.restore(sess, ckpt)\\n print('restore from the checkpoint{0}'.format(ckpt))\\n return\\n \\n if self.checkpoint_path is None:\\n return None\\n \\n exclusions = []\\n if self.checkpoint_exclude_scopes:\\n exclusions = [scope.strip()\\n for scope in self.checkpoint_exclude_scopes.split(',')]\\n # TODO(sguada) variables.filter_variables()\\n variables_to_restore = []\\n all_variables = slim.get_model_variables()\\n if tf.gfile.IsDirectory(self.checkpoint_path):\\n global_step = slim.get_or_create_global_step()\\n all_variables.append(global_step)\\n checkpoint_path = tf.train.latest_checkpoint(self.checkpoint_path)\\n else:\\n checkpoint_path = self.checkpoint_path\\n \\n for var in all_variables:\\n excluded = False\\n \\n for exclusion in exclusions:\\n if var.op.name.startswith(exclusion):\\n excluded = True\\n break\\n if not excluded:\\n variables_to_restore.append(var)\\n \\n# tf.logging.info('Fine-tuning from %s' % checkpoint_path)\\n \\n slim.assign_from_checkpoint_fn(\\n checkpoint_path,\\n variables_to_restore)(sess)\\n return\",\n \"def restore_session(self, dir_model):\\n self.logger.info(\\\"Reloading the latest trained model...\\\")\\n self.saver.restore(self.sess, dir_model)\",\n \"def resume(self):\\n raise TaskError(\\\"Task %s: subclass should override resume() method!\\\" % (\\n self))\",\n \"def restore(self, sess, path=None, var_list=None):\\n\\n saver = tf.train.Saver(var_list)\\n if path is None:\\n path = tf.train.latest_checkpoint(os.path.dirname(self.config.CHECKPOINTS_PATH))\\n saver.restore(sess, path)\\n print(\\\"model restored from %s\\\" % path)\",\n \"def restore_session(self, dir_model):\\r\\n self.logger.info(\\\"Reloading the latest trained model...\\\")\\r\\n self.saver.restore(self.sess, tf.train.latest_checkpoint(dir_model))\",\n \"def restore_session(saver, sess, model_dir):\\n checkpoint = tf.train.get_checkpoint_state(model_dir)\\n if checkpoint and checkpoint.model_checkpoint_path:\\n saver.restore(sess, checkpoint.model_checkpoint_path)\\n print(\\\"checkpoint loaded:\\\", checkpoint.model_checkpoint_path)\\n tokens = checkpoint.model_checkpoint_path.split(\\\"-\\\")\\n # set global step\\n global_t = int(tokens[2])\\n n_episode = int(tokens[1])\\n print(\\\">>> global step set: \\\", global_t)\\n else:\\n print(\\\"Could not find old checkpoint\\\")\\n global_t = 0\\n n_episode = 0\\n return global_t, n_episode\",\n \"def resume(self):\\n self._is_paused = False\\n for lobby in self._lobby_list:\\n lobby.resume()\",\n \"def restore_session(self, dir_model):\\n self.logger.info(\\\"Reloading the latest trained model...\\\")\\n self.saver.restore(self.session, dir_model)\",\n \"def restore_state(model, optimizer, latest_snapshot):\\n\\n checkpoint = torch.load(latest_snapshot,\\n map_location=lambda storage, loc: storage.cuda(args[\\\"local_rank\\\"]))\\n\\n model.load_state_dict(checkpoint['state_dict'])\\n optimizer.load_state_dict(checkpoint['optimizer'])\\n return checkpoint['seen_images'], checkpoint['epochs']\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7948833","0.79420406","0.7860005","0.7762703","0.7674831","0.7672587","0.75724417","0.74276704","0.72801906","0.72801906","0.72801906","0.72574735","0.71175265","0.7104059","0.71037406","0.7057032","0.6996928","0.69433475","0.69009686","0.68490225","0.6792626","0.6788472","0.6749746","0.67459744","0.67394125","0.67392135","0.67392135","0.672823","0.67098063","0.66881526","0.6682118","0.6680393","0.6675211","0.66605693","0.66438395","0.663735","0.6625476","0.6619497","0.66135186","0.6612828","0.6599553","0.65589356","0.6549294","0.6498661","0.6489125","0.6469346","0.6458742","0.64113504","0.63894993","0.6383509","0.6373229","0.6368509","0.6358853","0.63341725","0.6327635","0.63044006","0.63031054","0.629775","0.62963384","0.625694","0.62548053","0.6251234","0.6240128","0.6226096","0.62158215","0.62102205","0.62072927","0.6200744","0.6199379","0.61957073","0.61807716","0.61654747","0.6142801","0.61239934","0.6121214","0.61183596","0.6105505","0.6073445","0.6048859","0.6030843","0.6029003","0.60238105","0.601641","0.59911305","0.598936","0.5988211","0.59872574","0.59610385","0.59559953","0.5953618","0.5944356","0.5934199","0.5928434","0.5908737","0.59085727","0.5896641","0.5891888","0.58918315","0.58757514","0.58750933"],"string":"[\n \"0.7948833\",\n \"0.79420406\",\n \"0.7860005\",\n \"0.7762703\",\n \"0.7674831\",\n \"0.7672587\",\n \"0.75724417\",\n \"0.74276704\",\n \"0.72801906\",\n \"0.72801906\",\n \"0.72801906\",\n \"0.72574735\",\n \"0.71175265\",\n \"0.7104059\",\n \"0.71037406\",\n \"0.7057032\",\n \"0.6996928\",\n \"0.69433475\",\n \"0.69009686\",\n \"0.68490225\",\n \"0.6792626\",\n \"0.6788472\",\n \"0.6749746\",\n \"0.67459744\",\n \"0.67394125\",\n \"0.67392135\",\n \"0.67392135\",\n \"0.672823\",\n \"0.67098063\",\n \"0.66881526\",\n \"0.6682118\",\n \"0.6680393\",\n \"0.6675211\",\n \"0.66605693\",\n \"0.66438395\",\n \"0.663735\",\n \"0.6625476\",\n \"0.6619497\",\n \"0.66135186\",\n \"0.6612828\",\n \"0.6599553\",\n \"0.65589356\",\n \"0.6549294\",\n \"0.6498661\",\n \"0.6489125\",\n \"0.6469346\",\n \"0.6458742\",\n \"0.64113504\",\n \"0.63894993\",\n \"0.6383509\",\n \"0.6373229\",\n \"0.6368509\",\n \"0.6358853\",\n \"0.63341725\",\n \"0.6327635\",\n \"0.63044006\",\n \"0.63031054\",\n \"0.629775\",\n \"0.62963384\",\n \"0.625694\",\n \"0.62548053\",\n \"0.6251234\",\n \"0.6240128\",\n \"0.6226096\",\n \"0.62158215\",\n \"0.62102205\",\n \"0.62072927\",\n \"0.6200744\",\n \"0.6199379\",\n \"0.61957073\",\n \"0.61807716\",\n \"0.61654747\",\n \"0.6142801\",\n \"0.61239934\",\n \"0.6121214\",\n \"0.61183596\",\n \"0.6105505\",\n \"0.6073445\",\n \"0.6048859\",\n \"0.6030843\",\n \"0.6029003\",\n \"0.60238105\",\n \"0.601641\",\n \"0.59911305\",\n \"0.598936\",\n \"0.5988211\",\n \"0.59872574\",\n \"0.59610385\",\n \"0.59559953\",\n \"0.5953618\",\n \"0.5944356\",\n \"0.5934199\",\n \"0.5928434\",\n \"0.5908737\",\n \"0.59085727\",\n \"0.5896641\",\n \"0.5891888\",\n \"0.58918315\",\n \"0.58757514\",\n \"0.58750933\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.78904974"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":22886,"cells":{"query":{"kind":"string","value":"Yields counts of character ngrams from string s of order n."},"document":{"kind":"string","value":"def extract_char_ngrams(self, s: str, n: int) -> Counter:\n return Counter([s[i:i + n] for i in range(len(s) - n + 1)])"},"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 extract_char_ngrams(s: str, n: int) -> Counter:\n return Counter([s[i:i + n] for i in range(len(s) - n + 1)])","def precook(s, n=4, out=False):\n words = s.split()\n counts = defaultdict(int)\n for k in xrange(1,n+1):\n for i in xrange(len(words)-k+1):\n ngram = tuple(words[i:i+k])\n counts[ngram] += 1\n return counts","def _create_ngrams(tokens, n):\n\n ngrams = collections.Counter()\n for ngram in (tuple(tokens[i:i + n]) for i in xrange(len(tokens) - n + 1)):\n ngrams[ngram] += 1\n return ngrams","def _precook(s, n=4, out=False):\n if isinstance(s,str):\n words = s.split()\n # print(words)\n elif isinstance(s,list) or isinstance(s,tuple):\n words = s\n else:\n raise NotImplementedError(type(s))\n counts = defaultdict(int)\n for k in range(1, n + 1):\n for i in range(len(words) - k + 1):\n ngram = tuple(words[i:i + k])\n counts[ngram] += 1\n return (len(words), counts)","def _generateNgrams(self,text,n=2):\n token = Utilities.CVTokeniser(text)\n # token = nltk.word_tokenize(text)\n computedNgrams=ngrams(token,n)\n return Counter(computedNgrams)","def ngrams(text, n):\n return chain(*[ngrams_(text, i) for i in range(n + 1)])","def ngramas(n, string):\n\n ngrams = []\n i = 0\n while i + n < len(string):\n ngrams.append(string[i:i + n])\n i += 1\n\n return ngrams","def find_ngrams(self, n):\n\n output = {}\n\n for i in range(len(self.text)-n+1):\n s = ' '.join(self.text[i:i+n])\n # if s is not already in dictionary, set value to 0\n output.setdefault(s, 0)\n output[s] += 1\n return output","def get_ngrams(seq, n):\n return","def __init__(self, n, sents, corpus=''):\n assert n > 0\n self.n = n\n self.counts = counts = defaultdict(int)\n self.corpus = corpus\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 for i in range(len(sent) - n + 1):\n ngram = tuple(sent[i: i + n])\n counts[ngram] += 1\n counts[ngram[:-1]] += 1","def n_grams(tokens, n):\n return zip(*[tokens[i:] for i in range(n)])","def chngrams(string=\"\", n=3, top=None, threshold=0, exclude=[], **kwargs):\n\t# An optional dict-parameter can be used to specify a subclass of dict,\n\t# e.g., count(words, dict=readonlydict) as used in Document.\n\tcount = defaultdict(int)\n\tif n > 0:\n\t\tfor i in xrange(len(string)-n+1):\n\t\t\tw = string[i:i+n]\n\t\t\tif w not in exclude:\n\t\t\t\tcount[w] += 1\n\tif threshold > 0:\n\t\tcount = dict((k, v) for k, v in count.items() if v > threshold)\n\tif top is not None:\n\t\tcount = dict(heapq.nsmallest(top, count.items(), key=lambda kv: (-kv[1], kv[0])))\n\treturn kwargs.get(\"dict\", dict)(count)","def ngrams_(text, n):\n return zip(*[text[i:] for i in range(n)])","def _get_ngrams(segments, order):\n ngram_counts = collections.Counter()\n for seg in segments:\n for i in range(0, len(seg) - order + 1):\n ngram = tuple(seg[i:i+order])\n ngram_counts[ngram] += 1\n return ngram_counts","def sent_to_n_grams(sent: str, n: int) -> Iterator[Tuple[str, ...]]:\n\n words = [word for word in sent.split() if word not in string.punctuation]\n\n rows = [words[i:] for i in range(n)]\n\n return zip(*rows)","def ngrams(name_string, n=3):\n\n string = re.sub(r'[,-./]|\\sBD', r'', name_string)\n n_grams = zip(*[string[i:] for i in range(n)])\n return [''.join(n_gram) for n_gram in n_grams]","def iter_ngrams(self, sentence, n):\n return [tuple(sentence[i : i+n]) for i in range(len(sentence)-n+1)]","def compute_ngrams(str, n=2):\n #split the string\n st = tuple(str.split())\n #not list of list but list of tuple..\n gram = [st[x:x+n] for x in range(len(st)-n+1)]\n dgram = {}\n #convert ngram into dictionary:\n for key in gram:\n dgram.setdefault(key[0],[]).append(key[1:])\n return dgram","def count_n_grams(data, n, start_token='<s>', end_token = '<e>'):\r\n \r\n # Initialize dictionary of n-grams and their counts\r\n n_grams = {}\r\n\r\n \r\n for sentence in data: # complete this line\r\n \r\n # prepend start token n times, and append <e> one time\r\n sentence = [start_token]*n + sentence + [end_token]\r\n \r\n # convert list to tuple\r\n # So that the sequence of words can be used as\r\n # a key in the dictionary\r\n sentence = tuple(sentence)\r\n\r\n \r\n for i in range(len(sentence)+1-n): # complete this line\r\n\r\n # Get the n-gram from i to i+n\r\n n_gram = sentence[i:i+n]\r\n\r\n # check if the n-gram is in the dictionary\r\n if n_gram in n_grams: \r\n \r\n # Increment the count for this n-gram\r\n n_grams[n_gram] += 1\r\n else:\r\n # Initialize this n-gram count to 1\r\n n_grams[n_gram] = 1\r\n \r\n return n_grams","def count_reddit_comments_ngram_strs(year, month, n):\n ngram_strs = ngram_extract.extract_reddit_comments_ngram_strs(year, month, n)\n return Counter(itertools.chain.from_iterable(ngram_strs))","def count_ngrams(f, N):\n\t#print \">>> Computing n-gram frequency counts ...\"\n\t#freqs[n] contains n-gram frequencies, freqs[n-1] contains (n-1)-gram frequencies, etc.\n\tfreqs = collections.defaultdict(lambda: collections.defaultdict(int))\n\ttot =0\n\tfor line in f:\n\t\ttot +=1\n\t\tw = line\n\t\tfifo = [':'] * N # initialise n-gram storage with \":\" as stop characters\n\t\tfor i in range(N-1):\n\t\t\tw += ':'\n\t\tfor c in w:\n\t\t\tfifo.pop(0)\n\t\t\tfifo.append(c)\n\t\t\tfor idx in range(N):\n\t\t\t\tn = idx + 1\n\t\t\t\tngram = ''.join(fifo[:n]) # n-gram = first n characters in fifo\n\t\t\t\tfreqs[n][ngram] += 1\n\treturn freqs","def build_ngrams(tokens, n=2):\n ngrams = zip(*(islice(group, idx, None) for idx, group in enumerate(tee(tokens, n))))\n return ngrams","def ngrams(word, size):\n expanded = \"^\" + word + \"$\"\n for start in range(len(expanded) - size + 1):\n yield expanded[start:start + size]","def find_frequency(text, n=1):\n freqs = {}\n length = len(text)\n for i in xrange(0, length):\n upper = i+n\n if upper > length:\n break\n gram = text[i:upper]\n dict_operate(freqs, gram, 1, operator.add)\n return freqs","def repeatedString(s, n):\n\n count = 0\n s_count_a = s.count('a')\n\n count += math.floor(n / len(s)) * s_count_a\n for _ in range(n % len(s)):\n if s[_] == 'a':\n count += 1\n\n return count","def n_grams(tokens, n=1):\n shiftToken = lambda i: (el for j,el in enumerate(tokens) if j>=i)\n shiftedTokens = (shiftToken(i) for i in range(n))\n tupleNGrams = zip(*shiftedTokens)\n return tupleNGrams","def ngrams(text, n):\n grams = zip(*[text[i:] for i in range(n)])\n return [''.join(gram) for gram in grams]","def calculate_ngram_frequencies(text, n):\n\n import re\n\n # Create a new dictionary\n ngram_dict = {}\n\n # Find all sentences\n sentences_list = re.findall(r'[^\\.\\?!\"]+', text)\n\n # Iterate over sentences in the list\n for sentence in sentences_list:\n # Split words by a whitespace character\n words_list = sentence.rsplit()\n\n # Iterate over ngrams in the sentence\n for i in range(len(words_list) - n + 1):\n\n # Join the words to size of n\n ngram = ' '.join(words_list[i:i + n])\n\n # Record the presence of a new ngram\n if not ngram in ngram_dict:\n ngram_dict[ngram] = 1\n\n # Add the number of occurrence of the ngram\n elif ngram in ngram_dict:\n ngram_dict[ngram] += 1\n\n return ngram_dict","def _get_ngrams_with_counter(segment, max_order):\n ngram_counts = collections.Counter()\n for order in xrange(1, max_order + 1):\n for i in xrange(0, len(segment) - order + 1):\n ngram = tuple(segment[i:i + order])\n ngram_counts[ngram] += 1\n return ngram_counts","def ngrams(self, n=1, uncased=False, filter_fn=None, as_strings=True):\n\n def _skip(gram):\n if not filter_fn:\n return False\n return filter_fn(gram)\n\n words = self.words(True)\n ngrams = [(s, e + 1)\n for s in range(len(words))\n for e in range(s, min(s + n, len(words)))\n if not _skip(words[s:e + 1])]\n\n # Concatenate into strings\n if as_strings:\n ngrams = ['{}'.format(' '.join(words[s:e])) for (s, e) in ngrams]\n\n return ngrams","def ngrams(sequence, n):\n # credit: http://stackoverflow.com/questions/2380394/simple-implementation-of-n-gram-tf-idf-and-cosine-similarity-in-python\n sequence = list(sequence)\n count = max(0, len(sequence) - n + 1)\n return [tuple(sequence[i:i+n]) for i in range(count)]","def _ngrams(self, string_):\n def find_ngrams(input_list, n):\n return zip(*[input_list[i:] for i in range(n)])\n\n ngrams = []\n tokens = string_.split()\n\n for size in range(1, self._ngram_range + 1):\n tuples = find_ngrams(tokens, size)\n concatenated = [\"_\".join(tuple_) for tuple_ in tuples]\n ngrams.extend(concatenated)\n\n return \" \".join(ngrams)","def n_grama(sentence, n):\n t = tokenize(sentence)\n n_grams = zip(*[t[i:] for i in range(n)])\n return list(map(lambda n_gram: ' '.join(n_gram), n_grams))","def ngrams(self, n=1, uncased=False, filter_fn=None, as_strings=True):\n def _skip(gram):\n if not filter_fn:\n return False\n return filter_fn(gram)\n\n words = self.words(uncased)\n ngrams = [(s, e + 1)\n for s in range(len(words))\n for e in range(s, min(s + n, len(words)))\n if not _skip(words[s:e + 1])]\n\n # Concatenate into strings\n if as_strings:\n ngrams = ['{}'.format(' '.join(words[s:e])) for (s, e) in ngrams]\n\n return ngrams","def ngrams(words, n=1):\n return [tuple(words[j:j + n]) for j in range(len(words) - n + 1)]","def gen_ngrams(items, n):\n ngs = {}\n ilen = len(items)\n for i in xrange(ilen-n+1):\n ng = tuple(items[i:i+n])\n ngs[ng] = ngs.get(ng, 0) + 1\n return ngs","def substrCount(n, s):\r\n lst = []\r\n character = s[0]\r\n count = 1\r\n result = 0\r\n for i in range(1, n):\r\n if s[i] == character:\r\n count += 1\r\n else:\r\n lst.append((character, count))\r\n character = s[i]\r\n count = 1\r\n lst.append((character, count))\r\n\r\n for tpl in lst:\r\n \"\"\"calculate all possible palindromes created from same characters that are close to each other\r\n E.g: aaa => 6 possibles (3*4//2 = 6)\r\n \"\"\"\r\n result += tpl[1] * (tpl[1] + 1) // 2\r\n\r\n for i in range(1, len(lst) - 1):\r\n if lst[i - 1][0] == lst[i + 1][0] and lst[i][1] == 1:\r\n \"\"\"\r\n check palindromes created from 3 tuples with a different character in between\r\n \"\"\"\r\n result += min(lst[i - 1][1], lst[i + 1][1])\r\n\r\n return result","def word2ngrams(text, n=3):\n return [text[i:i+n] for i in range(len(text)-n+1)]","def generate_ngrams(iterable, n):\n return zip(*[itertools.islice(it, i, None) for i, it in enumerate(itertools.tee(iterable, n))])","def _count_ngram(ngram_input_list: Sequence[str], n_gram: int) ->Counter:\n ngram_counter: Counter = Counter()\n for i in range(1, n_gram + 1):\n for j in range(len(ngram_input_list) - i + 1):\n ngram_key = tuple(ngram_input_list[j:i + j])\n ngram_counter[ngram_key] += 1\n return ngram_counter","def sent2ngrams(text, n=3):\n if n == \"word\":\n return text.split()\n return list(chain(*[word2ngrams(i,n) for i in text.lower().split()]))","def ngrams(n, target):\n chars = collections.deque()\n while True:\n chars.append((yield))\n if len(chars) == n: \n target.send(chars)\n chars.popleft()","def get(self, n):\n parts = [' '.join(g) for g in ngrams(self.words, n)]\n return get_occurences(parts)","def word_ngrams(sent, n):\n\t\n\t# EXAMPLES \n\t# > word_ngrams(tokenize('hello world'), 1)\n\t# [('hello',), ('world',)]\n\t# > word_ngrams(tokenize('hello world'), 2)\n\t# [('<s>', 'hello'), ('hello', 'world'), ('world', '</s>')]\n\n\t# YOUR CODE HERE\n\ttokenized_sent = tokenize(sent)\n\tif n != 1:\n\t\ttokenized_sent.insert(0, '<s>')\n\t\ttokenized_sent.append('</s>')\n\treturn [tuple(tokenized_sent[i:i + n]) for i in range(0, len(tokenized_sent)-n+1)]","def get_ngrams(s, ngram_range=1):\n # tokens = s.split()\n # return filter(lambda token: len(token)>1, tokens)\n # return bigrams(s.split()) # NLTK bigrams method\n words = s.split()\n return [' '.join(words[i:i+ngram_range]) for i in range(len(words)-1)]","def ngrams(word, n):\n word = list(word)\n # insert extra tokens\n word.insert(0, '$')\n word.append('$')\n\n output = []\n for i in range(len(word) - n + 1):\n # print(i)\n # print(word[i:i + n])\n output.append(''.join(word[i:i + n]))\n return output","def extract_ngrams(line, min_order=1, max_order=NGRAM_ORDER) -> Counter:\n\n ngrams = Counter()\n tokens = line.split()\n for n in range(min_order, max_order + 1):\n for i in range(0, len(tokens) - n + 1):\n ngram = ' '.join(tokens[i: i + n])\n ngrams[ngram] += 1\n\n return ngrams","def extract_n_grams(string, n, overlap=0, unique=True):\n if n > len(string):\n return [] \n\n n_grams = []\n step = n - overlap\n n_grams = [string[i:i+n] for i in range(0, len(string)-step+1, step)]\n\n if unique:\n n_grams = list(set(n_grams))\n\n n_grams = [g+\"\\n\" for g in n_grams]\n\n return n_grams","def __makeNgrams(self, n):\n # start_time = time.time()\n ngrams = dict()\n itergrams = dict()\n\n for k in range(2,n+1):\n itergrams[k] = list(nltk.ngrams(self.words, k))\n\n for k, grams in itergrams.items():\n kgrams = defaultdict(Counter)\n for gram in grams: \n kgram = list(gram)\n key = ' '.join(kgram[:k-1])\n kgrams[key].update({kgram[-1]})\n ngrams[k] = kgrams\n # print ('finish gen ', k, 'grams at ', time.time()-start_time)\n return ngrams","def _count_ngram(ngram_input_list: Sequence[str], n_gram: int) -> Counter:\n ngram_counter: Counter = Counter()\n\n for i in range(1, n_gram + 1):\n for j in range(len(ngram_input_list) - i + 1):\n ngram_key = tuple(ngram_input_list[j : (i + j)])\n ngram_counter[ngram_key] += 1\n\n return ngram_counter","def __init__(self, n, sents):\n assert n > 0\n self._n = n\n print(\"Counting...\")\n count = defaultdict(int)\n while n >= 0:\n for sent in sents:\n s = sent[:] # En una oracion auxiliar agrego el item de start y end para contarlos\n s.insert(0, \"<s>\")\n s.append(\"</s>\")\n for i in range(len(s) - n + 1):\n count[tuple(s[i:i + n])] += 1\n n -= 1\n count[()] = count[()] - count[('<s>',)] - count[\n ('</s>',)] # Pero no quiero que <s> y </s> sean considerados por ()\n self._count = count\n print(\"Computing vocabulary...\")\n self._voc = voc = set()\n for sent in sents:\n voc = voc.union(set(sent))\n voc.add('</s>')\n self._voc = voc\n self._V = len(voc) # vocabulary size\n print(\"Done\")","def count_ngrams(file_name, n=2):\n # The defaultdict class may be useful here. Check the python \n # documentation for more information: \n # https://docs.python.org/3/library/collections.html#collections.defaultdict\n\n file = open(file_name, \"r\")\n text = []\n gram_dict = {}\n for line in file:\n exclude = set(string.punctuation)\n line = ''.join(char for char in line if char not in exclude)\n line = line.replace(\"\\n\", \"\").lower()\n text.extend(line.split())\n\n for wordIndex in range(0,len(text)-n+1):\n tmpLi = []\n for x in range(0,n):\n tmpLi.append(text[wordIndex + x])\n tup = tuple(tmpLi)\n if tup not in gram_dict:\n gram_dict[tup] = 1\n else:\n gram_dict[tup] += 1\n return gram_dict","def create_ngrams(word_list, n):\n yield zip(*[word_list[i:] for i in range(n)])","def grapheme_lengths(string):\n return iter(len(g) for g in graphemes(string))","def find_all_ngrams(dataset, n):\n return zip(*[dataset[i:] for i in xrange(n)])","def count_words(s, n):\n\n # TODO: Count the number of occurences of each word in s\n words = s.lower().split()\n dict = {}\n\n for item in words:\n dict[item] = words.count(item)\n\n # TODO: Sort the occurences in descending order (alphabetically in case of ties)\n items = dict.items()\n\n items.sort(key=lambda tup: tup[0])\n items.sort(key=lambda tup: tup[1], reverse=True)\n\n # TODO: Return the top n words as a list of tuples (<word>, <count>)\n return items[:n]","def calculateNGrams(text, n):\n\n return ([text[i:i+n] for i in range(len(text)-n+1)])","def ngrams(iterable, n=1):\n return zip(*(iterable[i:] for i in range(n)))","def count_given_ngrams2(seqx, ngrams, partial_order=True):\n # from batchpheno import utils\n\n # the input ngrams may or may not have the same length \n ngram_tb = {1: [], }\n for ngram in ngrams: # ngram is in tuple form \n if isinstance(ngram, tuple): \n length = len(ngram)\n if not ngram_tb.has_key(length): ngram_tb[length] = []\n ngram_tb[length].append(ngram)\n else: # assume to be unigrams \n assert isinstance(ngram, str)\n ngram_tb[1].append(ngram)\n \n # print('verify> ngram_tb:\\n%s\\n' % ngram_tb) # utils.sample_hashtable(ngram_tb, n_sample=10))\n\n ng_min, ng_max = min(ngram_tb.keys()), max(ngram_tb.keys())\n if partial_order:\n\n # evaluate all possible n-grams \n counts = count_ngrams2(seqx, min_length=ng_min, max_length=ng_max, partial_order=True)\n\n counts_prime = {}\n for n, ngx in ngram_tb.items(): # n in n-gram\n if not counts_prime.has_key(n): counts_prime[n] = {} \n if counts.has_key(n):\n for ngram in ngx: # query each desired ngram \n # if n == 1: print '> unigram: %s' % ngram\n # sorted('x') == sorted(('x', )) == ['x'] => f ngram is a unigram, can do ('e', ) or 'e'\n counts_prime[n][ngram] = counts[n][tuple(sorted(ngram))] \n else: \n for ngram in ngx: \n counts_prime[n][ngram] = 0 \n else: \n counts = count_ngrams2(seqx, min_length=ng_min, max_length=ng_max, partial_order=False)\n \n counts_prime = {}\n for n, ngx in ngram_tb.items(): # n in n-gram\n if not counts_prime.has_key(n): counts_prime[n] = {} \n if counts.has_key(n): \n for ngram in ngx: # query each desired ngram \n # assert isinstance(ngram, tuple), \"Ngram is not a tuple: %s\" % str(ngram)\n counts_prime[n][ngram] = counts[n][tuple(ngram)]\n else: \n for ngram in ngx: \n counts_prime[n][ngram] = 0 \n\n return counts_prime # n (as n-gram) -> counts (ngram -> count)","def generate_ngram(corpus,n=2):\r\n def generate_ngram_str(text,n):\r\n text = tokenizer.tokenize(text)\r\n for i in range(0, len(text)-n+1):\r\n yield text[i:i+n]\r\n if isinstance(corpus,str):\r\n for ngram in generate_ngram_str(corpus,n):\r\n yield ngram\r\n elif isinstance(corpus, (list, types.GeneratorType)):\r\n for text in corpus:\r\n for ngram in generate_ngram_str(text,n):\r\n yield ngram","def numberOfSubstrings(self, s: str) -> int:\n i = 0\n res = 0\n d = {c:0 for c in 'abc'}\n \n for j, val in enumerate(s):\n d[val] += 1\n while all(d.values()):\n d[s[i]] -= 1\n i += 1\n res += i\n \n return res","def _char_and_word_ngrams_counts(sentence: str, n_char_order: int, n_word_order: int, lowercase: bool) ->Tuple[Dict[int, Dict[Tuple[str, ...], Tensor]], Dict[int, Dict[Tuple[str, ...], Tensor]]]:\n if lowercase:\n sentence = sentence.lower()\n char_n_grams_counts = _ngram_counts(_get_characters(sentence, whitespace), n_char_order)\n word_n_grams_counts = _ngram_counts(_get_words_and_punctiation(sentence), n_word_order)\n return char_n_grams_counts, word_n_grams_counts","def count_words(s, n):\n \n strList = s.split(' ');#to split the string into a list of words\n rList = [];#to store the each word only once\n nList = [];#to store how many times each word has occured\n for i in range(len(strList)):\n if ((strList[i] in rList)==False):\n rList.append(strList[i]);\n nList.append(int(1));\n else:\n for j in range(len(rList)):\n if (strList[i]==rList[j]):\n nList[j]=nList[j]+1;\n \n tList = list();#a new empty tuple list\n for i in range(len(rList)):\n tList.append((rList[i],nList[i]));#construct the tuple list from rList and nList\n \n tList.sort(key=lambda tList: (-tList[1], tList[0]));#sort the tuple list: first by its 2nd element in reverse order \"-\", then sort by its 1st element in non-reverse order, no \"-\"\n \n # for testing\n #for i in tList:\n # print i;\n \n \n # TODO: Count the number of occurences of each word in s\n \n # TODO: Sort the occurences in descending order (alphabetically in case of ties)\n \n # TODO: Return the top n words as a list of tuples (<word>, <count>)\n \n return tList[:n] #return the first n pairs of elements as required","def get_ngrams(sequence, n):\n length = len(sequence)\n #if only require 1-gram, then we need to add one START and one END to the sequence. \n if n==1 or n==2:\n sequence=[\"START\"]*n+sequence+[\"STOP\"]\n end = n+1 #end i means that when n==1, we need to read one more data, that is to the end of sequence, which is slightly different from when n>1.\n #if require multi-grams, use the common calculation below.\n else:\n sequence = [\"START\"]*(n-1)+sequence+[\"STOP\"]\n end = 1\n if n==2:\n end = n\n result = []\n temp = ()\n #the process to construct the tuple-based array.\n for i in range(0,length+end):\n temp = tuple(sequence[i:i+n])\n\n result.append(temp)\n return result","def n_count(dna_string):\n a_count = 0\n c_count = 0\n g_count = 0\n t_count= 0\n for nuc in dna_string:\n if nuc.upper() == 'A':\n a_count += 1\n elif nuc.upper() == 'C':\n c_count += 1\n elif nuc.upper() == 'G':\n g_count += 1\n elif nuc.upper() == 'T':\n t_count += 1\n else:\n continue\n print(a_count, c_count, g_count, t_count)","def get_char_counts(string):\n counts = {}\n for char in iter(string):\n counts[char] = 1 if not char in counts.keys() else counts[char] + 1\n return counts","def extract_ngrams(line, min_order=1, max_order=BLEU.NGRAM_ORDER) -> Counter:\n\n ngrams = Counter() # type: Counter\n tokens = line.split()\n for n in range(min_order, max_order + 1):\n for i in range(0, len(tokens) - n + 1):\n ngram = ' '.join(tokens[i: i + n])\n ngrams[ngram] += 1\n\n return ngrams","def get_ngrams(tokens, min_n, max_n):\n all_ngrams = list()\n n_tokens = len(tokens)\n for i in range(n_tokens):\n for j in range(i + min_n, min(n_tokens, i + max_n) + 1):\n all_ngrams.append(\" \".join(tokens[i:j]))\n return all_ngrams","def nwords(s: str):\n letters = \"ABCDEFGHIJKLMNOPQRSTUVWXYZÄÜÖabcdefghijklmnopqrstuvwxyzüäö\"\n take = 0\n skip = 0\n for i in s:\n if i not in letters:\n skip += 1\n #print(\"S:\", skip)\n else:\n take += 1\n #print(\"t:\", take)\n res = (len(s) - take) + 1\n return res","def wc(substring):\n n = 0\n try:\n while True:\n n += (yield)\n except GeneratorExit:\n print(substring, n, flush=True)","def count_ngram(hyps_resp, n):\n if len(hyps_resp) == 0:\n print(\"ERROR, eval_distinct get empty input\")\n return\n\n if type(hyps_resp[0]) != list:\n print(\"ERROR, eval_distinct takes in a list of <class 'list'>, get a list of {} instead\".format(\n type(hyps_resp[0])))\n return\n\n ngram = set()\n for resp in hyps_resp:\n if len(resp) < n:\n continue\n for i in range(len(resp) - n + 1):\n ngram.add(' '.join(resp[i: i + n]))\n return len(ngram)","def findRepeatedDnaSequences(s):\n\n # empty string or string < 10 chars\n if s == '' or len(s) < 10:\n raise ValueError(\"String must be of length 10+. String: '{}' is too small.\".format(s))\n\n ten_letter_counts = {}\n two_or_more = set()\n\n i = 0\n while (i + 10) <= len(s):\n # get 10 letter substring\n sub = s[i:i+10]\n\n # get current count, if not seen before, set count to 1\n ten_letter_counts[sub] = ten_letter_counts.get(sub, 0) + 1\n\n # check if occures >= 2\n if ten_letter_counts[sub] >= 2:\n two_or_more.append(sub)\n\n\n i += 1\n\n return two_or_more","def get_tag_n_gram(n, filename):\n\n from collections import deque\n queue = deque()\n\n count_matrix = {}\n with open(filename) as f:\n for l in f:\n line = l.strip().split()\n if not line:\n continue\n\n tag = line[0]\n # Use a queue to keep track of conditioned string,\n # the occurence of last N - 1 string.\n queue.appendleft(tag)\n\n # Fill the queue until it gets at least N tags.\n if len(queue) > n - 1:\n k = \" \".join(queue)\n if k not in count_matrix.keys():\n count_matrix[k] = 1\n else:\n count_matrix[k] += 1\n\n # Get rid of last one.\n queue.pop()\n\n return count_matrix","def get_ngrams(sequence, n):\n\n # Set prefix and postfix\n prefix = \"START\"\n postfix = \"STOP\"\n # Append 1 prefix regardless of value of n\n sequence.insert(0, prefix)\n for i in range(n - 2) :\n sequence.insert(0, prefix)\n sequence.append(postfix)\n\n # Check if 1 <= n <= len(sequence)\n if (n > len(sequence)) :\n print(sequence)\n assert 1 <= n\n assert n <= len(sequence)\n\n # Create n-gram sequence\n n_gram_sequence = []\n for i in range(n, len(sequence) + 1) :\n temp_sequence = []\n for j in range(i - n, i) :\n temp_sequence.append(sequence[j])\n n_gram_sequence.append(tuple(temp_sequence))\n return n_gram_sequence","def count_ngrams(self):\n self.unigram = self.count_unigram(self.word_list)\n self.bigram = self.count_bigram(self.word_list)\n # self.trigram = self.count_trigram(self.word_list)\n # self.four_gram = self.count_four_gram(self.word_list)\n # self.five_gram = self.count_five_gram(self.word_list)","def everygrams(seq):\n for n in range(1, len(seq) + 1):\n for ng in nltk.util.ngrams(seq, n):\n yield ng","def full_ngrams(items, n):\n ngs = {}\n for i in xrange(1, n+1):\n ngs.update(gen_ngrams(items, i))\n return ngs","def bin_string_iter(n):\n for bin_string in product([0, 1], repeat=n):\n yield list(bin_string)","def ngram(self,phrase,n,unity=\"w\"):\n return self._support.ngram(phrase,n,unity)","def get_ngrams(s, ngmin=1, ngmax=1, tokenizer=list, separator=\"|\"):\n ngrams = [[] for x in range(ngmin, ngmax + 1)]\n s = tokenizer(s)\n for i, ch in enumerate(s):\n for ngsize in range(ngmin, ngmax + 1):\n if (i + ngsize) <= len(s):\n ngrams[ngsize - 1].append(separator.join(s[i:i+ngsize]))\n return ngrams","def part1(input_string):\n twos, threes = 0, 0\n for line in input_string:\n letters_seen = {}\n for char in line:\n letters_seen[char] = letters_seen.setdefault(char, 0)+1\n if 2 in letters_seen.values():\n twos += 1\n if 3 in letters_seen.values():\n threes += 1\n return threes * twos","def count_ngrams(phrase, length, lang):\n count = 0\n chinese_character_to_sound = {u'\\u5341': 's', u'\\u4e8c': 'e', u'\\u4e09': 's', u'\\u56db': 's',\n u'\\u4e94': 'w', u'\\u516d': 'l', u'\\u4e03': 'q', u'\\u516b': 'b', u'\\u5e5d': 'j'}\n ngram_downloader_langcode = {\"english\": \"eng\", \"chinese\": \"chi-sim\", \"french\": \"fre\",\n \"german\": \"ger\", \"hebrew\": \"heb\", \"italian\": \"ita\", \"russian\": \"rus\", \"spanish\": \"spa\"}\n\n if lang == \"chinese\":\n index = chinese_character_to_sound[phrase[0].lower()]\n else:\n index = phrase[0].lower()\n\n all_combinations = get_combo(index, length)\n print(all_combinations)\n\n fname, url, records = next(readline_google_store(\n ngram_len=length, lang=ngram_downloader_langcode[lang], indices=all_combinations))\n\n try:\n record = next(records)\n print(record.ngram)\n while record.ngram != phrase:\n record = next(records)\n print(record.ngram)\n\n while record.ngram == phrase:\n count += record.match_count\n record = next(records)\n print(record.ngram)\n\n except StopIteration:\n pass\n\n return count","def n_gram(list, n):\n ngrams = zip(*[list[i:] for i in range(n)])\n return [\" \".join(ngram) for ngram in ngrams]","def words_used_n_times(word_count_dict, n):\n n_times = []\n # TODO 6: define this function\n return n_times","def get_ngrams(stats,s,t,i):\n #lemma ngrams\n ngram_sizes = [\"bi\", \"tri\"]\n for ngram_size in ngram_sizes:\n lm_ngram = get_lemma_ngrams(s, t, i, ngram_size)\n if lm_ngram:\n put_feature_value_list(stats,\"lemma_\" + ngram_size + \"gr\", lm_ngram)\n\n #POS and deprel bigrams\n if i < s.length-1:\n put_feature_value_list(stats,\"deprels_bigr\", (t.deprel,s.nodes[i+1].deprel))\n put_feature_value_list(stats,\"pos_bigr\", (t.pos,s.nodes[i+1].pos))\n \n #POS and deprel trigrams\n if i < s.length-2:\n put_feature_value_list(stats,\"deprels_trigr\", (t.deprel, s.nodes[i+1].deprel, s.nodes[i+2].deprel))\n put_feature_value_list(stats,\"pos_trigr\", (t.pos, s.nodes[i+1].pos, s.nodes[i+2].pos))\n\n return stats","def get_grams(candidate, n):\n words = candidate.split(' ')\n # print(words)\n grams = list()\n for i in range(len(words) - n + 1):\n # print(words[i:i+n])\n grams.append(' '.join(words[i:i+n]))\n return grams","def find_ngrams(input_list, n=3):\n return zip(*[input_list[i:] for i in range(n)])","def get_ngrams(self, n = None):\n if not n:\n n = self.N\n\n temp = []\n for sent in self.get_sentences():\n temp.extend(list(sent))\n\n return nltk.ngrams(temp, n)","def number_tokens(dgraph):\n cnt = 0\n for node in dgraph.subgraphs(exclude_root=True):\n node[WORD] = (cnt, node[WORD])\n cnt += 1\n return dgraph","def count_given_ngrams(seqx, ngrams, partial_order=True): \n\n # usu. the input ngrams have the same length \n ngram_tb = {1: [], }\n for ngram in ngrams: # ngram is in tuple form \n if isinstance(ngram, tuple): \n length = len(ngram)\n if not ngram_tb.has_key(length): ngram_tb[length] = []\n ngram_tb[length].append(ngram)\n else: # assume to be unigrams \n ngram_tb[1].append(ngram)\n \n ng_min, ng_max = min(ngram_tb.keys()), max(ngram_tb.keys())\n if partial_order:\n\n # evaluate all possible n-grams \n counts = count_ngrams2(seqx, min_length=ng_min, max_length=ng_max, partial_order=True)\n\n counts_prime = {}\n for n, ngx in ngram_tb.items(): # n in n-gram\n if counts.has_key(n): \n for ngram in ngx: # query each desired ngram \n # if n == 1: print '> unigram: %s' % ngram\n # sorted('x') == sorted(('x', )) == ['x'] => f ngram is a unigram, can do ('e', ) or 'e'\n counts_prime[ngram] = counts[n][tuple(sorted(ngram))] \n else: \n for ngram in ngx: \n counts_prime[ngram] = 0 \n else: \n counts = count_ngrams2(seqx, min_length=ng_min, max_length=ng_max, partial_order=False)\n \n counts_prime = {}\n for n, ngx in ngram_tb.items(): # n in n-gram\n if counts.has_key(n): \n for ngram in ngx: # query each desired ngram \n counts_prime[ngram] = counts[n][tuple(ngram)]\n else: \n for ngram in ngx: \n counts_prime[ngram] = 0 \n\n return counts_prime # n-gram -> count","def make_ngrams(orig_source, n=2, start_marker=None, end_marker=None):\n source = orig_source[:] # Don't want to modify original if given a reference\n\n if start_marker is not None:\n if isinstance(source, str):\n source = start_marker + source\n else:\n source.insert(0, start_marker)\n\n if end_marker is not None:\n if isinstance(source, str):\n source += end_marker\n else:\n source.append(end_marker)\n\n for i in range(0, len(source) - n):\n yield source[i:i+n+1]","def range_ngrams(tokens, ngramRange=(1,2)):\n return chain(*(n_grams(tokens, i) for i in range(*ngramRange)))","def count_ngrams(word_list,n):\n ngram_dict = dict()\n for i in xrange(len(word_list)-n+1):\n ngram = tuple(word_list[i:i+n])\n if ngram in ngram_dict:\n # ngram already exists in dictionary\n # increment the count by 1\n ngram_dict[ngram] += 1\n else:\n # ngram does not exist in dictionary\n # initialize to 1\n ngram_dict[ngram] = 1\n return ngram_dict","def length(s: str) -> int:\n count = 0\n for i in s:\n count += 1\n return count","def count_chars(s: str) -> dict:\n count_dict = {}\n\n for c in s:\n if c in count_dict:\n count_dict[c] += 1\n else:\n count_dict[c] = 1\n\n return count_dict","def combinations(s, n):\n return (\"\".join(x) for x in tuples(s,n))","def mostFrequentNGram(text,n):\n\n ngram = calculateNGrams(text,n)\n return counterFrequency(ngram)","def __init__(self, sents, n, corpus='', D=None):\n\n self.n = n\n self.D = D\n self.corpus = corpus\n self.smoothingtechnique = 'Kneser Ney Smoothing'\n # N1+(·w_<i+1>)\n self._N_dot_tokens_dict = N_dot_tokens = defaultdict(set)\n # N1+(w^<n-1> ·)\n self._N_tokens_dot_dict = N_tokens_dot = defaultdict(set)\n # N1+(· w^<i-1>_<i-n+1> ·)\n self._N_dot_tokens_dot_dict = N_dot_tokens_dot = defaultdict(set)\n self.counts = counts = defaultdict(int)\n vocabulary = []\n\n if D is None:\n total_sents = len(sents)\n k = int(total_sents*9/10)\n training_sents = sents[:k]\n held_out_sents = sents[k:]\n training_sents = list(map(lambda x: ['<s>']*(n-1) + x + ['</s>'], training_sents))\n for sent in training_sents:\n for j in range(n+1):\n for i in range(n-j, len(sent) - j + 1):\n ngram = tuple(sent[i: i + j])\n counts[ngram] += 1\n if ngram:\n if len(ngram) == 1:\n vocabulary.append(ngram[0])\n else:\n right_token, left_token, right_kgram, left_kgram, middle_kgram =\\\n ngram[-1:], ngram[:1], ngram[1:], ngram[:-1], ngram[1:-1]\n N_dot_tokens[right_kgram].add(left_token)\n N_tokens_dot[left_kgram].add(right_token)\n if middle_kgram:\n N_dot_tokens_dot[middle_kgram].add(right_token)\n N_dot_tokens_dot[middle_kgram].add(left_token)\n if n - 1:\n counts[('<s>',)*(n-1)] = len(sents)\n self.vocab = set(vocabulary)\n aux = 0\n for w in self.vocab:\n aux += len(self._N_dot_tokens_dict[(w,)])\n self._N_dot_dot_attr = aux\n D_candidates = [i*0.12 for i in range(1, 9)]\n xs = []\n for D in D_candidates:\n self.D = D\n aux_perplexity = self.perplexity(held_out_sents)\n xs.append((D, aux_perplexity))\n xs.sort(key=lambda x: x[1])\n self.D = xs[0][0]\n with open('old-stuff/kneserney_' + str(n) + '_parameters_'+corpus, 'a') as f:\n f.write('Order: {}\\n'.format(self.n))\n f.write('D: {}\\n'.format(self.D))\n f.write('Perplexity observed: {}\\n'.format(xs[0][1]))\n f.write('-------------------------------\\n')\n f.close()\n\n # discount value D provided\n else:\n sents = list(map(lambda x: ['<s>']*(n-1) + x + ['</s>'], sents))\n for sent in sents:\n for j in range(n+1):\n # all k-grams for 0 <= k <= n\n for i in range(n-j, len(sent) - j + 1):\n ngram = tuple(sent[i: i + j])\n counts[ngram] += 1\n if ngram:\n if len(ngram) == 1:\n vocabulary.append(ngram[0])\n else:\n # e.g., ngram = (1,2,3,4,5,6,7,8)\n # right_token = (8,)\n # left_token = (1,)\n # right_kgram = (2,3,4,5,6,7,8)\n # left_kgram = (1,2,3,4,5,6,7)\n # middle_kgram = (2,3,4,5,6,7)\n right_token, left_token, right_kgram, left_kgram, middle_kgram =\\\n ngram[-1:], ngram[:1], ngram[1:], ngram[:-1], ngram[1:-1]\n N_dot_tokens[right_kgram].add(left_token)\n N_tokens_dot[left_kgram].add(right_token)\n if middle_kgram:\n N_dot_tokens_dot[middle_kgram].add(right_token)\n N_dot_tokens_dot[middle_kgram].add(left_token)\n if n-1:\n counts[('<s>',)*(n-1)] = len(sents)\n self.vocab = set(vocabulary)\n\n aux = 0\n for w in self.vocab:\n aux += len(self._N_dot_tokens_dict[(w,)])\n self._N_dot_dot_attr = aux\n\n xs = [k for k, v in counts.items() if v == 1 and n == len(k)]\n ys = [k for k, v in counts.items() if v == 2 and n == len(k)]\n n1 = len(xs)\n n2 = len(ys)\n self.D = n1 / (n1 + 2 * n2)","def run_length(s):\n\n s = re.sub(\"[^a-zA-Z]\",\"\", s)\n s = s.lower()\n cnt = 1\n y = []\n z = []\n ch = ''\n for i in range(len(s)):\n if i + 1 < len(s) and s[i] == s[i + 1]:\n cnt += 1\n else:\n if cnt > 1:\n z.append(s[i-1])\n y.append(str(cnt))\n else:\n z.append(s[i])\n y.append(str(cnt))\n cnt = 1\n for i in range(len(y)):\n ch = ch + y[i] + z[i]\n i += 1\n print ch"],"string":"[\n \"def extract_char_ngrams(s: str, n: int) -> Counter:\\n return Counter([s[i:i + n] for i in range(len(s) - n + 1)])\",\n \"def precook(s, n=4, out=False):\\n words = s.split()\\n counts = defaultdict(int)\\n for k in xrange(1,n+1):\\n for i in xrange(len(words)-k+1):\\n ngram = tuple(words[i:i+k])\\n counts[ngram] += 1\\n return counts\",\n \"def _create_ngrams(tokens, n):\\n\\n ngrams = collections.Counter()\\n for ngram in (tuple(tokens[i:i + n]) for i in xrange(len(tokens) - n + 1)):\\n ngrams[ngram] += 1\\n return ngrams\",\n \"def _precook(s, n=4, out=False):\\n if isinstance(s,str):\\n words = s.split()\\n # print(words)\\n elif isinstance(s,list) or isinstance(s,tuple):\\n words = s\\n else:\\n raise NotImplementedError(type(s))\\n counts = defaultdict(int)\\n for k in range(1, n + 1):\\n for i in range(len(words) - k + 1):\\n ngram = tuple(words[i:i + k])\\n counts[ngram] += 1\\n return (len(words), counts)\",\n \"def _generateNgrams(self,text,n=2):\\n token = Utilities.CVTokeniser(text)\\n # token = nltk.word_tokenize(text)\\n computedNgrams=ngrams(token,n)\\n return Counter(computedNgrams)\",\n \"def ngrams(text, n):\\n return chain(*[ngrams_(text, i) for i in range(n + 1)])\",\n \"def ngramas(n, string):\\n\\n ngrams = []\\n i = 0\\n while i + n < len(string):\\n ngrams.append(string[i:i + n])\\n i += 1\\n\\n return ngrams\",\n \"def find_ngrams(self, n):\\n\\n output = {}\\n\\n for i in range(len(self.text)-n+1):\\n s = ' '.join(self.text[i:i+n])\\n # if s is not already in dictionary, set value to 0\\n output.setdefault(s, 0)\\n output[s] += 1\\n return output\",\n \"def get_ngrams(seq, n):\\n return\",\n \"def __init__(self, n, sents, corpus=''):\\n assert n > 0\\n self.n = n\\n self.counts = counts = defaultdict(int)\\n self.corpus = corpus\\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 for i in range(len(sent) - n + 1):\\n ngram = tuple(sent[i: i + n])\\n counts[ngram] += 1\\n counts[ngram[:-1]] += 1\",\n \"def n_grams(tokens, n):\\n return zip(*[tokens[i:] for i in range(n)])\",\n \"def chngrams(string=\\\"\\\", n=3, top=None, threshold=0, exclude=[], **kwargs):\\n\\t# An optional dict-parameter can be used to specify a subclass of dict,\\n\\t# e.g., count(words, dict=readonlydict) as used in Document.\\n\\tcount = defaultdict(int)\\n\\tif n > 0:\\n\\t\\tfor i in xrange(len(string)-n+1):\\n\\t\\t\\tw = string[i:i+n]\\n\\t\\t\\tif w not in exclude:\\n\\t\\t\\t\\tcount[w] += 1\\n\\tif threshold > 0:\\n\\t\\tcount = dict((k, v) for k, v in count.items() if v > threshold)\\n\\tif top is not None:\\n\\t\\tcount = dict(heapq.nsmallest(top, count.items(), key=lambda kv: (-kv[1], kv[0])))\\n\\treturn kwargs.get(\\\"dict\\\", dict)(count)\",\n \"def ngrams_(text, n):\\n return zip(*[text[i:] for i in range(n)])\",\n \"def _get_ngrams(segments, order):\\n ngram_counts = collections.Counter()\\n for seg in segments:\\n for i in range(0, len(seg) - order + 1):\\n ngram = tuple(seg[i:i+order])\\n ngram_counts[ngram] += 1\\n return ngram_counts\",\n \"def sent_to_n_grams(sent: str, n: int) -> Iterator[Tuple[str, ...]]:\\n\\n words = [word for word in sent.split() if word not in string.punctuation]\\n\\n rows = [words[i:] for i in range(n)]\\n\\n return zip(*rows)\",\n \"def ngrams(name_string, n=3):\\n\\n string = re.sub(r'[,-./]|\\\\sBD', r'', name_string)\\n n_grams = zip(*[string[i:] for i in range(n)])\\n return [''.join(n_gram) for n_gram in n_grams]\",\n \"def iter_ngrams(self, sentence, n):\\n return [tuple(sentence[i : i+n]) for i in range(len(sentence)-n+1)]\",\n \"def compute_ngrams(str, n=2):\\n #split the string\\n st = tuple(str.split())\\n #not list of list but list of tuple..\\n gram = [st[x:x+n] for x in range(len(st)-n+1)]\\n dgram = {}\\n #convert ngram into dictionary:\\n for key in gram:\\n dgram.setdefault(key[0],[]).append(key[1:])\\n return dgram\",\n \"def count_n_grams(data, n, start_token='<s>', end_token = '<e>'):\\r\\n \\r\\n # Initialize dictionary of n-grams and their counts\\r\\n n_grams = {}\\r\\n\\r\\n \\r\\n for sentence in data: # complete this line\\r\\n \\r\\n # prepend start token n times, and append <e> one time\\r\\n sentence = [start_token]*n + sentence + [end_token]\\r\\n \\r\\n # convert list to tuple\\r\\n # So that the sequence of words can be used as\\r\\n # a key in the dictionary\\r\\n sentence = tuple(sentence)\\r\\n\\r\\n \\r\\n for i in range(len(sentence)+1-n): # complete this line\\r\\n\\r\\n # Get the n-gram from i to i+n\\r\\n n_gram = sentence[i:i+n]\\r\\n\\r\\n # check if the n-gram is in the dictionary\\r\\n if n_gram in n_grams: \\r\\n \\r\\n # Increment the count for this n-gram\\r\\n n_grams[n_gram] += 1\\r\\n else:\\r\\n # Initialize this n-gram count to 1\\r\\n n_grams[n_gram] = 1\\r\\n \\r\\n return n_grams\",\n \"def count_reddit_comments_ngram_strs(year, month, n):\\n ngram_strs = ngram_extract.extract_reddit_comments_ngram_strs(year, month, n)\\n return Counter(itertools.chain.from_iterable(ngram_strs))\",\n \"def count_ngrams(f, N):\\n\\t#print \\\">>> Computing n-gram frequency counts ...\\\"\\n\\t#freqs[n] contains n-gram frequencies, freqs[n-1] contains (n-1)-gram frequencies, etc.\\n\\tfreqs = collections.defaultdict(lambda: collections.defaultdict(int))\\n\\ttot =0\\n\\tfor line in f:\\n\\t\\ttot +=1\\n\\t\\tw = line\\n\\t\\tfifo = [':'] * N # initialise n-gram storage with \\\":\\\" as stop characters\\n\\t\\tfor i in range(N-1):\\n\\t\\t\\tw += ':'\\n\\t\\tfor c in w:\\n\\t\\t\\tfifo.pop(0)\\n\\t\\t\\tfifo.append(c)\\n\\t\\t\\tfor idx in range(N):\\n\\t\\t\\t\\tn = idx + 1\\n\\t\\t\\t\\tngram = ''.join(fifo[:n]) # n-gram = first n characters in fifo\\n\\t\\t\\t\\tfreqs[n][ngram] += 1\\n\\treturn freqs\",\n \"def build_ngrams(tokens, n=2):\\n ngrams = zip(*(islice(group, idx, None) for idx, group in enumerate(tee(tokens, n))))\\n return ngrams\",\n \"def ngrams(word, size):\\n expanded = \\\"^\\\" + word + \\\"$\\\"\\n for start in range(len(expanded) - size + 1):\\n yield expanded[start:start + size]\",\n \"def find_frequency(text, n=1):\\n freqs = {}\\n length = len(text)\\n for i in xrange(0, length):\\n upper = i+n\\n if upper > length:\\n break\\n gram = text[i:upper]\\n dict_operate(freqs, gram, 1, operator.add)\\n return freqs\",\n \"def repeatedString(s, n):\\n\\n count = 0\\n s_count_a = s.count('a')\\n\\n count += math.floor(n / len(s)) * s_count_a\\n for _ in range(n % len(s)):\\n if s[_] == 'a':\\n count += 1\\n\\n return count\",\n \"def n_grams(tokens, n=1):\\n shiftToken = lambda i: (el for j,el in enumerate(tokens) if j>=i)\\n shiftedTokens = (shiftToken(i) for i in range(n))\\n tupleNGrams = zip(*shiftedTokens)\\n return tupleNGrams\",\n \"def ngrams(text, n):\\n grams = zip(*[text[i:] for i in range(n)])\\n return [''.join(gram) for gram in grams]\",\n \"def calculate_ngram_frequencies(text, n):\\n\\n import re\\n\\n # Create a new dictionary\\n ngram_dict = {}\\n\\n # Find all sentences\\n sentences_list = re.findall(r'[^\\\\.\\\\?!\\\"]+', text)\\n\\n # Iterate over sentences in the list\\n for sentence in sentences_list:\\n # Split words by a whitespace character\\n words_list = sentence.rsplit()\\n\\n # Iterate over ngrams in the sentence\\n for i in range(len(words_list) - n + 1):\\n\\n # Join the words to size of n\\n ngram = ' '.join(words_list[i:i + n])\\n\\n # Record the presence of a new ngram\\n if not ngram in ngram_dict:\\n ngram_dict[ngram] = 1\\n\\n # Add the number of occurrence of the ngram\\n elif ngram in ngram_dict:\\n ngram_dict[ngram] += 1\\n\\n return ngram_dict\",\n \"def _get_ngrams_with_counter(segment, max_order):\\n ngram_counts = collections.Counter()\\n for order in xrange(1, max_order + 1):\\n for i in xrange(0, len(segment) - order + 1):\\n ngram = tuple(segment[i:i + order])\\n ngram_counts[ngram] += 1\\n return ngram_counts\",\n \"def ngrams(self, n=1, uncased=False, filter_fn=None, as_strings=True):\\n\\n def _skip(gram):\\n if not filter_fn:\\n return False\\n return filter_fn(gram)\\n\\n words = self.words(True)\\n ngrams = [(s, e + 1)\\n for s in range(len(words))\\n for e in range(s, min(s + n, len(words)))\\n if not _skip(words[s:e + 1])]\\n\\n # Concatenate into strings\\n if as_strings:\\n ngrams = ['{}'.format(' '.join(words[s:e])) for (s, e) in ngrams]\\n\\n return ngrams\",\n \"def ngrams(sequence, n):\\n # credit: http://stackoverflow.com/questions/2380394/simple-implementation-of-n-gram-tf-idf-and-cosine-similarity-in-python\\n sequence = list(sequence)\\n count = max(0, len(sequence) - n + 1)\\n return [tuple(sequence[i:i+n]) for i in range(count)]\",\n \"def _ngrams(self, string_):\\n def find_ngrams(input_list, n):\\n return zip(*[input_list[i:] for i in range(n)])\\n\\n ngrams = []\\n tokens = string_.split()\\n\\n for size in range(1, self._ngram_range + 1):\\n tuples = find_ngrams(tokens, size)\\n concatenated = [\\\"_\\\".join(tuple_) for tuple_ in tuples]\\n ngrams.extend(concatenated)\\n\\n return \\\" \\\".join(ngrams)\",\n \"def n_grama(sentence, n):\\n t = tokenize(sentence)\\n n_grams = zip(*[t[i:] for i in range(n)])\\n return list(map(lambda n_gram: ' '.join(n_gram), n_grams))\",\n \"def ngrams(self, n=1, uncased=False, filter_fn=None, as_strings=True):\\n def _skip(gram):\\n if not filter_fn:\\n return False\\n return filter_fn(gram)\\n\\n words = self.words(uncased)\\n ngrams = [(s, e + 1)\\n for s in range(len(words))\\n for e in range(s, min(s + n, len(words)))\\n if not _skip(words[s:e + 1])]\\n\\n # Concatenate into strings\\n if as_strings:\\n ngrams = ['{}'.format(' '.join(words[s:e])) for (s, e) in ngrams]\\n\\n return ngrams\",\n \"def ngrams(words, n=1):\\n return [tuple(words[j:j + n]) for j in range(len(words) - n + 1)]\",\n \"def gen_ngrams(items, n):\\n ngs = {}\\n ilen = len(items)\\n for i in xrange(ilen-n+1):\\n ng = tuple(items[i:i+n])\\n ngs[ng] = ngs.get(ng, 0) + 1\\n return ngs\",\n \"def substrCount(n, s):\\r\\n lst = []\\r\\n character = s[0]\\r\\n count = 1\\r\\n result = 0\\r\\n for i in range(1, n):\\r\\n if s[i] == character:\\r\\n count += 1\\r\\n else:\\r\\n lst.append((character, count))\\r\\n character = s[i]\\r\\n count = 1\\r\\n lst.append((character, count))\\r\\n\\r\\n for tpl in lst:\\r\\n \\\"\\\"\\\"calculate all possible palindromes created from same characters that are close to each other\\r\\n E.g: aaa => 6 possibles (3*4//2 = 6)\\r\\n \\\"\\\"\\\"\\r\\n result += tpl[1] * (tpl[1] + 1) // 2\\r\\n\\r\\n for i in range(1, len(lst) - 1):\\r\\n if lst[i - 1][0] == lst[i + 1][0] and lst[i][1] == 1:\\r\\n \\\"\\\"\\\"\\r\\n check palindromes created from 3 tuples with a different character in between\\r\\n \\\"\\\"\\\"\\r\\n result += min(lst[i - 1][1], lst[i + 1][1])\\r\\n\\r\\n return result\",\n \"def word2ngrams(text, n=3):\\n return [text[i:i+n] for i in range(len(text)-n+1)]\",\n \"def generate_ngrams(iterable, n):\\n return zip(*[itertools.islice(it, i, None) for i, it in enumerate(itertools.tee(iterable, n))])\",\n \"def _count_ngram(ngram_input_list: Sequence[str], n_gram: int) ->Counter:\\n ngram_counter: Counter = Counter()\\n for i in range(1, n_gram + 1):\\n for j in range(len(ngram_input_list) - i + 1):\\n ngram_key = tuple(ngram_input_list[j:i + j])\\n ngram_counter[ngram_key] += 1\\n return ngram_counter\",\n \"def sent2ngrams(text, n=3):\\n if n == \\\"word\\\":\\n return text.split()\\n return list(chain(*[word2ngrams(i,n) for i in text.lower().split()]))\",\n \"def ngrams(n, target):\\n chars = collections.deque()\\n while True:\\n chars.append((yield))\\n if len(chars) == n: \\n target.send(chars)\\n chars.popleft()\",\n \"def get(self, n):\\n parts = [' '.join(g) for g in ngrams(self.words, n)]\\n return get_occurences(parts)\",\n \"def word_ngrams(sent, n):\\n\\t\\n\\t# EXAMPLES \\n\\t# > word_ngrams(tokenize('hello world'), 1)\\n\\t# [('hello',), ('world',)]\\n\\t# > word_ngrams(tokenize('hello world'), 2)\\n\\t# [('<s>', 'hello'), ('hello', 'world'), ('world', '</s>')]\\n\\n\\t# YOUR CODE HERE\\n\\ttokenized_sent = tokenize(sent)\\n\\tif n != 1:\\n\\t\\ttokenized_sent.insert(0, '<s>')\\n\\t\\ttokenized_sent.append('</s>')\\n\\treturn [tuple(tokenized_sent[i:i + n]) for i in range(0, len(tokenized_sent)-n+1)]\",\n \"def get_ngrams(s, ngram_range=1):\\n # tokens = s.split()\\n # return filter(lambda token: len(token)>1, tokens)\\n # return bigrams(s.split()) # NLTK bigrams method\\n words = s.split()\\n return [' '.join(words[i:i+ngram_range]) for i in range(len(words)-1)]\",\n \"def ngrams(word, n):\\n word = list(word)\\n # insert extra tokens\\n word.insert(0, '$')\\n word.append('$')\\n\\n output = []\\n for i in range(len(word) - n + 1):\\n # print(i)\\n # print(word[i:i + n])\\n output.append(''.join(word[i:i + n]))\\n return output\",\n \"def extract_ngrams(line, min_order=1, max_order=NGRAM_ORDER) -> Counter:\\n\\n ngrams = Counter()\\n tokens = line.split()\\n for n in range(min_order, max_order + 1):\\n for i in range(0, len(tokens) - n + 1):\\n ngram = ' '.join(tokens[i: i + n])\\n ngrams[ngram] += 1\\n\\n return ngrams\",\n \"def extract_n_grams(string, n, overlap=0, unique=True):\\n if n > len(string):\\n return [] \\n\\n n_grams = []\\n step = n - overlap\\n n_grams = [string[i:i+n] for i in range(0, len(string)-step+1, step)]\\n\\n if unique:\\n n_grams = list(set(n_grams))\\n\\n n_grams = [g+\\\"\\\\n\\\" for g in n_grams]\\n\\n return n_grams\",\n \"def __makeNgrams(self, n):\\n # start_time = time.time()\\n ngrams = dict()\\n itergrams = dict()\\n\\n for k in range(2,n+1):\\n itergrams[k] = list(nltk.ngrams(self.words, k))\\n\\n for k, grams in itergrams.items():\\n kgrams = defaultdict(Counter)\\n for gram in grams: \\n kgram = list(gram)\\n key = ' '.join(kgram[:k-1])\\n kgrams[key].update({kgram[-1]})\\n ngrams[k] = kgrams\\n # print ('finish gen ', k, 'grams at ', time.time()-start_time)\\n return ngrams\",\n \"def _count_ngram(ngram_input_list: Sequence[str], n_gram: int) -> Counter:\\n ngram_counter: Counter = Counter()\\n\\n for i in range(1, n_gram + 1):\\n for j in range(len(ngram_input_list) - i + 1):\\n ngram_key = tuple(ngram_input_list[j : (i + j)])\\n ngram_counter[ngram_key] += 1\\n\\n return ngram_counter\",\n \"def __init__(self, n, sents):\\n assert n > 0\\n self._n = n\\n print(\\\"Counting...\\\")\\n count = defaultdict(int)\\n while n >= 0:\\n for sent in sents:\\n s = sent[:] # En una oracion auxiliar agrego el item de start y end para contarlos\\n s.insert(0, \\\"<s>\\\")\\n s.append(\\\"</s>\\\")\\n for i in range(len(s) - n + 1):\\n count[tuple(s[i:i + n])] += 1\\n n -= 1\\n count[()] = count[()] - count[('<s>',)] - count[\\n ('</s>',)] # Pero no quiero que <s> y </s> sean considerados por ()\\n self._count = count\\n print(\\\"Computing vocabulary...\\\")\\n self._voc = voc = set()\\n for sent in sents:\\n voc = voc.union(set(sent))\\n voc.add('</s>')\\n self._voc = voc\\n self._V = len(voc) # vocabulary size\\n print(\\\"Done\\\")\",\n \"def count_ngrams(file_name, n=2):\\n # The defaultdict class may be useful here. Check the python \\n # documentation for more information: \\n # https://docs.python.org/3/library/collections.html#collections.defaultdict\\n\\n file = open(file_name, \\\"r\\\")\\n text = []\\n gram_dict = {}\\n for line in file:\\n exclude = set(string.punctuation)\\n line = ''.join(char for char in line if char not in exclude)\\n line = line.replace(\\\"\\\\n\\\", \\\"\\\").lower()\\n text.extend(line.split())\\n\\n for wordIndex in range(0,len(text)-n+1):\\n tmpLi = []\\n for x in range(0,n):\\n tmpLi.append(text[wordIndex + x])\\n tup = tuple(tmpLi)\\n if tup not in gram_dict:\\n gram_dict[tup] = 1\\n else:\\n gram_dict[tup] += 1\\n return gram_dict\",\n \"def create_ngrams(word_list, n):\\n yield zip(*[word_list[i:] for i in range(n)])\",\n \"def grapheme_lengths(string):\\n return iter(len(g) for g in graphemes(string))\",\n \"def find_all_ngrams(dataset, n):\\n return zip(*[dataset[i:] for i in xrange(n)])\",\n \"def count_words(s, n):\\n\\n # TODO: Count the number of occurences of each word in s\\n words = s.lower().split()\\n dict = {}\\n\\n for item in words:\\n dict[item] = words.count(item)\\n\\n # TODO: Sort the occurences in descending order (alphabetically in case of ties)\\n items = dict.items()\\n\\n items.sort(key=lambda tup: tup[0])\\n items.sort(key=lambda tup: tup[1], reverse=True)\\n\\n # TODO: Return the top n words as a list of tuples (<word>, <count>)\\n return items[:n]\",\n \"def calculateNGrams(text, n):\\n\\n return ([text[i:i+n] for i in range(len(text)-n+1)])\",\n \"def ngrams(iterable, n=1):\\n return zip(*(iterable[i:] for i in range(n)))\",\n \"def count_given_ngrams2(seqx, ngrams, partial_order=True):\\n # from batchpheno import utils\\n\\n # the input ngrams may or may not have the same length \\n ngram_tb = {1: [], }\\n for ngram in ngrams: # ngram is in tuple form \\n if isinstance(ngram, tuple): \\n length = len(ngram)\\n if not ngram_tb.has_key(length): ngram_tb[length] = []\\n ngram_tb[length].append(ngram)\\n else: # assume to be unigrams \\n assert isinstance(ngram, str)\\n ngram_tb[1].append(ngram)\\n \\n # print('verify> ngram_tb:\\\\n%s\\\\n' % ngram_tb) # utils.sample_hashtable(ngram_tb, n_sample=10))\\n\\n ng_min, ng_max = min(ngram_tb.keys()), max(ngram_tb.keys())\\n if partial_order:\\n\\n # evaluate all possible n-grams \\n counts = count_ngrams2(seqx, min_length=ng_min, max_length=ng_max, partial_order=True)\\n\\n counts_prime = {}\\n for n, ngx in ngram_tb.items(): # n in n-gram\\n if not counts_prime.has_key(n): counts_prime[n] = {} \\n if counts.has_key(n):\\n for ngram in ngx: # query each desired ngram \\n # if n == 1: print '> unigram: %s' % ngram\\n # sorted('x') == sorted(('x', )) == ['x'] => f ngram is a unigram, can do ('e', ) or 'e'\\n counts_prime[n][ngram] = counts[n][tuple(sorted(ngram))] \\n else: \\n for ngram in ngx: \\n counts_prime[n][ngram] = 0 \\n else: \\n counts = count_ngrams2(seqx, min_length=ng_min, max_length=ng_max, partial_order=False)\\n \\n counts_prime = {}\\n for n, ngx in ngram_tb.items(): # n in n-gram\\n if not counts_prime.has_key(n): counts_prime[n] = {} \\n if counts.has_key(n): \\n for ngram in ngx: # query each desired ngram \\n # assert isinstance(ngram, tuple), \\\"Ngram is not a tuple: %s\\\" % str(ngram)\\n counts_prime[n][ngram] = counts[n][tuple(ngram)]\\n else: \\n for ngram in ngx: \\n counts_prime[n][ngram] = 0 \\n\\n return counts_prime # n (as n-gram) -> counts (ngram -> count)\",\n \"def generate_ngram(corpus,n=2):\\r\\n def generate_ngram_str(text,n):\\r\\n text = tokenizer.tokenize(text)\\r\\n for i in range(0, len(text)-n+1):\\r\\n yield text[i:i+n]\\r\\n if isinstance(corpus,str):\\r\\n for ngram in generate_ngram_str(corpus,n):\\r\\n yield ngram\\r\\n elif isinstance(corpus, (list, types.GeneratorType)):\\r\\n for text in corpus:\\r\\n for ngram in generate_ngram_str(text,n):\\r\\n yield ngram\",\n \"def numberOfSubstrings(self, s: str) -> int:\\n i = 0\\n res = 0\\n d = {c:0 for c in 'abc'}\\n \\n for j, val in enumerate(s):\\n d[val] += 1\\n while all(d.values()):\\n d[s[i]] -= 1\\n i += 1\\n res += i\\n \\n return res\",\n \"def _char_and_word_ngrams_counts(sentence: str, n_char_order: int, n_word_order: int, lowercase: bool) ->Tuple[Dict[int, Dict[Tuple[str, ...], Tensor]], Dict[int, Dict[Tuple[str, ...], Tensor]]]:\\n if lowercase:\\n sentence = sentence.lower()\\n char_n_grams_counts = _ngram_counts(_get_characters(sentence, whitespace), n_char_order)\\n word_n_grams_counts = _ngram_counts(_get_words_and_punctiation(sentence), n_word_order)\\n return char_n_grams_counts, word_n_grams_counts\",\n \"def count_words(s, n):\\n \\n strList = s.split(' ');#to split the string into a list of words\\n rList = [];#to store the each word only once\\n nList = [];#to store how many times each word has occured\\n for i in range(len(strList)):\\n if ((strList[i] in rList)==False):\\n rList.append(strList[i]);\\n nList.append(int(1));\\n else:\\n for j in range(len(rList)):\\n if (strList[i]==rList[j]):\\n nList[j]=nList[j]+1;\\n \\n tList = list();#a new empty tuple list\\n for i in range(len(rList)):\\n tList.append((rList[i],nList[i]));#construct the tuple list from rList and nList\\n \\n tList.sort(key=lambda tList: (-tList[1], tList[0]));#sort the tuple list: first by its 2nd element in reverse order \\\"-\\\", then sort by its 1st element in non-reverse order, no \\\"-\\\"\\n \\n # for testing\\n #for i in tList:\\n # print i;\\n \\n \\n # TODO: Count the number of occurences of each word in s\\n \\n # TODO: Sort the occurences in descending order (alphabetically in case of ties)\\n \\n # TODO: Return the top n words as a list of tuples (<word>, <count>)\\n \\n return tList[:n] #return the first n pairs of elements as required\",\n \"def get_ngrams(sequence, n):\\n length = len(sequence)\\n #if only require 1-gram, then we need to add one START and one END to the sequence. \\n if n==1 or n==2:\\n sequence=[\\\"START\\\"]*n+sequence+[\\\"STOP\\\"]\\n end = n+1 #end i means that when n==1, we need to read one more data, that is to the end of sequence, which is slightly different from when n>1.\\n #if require multi-grams, use the common calculation below.\\n else:\\n sequence = [\\\"START\\\"]*(n-1)+sequence+[\\\"STOP\\\"]\\n end = 1\\n if n==2:\\n end = n\\n result = []\\n temp = ()\\n #the process to construct the tuple-based array.\\n for i in range(0,length+end):\\n temp = tuple(sequence[i:i+n])\\n\\n result.append(temp)\\n return result\",\n \"def n_count(dna_string):\\n a_count = 0\\n c_count = 0\\n g_count = 0\\n t_count= 0\\n for nuc in dna_string:\\n if nuc.upper() == 'A':\\n a_count += 1\\n elif nuc.upper() == 'C':\\n c_count += 1\\n elif nuc.upper() == 'G':\\n g_count += 1\\n elif nuc.upper() == 'T':\\n t_count += 1\\n else:\\n continue\\n print(a_count, c_count, g_count, t_count)\",\n \"def get_char_counts(string):\\n counts = {}\\n for char in iter(string):\\n counts[char] = 1 if not char in counts.keys() else counts[char] + 1\\n return counts\",\n \"def extract_ngrams(line, min_order=1, max_order=BLEU.NGRAM_ORDER) -> Counter:\\n\\n ngrams = Counter() # type: Counter\\n tokens = line.split()\\n for n in range(min_order, max_order + 1):\\n for i in range(0, len(tokens) - n + 1):\\n ngram = ' '.join(tokens[i: i + n])\\n ngrams[ngram] += 1\\n\\n return ngrams\",\n \"def get_ngrams(tokens, min_n, max_n):\\n all_ngrams = list()\\n n_tokens = len(tokens)\\n for i in range(n_tokens):\\n for j in range(i + min_n, min(n_tokens, i + max_n) + 1):\\n all_ngrams.append(\\\" \\\".join(tokens[i:j]))\\n return all_ngrams\",\n \"def nwords(s: str):\\n letters = \\\"ABCDEFGHIJKLMNOPQRSTUVWXYZÄÜÖabcdefghijklmnopqrstuvwxyzüäö\\\"\\n take = 0\\n skip = 0\\n for i in s:\\n if i not in letters:\\n skip += 1\\n #print(\\\"S:\\\", skip)\\n else:\\n take += 1\\n #print(\\\"t:\\\", take)\\n res = (len(s) - take) + 1\\n return res\",\n \"def wc(substring):\\n n = 0\\n try:\\n while True:\\n n += (yield)\\n except GeneratorExit:\\n print(substring, n, flush=True)\",\n \"def count_ngram(hyps_resp, n):\\n if len(hyps_resp) == 0:\\n print(\\\"ERROR, eval_distinct get empty input\\\")\\n return\\n\\n if type(hyps_resp[0]) != list:\\n print(\\\"ERROR, eval_distinct takes in a list of <class 'list'>, get a list of {} instead\\\".format(\\n type(hyps_resp[0])))\\n return\\n\\n ngram = set()\\n for resp in hyps_resp:\\n if len(resp) < n:\\n continue\\n for i in range(len(resp) - n + 1):\\n ngram.add(' '.join(resp[i: i + n]))\\n return len(ngram)\",\n \"def findRepeatedDnaSequences(s):\\n\\n # empty string or string < 10 chars\\n if s == '' or len(s) < 10:\\n raise ValueError(\\\"String must be of length 10+. String: '{}' is too small.\\\".format(s))\\n\\n ten_letter_counts = {}\\n two_or_more = set()\\n\\n i = 0\\n while (i + 10) <= len(s):\\n # get 10 letter substring\\n sub = s[i:i+10]\\n\\n # get current count, if not seen before, set count to 1\\n ten_letter_counts[sub] = ten_letter_counts.get(sub, 0) + 1\\n\\n # check if occures >= 2\\n if ten_letter_counts[sub] >= 2:\\n two_or_more.append(sub)\\n\\n\\n i += 1\\n\\n return two_or_more\",\n \"def get_tag_n_gram(n, filename):\\n\\n from collections import deque\\n queue = deque()\\n\\n count_matrix = {}\\n with open(filename) as f:\\n for l in f:\\n line = l.strip().split()\\n if not line:\\n continue\\n\\n tag = line[0]\\n # Use a queue to keep track of conditioned string,\\n # the occurence of last N - 1 string.\\n queue.appendleft(tag)\\n\\n # Fill the queue until it gets at least N tags.\\n if len(queue) > n - 1:\\n k = \\\" \\\".join(queue)\\n if k not in count_matrix.keys():\\n count_matrix[k] = 1\\n else:\\n count_matrix[k] += 1\\n\\n # Get rid of last one.\\n queue.pop()\\n\\n return count_matrix\",\n \"def get_ngrams(sequence, n):\\n\\n # Set prefix and postfix\\n prefix = \\\"START\\\"\\n postfix = \\\"STOP\\\"\\n # Append 1 prefix regardless of value of n\\n sequence.insert(0, prefix)\\n for i in range(n - 2) :\\n sequence.insert(0, prefix)\\n sequence.append(postfix)\\n\\n # Check if 1 <= n <= len(sequence)\\n if (n > len(sequence)) :\\n print(sequence)\\n assert 1 <= n\\n assert n <= len(sequence)\\n\\n # Create n-gram sequence\\n n_gram_sequence = []\\n for i in range(n, len(sequence) + 1) :\\n temp_sequence = []\\n for j in range(i - n, i) :\\n temp_sequence.append(sequence[j])\\n n_gram_sequence.append(tuple(temp_sequence))\\n return n_gram_sequence\",\n \"def count_ngrams(self):\\n self.unigram = self.count_unigram(self.word_list)\\n self.bigram = self.count_bigram(self.word_list)\\n # self.trigram = self.count_trigram(self.word_list)\\n # self.four_gram = self.count_four_gram(self.word_list)\\n # self.five_gram = self.count_five_gram(self.word_list)\",\n \"def everygrams(seq):\\n for n in range(1, len(seq) + 1):\\n for ng in nltk.util.ngrams(seq, n):\\n yield ng\",\n \"def full_ngrams(items, n):\\n ngs = {}\\n for i in xrange(1, n+1):\\n ngs.update(gen_ngrams(items, i))\\n return ngs\",\n \"def bin_string_iter(n):\\n for bin_string in product([0, 1], repeat=n):\\n yield list(bin_string)\",\n \"def ngram(self,phrase,n,unity=\\\"w\\\"):\\n return self._support.ngram(phrase,n,unity)\",\n \"def get_ngrams(s, ngmin=1, ngmax=1, tokenizer=list, separator=\\\"|\\\"):\\n ngrams = [[] for x in range(ngmin, ngmax + 1)]\\n s = tokenizer(s)\\n for i, ch in enumerate(s):\\n for ngsize in range(ngmin, ngmax + 1):\\n if (i + ngsize) <= len(s):\\n ngrams[ngsize - 1].append(separator.join(s[i:i+ngsize]))\\n return ngrams\",\n \"def part1(input_string):\\n twos, threes = 0, 0\\n for line in input_string:\\n letters_seen = {}\\n for char in line:\\n letters_seen[char] = letters_seen.setdefault(char, 0)+1\\n if 2 in letters_seen.values():\\n twos += 1\\n if 3 in letters_seen.values():\\n threes += 1\\n return threes * twos\",\n \"def count_ngrams(phrase, length, lang):\\n count = 0\\n chinese_character_to_sound = {u'\\\\u5341': 's', u'\\\\u4e8c': 'e', u'\\\\u4e09': 's', u'\\\\u56db': 's',\\n u'\\\\u4e94': 'w', u'\\\\u516d': 'l', u'\\\\u4e03': 'q', u'\\\\u516b': 'b', u'\\\\u5e5d': 'j'}\\n ngram_downloader_langcode = {\\\"english\\\": \\\"eng\\\", \\\"chinese\\\": \\\"chi-sim\\\", \\\"french\\\": \\\"fre\\\",\\n \\\"german\\\": \\\"ger\\\", \\\"hebrew\\\": \\\"heb\\\", \\\"italian\\\": \\\"ita\\\", \\\"russian\\\": \\\"rus\\\", \\\"spanish\\\": \\\"spa\\\"}\\n\\n if lang == \\\"chinese\\\":\\n index = chinese_character_to_sound[phrase[0].lower()]\\n else:\\n index = phrase[0].lower()\\n\\n all_combinations = get_combo(index, length)\\n print(all_combinations)\\n\\n fname, url, records = next(readline_google_store(\\n ngram_len=length, lang=ngram_downloader_langcode[lang], indices=all_combinations))\\n\\n try:\\n record = next(records)\\n print(record.ngram)\\n while record.ngram != phrase:\\n record = next(records)\\n print(record.ngram)\\n\\n while record.ngram == phrase:\\n count += record.match_count\\n record = next(records)\\n print(record.ngram)\\n\\n except StopIteration:\\n pass\\n\\n return count\",\n \"def n_gram(list, n):\\n ngrams = zip(*[list[i:] for i in range(n)])\\n return [\\\" \\\".join(ngram) for ngram in ngrams]\",\n \"def words_used_n_times(word_count_dict, n):\\n n_times = []\\n # TODO 6: define this function\\n return n_times\",\n \"def get_ngrams(stats,s,t,i):\\n #lemma ngrams\\n ngram_sizes = [\\\"bi\\\", \\\"tri\\\"]\\n for ngram_size in ngram_sizes:\\n lm_ngram = get_lemma_ngrams(s, t, i, ngram_size)\\n if lm_ngram:\\n put_feature_value_list(stats,\\\"lemma_\\\" + ngram_size + \\\"gr\\\", lm_ngram)\\n\\n #POS and deprel bigrams\\n if i < s.length-1:\\n put_feature_value_list(stats,\\\"deprels_bigr\\\", (t.deprel,s.nodes[i+1].deprel))\\n put_feature_value_list(stats,\\\"pos_bigr\\\", (t.pos,s.nodes[i+1].pos))\\n \\n #POS and deprel trigrams\\n if i < s.length-2:\\n put_feature_value_list(stats,\\\"deprels_trigr\\\", (t.deprel, s.nodes[i+1].deprel, s.nodes[i+2].deprel))\\n put_feature_value_list(stats,\\\"pos_trigr\\\", (t.pos, s.nodes[i+1].pos, s.nodes[i+2].pos))\\n\\n return stats\",\n \"def get_grams(candidate, n):\\n words = candidate.split(' ')\\n # print(words)\\n grams = list()\\n for i in range(len(words) - n + 1):\\n # print(words[i:i+n])\\n grams.append(' '.join(words[i:i+n]))\\n return grams\",\n \"def find_ngrams(input_list, n=3):\\n return zip(*[input_list[i:] for i in range(n)])\",\n \"def get_ngrams(self, n = None):\\n if not n:\\n n = self.N\\n\\n temp = []\\n for sent in self.get_sentences():\\n temp.extend(list(sent))\\n\\n return nltk.ngrams(temp, n)\",\n \"def number_tokens(dgraph):\\n cnt = 0\\n for node in dgraph.subgraphs(exclude_root=True):\\n node[WORD] = (cnt, node[WORD])\\n cnt += 1\\n return dgraph\",\n \"def count_given_ngrams(seqx, ngrams, partial_order=True): \\n\\n # usu. the input ngrams have the same length \\n ngram_tb = {1: [], }\\n for ngram in ngrams: # ngram is in tuple form \\n if isinstance(ngram, tuple): \\n length = len(ngram)\\n if not ngram_tb.has_key(length): ngram_tb[length] = []\\n ngram_tb[length].append(ngram)\\n else: # assume to be unigrams \\n ngram_tb[1].append(ngram)\\n \\n ng_min, ng_max = min(ngram_tb.keys()), max(ngram_tb.keys())\\n if partial_order:\\n\\n # evaluate all possible n-grams \\n counts = count_ngrams2(seqx, min_length=ng_min, max_length=ng_max, partial_order=True)\\n\\n counts_prime = {}\\n for n, ngx in ngram_tb.items(): # n in n-gram\\n if counts.has_key(n): \\n for ngram in ngx: # query each desired ngram \\n # if n == 1: print '> unigram: %s' % ngram\\n # sorted('x') == sorted(('x', )) == ['x'] => f ngram is a unigram, can do ('e', ) or 'e'\\n counts_prime[ngram] = counts[n][tuple(sorted(ngram))] \\n else: \\n for ngram in ngx: \\n counts_prime[ngram] = 0 \\n else: \\n counts = count_ngrams2(seqx, min_length=ng_min, max_length=ng_max, partial_order=False)\\n \\n counts_prime = {}\\n for n, ngx in ngram_tb.items(): # n in n-gram\\n if counts.has_key(n): \\n for ngram in ngx: # query each desired ngram \\n counts_prime[ngram] = counts[n][tuple(ngram)]\\n else: \\n for ngram in ngx: \\n counts_prime[ngram] = 0 \\n\\n return counts_prime # n-gram -> count\",\n \"def make_ngrams(orig_source, n=2, start_marker=None, end_marker=None):\\n source = orig_source[:] # Don't want to modify original if given a reference\\n\\n if start_marker is not None:\\n if isinstance(source, str):\\n source = start_marker + source\\n else:\\n source.insert(0, start_marker)\\n\\n if end_marker is not None:\\n if isinstance(source, str):\\n source += end_marker\\n else:\\n source.append(end_marker)\\n\\n for i in range(0, len(source) - n):\\n yield source[i:i+n+1]\",\n \"def range_ngrams(tokens, ngramRange=(1,2)):\\n return chain(*(n_grams(tokens, i) for i in range(*ngramRange)))\",\n \"def count_ngrams(word_list,n):\\n ngram_dict = dict()\\n for i in xrange(len(word_list)-n+1):\\n ngram = tuple(word_list[i:i+n])\\n if ngram in ngram_dict:\\n # ngram already exists in dictionary\\n # increment the count by 1\\n ngram_dict[ngram] += 1\\n else:\\n # ngram does not exist in dictionary\\n # initialize to 1\\n ngram_dict[ngram] = 1\\n return ngram_dict\",\n \"def length(s: str) -> int:\\n count = 0\\n for i in s:\\n count += 1\\n return count\",\n \"def count_chars(s: str) -> dict:\\n count_dict = {}\\n\\n for c in s:\\n if c in count_dict:\\n count_dict[c] += 1\\n else:\\n count_dict[c] = 1\\n\\n return count_dict\",\n \"def combinations(s, n):\\n return (\\\"\\\".join(x) for x in tuples(s,n))\",\n \"def mostFrequentNGram(text,n):\\n\\n ngram = calculateNGrams(text,n)\\n return counterFrequency(ngram)\",\n \"def __init__(self, sents, n, corpus='', D=None):\\n\\n self.n = n\\n self.D = D\\n self.corpus = corpus\\n self.smoothingtechnique = 'Kneser Ney Smoothing'\\n # N1+(·w_<i+1>)\\n self._N_dot_tokens_dict = N_dot_tokens = defaultdict(set)\\n # N1+(w^<n-1> ·)\\n self._N_tokens_dot_dict = N_tokens_dot = defaultdict(set)\\n # N1+(· w^<i-1>_<i-n+1> ·)\\n self._N_dot_tokens_dot_dict = N_dot_tokens_dot = defaultdict(set)\\n self.counts = counts = defaultdict(int)\\n vocabulary = []\\n\\n if D is None:\\n total_sents = len(sents)\\n k = int(total_sents*9/10)\\n training_sents = sents[:k]\\n held_out_sents = sents[k:]\\n training_sents = list(map(lambda x: ['<s>']*(n-1) + x + ['</s>'], training_sents))\\n for sent in training_sents:\\n for j in range(n+1):\\n for i in range(n-j, len(sent) - j + 1):\\n ngram = tuple(sent[i: i + j])\\n counts[ngram] += 1\\n if ngram:\\n if len(ngram) == 1:\\n vocabulary.append(ngram[0])\\n else:\\n right_token, left_token, right_kgram, left_kgram, middle_kgram =\\\\\\n ngram[-1:], ngram[:1], ngram[1:], ngram[:-1], ngram[1:-1]\\n N_dot_tokens[right_kgram].add(left_token)\\n N_tokens_dot[left_kgram].add(right_token)\\n if middle_kgram:\\n N_dot_tokens_dot[middle_kgram].add(right_token)\\n N_dot_tokens_dot[middle_kgram].add(left_token)\\n if n - 1:\\n counts[('<s>',)*(n-1)] = len(sents)\\n self.vocab = set(vocabulary)\\n aux = 0\\n for w in self.vocab:\\n aux += len(self._N_dot_tokens_dict[(w,)])\\n self._N_dot_dot_attr = aux\\n D_candidates = [i*0.12 for i in range(1, 9)]\\n xs = []\\n for D in D_candidates:\\n self.D = D\\n aux_perplexity = self.perplexity(held_out_sents)\\n xs.append((D, aux_perplexity))\\n xs.sort(key=lambda x: x[1])\\n self.D = xs[0][0]\\n with open('old-stuff/kneserney_' + str(n) + '_parameters_'+corpus, 'a') as f:\\n f.write('Order: {}\\\\n'.format(self.n))\\n f.write('D: {}\\\\n'.format(self.D))\\n f.write('Perplexity observed: {}\\\\n'.format(xs[0][1]))\\n f.write('-------------------------------\\\\n')\\n f.close()\\n\\n # discount value D provided\\n else:\\n sents = list(map(lambda x: ['<s>']*(n-1) + x + ['</s>'], sents))\\n for sent in sents:\\n for j in range(n+1):\\n # all k-grams for 0 <= k <= n\\n for i in range(n-j, len(sent) - j + 1):\\n ngram = tuple(sent[i: i + j])\\n counts[ngram] += 1\\n if ngram:\\n if len(ngram) == 1:\\n vocabulary.append(ngram[0])\\n else:\\n # e.g., ngram = (1,2,3,4,5,6,7,8)\\n # right_token = (8,)\\n # left_token = (1,)\\n # right_kgram = (2,3,4,5,6,7,8)\\n # left_kgram = (1,2,3,4,5,6,7)\\n # middle_kgram = (2,3,4,5,6,7)\\n right_token, left_token, right_kgram, left_kgram, middle_kgram =\\\\\\n ngram[-1:], ngram[:1], ngram[1:], ngram[:-1], ngram[1:-1]\\n N_dot_tokens[right_kgram].add(left_token)\\n N_tokens_dot[left_kgram].add(right_token)\\n if middle_kgram:\\n N_dot_tokens_dot[middle_kgram].add(right_token)\\n N_dot_tokens_dot[middle_kgram].add(left_token)\\n if n-1:\\n counts[('<s>',)*(n-1)] = len(sents)\\n self.vocab = set(vocabulary)\\n\\n aux = 0\\n for w in self.vocab:\\n aux += len(self._N_dot_tokens_dict[(w,)])\\n self._N_dot_dot_attr = aux\\n\\n xs = [k for k, v in counts.items() if v == 1 and n == len(k)]\\n ys = [k for k, v in counts.items() if v == 2 and n == len(k)]\\n n1 = len(xs)\\n n2 = len(ys)\\n self.D = n1 / (n1 + 2 * n2)\",\n \"def run_length(s):\\n\\n s = re.sub(\\\"[^a-zA-Z]\\\",\\\"\\\", s)\\n s = s.lower()\\n cnt = 1\\n y = []\\n z = []\\n ch = ''\\n for i in range(len(s)):\\n if i + 1 < len(s) and s[i] == s[i + 1]:\\n cnt += 1\\n else:\\n if cnt > 1:\\n z.append(s[i-1])\\n y.append(str(cnt))\\n else:\\n z.append(s[i])\\n y.append(str(cnt))\\n cnt = 1\\n for i in range(len(y)):\\n ch = ch + y[i] + z[i]\\n i += 1\\n print ch\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.82485414","0.76264787","0.73532337","0.73268604","0.71129584","0.7092459","0.70224917","0.6941578","0.6845443","0.67267495","0.6712389","0.6680387","0.66529167","0.6583822","0.6576275","0.65749717","0.65712875","0.6563945","0.6559195","0.6554432","0.6537288","0.65310955","0.6525532","0.6523345","0.649932","0.6475966","0.64716464","0.64691967","0.6463616","0.64389265","0.6405815","0.6381632","0.63645977","0.6358814","0.6337967","0.6283484","0.6274967","0.6253658","0.6246294","0.6235122","0.6233911","0.6218494","0.6216373","0.6216049","0.62082165","0.61859655","0.61778104","0.61764294","0.6170873","0.6138146","0.61356354","0.61112165","0.60515225","0.60487723","0.6042948","0.6040732","0.601688","0.60121644","0.5994272","0.5977052","0.596538","0.595869","0.59463215","0.59162253","0.59120154","0.5904226","0.59009075","0.58966","0.5888076","0.58596015","0.58467793","0.58449423","0.58367765","0.582257","0.58180463","0.58039","0.5798997","0.5797388","0.5795592","0.5786422","0.57825387","0.57570297","0.5745922","0.5738665","0.5733385","0.57304966","0.5729876","0.5729418","0.5718782","0.5714418","0.5708834","0.57073003","0.56977654","0.5675418","0.56678396","0.5641581","0.5634368","0.5625828","0.5622218"],"string":"[\n \"0.82485414\",\n \"0.76264787\",\n \"0.73532337\",\n \"0.73268604\",\n \"0.71129584\",\n \"0.7092459\",\n \"0.70224917\",\n \"0.6941578\",\n \"0.6845443\",\n \"0.67267495\",\n \"0.6712389\",\n \"0.6680387\",\n \"0.66529167\",\n \"0.6583822\",\n \"0.6576275\",\n \"0.65749717\",\n \"0.65712875\",\n \"0.6563945\",\n \"0.6559195\",\n \"0.6554432\",\n \"0.6537288\",\n \"0.65310955\",\n \"0.6525532\",\n \"0.6523345\",\n \"0.649932\",\n \"0.6475966\",\n \"0.64716464\",\n \"0.64691967\",\n \"0.6463616\",\n \"0.64389265\",\n \"0.6405815\",\n \"0.6381632\",\n \"0.63645977\",\n \"0.6358814\",\n \"0.6337967\",\n \"0.6283484\",\n \"0.6274967\",\n \"0.6253658\",\n \"0.6246294\",\n \"0.6235122\",\n \"0.6233911\",\n \"0.6218494\",\n \"0.6216373\",\n \"0.6216049\",\n \"0.62082165\",\n \"0.61859655\",\n \"0.61778104\",\n \"0.61764294\",\n \"0.6170873\",\n \"0.6138146\",\n \"0.61356354\",\n \"0.61112165\",\n \"0.60515225\",\n \"0.60487723\",\n \"0.6042948\",\n \"0.6040732\",\n \"0.601688\",\n \"0.60121644\",\n \"0.5994272\",\n \"0.5977052\",\n \"0.596538\",\n \"0.595869\",\n \"0.59463215\",\n \"0.59162253\",\n \"0.59120154\",\n \"0.5904226\",\n \"0.59009075\",\n \"0.58966\",\n \"0.5888076\",\n \"0.58596015\",\n \"0.58467793\",\n \"0.58449423\",\n \"0.58367765\",\n \"0.582257\",\n \"0.58180463\",\n \"0.58039\",\n \"0.5798997\",\n \"0.5797388\",\n \"0.5795592\",\n \"0.5786422\",\n \"0.57825387\",\n \"0.57570297\",\n \"0.5745922\",\n \"0.5738665\",\n \"0.5733385\",\n \"0.57304966\",\n \"0.5729876\",\n \"0.5729418\",\n \"0.5718782\",\n \"0.5714418\",\n \"0.5708834\",\n \"0.57073003\",\n \"0.56977654\",\n \"0.5675418\",\n \"0.56678396\",\n \"0.5641581\",\n \"0.5634368\",\n \"0.5625828\",\n \"0.5622218\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8287722"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":22887,"cells":{"query":{"kind":"string","value":"Yields counts of character ngrams from string s of order n."},"document":{"kind":"string","value":"def extract_char_ngrams(self, s: str, n: int) -> Counter:\n return Counter([s[i:i + n] for i in range(len(s) - n + 1)])"},"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 extract_char_ngrams(s: str, n: int) -> Counter:\n return Counter([s[i:i + n] for i in range(len(s) - n + 1)])","def precook(s, n=4, out=False):\n words = s.split()\n counts = defaultdict(int)\n for k in xrange(1,n+1):\n for i in xrange(len(words)-k+1):\n ngram = tuple(words[i:i+k])\n counts[ngram] += 1\n return counts","def _create_ngrams(tokens, n):\n\n ngrams = collections.Counter()\n for ngram in (tuple(tokens[i:i + n]) for i in xrange(len(tokens) - n + 1)):\n ngrams[ngram] += 1\n return ngrams","def _precook(s, n=4, out=False):\n if isinstance(s,str):\n words = s.split()\n # print(words)\n elif isinstance(s,list) or isinstance(s,tuple):\n words = s\n else:\n raise NotImplementedError(type(s))\n counts = defaultdict(int)\n for k in range(1, n + 1):\n for i in range(len(words) - k + 1):\n ngram = tuple(words[i:i + k])\n counts[ngram] += 1\n return (len(words), counts)","def _generateNgrams(self,text,n=2):\n token = Utilities.CVTokeniser(text)\n # token = nltk.word_tokenize(text)\n computedNgrams=ngrams(token,n)\n return Counter(computedNgrams)","def ngrams(text, n):\n return chain(*[ngrams_(text, i) for i in range(n + 1)])","def ngramas(n, string):\n\n ngrams = []\n i = 0\n while i + n < len(string):\n ngrams.append(string[i:i + n])\n i += 1\n\n return ngrams","def find_ngrams(self, n):\n\n output = {}\n\n for i in range(len(self.text)-n+1):\n s = ' '.join(self.text[i:i+n])\n # if s is not already in dictionary, set value to 0\n output.setdefault(s, 0)\n output[s] += 1\n return output","def get_ngrams(seq, n):\n return","def __init__(self, n, sents, corpus=''):\n assert n > 0\n self.n = n\n self.counts = counts = defaultdict(int)\n self.corpus = corpus\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 for i in range(len(sent) - n + 1):\n ngram = tuple(sent[i: i + n])\n counts[ngram] += 1\n counts[ngram[:-1]] += 1","def n_grams(tokens, n):\n return zip(*[tokens[i:] for i in range(n)])","def chngrams(string=\"\", n=3, top=None, threshold=0, exclude=[], **kwargs):\n\t# An optional dict-parameter can be used to specify a subclass of dict,\n\t# e.g., count(words, dict=readonlydict) as used in Document.\n\tcount = defaultdict(int)\n\tif n > 0:\n\t\tfor i in xrange(len(string)-n+1):\n\t\t\tw = string[i:i+n]\n\t\t\tif w not in exclude:\n\t\t\t\tcount[w] += 1\n\tif threshold > 0:\n\t\tcount = dict((k, v) for k, v in count.items() if v > threshold)\n\tif top is not None:\n\t\tcount = dict(heapq.nsmallest(top, count.items(), key=lambda kv: (-kv[1], kv[0])))\n\treturn kwargs.get(\"dict\", dict)(count)","def ngrams_(text, n):\n return zip(*[text[i:] for i in range(n)])","def _get_ngrams(segments, order):\n ngram_counts = collections.Counter()\n for seg in segments:\n for i in range(0, len(seg) - order + 1):\n ngram = tuple(seg[i:i+order])\n ngram_counts[ngram] += 1\n return ngram_counts","def sent_to_n_grams(sent: str, n: int) -> Iterator[Tuple[str, ...]]:\n\n words = [word for word in sent.split() if word not in string.punctuation]\n\n rows = [words[i:] for i in range(n)]\n\n return zip(*rows)","def ngrams(name_string, n=3):\n\n string = re.sub(r'[,-./]|\\sBD', r'', name_string)\n n_grams = zip(*[string[i:] for i in range(n)])\n return [''.join(n_gram) for n_gram in n_grams]","def iter_ngrams(self, sentence, n):\n return [tuple(sentence[i : i+n]) for i in range(len(sentence)-n+1)]","def compute_ngrams(str, n=2):\n #split the string\n st = tuple(str.split())\n #not list of list but list of tuple..\n gram = [st[x:x+n] for x in range(len(st)-n+1)]\n dgram = {}\n #convert ngram into dictionary:\n for key in gram:\n dgram.setdefault(key[0],[]).append(key[1:])\n return dgram","def count_n_grams(data, n, start_token='<s>', end_token = '<e>'):\r\n \r\n # Initialize dictionary of n-grams and their counts\r\n n_grams = {}\r\n\r\n \r\n for sentence in data: # complete this line\r\n \r\n # prepend start token n times, and append <e> one time\r\n sentence = [start_token]*n + sentence + [end_token]\r\n \r\n # convert list to tuple\r\n # So that the sequence of words can be used as\r\n # a key in the dictionary\r\n sentence = tuple(sentence)\r\n\r\n \r\n for i in range(len(sentence)+1-n): # complete this line\r\n\r\n # Get the n-gram from i to i+n\r\n n_gram = sentence[i:i+n]\r\n\r\n # check if the n-gram is in the dictionary\r\n if n_gram in n_grams: \r\n \r\n # Increment the count for this n-gram\r\n n_grams[n_gram] += 1\r\n else:\r\n # Initialize this n-gram count to 1\r\n n_grams[n_gram] = 1\r\n \r\n return n_grams","def count_reddit_comments_ngram_strs(year, month, n):\n ngram_strs = ngram_extract.extract_reddit_comments_ngram_strs(year, month, n)\n return Counter(itertools.chain.from_iterable(ngram_strs))","def count_ngrams(f, N):\n\t#print \">>> Computing n-gram frequency counts ...\"\n\t#freqs[n] contains n-gram frequencies, freqs[n-1] contains (n-1)-gram frequencies, etc.\n\tfreqs = collections.defaultdict(lambda: collections.defaultdict(int))\n\ttot =0\n\tfor line in f:\n\t\ttot +=1\n\t\tw = line\n\t\tfifo = [':'] * N # initialise n-gram storage with \":\" as stop characters\n\t\tfor i in range(N-1):\n\t\t\tw += ':'\n\t\tfor c in w:\n\t\t\tfifo.pop(0)\n\t\t\tfifo.append(c)\n\t\t\tfor idx in range(N):\n\t\t\t\tn = idx + 1\n\t\t\t\tngram = ''.join(fifo[:n]) # n-gram = first n characters in fifo\n\t\t\t\tfreqs[n][ngram] += 1\n\treturn freqs","def build_ngrams(tokens, n=2):\n ngrams = zip(*(islice(group, idx, None) for idx, group in enumerate(tee(tokens, n))))\n return ngrams","def ngrams(word, size):\n expanded = \"^\" + word + \"$\"\n for start in range(len(expanded) - size + 1):\n yield expanded[start:start + size]","def find_frequency(text, n=1):\n freqs = {}\n length = len(text)\n for i in xrange(0, length):\n upper = i+n\n if upper > length:\n break\n gram = text[i:upper]\n dict_operate(freqs, gram, 1, operator.add)\n return freqs","def repeatedString(s, n):\n\n count = 0\n s_count_a = s.count('a')\n\n count += math.floor(n / len(s)) * s_count_a\n for _ in range(n % len(s)):\n if s[_] == 'a':\n count += 1\n\n return count","def n_grams(tokens, n=1):\n shiftToken = lambda i: (el for j,el in enumerate(tokens) if j>=i)\n shiftedTokens = (shiftToken(i) for i in range(n))\n tupleNGrams = zip(*shiftedTokens)\n return tupleNGrams","def ngrams(text, n):\n grams = zip(*[text[i:] for i in range(n)])\n return [''.join(gram) for gram in grams]","def calculate_ngram_frequencies(text, n):\n\n import re\n\n # Create a new dictionary\n ngram_dict = {}\n\n # Find all sentences\n sentences_list = re.findall(r'[^\\.\\?!\"]+', text)\n\n # Iterate over sentences in the list\n for sentence in sentences_list:\n # Split words by a whitespace character\n words_list = sentence.rsplit()\n\n # Iterate over ngrams in the sentence\n for i in range(len(words_list) - n + 1):\n\n # Join the words to size of n\n ngram = ' '.join(words_list[i:i + n])\n\n # Record the presence of a new ngram\n if not ngram in ngram_dict:\n ngram_dict[ngram] = 1\n\n # Add the number of occurrence of the ngram\n elif ngram in ngram_dict:\n ngram_dict[ngram] += 1\n\n return ngram_dict","def _get_ngrams_with_counter(segment, max_order):\n ngram_counts = collections.Counter()\n for order in xrange(1, max_order + 1):\n for i in xrange(0, len(segment) - order + 1):\n ngram = tuple(segment[i:i + order])\n ngram_counts[ngram] += 1\n return ngram_counts","def ngrams(self, n=1, uncased=False, filter_fn=None, as_strings=True):\n\n def _skip(gram):\n if not filter_fn:\n return False\n return filter_fn(gram)\n\n words = self.words(True)\n ngrams = [(s, e + 1)\n for s in range(len(words))\n for e in range(s, min(s + n, len(words)))\n if not _skip(words[s:e + 1])]\n\n # Concatenate into strings\n if as_strings:\n ngrams = ['{}'.format(' '.join(words[s:e])) for (s, e) in ngrams]\n\n return ngrams","def ngrams(sequence, n):\n # credit: http://stackoverflow.com/questions/2380394/simple-implementation-of-n-gram-tf-idf-and-cosine-similarity-in-python\n sequence = list(sequence)\n count = max(0, len(sequence) - n + 1)\n return [tuple(sequence[i:i+n]) for i in range(count)]","def _ngrams(self, string_):\n def find_ngrams(input_list, n):\n return zip(*[input_list[i:] for i in range(n)])\n\n ngrams = []\n tokens = string_.split()\n\n for size in range(1, self._ngram_range + 1):\n tuples = find_ngrams(tokens, size)\n concatenated = [\"_\".join(tuple_) for tuple_ in tuples]\n ngrams.extend(concatenated)\n\n return \" \".join(ngrams)","def n_grama(sentence, n):\n t = tokenize(sentence)\n n_grams = zip(*[t[i:] for i in range(n)])\n return list(map(lambda n_gram: ' '.join(n_gram), n_grams))","def ngrams(self, n=1, uncased=False, filter_fn=None, as_strings=True):\n def _skip(gram):\n if not filter_fn:\n return False\n return filter_fn(gram)\n\n words = self.words(uncased)\n ngrams = [(s, e + 1)\n for s in range(len(words))\n for e in range(s, min(s + n, len(words)))\n if not _skip(words[s:e + 1])]\n\n # Concatenate into strings\n if as_strings:\n ngrams = ['{}'.format(' '.join(words[s:e])) for (s, e) in ngrams]\n\n return ngrams","def ngrams(words, n=1):\n return [tuple(words[j:j + n]) for j in range(len(words) - n + 1)]","def gen_ngrams(items, n):\n ngs = {}\n ilen = len(items)\n for i in xrange(ilen-n+1):\n ng = tuple(items[i:i+n])\n ngs[ng] = ngs.get(ng, 0) + 1\n return ngs","def substrCount(n, s):\r\n lst = []\r\n character = s[0]\r\n count = 1\r\n result = 0\r\n for i in range(1, n):\r\n if s[i] == character:\r\n count += 1\r\n else:\r\n lst.append((character, count))\r\n character = s[i]\r\n count = 1\r\n lst.append((character, count))\r\n\r\n for tpl in lst:\r\n \"\"\"calculate all possible palindromes created from same characters that are close to each other\r\n E.g: aaa => 6 possibles (3*4//2 = 6)\r\n \"\"\"\r\n result += tpl[1] * (tpl[1] + 1) // 2\r\n\r\n for i in range(1, len(lst) - 1):\r\n if lst[i - 1][0] == lst[i + 1][0] and lst[i][1] == 1:\r\n \"\"\"\r\n check palindromes created from 3 tuples with a different character in between\r\n \"\"\"\r\n result += min(lst[i - 1][1], lst[i + 1][1])\r\n\r\n return result","def word2ngrams(text, n=3):\n return [text[i:i+n] for i in range(len(text)-n+1)]","def generate_ngrams(iterable, n):\n return zip(*[itertools.islice(it, i, None) for i, it in enumerate(itertools.tee(iterable, n))])","def _count_ngram(ngram_input_list: Sequence[str], n_gram: int) ->Counter:\n ngram_counter: Counter = Counter()\n for i in range(1, n_gram + 1):\n for j in range(len(ngram_input_list) - i + 1):\n ngram_key = tuple(ngram_input_list[j:i + j])\n ngram_counter[ngram_key] += 1\n return ngram_counter","def sent2ngrams(text, n=3):\n if n == \"word\":\n return text.split()\n return list(chain(*[word2ngrams(i,n) for i in text.lower().split()]))","def ngrams(n, target):\n chars = collections.deque()\n while True:\n chars.append((yield))\n if len(chars) == n: \n target.send(chars)\n chars.popleft()","def get(self, n):\n parts = [' '.join(g) for g in ngrams(self.words, n)]\n return get_occurences(parts)","def word_ngrams(sent, n):\n\t\n\t# EXAMPLES \n\t# > word_ngrams(tokenize('hello world'), 1)\n\t# [('hello',), ('world',)]\n\t# > word_ngrams(tokenize('hello world'), 2)\n\t# [('<s>', 'hello'), ('hello', 'world'), ('world', '</s>')]\n\n\t# YOUR CODE HERE\n\ttokenized_sent = tokenize(sent)\n\tif n != 1:\n\t\ttokenized_sent.insert(0, '<s>')\n\t\ttokenized_sent.append('</s>')\n\treturn [tuple(tokenized_sent[i:i + n]) for i in range(0, len(tokenized_sent)-n+1)]","def get_ngrams(s, ngram_range=1):\n # tokens = s.split()\n # return filter(lambda token: len(token)>1, tokens)\n # return bigrams(s.split()) # NLTK bigrams method\n words = s.split()\n return [' '.join(words[i:i+ngram_range]) for i in range(len(words)-1)]","def ngrams(word, n):\n word = list(word)\n # insert extra tokens\n word.insert(0, '$')\n word.append('$')\n\n output = []\n for i in range(len(word) - n + 1):\n # print(i)\n # print(word[i:i + n])\n output.append(''.join(word[i:i + n]))\n return output","def extract_ngrams(line, min_order=1, max_order=NGRAM_ORDER) -> Counter:\n\n ngrams = Counter()\n tokens = line.split()\n for n in range(min_order, max_order + 1):\n for i in range(0, len(tokens) - n + 1):\n ngram = ' '.join(tokens[i: i + n])\n ngrams[ngram] += 1\n\n return ngrams","def extract_n_grams(string, n, overlap=0, unique=True):\n if n > len(string):\n return [] \n\n n_grams = []\n step = n - overlap\n n_grams = [string[i:i+n] for i in range(0, len(string)-step+1, step)]\n\n if unique:\n n_grams = list(set(n_grams))\n\n n_grams = [g+\"\\n\" for g in n_grams]\n\n return n_grams","def __makeNgrams(self, n):\n # start_time = time.time()\n ngrams = dict()\n itergrams = dict()\n\n for k in range(2,n+1):\n itergrams[k] = list(nltk.ngrams(self.words, k))\n\n for k, grams in itergrams.items():\n kgrams = defaultdict(Counter)\n for gram in grams: \n kgram = list(gram)\n key = ' '.join(kgram[:k-1])\n kgrams[key].update({kgram[-1]})\n ngrams[k] = kgrams\n # print ('finish gen ', k, 'grams at ', time.time()-start_time)\n return ngrams","def _count_ngram(ngram_input_list: Sequence[str], n_gram: int) -> Counter:\n ngram_counter: Counter = Counter()\n\n for i in range(1, n_gram + 1):\n for j in range(len(ngram_input_list) - i + 1):\n ngram_key = tuple(ngram_input_list[j : (i + j)])\n ngram_counter[ngram_key] += 1\n\n return ngram_counter","def __init__(self, n, sents):\n assert n > 0\n self._n = n\n print(\"Counting...\")\n count = defaultdict(int)\n while n >= 0:\n for sent in sents:\n s = sent[:] # En una oracion auxiliar agrego el item de start y end para contarlos\n s.insert(0, \"<s>\")\n s.append(\"</s>\")\n for i in range(len(s) - n + 1):\n count[tuple(s[i:i + n])] += 1\n n -= 1\n count[()] = count[()] - count[('<s>',)] - count[\n ('</s>',)] # Pero no quiero que <s> y </s> sean considerados por ()\n self._count = count\n print(\"Computing vocabulary...\")\n self._voc = voc = set()\n for sent in sents:\n voc = voc.union(set(sent))\n voc.add('</s>')\n self._voc = voc\n self._V = len(voc) # vocabulary size\n print(\"Done\")","def count_ngrams(file_name, n=2):\n # The defaultdict class may be useful here. Check the python \n # documentation for more information: \n # https://docs.python.org/3/library/collections.html#collections.defaultdict\n\n file = open(file_name, \"r\")\n text = []\n gram_dict = {}\n for line in file:\n exclude = set(string.punctuation)\n line = ''.join(char for char in line if char not in exclude)\n line = line.replace(\"\\n\", \"\").lower()\n text.extend(line.split())\n\n for wordIndex in range(0,len(text)-n+1):\n tmpLi = []\n for x in range(0,n):\n tmpLi.append(text[wordIndex + x])\n tup = tuple(tmpLi)\n if tup not in gram_dict:\n gram_dict[tup] = 1\n else:\n gram_dict[tup] += 1\n return gram_dict","def create_ngrams(word_list, n):\n yield zip(*[word_list[i:] for i in range(n)])","def grapheme_lengths(string):\n return iter(len(g) for g in graphemes(string))","def find_all_ngrams(dataset, n):\n return zip(*[dataset[i:] for i in xrange(n)])","def count_words(s, n):\n\n # TODO: Count the number of occurences of each word in s\n words = s.lower().split()\n dict = {}\n\n for item in words:\n dict[item] = words.count(item)\n\n # TODO: Sort the occurences in descending order (alphabetically in case of ties)\n items = dict.items()\n\n items.sort(key=lambda tup: tup[0])\n items.sort(key=lambda tup: tup[1], reverse=True)\n\n # TODO: Return the top n words as a list of tuples (<word>, <count>)\n return items[:n]","def calculateNGrams(text, n):\n\n return ([text[i:i+n] for i in range(len(text)-n+1)])","def ngrams(iterable, n=1):\n return zip(*(iterable[i:] for i in range(n)))","def count_given_ngrams2(seqx, ngrams, partial_order=True):\n # from batchpheno import utils\n\n # the input ngrams may or may not have the same length \n ngram_tb = {1: [], }\n for ngram in ngrams: # ngram is in tuple form \n if isinstance(ngram, tuple): \n length = len(ngram)\n if not ngram_tb.has_key(length): ngram_tb[length] = []\n ngram_tb[length].append(ngram)\n else: # assume to be unigrams \n assert isinstance(ngram, str)\n ngram_tb[1].append(ngram)\n \n # print('verify> ngram_tb:\\n%s\\n' % ngram_tb) # utils.sample_hashtable(ngram_tb, n_sample=10))\n\n ng_min, ng_max = min(ngram_tb.keys()), max(ngram_tb.keys())\n if partial_order:\n\n # evaluate all possible n-grams \n counts = count_ngrams2(seqx, min_length=ng_min, max_length=ng_max, partial_order=True)\n\n counts_prime = {}\n for n, ngx in ngram_tb.items(): # n in n-gram\n if not counts_prime.has_key(n): counts_prime[n] = {} \n if counts.has_key(n):\n for ngram in ngx: # query each desired ngram \n # if n == 1: print '> unigram: %s' % ngram\n # sorted('x') == sorted(('x', )) == ['x'] => f ngram is a unigram, can do ('e', ) or 'e'\n counts_prime[n][ngram] = counts[n][tuple(sorted(ngram))] \n else: \n for ngram in ngx: \n counts_prime[n][ngram] = 0 \n else: \n counts = count_ngrams2(seqx, min_length=ng_min, max_length=ng_max, partial_order=False)\n \n counts_prime = {}\n for n, ngx in ngram_tb.items(): # n in n-gram\n if not counts_prime.has_key(n): counts_prime[n] = {} \n if counts.has_key(n): \n for ngram in ngx: # query each desired ngram \n # assert isinstance(ngram, tuple), \"Ngram is not a tuple: %s\" % str(ngram)\n counts_prime[n][ngram] = counts[n][tuple(ngram)]\n else: \n for ngram in ngx: \n counts_prime[n][ngram] = 0 \n\n return counts_prime # n (as n-gram) -> counts (ngram -> count)","def generate_ngram(corpus,n=2):\r\n def generate_ngram_str(text,n):\r\n text = tokenizer.tokenize(text)\r\n for i in range(0, len(text)-n+1):\r\n yield text[i:i+n]\r\n if isinstance(corpus,str):\r\n for ngram in generate_ngram_str(corpus,n):\r\n yield ngram\r\n elif isinstance(corpus, (list, types.GeneratorType)):\r\n for text in corpus:\r\n for ngram in generate_ngram_str(text,n):\r\n yield ngram","def numberOfSubstrings(self, s: str) -> int:\n i = 0\n res = 0\n d = {c:0 for c in 'abc'}\n \n for j, val in enumerate(s):\n d[val] += 1\n while all(d.values()):\n d[s[i]] -= 1\n i += 1\n res += i\n \n return res","def _char_and_word_ngrams_counts(sentence: str, n_char_order: int, n_word_order: int, lowercase: bool) ->Tuple[Dict[int, Dict[Tuple[str, ...], Tensor]], Dict[int, Dict[Tuple[str, ...], Tensor]]]:\n if lowercase:\n sentence = sentence.lower()\n char_n_grams_counts = _ngram_counts(_get_characters(sentence, whitespace), n_char_order)\n word_n_grams_counts = _ngram_counts(_get_words_and_punctiation(sentence), n_word_order)\n return char_n_grams_counts, word_n_grams_counts","def count_words(s, n):\n \n strList = s.split(' ');#to split the string into a list of words\n rList = [];#to store the each word only once\n nList = [];#to store how many times each word has occured\n for i in range(len(strList)):\n if ((strList[i] in rList)==False):\n rList.append(strList[i]);\n nList.append(int(1));\n else:\n for j in range(len(rList)):\n if (strList[i]==rList[j]):\n nList[j]=nList[j]+1;\n \n tList = list();#a new empty tuple list\n for i in range(len(rList)):\n tList.append((rList[i],nList[i]));#construct the tuple list from rList and nList\n \n tList.sort(key=lambda tList: (-tList[1], tList[0]));#sort the tuple list: first by its 2nd element in reverse order \"-\", then sort by its 1st element in non-reverse order, no \"-\"\n \n # for testing\n #for i in tList:\n # print i;\n \n \n # TODO: Count the number of occurences of each word in s\n \n # TODO: Sort the occurences in descending order (alphabetically in case of ties)\n \n # TODO: Return the top n words as a list of tuples (<word>, <count>)\n \n return tList[:n] #return the first n pairs of elements as required","def get_ngrams(sequence, n):\n length = len(sequence)\n #if only require 1-gram, then we need to add one START and one END to the sequence. \n if n==1 or n==2:\n sequence=[\"START\"]*n+sequence+[\"STOP\"]\n end = n+1 #end i means that when n==1, we need to read one more data, that is to the end of sequence, which is slightly different from when n>1.\n #if require multi-grams, use the common calculation below.\n else:\n sequence = [\"START\"]*(n-1)+sequence+[\"STOP\"]\n end = 1\n if n==2:\n end = n\n result = []\n temp = ()\n #the process to construct the tuple-based array.\n for i in range(0,length+end):\n temp = tuple(sequence[i:i+n])\n\n result.append(temp)\n return result","def n_count(dna_string):\n a_count = 0\n c_count = 0\n g_count = 0\n t_count= 0\n for nuc in dna_string:\n if nuc.upper() == 'A':\n a_count += 1\n elif nuc.upper() == 'C':\n c_count += 1\n elif nuc.upper() == 'G':\n g_count += 1\n elif nuc.upper() == 'T':\n t_count += 1\n else:\n continue\n print(a_count, c_count, g_count, t_count)","def get_char_counts(string):\n counts = {}\n for char in iter(string):\n counts[char] = 1 if not char in counts.keys() else counts[char] + 1\n return counts","def extract_ngrams(line, min_order=1, max_order=BLEU.NGRAM_ORDER) -> Counter:\n\n ngrams = Counter() # type: Counter\n tokens = line.split()\n for n in range(min_order, max_order + 1):\n for i in range(0, len(tokens) - n + 1):\n ngram = ' '.join(tokens[i: i + n])\n ngrams[ngram] += 1\n\n return ngrams","def get_ngrams(tokens, min_n, max_n):\n all_ngrams = list()\n n_tokens = len(tokens)\n for i in range(n_tokens):\n for j in range(i + min_n, min(n_tokens, i + max_n) + 1):\n all_ngrams.append(\" \".join(tokens[i:j]))\n return all_ngrams","def nwords(s: str):\n letters = \"ABCDEFGHIJKLMNOPQRSTUVWXYZÄÜÖabcdefghijklmnopqrstuvwxyzüäö\"\n take = 0\n skip = 0\n for i in s:\n if i not in letters:\n skip += 1\n #print(\"S:\", skip)\n else:\n take += 1\n #print(\"t:\", take)\n res = (len(s) - take) + 1\n return res","def wc(substring):\n n = 0\n try:\n while True:\n n += (yield)\n except GeneratorExit:\n print(substring, n, flush=True)","def count_ngram(hyps_resp, n):\n if len(hyps_resp) == 0:\n print(\"ERROR, eval_distinct get empty input\")\n return\n\n if type(hyps_resp[0]) != list:\n print(\"ERROR, eval_distinct takes in a list of <class 'list'>, get a list of {} instead\".format(\n type(hyps_resp[0])))\n return\n\n ngram = set()\n for resp in hyps_resp:\n if len(resp) < n:\n continue\n for i in range(len(resp) - n + 1):\n ngram.add(' '.join(resp[i: i + n]))\n return len(ngram)","def findRepeatedDnaSequences(s):\n\n # empty string or string < 10 chars\n if s == '' or len(s) < 10:\n raise ValueError(\"String must be of length 10+. String: '{}' is too small.\".format(s))\n\n ten_letter_counts = {}\n two_or_more = set()\n\n i = 0\n while (i + 10) <= len(s):\n # get 10 letter substring\n sub = s[i:i+10]\n\n # get current count, if not seen before, set count to 1\n ten_letter_counts[sub] = ten_letter_counts.get(sub, 0) + 1\n\n # check if occures >= 2\n if ten_letter_counts[sub] >= 2:\n two_or_more.append(sub)\n\n\n i += 1\n\n return two_or_more","def get_tag_n_gram(n, filename):\n\n from collections import deque\n queue = deque()\n\n count_matrix = {}\n with open(filename) as f:\n for l in f:\n line = l.strip().split()\n if not line:\n continue\n\n tag = line[0]\n # Use a queue to keep track of conditioned string,\n # the occurence of last N - 1 string.\n queue.appendleft(tag)\n\n # Fill the queue until it gets at least N tags.\n if len(queue) > n - 1:\n k = \" \".join(queue)\n if k not in count_matrix.keys():\n count_matrix[k] = 1\n else:\n count_matrix[k] += 1\n\n # Get rid of last one.\n queue.pop()\n\n return count_matrix","def get_ngrams(sequence, n):\n\n # Set prefix and postfix\n prefix = \"START\"\n postfix = \"STOP\"\n # Append 1 prefix regardless of value of n\n sequence.insert(0, prefix)\n for i in range(n - 2) :\n sequence.insert(0, prefix)\n sequence.append(postfix)\n\n # Check if 1 <= n <= len(sequence)\n if (n > len(sequence)) :\n print(sequence)\n assert 1 <= n\n assert n <= len(sequence)\n\n # Create n-gram sequence\n n_gram_sequence = []\n for i in range(n, len(sequence) + 1) :\n temp_sequence = []\n for j in range(i - n, i) :\n temp_sequence.append(sequence[j])\n n_gram_sequence.append(tuple(temp_sequence))\n return n_gram_sequence","def count_ngrams(self):\n self.unigram = self.count_unigram(self.word_list)\n self.bigram = self.count_bigram(self.word_list)\n # self.trigram = self.count_trigram(self.word_list)\n # self.four_gram = self.count_four_gram(self.word_list)\n # self.five_gram = self.count_five_gram(self.word_list)","def everygrams(seq):\n for n in range(1, len(seq) + 1):\n for ng in nltk.util.ngrams(seq, n):\n yield ng","def full_ngrams(items, n):\n ngs = {}\n for i in xrange(1, n+1):\n ngs.update(gen_ngrams(items, i))\n return ngs","def bin_string_iter(n):\n for bin_string in product([0, 1], repeat=n):\n yield list(bin_string)","def ngram(self,phrase,n,unity=\"w\"):\n return self._support.ngram(phrase,n,unity)","def get_ngrams(s, ngmin=1, ngmax=1, tokenizer=list, separator=\"|\"):\n ngrams = [[] for x in range(ngmin, ngmax + 1)]\n s = tokenizer(s)\n for i, ch in enumerate(s):\n for ngsize in range(ngmin, ngmax + 1):\n if (i + ngsize) <= len(s):\n ngrams[ngsize - 1].append(separator.join(s[i:i+ngsize]))\n return ngrams","def part1(input_string):\n twos, threes = 0, 0\n for line in input_string:\n letters_seen = {}\n for char in line:\n letters_seen[char] = letters_seen.setdefault(char, 0)+1\n if 2 in letters_seen.values():\n twos += 1\n if 3 in letters_seen.values():\n threes += 1\n return threes * twos","def count_ngrams(phrase, length, lang):\n count = 0\n chinese_character_to_sound = {u'\\u5341': 's', u'\\u4e8c': 'e', u'\\u4e09': 's', u'\\u56db': 's',\n u'\\u4e94': 'w', u'\\u516d': 'l', u'\\u4e03': 'q', u'\\u516b': 'b', u'\\u5e5d': 'j'}\n ngram_downloader_langcode = {\"english\": \"eng\", \"chinese\": \"chi-sim\", \"french\": \"fre\",\n \"german\": \"ger\", \"hebrew\": \"heb\", \"italian\": \"ita\", \"russian\": \"rus\", \"spanish\": \"spa\"}\n\n if lang == \"chinese\":\n index = chinese_character_to_sound[phrase[0].lower()]\n else:\n index = phrase[0].lower()\n\n all_combinations = get_combo(index, length)\n print(all_combinations)\n\n fname, url, records = next(readline_google_store(\n ngram_len=length, lang=ngram_downloader_langcode[lang], indices=all_combinations))\n\n try:\n record = next(records)\n print(record.ngram)\n while record.ngram != phrase:\n record = next(records)\n print(record.ngram)\n\n while record.ngram == phrase:\n count += record.match_count\n record = next(records)\n print(record.ngram)\n\n except StopIteration:\n pass\n\n return count","def n_gram(list, n):\n ngrams = zip(*[list[i:] for i in range(n)])\n return [\" \".join(ngram) for ngram in ngrams]","def words_used_n_times(word_count_dict, n):\n n_times = []\n # TODO 6: define this function\n return n_times","def get_ngrams(stats,s,t,i):\n #lemma ngrams\n ngram_sizes = [\"bi\", \"tri\"]\n for ngram_size in ngram_sizes:\n lm_ngram = get_lemma_ngrams(s, t, i, ngram_size)\n if lm_ngram:\n put_feature_value_list(stats,\"lemma_\" + ngram_size + \"gr\", lm_ngram)\n\n #POS and deprel bigrams\n if i < s.length-1:\n put_feature_value_list(stats,\"deprels_bigr\", (t.deprel,s.nodes[i+1].deprel))\n put_feature_value_list(stats,\"pos_bigr\", (t.pos,s.nodes[i+1].pos))\n \n #POS and deprel trigrams\n if i < s.length-2:\n put_feature_value_list(stats,\"deprels_trigr\", (t.deprel, s.nodes[i+1].deprel, s.nodes[i+2].deprel))\n put_feature_value_list(stats,\"pos_trigr\", (t.pos, s.nodes[i+1].pos, s.nodes[i+2].pos))\n\n return stats","def get_grams(candidate, n):\n words = candidate.split(' ')\n # print(words)\n grams = list()\n for i in range(len(words) - n + 1):\n # print(words[i:i+n])\n grams.append(' '.join(words[i:i+n]))\n return grams","def find_ngrams(input_list, n=3):\n return zip(*[input_list[i:] for i in range(n)])","def get_ngrams(self, n = None):\n if not n:\n n = self.N\n\n temp = []\n for sent in self.get_sentences():\n temp.extend(list(sent))\n\n return nltk.ngrams(temp, n)","def number_tokens(dgraph):\n cnt = 0\n for node in dgraph.subgraphs(exclude_root=True):\n node[WORD] = (cnt, node[WORD])\n cnt += 1\n return dgraph","def count_given_ngrams(seqx, ngrams, partial_order=True): \n\n # usu. the input ngrams have the same length \n ngram_tb = {1: [], }\n for ngram in ngrams: # ngram is in tuple form \n if isinstance(ngram, tuple): \n length = len(ngram)\n if not ngram_tb.has_key(length): ngram_tb[length] = []\n ngram_tb[length].append(ngram)\n else: # assume to be unigrams \n ngram_tb[1].append(ngram)\n \n ng_min, ng_max = min(ngram_tb.keys()), max(ngram_tb.keys())\n if partial_order:\n\n # evaluate all possible n-grams \n counts = count_ngrams2(seqx, min_length=ng_min, max_length=ng_max, partial_order=True)\n\n counts_prime = {}\n for n, ngx in ngram_tb.items(): # n in n-gram\n if counts.has_key(n): \n for ngram in ngx: # query each desired ngram \n # if n == 1: print '> unigram: %s' % ngram\n # sorted('x') == sorted(('x', )) == ['x'] => f ngram is a unigram, can do ('e', ) or 'e'\n counts_prime[ngram] = counts[n][tuple(sorted(ngram))] \n else: \n for ngram in ngx: \n counts_prime[ngram] = 0 \n else: \n counts = count_ngrams2(seqx, min_length=ng_min, max_length=ng_max, partial_order=False)\n \n counts_prime = {}\n for n, ngx in ngram_tb.items(): # n in n-gram\n if counts.has_key(n): \n for ngram in ngx: # query each desired ngram \n counts_prime[ngram] = counts[n][tuple(ngram)]\n else: \n for ngram in ngx: \n counts_prime[ngram] = 0 \n\n return counts_prime # n-gram -> count","def make_ngrams(orig_source, n=2, start_marker=None, end_marker=None):\n source = orig_source[:] # Don't want to modify original if given a reference\n\n if start_marker is not None:\n if isinstance(source, str):\n source = start_marker + source\n else:\n source.insert(0, start_marker)\n\n if end_marker is not None:\n if isinstance(source, str):\n source += end_marker\n else:\n source.append(end_marker)\n\n for i in range(0, len(source) - n):\n yield source[i:i+n+1]","def range_ngrams(tokens, ngramRange=(1,2)):\n return chain(*(n_grams(tokens, i) for i in range(*ngramRange)))","def count_ngrams(word_list,n):\n ngram_dict = dict()\n for i in xrange(len(word_list)-n+1):\n ngram = tuple(word_list[i:i+n])\n if ngram in ngram_dict:\n # ngram already exists in dictionary\n # increment the count by 1\n ngram_dict[ngram] += 1\n else:\n # ngram does not exist in dictionary\n # initialize to 1\n ngram_dict[ngram] = 1\n return ngram_dict","def length(s: str) -> int:\n count = 0\n for i in s:\n count += 1\n return count","def count_chars(s: str) -> dict:\n count_dict = {}\n\n for c in s:\n if c in count_dict:\n count_dict[c] += 1\n else:\n count_dict[c] = 1\n\n return count_dict","def combinations(s, n):\n return (\"\".join(x) for x in tuples(s,n))","def mostFrequentNGram(text,n):\n\n ngram = calculateNGrams(text,n)\n return counterFrequency(ngram)","def __init__(self, sents, n, corpus='', D=None):\n\n self.n = n\n self.D = D\n self.corpus = corpus\n self.smoothingtechnique = 'Kneser Ney Smoothing'\n # N1+(·w_<i+1>)\n self._N_dot_tokens_dict = N_dot_tokens = defaultdict(set)\n # N1+(w^<n-1> ·)\n self._N_tokens_dot_dict = N_tokens_dot = defaultdict(set)\n # N1+(· w^<i-1>_<i-n+1> ·)\n self._N_dot_tokens_dot_dict = N_dot_tokens_dot = defaultdict(set)\n self.counts = counts = defaultdict(int)\n vocabulary = []\n\n if D is None:\n total_sents = len(sents)\n k = int(total_sents*9/10)\n training_sents = sents[:k]\n held_out_sents = sents[k:]\n training_sents = list(map(lambda x: ['<s>']*(n-1) + x + ['</s>'], training_sents))\n for sent in training_sents:\n for j in range(n+1):\n for i in range(n-j, len(sent) - j + 1):\n ngram = tuple(sent[i: i + j])\n counts[ngram] += 1\n if ngram:\n if len(ngram) == 1:\n vocabulary.append(ngram[0])\n else:\n right_token, left_token, right_kgram, left_kgram, middle_kgram =\\\n ngram[-1:], ngram[:1], ngram[1:], ngram[:-1], ngram[1:-1]\n N_dot_tokens[right_kgram].add(left_token)\n N_tokens_dot[left_kgram].add(right_token)\n if middle_kgram:\n N_dot_tokens_dot[middle_kgram].add(right_token)\n N_dot_tokens_dot[middle_kgram].add(left_token)\n if n - 1:\n counts[('<s>',)*(n-1)] = len(sents)\n self.vocab = set(vocabulary)\n aux = 0\n for w in self.vocab:\n aux += len(self._N_dot_tokens_dict[(w,)])\n self._N_dot_dot_attr = aux\n D_candidates = [i*0.12 for i in range(1, 9)]\n xs = []\n for D in D_candidates:\n self.D = D\n aux_perplexity = self.perplexity(held_out_sents)\n xs.append((D, aux_perplexity))\n xs.sort(key=lambda x: x[1])\n self.D = xs[0][0]\n with open('old-stuff/kneserney_' + str(n) + '_parameters_'+corpus, 'a') as f:\n f.write('Order: {}\\n'.format(self.n))\n f.write('D: {}\\n'.format(self.D))\n f.write('Perplexity observed: {}\\n'.format(xs[0][1]))\n f.write('-------------------------------\\n')\n f.close()\n\n # discount value D provided\n else:\n sents = list(map(lambda x: ['<s>']*(n-1) + x + ['</s>'], sents))\n for sent in sents:\n for j in range(n+1):\n # all k-grams for 0 <= k <= n\n for i in range(n-j, len(sent) - j + 1):\n ngram = tuple(sent[i: i + j])\n counts[ngram] += 1\n if ngram:\n if len(ngram) == 1:\n vocabulary.append(ngram[0])\n else:\n # e.g., ngram = (1,2,3,4,5,6,7,8)\n # right_token = (8,)\n # left_token = (1,)\n # right_kgram = (2,3,4,5,6,7,8)\n # left_kgram = (1,2,3,4,5,6,7)\n # middle_kgram = (2,3,4,5,6,7)\n right_token, left_token, right_kgram, left_kgram, middle_kgram =\\\n ngram[-1:], ngram[:1], ngram[1:], ngram[:-1], ngram[1:-1]\n N_dot_tokens[right_kgram].add(left_token)\n N_tokens_dot[left_kgram].add(right_token)\n if middle_kgram:\n N_dot_tokens_dot[middle_kgram].add(right_token)\n N_dot_tokens_dot[middle_kgram].add(left_token)\n if n-1:\n counts[('<s>',)*(n-1)] = len(sents)\n self.vocab = set(vocabulary)\n\n aux = 0\n for w in self.vocab:\n aux += len(self._N_dot_tokens_dict[(w,)])\n self._N_dot_dot_attr = aux\n\n xs = [k for k, v in counts.items() if v == 1 and n == len(k)]\n ys = [k for k, v in counts.items() if v == 2 and n == len(k)]\n n1 = len(xs)\n n2 = len(ys)\n self.D = n1 / (n1 + 2 * n2)","def run_length(s):\n\n s = re.sub(\"[^a-zA-Z]\",\"\", s)\n s = s.lower()\n cnt = 1\n y = []\n z = []\n ch = ''\n for i in range(len(s)):\n if i + 1 < len(s) and s[i] == s[i + 1]:\n cnt += 1\n else:\n if cnt > 1:\n z.append(s[i-1])\n y.append(str(cnt))\n else:\n z.append(s[i])\n y.append(str(cnt))\n cnt = 1\n for i in range(len(y)):\n ch = ch + y[i] + z[i]\n i += 1\n print ch"],"string":"[\n \"def extract_char_ngrams(s: str, n: int) -> Counter:\\n return Counter([s[i:i + n] for i in range(len(s) - n + 1)])\",\n \"def precook(s, n=4, out=False):\\n words = s.split()\\n counts = defaultdict(int)\\n for k in xrange(1,n+1):\\n for i in xrange(len(words)-k+1):\\n ngram = tuple(words[i:i+k])\\n counts[ngram] += 1\\n return counts\",\n \"def _create_ngrams(tokens, n):\\n\\n ngrams = collections.Counter()\\n for ngram in (tuple(tokens[i:i + n]) for i in xrange(len(tokens) - n + 1)):\\n ngrams[ngram] += 1\\n return ngrams\",\n \"def _precook(s, n=4, out=False):\\n if isinstance(s,str):\\n words = s.split()\\n # print(words)\\n elif isinstance(s,list) or isinstance(s,tuple):\\n words = s\\n else:\\n raise NotImplementedError(type(s))\\n counts = defaultdict(int)\\n for k in range(1, n + 1):\\n for i in range(len(words) - k + 1):\\n ngram = tuple(words[i:i + k])\\n counts[ngram] += 1\\n return (len(words), counts)\",\n \"def _generateNgrams(self,text,n=2):\\n token = Utilities.CVTokeniser(text)\\n # token = nltk.word_tokenize(text)\\n computedNgrams=ngrams(token,n)\\n return Counter(computedNgrams)\",\n \"def ngrams(text, n):\\n return chain(*[ngrams_(text, i) for i in range(n + 1)])\",\n \"def ngramas(n, string):\\n\\n ngrams = []\\n i = 0\\n while i + n < len(string):\\n ngrams.append(string[i:i + n])\\n i += 1\\n\\n return ngrams\",\n \"def find_ngrams(self, n):\\n\\n output = {}\\n\\n for i in range(len(self.text)-n+1):\\n s = ' '.join(self.text[i:i+n])\\n # if s is not already in dictionary, set value to 0\\n output.setdefault(s, 0)\\n output[s] += 1\\n return output\",\n \"def get_ngrams(seq, n):\\n return\",\n \"def __init__(self, n, sents, corpus=''):\\n assert n > 0\\n self.n = n\\n self.counts = counts = defaultdict(int)\\n self.corpus = corpus\\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 for i in range(len(sent) - n + 1):\\n ngram = tuple(sent[i: i + n])\\n counts[ngram] += 1\\n counts[ngram[:-1]] += 1\",\n \"def n_grams(tokens, n):\\n return zip(*[tokens[i:] for i in range(n)])\",\n \"def chngrams(string=\\\"\\\", n=3, top=None, threshold=0, exclude=[], **kwargs):\\n\\t# An optional dict-parameter can be used to specify a subclass of dict,\\n\\t# e.g., count(words, dict=readonlydict) as used in Document.\\n\\tcount = defaultdict(int)\\n\\tif n > 0:\\n\\t\\tfor i in xrange(len(string)-n+1):\\n\\t\\t\\tw = string[i:i+n]\\n\\t\\t\\tif w not in exclude:\\n\\t\\t\\t\\tcount[w] += 1\\n\\tif threshold > 0:\\n\\t\\tcount = dict((k, v) for k, v in count.items() if v > threshold)\\n\\tif top is not None:\\n\\t\\tcount = dict(heapq.nsmallest(top, count.items(), key=lambda kv: (-kv[1], kv[0])))\\n\\treturn kwargs.get(\\\"dict\\\", dict)(count)\",\n \"def ngrams_(text, n):\\n return zip(*[text[i:] for i in range(n)])\",\n \"def _get_ngrams(segments, order):\\n ngram_counts = collections.Counter()\\n for seg in segments:\\n for i in range(0, len(seg) - order + 1):\\n ngram = tuple(seg[i:i+order])\\n ngram_counts[ngram] += 1\\n return ngram_counts\",\n \"def sent_to_n_grams(sent: str, n: int) -> Iterator[Tuple[str, ...]]:\\n\\n words = [word for word in sent.split() if word not in string.punctuation]\\n\\n rows = [words[i:] for i in range(n)]\\n\\n return zip(*rows)\",\n \"def ngrams(name_string, n=3):\\n\\n string = re.sub(r'[,-./]|\\\\sBD', r'', name_string)\\n n_grams = zip(*[string[i:] for i in range(n)])\\n return [''.join(n_gram) for n_gram in n_grams]\",\n \"def iter_ngrams(self, sentence, n):\\n return [tuple(sentence[i : i+n]) for i in range(len(sentence)-n+1)]\",\n \"def compute_ngrams(str, n=2):\\n #split the string\\n st = tuple(str.split())\\n #not list of list but list of tuple..\\n gram = [st[x:x+n] for x in range(len(st)-n+1)]\\n dgram = {}\\n #convert ngram into dictionary:\\n for key in gram:\\n dgram.setdefault(key[0],[]).append(key[1:])\\n return dgram\",\n \"def count_n_grams(data, n, start_token='<s>', end_token = '<e>'):\\r\\n \\r\\n # Initialize dictionary of n-grams and their counts\\r\\n n_grams = {}\\r\\n\\r\\n \\r\\n for sentence in data: # complete this line\\r\\n \\r\\n # prepend start token n times, and append <e> one time\\r\\n sentence = [start_token]*n + sentence + [end_token]\\r\\n \\r\\n # convert list to tuple\\r\\n # So that the sequence of words can be used as\\r\\n # a key in the dictionary\\r\\n sentence = tuple(sentence)\\r\\n\\r\\n \\r\\n for i in range(len(sentence)+1-n): # complete this line\\r\\n\\r\\n # Get the n-gram from i to i+n\\r\\n n_gram = sentence[i:i+n]\\r\\n\\r\\n # check if the n-gram is in the dictionary\\r\\n if n_gram in n_grams: \\r\\n \\r\\n # Increment the count for this n-gram\\r\\n n_grams[n_gram] += 1\\r\\n else:\\r\\n # Initialize this n-gram count to 1\\r\\n n_grams[n_gram] = 1\\r\\n \\r\\n return n_grams\",\n \"def count_reddit_comments_ngram_strs(year, month, n):\\n ngram_strs = ngram_extract.extract_reddit_comments_ngram_strs(year, month, n)\\n return Counter(itertools.chain.from_iterable(ngram_strs))\",\n \"def count_ngrams(f, N):\\n\\t#print \\\">>> Computing n-gram frequency counts ...\\\"\\n\\t#freqs[n] contains n-gram frequencies, freqs[n-1] contains (n-1)-gram frequencies, etc.\\n\\tfreqs = collections.defaultdict(lambda: collections.defaultdict(int))\\n\\ttot =0\\n\\tfor line in f:\\n\\t\\ttot +=1\\n\\t\\tw = line\\n\\t\\tfifo = [':'] * N # initialise n-gram storage with \\\":\\\" as stop characters\\n\\t\\tfor i in range(N-1):\\n\\t\\t\\tw += ':'\\n\\t\\tfor c in w:\\n\\t\\t\\tfifo.pop(0)\\n\\t\\t\\tfifo.append(c)\\n\\t\\t\\tfor idx in range(N):\\n\\t\\t\\t\\tn = idx + 1\\n\\t\\t\\t\\tngram = ''.join(fifo[:n]) # n-gram = first n characters in fifo\\n\\t\\t\\t\\tfreqs[n][ngram] += 1\\n\\treturn freqs\",\n \"def build_ngrams(tokens, n=2):\\n ngrams = zip(*(islice(group, idx, None) for idx, group in enumerate(tee(tokens, n))))\\n return ngrams\",\n \"def ngrams(word, size):\\n expanded = \\\"^\\\" + word + \\\"$\\\"\\n for start in range(len(expanded) - size + 1):\\n yield expanded[start:start + size]\",\n \"def find_frequency(text, n=1):\\n freqs = {}\\n length = len(text)\\n for i in xrange(0, length):\\n upper = i+n\\n if upper > length:\\n break\\n gram = text[i:upper]\\n dict_operate(freqs, gram, 1, operator.add)\\n return freqs\",\n \"def repeatedString(s, n):\\n\\n count = 0\\n s_count_a = s.count('a')\\n\\n count += math.floor(n / len(s)) * s_count_a\\n for _ in range(n % len(s)):\\n if s[_] == 'a':\\n count += 1\\n\\n return count\",\n \"def n_grams(tokens, n=1):\\n shiftToken = lambda i: (el for j,el in enumerate(tokens) if j>=i)\\n shiftedTokens = (shiftToken(i) for i in range(n))\\n tupleNGrams = zip(*shiftedTokens)\\n return tupleNGrams\",\n \"def ngrams(text, n):\\n grams = zip(*[text[i:] for i in range(n)])\\n return [''.join(gram) for gram in grams]\",\n \"def calculate_ngram_frequencies(text, n):\\n\\n import re\\n\\n # Create a new dictionary\\n ngram_dict = {}\\n\\n # Find all sentences\\n sentences_list = re.findall(r'[^\\\\.\\\\?!\\\"]+', text)\\n\\n # Iterate over sentences in the list\\n for sentence in sentences_list:\\n # Split words by a whitespace character\\n words_list = sentence.rsplit()\\n\\n # Iterate over ngrams in the sentence\\n for i in range(len(words_list) - n + 1):\\n\\n # Join the words to size of n\\n ngram = ' '.join(words_list[i:i + n])\\n\\n # Record the presence of a new ngram\\n if not ngram in ngram_dict:\\n ngram_dict[ngram] = 1\\n\\n # Add the number of occurrence of the ngram\\n elif ngram in ngram_dict:\\n ngram_dict[ngram] += 1\\n\\n return ngram_dict\",\n \"def _get_ngrams_with_counter(segment, max_order):\\n ngram_counts = collections.Counter()\\n for order in xrange(1, max_order + 1):\\n for i in xrange(0, len(segment) - order + 1):\\n ngram = tuple(segment[i:i + order])\\n ngram_counts[ngram] += 1\\n return ngram_counts\",\n \"def ngrams(self, n=1, uncased=False, filter_fn=None, as_strings=True):\\n\\n def _skip(gram):\\n if not filter_fn:\\n return False\\n return filter_fn(gram)\\n\\n words = self.words(True)\\n ngrams = [(s, e + 1)\\n for s in range(len(words))\\n for e in range(s, min(s + n, len(words)))\\n if not _skip(words[s:e + 1])]\\n\\n # Concatenate into strings\\n if as_strings:\\n ngrams = ['{}'.format(' '.join(words[s:e])) for (s, e) in ngrams]\\n\\n return ngrams\",\n \"def ngrams(sequence, n):\\n # credit: http://stackoverflow.com/questions/2380394/simple-implementation-of-n-gram-tf-idf-and-cosine-similarity-in-python\\n sequence = list(sequence)\\n count = max(0, len(sequence) - n + 1)\\n return [tuple(sequence[i:i+n]) for i in range(count)]\",\n \"def _ngrams(self, string_):\\n def find_ngrams(input_list, n):\\n return zip(*[input_list[i:] for i in range(n)])\\n\\n ngrams = []\\n tokens = string_.split()\\n\\n for size in range(1, self._ngram_range + 1):\\n tuples = find_ngrams(tokens, size)\\n concatenated = [\\\"_\\\".join(tuple_) for tuple_ in tuples]\\n ngrams.extend(concatenated)\\n\\n return \\\" \\\".join(ngrams)\",\n \"def n_grama(sentence, n):\\n t = tokenize(sentence)\\n n_grams = zip(*[t[i:] for i in range(n)])\\n return list(map(lambda n_gram: ' '.join(n_gram), n_grams))\",\n \"def ngrams(self, n=1, uncased=False, filter_fn=None, as_strings=True):\\n def _skip(gram):\\n if not filter_fn:\\n return False\\n return filter_fn(gram)\\n\\n words = self.words(uncased)\\n ngrams = [(s, e + 1)\\n for s in range(len(words))\\n for e in range(s, min(s + n, len(words)))\\n if not _skip(words[s:e + 1])]\\n\\n # Concatenate into strings\\n if as_strings:\\n ngrams = ['{}'.format(' '.join(words[s:e])) for (s, e) in ngrams]\\n\\n return ngrams\",\n \"def ngrams(words, n=1):\\n return [tuple(words[j:j + n]) for j in range(len(words) - n + 1)]\",\n \"def gen_ngrams(items, n):\\n ngs = {}\\n ilen = len(items)\\n for i in xrange(ilen-n+1):\\n ng = tuple(items[i:i+n])\\n ngs[ng] = ngs.get(ng, 0) + 1\\n return ngs\",\n \"def substrCount(n, s):\\r\\n lst = []\\r\\n character = s[0]\\r\\n count = 1\\r\\n result = 0\\r\\n for i in range(1, n):\\r\\n if s[i] == character:\\r\\n count += 1\\r\\n else:\\r\\n lst.append((character, count))\\r\\n character = s[i]\\r\\n count = 1\\r\\n lst.append((character, count))\\r\\n\\r\\n for tpl in lst:\\r\\n \\\"\\\"\\\"calculate all possible palindromes created from same characters that are close to each other\\r\\n E.g: aaa => 6 possibles (3*4//2 = 6)\\r\\n \\\"\\\"\\\"\\r\\n result += tpl[1] * (tpl[1] + 1) // 2\\r\\n\\r\\n for i in range(1, len(lst) - 1):\\r\\n if lst[i - 1][0] == lst[i + 1][0] and lst[i][1] == 1:\\r\\n \\\"\\\"\\\"\\r\\n check palindromes created from 3 tuples with a different character in between\\r\\n \\\"\\\"\\\"\\r\\n result += min(lst[i - 1][1], lst[i + 1][1])\\r\\n\\r\\n return result\",\n \"def word2ngrams(text, n=3):\\n return [text[i:i+n] for i in range(len(text)-n+1)]\",\n \"def generate_ngrams(iterable, n):\\n return zip(*[itertools.islice(it, i, None) for i, it in enumerate(itertools.tee(iterable, n))])\",\n \"def _count_ngram(ngram_input_list: Sequence[str], n_gram: int) ->Counter:\\n ngram_counter: Counter = Counter()\\n for i in range(1, n_gram + 1):\\n for j in range(len(ngram_input_list) - i + 1):\\n ngram_key = tuple(ngram_input_list[j:i + j])\\n ngram_counter[ngram_key] += 1\\n return ngram_counter\",\n \"def sent2ngrams(text, n=3):\\n if n == \\\"word\\\":\\n return text.split()\\n return list(chain(*[word2ngrams(i,n) for i in text.lower().split()]))\",\n \"def ngrams(n, target):\\n chars = collections.deque()\\n while True:\\n chars.append((yield))\\n if len(chars) == n: \\n target.send(chars)\\n chars.popleft()\",\n \"def get(self, n):\\n parts = [' '.join(g) for g in ngrams(self.words, n)]\\n return get_occurences(parts)\",\n \"def word_ngrams(sent, n):\\n\\t\\n\\t# EXAMPLES \\n\\t# > word_ngrams(tokenize('hello world'), 1)\\n\\t# [('hello',), ('world',)]\\n\\t# > word_ngrams(tokenize('hello world'), 2)\\n\\t# [('<s>', 'hello'), ('hello', 'world'), ('world', '</s>')]\\n\\n\\t# YOUR CODE HERE\\n\\ttokenized_sent = tokenize(sent)\\n\\tif n != 1:\\n\\t\\ttokenized_sent.insert(0, '<s>')\\n\\t\\ttokenized_sent.append('</s>')\\n\\treturn [tuple(tokenized_sent[i:i + n]) for i in range(0, len(tokenized_sent)-n+1)]\",\n \"def get_ngrams(s, ngram_range=1):\\n # tokens = s.split()\\n # return filter(lambda token: len(token)>1, tokens)\\n # return bigrams(s.split()) # NLTK bigrams method\\n words = s.split()\\n return [' '.join(words[i:i+ngram_range]) for i in range(len(words)-1)]\",\n \"def ngrams(word, n):\\n word = list(word)\\n # insert extra tokens\\n word.insert(0, '$')\\n word.append('$')\\n\\n output = []\\n for i in range(len(word) - n + 1):\\n # print(i)\\n # print(word[i:i + n])\\n output.append(''.join(word[i:i + n]))\\n return output\",\n \"def extract_ngrams(line, min_order=1, max_order=NGRAM_ORDER) -> Counter:\\n\\n ngrams = Counter()\\n tokens = line.split()\\n for n in range(min_order, max_order + 1):\\n for i in range(0, len(tokens) - n + 1):\\n ngram = ' '.join(tokens[i: i + n])\\n ngrams[ngram] += 1\\n\\n return ngrams\",\n \"def extract_n_grams(string, n, overlap=0, unique=True):\\n if n > len(string):\\n return [] \\n\\n n_grams = []\\n step = n - overlap\\n n_grams = [string[i:i+n] for i in range(0, len(string)-step+1, step)]\\n\\n if unique:\\n n_grams = list(set(n_grams))\\n\\n n_grams = [g+\\\"\\\\n\\\" for g in n_grams]\\n\\n return n_grams\",\n \"def __makeNgrams(self, n):\\n # start_time = time.time()\\n ngrams = dict()\\n itergrams = dict()\\n\\n for k in range(2,n+1):\\n itergrams[k] = list(nltk.ngrams(self.words, k))\\n\\n for k, grams in itergrams.items():\\n kgrams = defaultdict(Counter)\\n for gram in grams: \\n kgram = list(gram)\\n key = ' '.join(kgram[:k-1])\\n kgrams[key].update({kgram[-1]})\\n ngrams[k] = kgrams\\n # print ('finish gen ', k, 'grams at ', time.time()-start_time)\\n return ngrams\",\n \"def _count_ngram(ngram_input_list: Sequence[str], n_gram: int) -> Counter:\\n ngram_counter: Counter = Counter()\\n\\n for i in range(1, n_gram + 1):\\n for j in range(len(ngram_input_list) - i + 1):\\n ngram_key = tuple(ngram_input_list[j : (i + j)])\\n ngram_counter[ngram_key] += 1\\n\\n return ngram_counter\",\n \"def __init__(self, n, sents):\\n assert n > 0\\n self._n = n\\n print(\\\"Counting...\\\")\\n count = defaultdict(int)\\n while n >= 0:\\n for sent in sents:\\n s = sent[:] # En una oracion auxiliar agrego el item de start y end para contarlos\\n s.insert(0, \\\"<s>\\\")\\n s.append(\\\"</s>\\\")\\n for i in range(len(s) - n + 1):\\n count[tuple(s[i:i + n])] += 1\\n n -= 1\\n count[()] = count[()] - count[('<s>',)] - count[\\n ('</s>',)] # Pero no quiero que <s> y </s> sean considerados por ()\\n self._count = count\\n print(\\\"Computing vocabulary...\\\")\\n self._voc = voc = set()\\n for sent in sents:\\n voc = voc.union(set(sent))\\n voc.add('</s>')\\n self._voc = voc\\n self._V = len(voc) # vocabulary size\\n print(\\\"Done\\\")\",\n \"def count_ngrams(file_name, n=2):\\n # The defaultdict class may be useful here. Check the python \\n # documentation for more information: \\n # https://docs.python.org/3/library/collections.html#collections.defaultdict\\n\\n file = open(file_name, \\\"r\\\")\\n text = []\\n gram_dict = {}\\n for line in file:\\n exclude = set(string.punctuation)\\n line = ''.join(char for char in line if char not in exclude)\\n line = line.replace(\\\"\\\\n\\\", \\\"\\\").lower()\\n text.extend(line.split())\\n\\n for wordIndex in range(0,len(text)-n+1):\\n tmpLi = []\\n for x in range(0,n):\\n tmpLi.append(text[wordIndex + x])\\n tup = tuple(tmpLi)\\n if tup not in gram_dict:\\n gram_dict[tup] = 1\\n else:\\n gram_dict[tup] += 1\\n return gram_dict\",\n \"def create_ngrams(word_list, n):\\n yield zip(*[word_list[i:] for i in range(n)])\",\n \"def grapheme_lengths(string):\\n return iter(len(g) for g in graphemes(string))\",\n \"def find_all_ngrams(dataset, n):\\n return zip(*[dataset[i:] for i in xrange(n)])\",\n \"def count_words(s, n):\\n\\n # TODO: Count the number of occurences of each word in s\\n words = s.lower().split()\\n dict = {}\\n\\n for item in words:\\n dict[item] = words.count(item)\\n\\n # TODO: Sort the occurences in descending order (alphabetically in case of ties)\\n items = dict.items()\\n\\n items.sort(key=lambda tup: tup[0])\\n items.sort(key=lambda tup: tup[1], reverse=True)\\n\\n # TODO: Return the top n words as a list of tuples (<word>, <count>)\\n return items[:n]\",\n \"def calculateNGrams(text, n):\\n\\n return ([text[i:i+n] for i in range(len(text)-n+1)])\",\n \"def ngrams(iterable, n=1):\\n return zip(*(iterable[i:] for i in range(n)))\",\n \"def count_given_ngrams2(seqx, ngrams, partial_order=True):\\n # from batchpheno import utils\\n\\n # the input ngrams may or may not have the same length \\n ngram_tb = {1: [], }\\n for ngram in ngrams: # ngram is in tuple form \\n if isinstance(ngram, tuple): \\n length = len(ngram)\\n if not ngram_tb.has_key(length): ngram_tb[length] = []\\n ngram_tb[length].append(ngram)\\n else: # assume to be unigrams \\n assert isinstance(ngram, str)\\n ngram_tb[1].append(ngram)\\n \\n # print('verify> ngram_tb:\\\\n%s\\\\n' % ngram_tb) # utils.sample_hashtable(ngram_tb, n_sample=10))\\n\\n ng_min, ng_max = min(ngram_tb.keys()), max(ngram_tb.keys())\\n if partial_order:\\n\\n # evaluate all possible n-grams \\n counts = count_ngrams2(seqx, min_length=ng_min, max_length=ng_max, partial_order=True)\\n\\n counts_prime = {}\\n for n, ngx in ngram_tb.items(): # n in n-gram\\n if not counts_prime.has_key(n): counts_prime[n] = {} \\n if counts.has_key(n):\\n for ngram in ngx: # query each desired ngram \\n # if n == 1: print '> unigram: %s' % ngram\\n # sorted('x') == sorted(('x', )) == ['x'] => f ngram is a unigram, can do ('e', ) or 'e'\\n counts_prime[n][ngram] = counts[n][tuple(sorted(ngram))] \\n else: \\n for ngram in ngx: \\n counts_prime[n][ngram] = 0 \\n else: \\n counts = count_ngrams2(seqx, min_length=ng_min, max_length=ng_max, partial_order=False)\\n \\n counts_prime = {}\\n for n, ngx in ngram_tb.items(): # n in n-gram\\n if not counts_prime.has_key(n): counts_prime[n] = {} \\n if counts.has_key(n): \\n for ngram in ngx: # query each desired ngram \\n # assert isinstance(ngram, tuple), \\\"Ngram is not a tuple: %s\\\" % str(ngram)\\n counts_prime[n][ngram] = counts[n][tuple(ngram)]\\n else: \\n for ngram in ngx: \\n counts_prime[n][ngram] = 0 \\n\\n return counts_prime # n (as n-gram) -> counts (ngram -> count)\",\n \"def generate_ngram(corpus,n=2):\\r\\n def generate_ngram_str(text,n):\\r\\n text = tokenizer.tokenize(text)\\r\\n for i in range(0, len(text)-n+1):\\r\\n yield text[i:i+n]\\r\\n if isinstance(corpus,str):\\r\\n for ngram in generate_ngram_str(corpus,n):\\r\\n yield ngram\\r\\n elif isinstance(corpus, (list, types.GeneratorType)):\\r\\n for text in corpus:\\r\\n for ngram in generate_ngram_str(text,n):\\r\\n yield ngram\",\n \"def numberOfSubstrings(self, s: str) -> int:\\n i = 0\\n res = 0\\n d = {c:0 for c in 'abc'}\\n \\n for j, val in enumerate(s):\\n d[val] += 1\\n while all(d.values()):\\n d[s[i]] -= 1\\n i += 1\\n res += i\\n \\n return res\",\n \"def _char_and_word_ngrams_counts(sentence: str, n_char_order: int, n_word_order: int, lowercase: bool) ->Tuple[Dict[int, Dict[Tuple[str, ...], Tensor]], Dict[int, Dict[Tuple[str, ...], Tensor]]]:\\n if lowercase:\\n sentence = sentence.lower()\\n char_n_grams_counts = _ngram_counts(_get_characters(sentence, whitespace), n_char_order)\\n word_n_grams_counts = _ngram_counts(_get_words_and_punctiation(sentence), n_word_order)\\n return char_n_grams_counts, word_n_grams_counts\",\n \"def count_words(s, n):\\n \\n strList = s.split(' ');#to split the string into a list of words\\n rList = [];#to store the each word only once\\n nList = [];#to store how many times each word has occured\\n for i in range(len(strList)):\\n if ((strList[i] in rList)==False):\\n rList.append(strList[i]);\\n nList.append(int(1));\\n else:\\n for j in range(len(rList)):\\n if (strList[i]==rList[j]):\\n nList[j]=nList[j]+1;\\n \\n tList = list();#a new empty tuple list\\n for i in range(len(rList)):\\n tList.append((rList[i],nList[i]));#construct the tuple list from rList and nList\\n \\n tList.sort(key=lambda tList: (-tList[1], tList[0]));#sort the tuple list: first by its 2nd element in reverse order \\\"-\\\", then sort by its 1st element in non-reverse order, no \\\"-\\\"\\n \\n # for testing\\n #for i in tList:\\n # print i;\\n \\n \\n # TODO: Count the number of occurences of each word in s\\n \\n # TODO: Sort the occurences in descending order (alphabetically in case of ties)\\n \\n # TODO: Return the top n words as a list of tuples (<word>, <count>)\\n \\n return tList[:n] #return the first n pairs of elements as required\",\n \"def get_ngrams(sequence, n):\\n length = len(sequence)\\n #if only require 1-gram, then we need to add one START and one END to the sequence. \\n if n==1 or n==2:\\n sequence=[\\\"START\\\"]*n+sequence+[\\\"STOP\\\"]\\n end = n+1 #end i means that when n==1, we need to read one more data, that is to the end of sequence, which is slightly different from when n>1.\\n #if require multi-grams, use the common calculation below.\\n else:\\n sequence = [\\\"START\\\"]*(n-1)+sequence+[\\\"STOP\\\"]\\n end = 1\\n if n==2:\\n end = n\\n result = []\\n temp = ()\\n #the process to construct the tuple-based array.\\n for i in range(0,length+end):\\n temp = tuple(sequence[i:i+n])\\n\\n result.append(temp)\\n return result\",\n \"def n_count(dna_string):\\n a_count = 0\\n c_count = 0\\n g_count = 0\\n t_count= 0\\n for nuc in dna_string:\\n if nuc.upper() == 'A':\\n a_count += 1\\n elif nuc.upper() == 'C':\\n c_count += 1\\n elif nuc.upper() == 'G':\\n g_count += 1\\n elif nuc.upper() == 'T':\\n t_count += 1\\n else:\\n continue\\n print(a_count, c_count, g_count, t_count)\",\n \"def get_char_counts(string):\\n counts = {}\\n for char in iter(string):\\n counts[char] = 1 if not char in counts.keys() else counts[char] + 1\\n return counts\",\n \"def extract_ngrams(line, min_order=1, max_order=BLEU.NGRAM_ORDER) -> Counter:\\n\\n ngrams = Counter() # type: Counter\\n tokens = line.split()\\n for n in range(min_order, max_order + 1):\\n for i in range(0, len(tokens) - n + 1):\\n ngram = ' '.join(tokens[i: i + n])\\n ngrams[ngram] += 1\\n\\n return ngrams\",\n \"def get_ngrams(tokens, min_n, max_n):\\n all_ngrams = list()\\n n_tokens = len(tokens)\\n for i in range(n_tokens):\\n for j in range(i + min_n, min(n_tokens, i + max_n) + 1):\\n all_ngrams.append(\\\" \\\".join(tokens[i:j]))\\n return all_ngrams\",\n \"def nwords(s: str):\\n letters = \\\"ABCDEFGHIJKLMNOPQRSTUVWXYZÄÜÖabcdefghijklmnopqrstuvwxyzüäö\\\"\\n take = 0\\n skip = 0\\n for i in s:\\n if i not in letters:\\n skip += 1\\n #print(\\\"S:\\\", skip)\\n else:\\n take += 1\\n #print(\\\"t:\\\", take)\\n res = (len(s) - take) + 1\\n return res\",\n \"def wc(substring):\\n n = 0\\n try:\\n while True:\\n n += (yield)\\n except GeneratorExit:\\n print(substring, n, flush=True)\",\n \"def count_ngram(hyps_resp, n):\\n if len(hyps_resp) == 0:\\n print(\\\"ERROR, eval_distinct get empty input\\\")\\n return\\n\\n if type(hyps_resp[0]) != list:\\n print(\\\"ERROR, eval_distinct takes in a list of <class 'list'>, get a list of {} instead\\\".format(\\n type(hyps_resp[0])))\\n return\\n\\n ngram = set()\\n for resp in hyps_resp:\\n if len(resp) < n:\\n continue\\n for i in range(len(resp) - n + 1):\\n ngram.add(' '.join(resp[i: i + n]))\\n return len(ngram)\",\n \"def findRepeatedDnaSequences(s):\\n\\n # empty string or string < 10 chars\\n if s == '' or len(s) < 10:\\n raise ValueError(\\\"String must be of length 10+. String: '{}' is too small.\\\".format(s))\\n\\n ten_letter_counts = {}\\n two_or_more = set()\\n\\n i = 0\\n while (i + 10) <= len(s):\\n # get 10 letter substring\\n sub = s[i:i+10]\\n\\n # get current count, if not seen before, set count to 1\\n ten_letter_counts[sub] = ten_letter_counts.get(sub, 0) + 1\\n\\n # check if occures >= 2\\n if ten_letter_counts[sub] >= 2:\\n two_or_more.append(sub)\\n\\n\\n i += 1\\n\\n return two_or_more\",\n \"def get_tag_n_gram(n, filename):\\n\\n from collections import deque\\n queue = deque()\\n\\n count_matrix = {}\\n with open(filename) as f:\\n for l in f:\\n line = l.strip().split()\\n if not line:\\n continue\\n\\n tag = line[0]\\n # Use a queue to keep track of conditioned string,\\n # the occurence of last N - 1 string.\\n queue.appendleft(tag)\\n\\n # Fill the queue until it gets at least N tags.\\n if len(queue) > n - 1:\\n k = \\\" \\\".join(queue)\\n if k not in count_matrix.keys():\\n count_matrix[k] = 1\\n else:\\n count_matrix[k] += 1\\n\\n # Get rid of last one.\\n queue.pop()\\n\\n return count_matrix\",\n \"def get_ngrams(sequence, n):\\n\\n # Set prefix and postfix\\n prefix = \\\"START\\\"\\n postfix = \\\"STOP\\\"\\n # Append 1 prefix regardless of value of n\\n sequence.insert(0, prefix)\\n for i in range(n - 2) :\\n sequence.insert(0, prefix)\\n sequence.append(postfix)\\n\\n # Check if 1 <= n <= len(sequence)\\n if (n > len(sequence)) :\\n print(sequence)\\n assert 1 <= n\\n assert n <= len(sequence)\\n\\n # Create n-gram sequence\\n n_gram_sequence = []\\n for i in range(n, len(sequence) + 1) :\\n temp_sequence = []\\n for j in range(i - n, i) :\\n temp_sequence.append(sequence[j])\\n n_gram_sequence.append(tuple(temp_sequence))\\n return n_gram_sequence\",\n \"def count_ngrams(self):\\n self.unigram = self.count_unigram(self.word_list)\\n self.bigram = self.count_bigram(self.word_list)\\n # self.trigram = self.count_trigram(self.word_list)\\n # self.four_gram = self.count_four_gram(self.word_list)\\n # self.five_gram = self.count_five_gram(self.word_list)\",\n \"def everygrams(seq):\\n for n in range(1, len(seq) + 1):\\n for ng in nltk.util.ngrams(seq, n):\\n yield ng\",\n \"def full_ngrams(items, n):\\n ngs = {}\\n for i in xrange(1, n+1):\\n ngs.update(gen_ngrams(items, i))\\n return ngs\",\n \"def bin_string_iter(n):\\n for bin_string in product([0, 1], repeat=n):\\n yield list(bin_string)\",\n \"def ngram(self,phrase,n,unity=\\\"w\\\"):\\n return self._support.ngram(phrase,n,unity)\",\n \"def get_ngrams(s, ngmin=1, ngmax=1, tokenizer=list, separator=\\\"|\\\"):\\n ngrams = [[] for x in range(ngmin, ngmax + 1)]\\n s = tokenizer(s)\\n for i, ch in enumerate(s):\\n for ngsize in range(ngmin, ngmax + 1):\\n if (i + ngsize) <= len(s):\\n ngrams[ngsize - 1].append(separator.join(s[i:i+ngsize]))\\n return ngrams\",\n \"def part1(input_string):\\n twos, threes = 0, 0\\n for line in input_string:\\n letters_seen = {}\\n for char in line:\\n letters_seen[char] = letters_seen.setdefault(char, 0)+1\\n if 2 in letters_seen.values():\\n twos += 1\\n if 3 in letters_seen.values():\\n threes += 1\\n return threes * twos\",\n \"def count_ngrams(phrase, length, lang):\\n count = 0\\n chinese_character_to_sound = {u'\\\\u5341': 's', u'\\\\u4e8c': 'e', u'\\\\u4e09': 's', u'\\\\u56db': 's',\\n u'\\\\u4e94': 'w', u'\\\\u516d': 'l', u'\\\\u4e03': 'q', u'\\\\u516b': 'b', u'\\\\u5e5d': 'j'}\\n ngram_downloader_langcode = {\\\"english\\\": \\\"eng\\\", \\\"chinese\\\": \\\"chi-sim\\\", \\\"french\\\": \\\"fre\\\",\\n \\\"german\\\": \\\"ger\\\", \\\"hebrew\\\": \\\"heb\\\", \\\"italian\\\": \\\"ita\\\", \\\"russian\\\": \\\"rus\\\", \\\"spanish\\\": \\\"spa\\\"}\\n\\n if lang == \\\"chinese\\\":\\n index = chinese_character_to_sound[phrase[0].lower()]\\n else:\\n index = phrase[0].lower()\\n\\n all_combinations = get_combo(index, length)\\n print(all_combinations)\\n\\n fname, url, records = next(readline_google_store(\\n ngram_len=length, lang=ngram_downloader_langcode[lang], indices=all_combinations))\\n\\n try:\\n record = next(records)\\n print(record.ngram)\\n while record.ngram != phrase:\\n record = next(records)\\n print(record.ngram)\\n\\n while record.ngram == phrase:\\n count += record.match_count\\n record = next(records)\\n print(record.ngram)\\n\\n except StopIteration:\\n pass\\n\\n return count\",\n \"def n_gram(list, n):\\n ngrams = zip(*[list[i:] for i in range(n)])\\n return [\\\" \\\".join(ngram) for ngram in ngrams]\",\n \"def words_used_n_times(word_count_dict, n):\\n n_times = []\\n # TODO 6: define this function\\n return n_times\",\n \"def get_ngrams(stats,s,t,i):\\n #lemma ngrams\\n ngram_sizes = [\\\"bi\\\", \\\"tri\\\"]\\n for ngram_size in ngram_sizes:\\n lm_ngram = get_lemma_ngrams(s, t, i, ngram_size)\\n if lm_ngram:\\n put_feature_value_list(stats,\\\"lemma_\\\" + ngram_size + \\\"gr\\\", lm_ngram)\\n\\n #POS and deprel bigrams\\n if i < s.length-1:\\n put_feature_value_list(stats,\\\"deprels_bigr\\\", (t.deprel,s.nodes[i+1].deprel))\\n put_feature_value_list(stats,\\\"pos_bigr\\\", (t.pos,s.nodes[i+1].pos))\\n \\n #POS and deprel trigrams\\n if i < s.length-2:\\n put_feature_value_list(stats,\\\"deprels_trigr\\\", (t.deprel, s.nodes[i+1].deprel, s.nodes[i+2].deprel))\\n put_feature_value_list(stats,\\\"pos_trigr\\\", (t.pos, s.nodes[i+1].pos, s.nodes[i+2].pos))\\n\\n return stats\",\n \"def get_grams(candidate, n):\\n words = candidate.split(' ')\\n # print(words)\\n grams = list()\\n for i in range(len(words) - n + 1):\\n # print(words[i:i+n])\\n grams.append(' '.join(words[i:i+n]))\\n return grams\",\n \"def find_ngrams(input_list, n=3):\\n return zip(*[input_list[i:] for i in range(n)])\",\n \"def get_ngrams(self, n = None):\\n if not n:\\n n = self.N\\n\\n temp = []\\n for sent in self.get_sentences():\\n temp.extend(list(sent))\\n\\n return nltk.ngrams(temp, n)\",\n \"def number_tokens(dgraph):\\n cnt = 0\\n for node in dgraph.subgraphs(exclude_root=True):\\n node[WORD] = (cnt, node[WORD])\\n cnt += 1\\n return dgraph\",\n \"def count_given_ngrams(seqx, ngrams, partial_order=True): \\n\\n # usu. the input ngrams have the same length \\n ngram_tb = {1: [], }\\n for ngram in ngrams: # ngram is in tuple form \\n if isinstance(ngram, tuple): \\n length = len(ngram)\\n if not ngram_tb.has_key(length): ngram_tb[length] = []\\n ngram_tb[length].append(ngram)\\n else: # assume to be unigrams \\n ngram_tb[1].append(ngram)\\n \\n ng_min, ng_max = min(ngram_tb.keys()), max(ngram_tb.keys())\\n if partial_order:\\n\\n # evaluate all possible n-grams \\n counts = count_ngrams2(seqx, min_length=ng_min, max_length=ng_max, partial_order=True)\\n\\n counts_prime = {}\\n for n, ngx in ngram_tb.items(): # n in n-gram\\n if counts.has_key(n): \\n for ngram in ngx: # query each desired ngram \\n # if n == 1: print '> unigram: %s' % ngram\\n # sorted('x') == sorted(('x', )) == ['x'] => f ngram is a unigram, can do ('e', ) or 'e'\\n counts_prime[ngram] = counts[n][tuple(sorted(ngram))] \\n else: \\n for ngram in ngx: \\n counts_prime[ngram] = 0 \\n else: \\n counts = count_ngrams2(seqx, min_length=ng_min, max_length=ng_max, partial_order=False)\\n \\n counts_prime = {}\\n for n, ngx in ngram_tb.items(): # n in n-gram\\n if counts.has_key(n): \\n for ngram in ngx: # query each desired ngram \\n counts_prime[ngram] = counts[n][tuple(ngram)]\\n else: \\n for ngram in ngx: \\n counts_prime[ngram] = 0 \\n\\n return counts_prime # n-gram -> count\",\n \"def make_ngrams(orig_source, n=2, start_marker=None, end_marker=None):\\n source = orig_source[:] # Don't want to modify original if given a reference\\n\\n if start_marker is not None:\\n if isinstance(source, str):\\n source = start_marker + source\\n else:\\n source.insert(0, start_marker)\\n\\n if end_marker is not None:\\n if isinstance(source, str):\\n source += end_marker\\n else:\\n source.append(end_marker)\\n\\n for i in range(0, len(source) - n):\\n yield source[i:i+n+1]\",\n \"def range_ngrams(tokens, ngramRange=(1,2)):\\n return chain(*(n_grams(tokens, i) for i in range(*ngramRange)))\",\n \"def count_ngrams(word_list,n):\\n ngram_dict = dict()\\n for i in xrange(len(word_list)-n+1):\\n ngram = tuple(word_list[i:i+n])\\n if ngram in ngram_dict:\\n # ngram already exists in dictionary\\n # increment the count by 1\\n ngram_dict[ngram] += 1\\n else:\\n # ngram does not exist in dictionary\\n # initialize to 1\\n ngram_dict[ngram] = 1\\n return ngram_dict\",\n \"def length(s: str) -> int:\\n count = 0\\n for i in s:\\n count += 1\\n return count\",\n \"def count_chars(s: str) -> dict:\\n count_dict = {}\\n\\n for c in s:\\n if c in count_dict:\\n count_dict[c] += 1\\n else:\\n count_dict[c] = 1\\n\\n return count_dict\",\n \"def combinations(s, n):\\n return (\\\"\\\".join(x) for x in tuples(s,n))\",\n \"def mostFrequentNGram(text,n):\\n\\n ngram = calculateNGrams(text,n)\\n return counterFrequency(ngram)\",\n \"def __init__(self, sents, n, corpus='', D=None):\\n\\n self.n = n\\n self.D = D\\n self.corpus = corpus\\n self.smoothingtechnique = 'Kneser Ney Smoothing'\\n # N1+(·w_<i+1>)\\n self._N_dot_tokens_dict = N_dot_tokens = defaultdict(set)\\n # N1+(w^<n-1> ·)\\n self._N_tokens_dot_dict = N_tokens_dot = defaultdict(set)\\n # N1+(· w^<i-1>_<i-n+1> ·)\\n self._N_dot_tokens_dot_dict = N_dot_tokens_dot = defaultdict(set)\\n self.counts = counts = defaultdict(int)\\n vocabulary = []\\n\\n if D is None:\\n total_sents = len(sents)\\n k = int(total_sents*9/10)\\n training_sents = sents[:k]\\n held_out_sents = sents[k:]\\n training_sents = list(map(lambda x: ['<s>']*(n-1) + x + ['</s>'], training_sents))\\n for sent in training_sents:\\n for j in range(n+1):\\n for i in range(n-j, len(sent) - j + 1):\\n ngram = tuple(sent[i: i + j])\\n counts[ngram] += 1\\n if ngram:\\n if len(ngram) == 1:\\n vocabulary.append(ngram[0])\\n else:\\n right_token, left_token, right_kgram, left_kgram, middle_kgram =\\\\\\n ngram[-1:], ngram[:1], ngram[1:], ngram[:-1], ngram[1:-1]\\n N_dot_tokens[right_kgram].add(left_token)\\n N_tokens_dot[left_kgram].add(right_token)\\n if middle_kgram:\\n N_dot_tokens_dot[middle_kgram].add(right_token)\\n N_dot_tokens_dot[middle_kgram].add(left_token)\\n if n - 1:\\n counts[('<s>',)*(n-1)] = len(sents)\\n self.vocab = set(vocabulary)\\n aux = 0\\n for w in self.vocab:\\n aux += len(self._N_dot_tokens_dict[(w,)])\\n self._N_dot_dot_attr = aux\\n D_candidates = [i*0.12 for i in range(1, 9)]\\n xs = []\\n for D in D_candidates:\\n self.D = D\\n aux_perplexity = self.perplexity(held_out_sents)\\n xs.append((D, aux_perplexity))\\n xs.sort(key=lambda x: x[1])\\n self.D = xs[0][0]\\n with open('old-stuff/kneserney_' + str(n) + '_parameters_'+corpus, 'a') as f:\\n f.write('Order: {}\\\\n'.format(self.n))\\n f.write('D: {}\\\\n'.format(self.D))\\n f.write('Perplexity observed: {}\\\\n'.format(xs[0][1]))\\n f.write('-------------------------------\\\\n')\\n f.close()\\n\\n # discount value D provided\\n else:\\n sents = list(map(lambda x: ['<s>']*(n-1) + x + ['</s>'], sents))\\n for sent in sents:\\n for j in range(n+1):\\n # all k-grams for 0 <= k <= n\\n for i in range(n-j, len(sent) - j + 1):\\n ngram = tuple(sent[i: i + j])\\n counts[ngram] += 1\\n if ngram:\\n if len(ngram) == 1:\\n vocabulary.append(ngram[0])\\n else:\\n # e.g., ngram = (1,2,3,4,5,6,7,8)\\n # right_token = (8,)\\n # left_token = (1,)\\n # right_kgram = (2,3,4,5,6,7,8)\\n # left_kgram = (1,2,3,4,5,6,7)\\n # middle_kgram = (2,3,4,5,6,7)\\n right_token, left_token, right_kgram, left_kgram, middle_kgram =\\\\\\n ngram[-1:], ngram[:1], ngram[1:], ngram[:-1], ngram[1:-1]\\n N_dot_tokens[right_kgram].add(left_token)\\n N_tokens_dot[left_kgram].add(right_token)\\n if middle_kgram:\\n N_dot_tokens_dot[middle_kgram].add(right_token)\\n N_dot_tokens_dot[middle_kgram].add(left_token)\\n if n-1:\\n counts[('<s>',)*(n-1)] = len(sents)\\n self.vocab = set(vocabulary)\\n\\n aux = 0\\n for w in self.vocab:\\n aux += len(self._N_dot_tokens_dict[(w,)])\\n self._N_dot_dot_attr = aux\\n\\n xs = [k for k, v in counts.items() if v == 1 and n == len(k)]\\n ys = [k for k, v in counts.items() if v == 2 and n == len(k)]\\n n1 = len(xs)\\n n2 = len(ys)\\n self.D = n1 / (n1 + 2 * n2)\",\n \"def run_length(s):\\n\\n s = re.sub(\\\"[^a-zA-Z]\\\",\\\"\\\", s)\\n s = s.lower()\\n cnt = 1\\n y = []\\n z = []\\n ch = ''\\n for i in range(len(s)):\\n if i + 1 < len(s) and s[i] == s[i + 1]:\\n cnt += 1\\n else:\\n if cnt > 1:\\n z.append(s[i-1])\\n y.append(str(cnt))\\n else:\\n z.append(s[i])\\n y.append(str(cnt))\\n cnt = 1\\n for i in range(len(y)):\\n ch = ch + y[i] + z[i]\\n i += 1\\n print ch\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.82485414","0.76264787","0.73532337","0.73268604","0.71129584","0.7092459","0.70224917","0.6941578","0.6845443","0.67267495","0.6712389","0.6680387","0.66529167","0.6583822","0.6576275","0.65749717","0.65712875","0.6563945","0.6559195","0.6554432","0.6537288","0.65310955","0.6525532","0.6523345","0.649932","0.6475966","0.64716464","0.64691967","0.6463616","0.64389265","0.6405815","0.6381632","0.63645977","0.6358814","0.6337967","0.6283484","0.6274967","0.6253658","0.6246294","0.6235122","0.6233911","0.6218494","0.6216373","0.6216049","0.62082165","0.61859655","0.61778104","0.61764294","0.6170873","0.6138146","0.61356354","0.61112165","0.60515225","0.60487723","0.6042948","0.6040732","0.601688","0.60121644","0.5994272","0.5977052","0.596538","0.595869","0.59463215","0.59162253","0.59120154","0.5904226","0.59009075","0.58966","0.5888076","0.58596015","0.58467793","0.58449423","0.58367765","0.582257","0.58180463","0.58039","0.5798997","0.5797388","0.5795592","0.5786422","0.57825387","0.57570297","0.5745922","0.5738665","0.5733385","0.57304966","0.5729876","0.5729418","0.5718782","0.5714418","0.5708834","0.57073003","0.56977654","0.5675418","0.56678396","0.5641581","0.5634368","0.5625828","0.5622218"],"string":"[\n \"0.82485414\",\n \"0.76264787\",\n \"0.73532337\",\n \"0.73268604\",\n \"0.71129584\",\n \"0.7092459\",\n \"0.70224917\",\n \"0.6941578\",\n \"0.6845443\",\n \"0.67267495\",\n \"0.6712389\",\n \"0.6680387\",\n \"0.66529167\",\n \"0.6583822\",\n \"0.6576275\",\n \"0.65749717\",\n \"0.65712875\",\n \"0.6563945\",\n \"0.6559195\",\n \"0.6554432\",\n \"0.6537288\",\n \"0.65310955\",\n \"0.6525532\",\n \"0.6523345\",\n \"0.649932\",\n \"0.6475966\",\n \"0.64716464\",\n \"0.64691967\",\n \"0.6463616\",\n \"0.64389265\",\n \"0.6405815\",\n \"0.6381632\",\n \"0.63645977\",\n \"0.6358814\",\n \"0.6337967\",\n \"0.6283484\",\n \"0.6274967\",\n \"0.6253658\",\n \"0.6246294\",\n \"0.6235122\",\n \"0.6233911\",\n \"0.6218494\",\n \"0.6216373\",\n \"0.6216049\",\n \"0.62082165\",\n \"0.61859655\",\n \"0.61778104\",\n \"0.61764294\",\n \"0.6170873\",\n \"0.6138146\",\n \"0.61356354\",\n \"0.61112165\",\n \"0.60515225\",\n \"0.60487723\",\n \"0.6042948\",\n \"0.6040732\",\n \"0.601688\",\n \"0.60121644\",\n \"0.5994272\",\n \"0.5977052\",\n \"0.596538\",\n \"0.595869\",\n \"0.59463215\",\n \"0.59162253\",\n \"0.59120154\",\n \"0.5904226\",\n \"0.59009075\",\n \"0.58966\",\n \"0.5888076\",\n \"0.58596015\",\n \"0.58467793\",\n \"0.58449423\",\n \"0.58367765\",\n \"0.582257\",\n \"0.58180463\",\n \"0.58039\",\n \"0.5798997\",\n \"0.5797388\",\n \"0.5795592\",\n \"0.5786422\",\n \"0.57825387\",\n \"0.57570297\",\n \"0.5745922\",\n \"0.5738665\",\n \"0.5733385\",\n \"0.57304966\",\n \"0.5729876\",\n \"0.5729418\",\n \"0.5718782\",\n \"0.5714418\",\n \"0.5708834\",\n \"0.57073003\",\n \"0.56977654\",\n \"0.5675418\",\n \"0.56678396\",\n \"0.5641581\",\n \"0.5634368\",\n \"0.5625828\",\n \"0.5622218\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8287722"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":22888,"cells":{"query":{"kind":"string","value":"Computes ChrF on a single sentence pair."},"document":{"kind":"string","value":"def sentence_score(self, hypothesis: str, references: List[str]) -> CHRFScore:\n hypothesis, references = references[0], [hypothesis]\n\n assert not isinstance(references, str), \\\n \"sentence_score needs a list of references, not a single string\"\n stats = self.get_sentence_statistics(hypothesis, references)\n return self.compute_chrf(stats, self.order, self.beta)"},"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 chrf(hypotheses, references):\n return sacrebleu.corpus_chrf(hypotheses=hypotheses, references=references)","def _chrf_score_compute(total_preds_char_n_grams: Dict[int, Tensor], total_preds_word_n_grams: Dict[int, Tensor], total_target_char_n_grams: Dict[int, Tensor], total_target_word_n_grams: Dict[int, Tensor], total_matching_char_n_grams: Dict[int, Tensor], total_matching_word_n_grams: Dict[int, Tensor], n_order: float, beta: float) ->Tensor:\n chrf_f_score = _calculate_fscore(total_matching_char_n_grams, total_matching_word_n_grams, total_preds_char_n_grams, total_preds_word_n_grams, total_target_char_n_grams, total_target_word_n_grams, n_order, beta)\n return chrf_f_score","def sentence_chrf(hypothesis: str,\n reference: str,\n order: int = CHRF_ORDER,\n beta: float = CHRF_BETA,\n remove_whitespace: bool = True) -> CHRF:\n statistics = get_sentence_statistics(hypothesis, reference, order=order, remove_whitespace=remove_whitespace)\n avg_precision, avg_recall = _avg_precision_and_recall(statistics, order)\n return CHRF(_chrf(avg_precision, avg_recall, beta=beta))","def calculate_flesch_score(text):\n\n # Use the given formula and call other functions to get the values\n score = 206.835 - 1.015 * count_words(text) / count_sentences(text) - 84.6 * count_syllables(text) / count_words(\n text)\n\n return score","def _calculate_sentence_level_chrf_score(targets: List[str], pred_char_n_grams_counts: Dict[int, Dict[Tuple[str, ...], Tensor]], pred_word_n_grams_counts: Dict[int, Dict[Tuple[str, ...], Tensor]], preds_char_n_grams: Dict[int, Tensor], preds_word_n_grams: Dict[int, Tensor], n_char_order: int, n_word_order: int, n_order: float, beta: float, lowercase: bool, whitespace: bool) ->Tuple[Tensor, Dict[int, Tensor], Dict[int, Tensor], Dict[int, Tensor], Dict[int, Tensor]]:\n best_f_score = tensor(0.0)\n best_matching_char_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\n best_matching_word_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\n best_target_char_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\n best_target_word_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\n for target in targets:\n target_char_n_grams_counts, target_word_n_grams_counts, target_char_n_grams, target_word_n_grams = _get_n_grams_counts_and_total_ngrams(target, n_char_order, n_word_order, lowercase, whitespace)\n matching_char_n_grams = _get_ngram_matches(target_char_n_grams_counts, pred_char_n_grams_counts)\n matching_word_n_grams = _get_ngram_matches(target_word_n_grams_counts, pred_word_n_grams_counts)\n f_score = _calculate_fscore(matching_char_n_grams, matching_word_n_grams, preds_char_n_grams, preds_word_n_grams, target_char_n_grams, target_word_n_grams, n_order, beta)\n if f_score > best_f_score:\n best_f_score = f_score\n best_matching_char_n_grams = matching_char_n_grams\n best_matching_word_n_grams = matching_word_n_grams\n best_target_char_n_grams = target_char_n_grams\n best_target_word_n_grams = target_word_n_grams\n return best_f_score, best_matching_char_n_grams, best_matching_word_n_grams, best_target_char_n_grams, best_target_word_n_grams","def _transcode_crf(binary: Path, params: str, crf: float) -> Dict[str, float]:\n with tqdm(FILES, leave=False, desc=f'Try CRF={crf}') as paths:\n scores = [_transcode_crf_one(binary, params, crf, p) for p in paths]\n return {k: hmean([score[k] for score in scores]) for k in COLUMNS}","def dcsrbf(r):\n return 3*(num.power(num.maximum(0, 1-r), 3) - num.power(num.maximum(0, 1-r),2)*(3*r+1))","def FtoC(F):\n c = ((F-32)/9.)*5\n return c","def qed_furry_cc( s, m, r):\n \n S1 = [ binomial( r + n - 1, n ) for n in range(s+1) ]\n S2 = [ Fraction(binomial(2*n,n), 4**n) for n in range(s+1) ]\n S3 = [ (-1)**n * Fraction(binomial(2*n,n), 4**n) for n in range(s+1) ]\n\n C = lConvolute(lConvolute( S1, S2 ), S3)\n\n l1_t2 = s + m\n l2 = r + s\n\n if l1_t2 % 2 != 0:\n return 0\n\n denom = factorial(m) * factorial(r)\n nom = double_factorial( l1_t2 - 1 )\n\n return Fraction( nom * C[s], denom )","def compute_cramer(contingency_tb, expected_tb):\n keys_A = contingency_tb.columns[:-1].tolist()\n keys_B = contingency_tb.index[:-1].tolist()\n cont_tb = contingency_tb.drop('total',axis=1)\n cont_tb = cont_tb.drop('total',axis=0)\n cont_tb[cont_tb.isnull()] = 0\n chi_2 = sum(((cont_tb - expected_tb) * (cont_tb - expected_tb) / expected_tb).sum(axis=1))\n \n l = len(keys_A)\n c = len(keys_B)\n n = contingency_tb.ix[len(keys_B),len(keys_A)]\n chi_2_max = n*(min(l,c)-1)\n \n cramer = math.sqrt(float(chi_2)/float(chi_2_max))\n return cramer","def conToCelc(faren):\n return (faren - 32)*(5/9)","def f2chi(f, kptsdf, c, arbfield=1.0):\n # Since the solution we obtain from cg and from iterative scheme is F_k where chi_k = eE/kT * f0(1-f0) * F_k\n # then we need to bring these factors back in to get the right units\n f0 = np.squeeze(kptsdf['k_FD'].values)\n prefactor = arbfield * c.e / c.kb_joule / c.T * f0 * (1 - f0)\n chi = np.squeeze(f) * np.squeeze(prefactor)\n return chi","def cry_f(s : str) -> CryptolTerm:\n return CryptolTerm(to_cryptol_str_customf(s, frames=1))","def cramers_v1(confusion_matrix):\n chi2 = ss.chi2_contingency(confusion_matrix)[0]\n n = confusion_matrix.sum()\n phi2 = chi2 / n\n r, k = confusion_matrix.shape\n phi2corr = max(0, phi2 - ((k-1)*(r-1))/(n-1))\n rcorr = r - ((r-1)**2)/(n-1)\n kcorr = k - ((k-1)**2)/(n-1)\n return np.sqrt(phi2corr / min((kcorr-1), (rcorr-1)))","def corpus_chrf(hypotheses: Iterable[str],\n references: Iterable[str],\n order: int = CHRF_ORDER,\n beta: float = CHRF_BETA,\n remove_whitespace: bool = True) -> CHRF:\n corpus_statistics = get_corpus_statistics(hypotheses, references, order=order, remove_whitespace=remove_whitespace)\n avg_precision, avg_recall = _avg_precision_and_recall(corpus_statistics, order)\n return CHRF(_chrf(avg_precision, avg_recall, beta=beta))","def cramer(colA,colB):\n contingency_tb = contingency_table(colA,colB)\n expected_tb = expected_table(contingency_tb)\n return compute_cramer(contingency_tb, expected_tb)","def _calculate_fscore(matching_char_n_grams: Dict[int, Tensor], matching_word_n_grams: Dict[int, Tensor], hyp_char_n_grams: Dict[int, Tensor], hyp_word_n_grams: Dict[int, Tensor], ref_char_n_grams: Dict[int, Tensor], ref_word_n_grams: Dict[int, Tensor], n_order: float, beta: float) ->Tensor:\n\n def _get_n_gram_fscore(matching_n_grams: Dict[int, Tensor], ref_n_grams: Dict[int, Tensor], hyp_n_grams: Dict[int, Tensor], beta: float) ->Dict[int, Tensor]:\n \"\"\"Get n-gram level f-score.\"\"\"\n precision: Dict[int, Tensor] = {n: (matching_n_grams[n] / hyp_n_grams[n] if hyp_n_grams[n] > 0 else tensor(0.0)) for n in matching_n_grams}\n recall: Dict[int, Tensor] = {n: (matching_n_grams[n] / ref_n_grams[n] if ref_n_grams[n] > 0 else tensor(0.0)) for n in matching_n_grams}\n denominator: Dict[int, Tensor] = {n: torch.max(beta ** 2 * precision[n] + recall[n], _EPS_SMOOTHING) for n in matching_n_grams}\n f_score: Dict[int, Tensor] = {n: ((1 + beta ** 2) * precision[n] * recall[n] / denominator[n]) for n in matching_n_grams}\n return f_score\n char_n_gram_f_score = _get_n_gram_fscore(matching_char_n_grams, ref_char_n_grams, hyp_char_n_grams, beta)\n word_n_gram_f_score = _get_n_gram_fscore(matching_word_n_grams, ref_word_n_grams, hyp_word_n_grams, beta)\n f_score = (sum(char_n_gram_f_score.values()) + sum(word_n_gram_f_score.values())) / tensor(n_order)\n return f_score","def chi2sf(x, k):","def correlation(func, len_Init_val, keystream):\r\n val = '1'\r\n final_value = '0'\r\n while len(val) < len_Init_val:\r\n val = '0' + val\r\n final_value += '0'\r\n\r\n while val != final_value:\r\n stream = func(val, len(keystream))\r\n freq = 0.\r\n for i in range(len(keystream)):\r\n if stream[i] == keystream[i]:\r\n freq += 1\r\n freq = freq/len(keystream)\r\n print(val + ' : ' + str(freq))\r\n val = incr(val)\r\n print('')","def fkg(word, sent, syll):\n flesch_kincaid_grade = (0.39* (word / sent)) + (11.8 * (syll / word)) - 15.59\n return flesch_kincaid_grade","def _erfcc(x):\n z = abs(x)\n t = 1. / (1. + 0.5 * z)\n r = t * math.exp(-z * z - 1.26551223 + t * (1.00002368 + t * (.37409196 +\n t * (.09678418 + t * (-.18628806 + t * (.27886807 +\n t * (-1.13520398 + t * (1.48851587 + t * (-.82215223 +\n t * .17087277)))))))))\n if (x >= 0.):\n return r\n else:\n return 2. - r","def fahren_conv(self, c):\n if c == 0:\n return 32\n else:\n return c * (9.0 / 5.0) + 32","def calculate_ac(str1, str2):\n\n total_letters = len(str1)\n ocr_letters = len(str2)\n if total_letters == 0 and ocr_letters == 0:\n acc_by_char = 1.0\n return acc_by_char\n diff = difflib.SequenceMatcher(None, str1, str2)\n correct_letters = 0\n for block in diff.get_matching_blocks():\n correct_letters = correct_letters + block[2]\n if ocr_letters == 0:\n acc_by_char = 0\n elif correct_letters == 0:\n acc_by_char = 0\n else:\n acc_1 = correct_letters / total_letters\n acc_2 = correct_letters / ocr_letters\n acc_by_char = 2 * (acc_1 * acc_2) / (acc_1 + acc_2)\n\n return float(acc_by_char)","def cofactors(f, g):\n lev, dom, per, F, G = f.unify(g)\n h, cff, cfg = dmp_cofactors(F, G, lev, dom)\n return per(h), per(cff), per(cfg)","async def f(self, c : float):\n f = c * 9/5 + 32\n await self.bot.say(\"{0} Fahrenheit\".format(f))","def coherence_partial_spec(fxy, fxx, fyy, fxr, fry, frr):\r\n coh = coherency_spec\r\n Rxr = coh(fxr, fxx, frr)\r\n Rry = coh(fry, fyy, frr)\r\n Rxy = coh(fxy, fxx, fyy)\r\n\r\n return (((np.abs(Rxy - Rxr * Rry)) ** 2) /\r\n ((1 - ((np.abs(Rxr)) ** 2)) * (1 - ((np.abs(Rry)) ** 2))))","def ctof(temp):\n return temp * 9/5 + 32 # functions should be surrounded by 2 blank lines","def cramers_corrected_stat(confusion_matrix):\n chi2 = ss.chi2_contingency(confusion_matrix)[0]\n n = confusion_matrix.sum().sum()\n phi2 = chi2/n\n r,k = confusion_matrix.shape\n phi2corr = max(0, phi2 - ((k-1)*(r-1))/(n-1)) \n rcorr = r - ((r-1)**2)/(n-1)\n kcorr = k - ((k-1)**2)/(n-1)\n return np.sqrt(phi2corr / min( (kcorr-1), (rcorr-1)))","def chromagram(signal,fs,n_fft=4096, hop_len=64, **kwargs):\n y_harmonic, y_percussive = librosa.effects.hpss(signal)\n C = librosa.feature.chromagram(y=y_harmonic, sr=fs, n_fft=n_fft, hop_length=hop_len)\n return C","def ChordMethod(f, a=0.0, b=1.0, x=0.75, tol=1e-10):\n\tstart = time()\n\n\t# Initialization of function values and error \n\tf_a = f(a)\n\tf_b = f(b)\n\tf_x = f(x)\n\terror = np.abs(f_x)\n\n\t# Initialization of iter number and array of error values\n\ti = 0\n\terrs = []\n\n\tif f_a*f_b<0:\n\t\twhile error > tol:\n\t\t\terrs.append(error)\n\n\t\t\tif f_a*f_x < 0:\n\t\t\t\tx = (x*f_a - a*f_x) / (f_a - f_x)\n\t\t\telse:\n\t\t\t\tx = (x*f_b - b*f_x) / (f_b - f_x)\n\n\t\t\tf_x = f(x)\n\t\t\terror = np.abs(f_x)\n\t\t\ti = i+1\n\telse:\n\t\tprint(\"Function values are of the same sign!\")\n\tend = time()\n\treturn x, (end-start), i","def compute_ctf(freqs,rots,akv,cs,wgh,dfmid1f,dfmid2f,angastf,dscale,bfactor=None): \n av = akv * 1e3 # Convert kilovots to volts\n cs = cs * 1e7 # Convert spherical aberation from mm to A\n \n # wavelength of electrons\n elambda = 12.2643247 / n.sqrt(av + av**2 * 0.978466e-6)\n \n wgh1 = dscale*n.sqrt(1.0 - wgh**2)\n wgh2 = dscale*wgh\n\n ix = freqs[:,0]\n iy = freqs[:,1]\n freq_radius = n.sqrt(ix**2 + iy**2)\n\n angle = elambda*freq_radius\n angspt = n.arctan2(iy,ix)\n if rots is not None:\n angspt = n.mod(angspt.reshape((-1,1)) + rots.reshape((1,-1)),2.0*n.pi)\n angle = angle.reshape((-1,1)) \n c1 = 2.0*n.pi*angle**2/(2.0*elambda)\n c2 = -c1*cs*angle**2/2.0\n angdif = angspt - angastf\n ccos = n.cos(2.0*angdif)\n df = 0.5*(dfmid1f + dfmid2f + ccos*(dfmid1f-dfmid2f))\n chi = c1*df + c2\n\n ctf = -wgh1*n.sin(chi) - wgh2*n.cos(chi)\n \n if bfactor is not None:\n ctf *= envelope_function(freq_radius, bfactor)\n\n return n.require(ctf,dtype = freqs.dtype)","def cdq2(f, x, h=1e-5):\n return (f(x+h)-f(x-h))/(2*h)\n raise NotImplementedError(\"Problem 2 Incomplete\")","def f1_score(confusion):\n sens = sensitivity(confusion)\n prec = precision(confusion)\n return 2 * sens * prec / (sens + prec)","def qed_furry_class_coeff( L, rt2, m ):\n\n if rt2 % 2 != 0:\n return 0\n \n r = rt2/2\n s = m + 2*r + 2*(L - 1)\n \n if s<0:\n return 0\n\n return qed_furry_cc(s,m,r)","def f1_score(confusion):\n p = precision(confusion)\n r = sensitivity(confusion)\n F1 = (2 * p * r) / (p + r)\n return F1","def gen_challange(sk, fid):\n Lf = poly(sk, fid)\n r = G.random()\n xc = G.random() # CAUTION: xc != mi\n\n Kf = g ** (r * Lf(xc))\n H = (g ** r, xc, g ** (r * Lf[0]))\n return (Kf, H)","def f2c(t):\r\n return round(5/9 * (t-32))","def cntd_qed_furry_class_coeff( L, rt2, m):\n\n if rt2 % 2 != 0:\n return 0\n \n r = rt2/2\n s = m + 2*r + 2*(L - 1)\n\n if s<0:\n return 0\n\n A = [ [ [ qed_furry_cc(sp, mp, rp) for mp in range(m+1) ] for rp in range(r+1) ] for sp in range(s+1) ]\n Alog = lLog( A )\n \n return Alog[s][r][m]","def convertC(TF):\r\n TC = 5.0/9.0*(TF - 32.0)\r\n return TC","def CesarChiff(message_a_chiff:str, decal:int)->str:\r\n mot_crypte = \"\"\r\n for lettre in message_a_chiff:\r\n mot_crypte += cryptage(decal, lettre)\r\n\r\n return mot_crypte","def fcp(self, var='x'):\n return self.charpoly(var).factor()","def ForsterCoupling(d1, d2, r):\n normr = norm(r)\n rn = r / normr ##Normalized distance vector\n Coupling = (3 * dot(d1, rn) * dot(d2, rn) - dot(d1, d2)) / normr**3\n return Coupling","def _calc_chromatic_term(self):\n LOG.debug(\"Calculating Chromatic Term.\")\n self._check_k_columns([\"K1L\", \"K2L\", \"K2SL\"])\n res = self._results_df\n tw = self.twiss_df\n\n with timeit(lambda t: LOG.debug(\" Time needed: {:f}\".format(t))):\n mask = (tw['K1L'] != 0) | (tw['K2L'] != 0) | (tw['K2SL'] != 0)\n if \"DX\" in tw and \"DY\" in tw:\n LOG.debug(\"Dispersion values found in model. Used for chromatic calculations\")\n sum_term = tw.loc[mask, 'K1L'] - \\\n (tw.loc[mask, 'K2L'] * tw.loc[mask, 'DX']) + \\\n (tw.loc[mask, 'K2SL'] * tw.loc[mask, 'DY'])\n else:\n LOG.info(\"Dispersion values NOT found in model. Using analytic values.\")\n if \"DX\" not in res or \"DY\" not in res:\n self.calc_linear_dispersion()\n sum_term = tw.loc[mask, 'K1L'] - \\\n (tw.loc[mask, 'K2L'] * res.loc[mask, 'DX']) + \\\n (tw.loc[mask, 'K2SL'] * res.loc[mask, 'DY'])\n\n res['CHROMX'] = sum_term * tw.loc[mask, 'BETX']\n res['CHROMY'] = sum_term * tw.loc[mask, 'BETY']\n\n LOG.debug(\"Chromatic Term Calculated.\")","def cpred(self, z0, z1, f0, f1):\n e0 = self.embed(z0)\n e1 = self.embed(z1)\n \n assert f0.shape[1] == z0.shape[1] and f1.shape[1] == z1.shape[1]\n \n f0 = self.fseek_emb(f0)\n f1 = self.fseek_emb(f1)\n \n e0 = torch.concat([e0, f0], dim = 2)\n e1 = torch.concat([e1, f1], dim = 2)\n \n B = self.contact.cmap(e0, e1)\n C = self.contact.predict(B)\n return C","def reactance_to_component(reactance, freq):\n logger.debug(\"reactance_to_component: reactance= %8.3f\", reactance)\n factor = 2*pi*freq\n if reactance < 0:\n # compute capacitance\n return -1/(factor*reactance), \"F\"\n else:\n # compute inductance\n return reactance/factor, \"H\"","def cmmdc(e, f):\n if f == 0:\n if e == 0:\n return 0\n else:\n return e\n else:\n r = e % f\n while r > 0:\n e = f\n f = r\n r = e % f\n return f","def terms_gcd(f):\n J, F = dmp_terms_gcd(f.rep, f.lev, f.dom)\n return J, f.per(F)","def cross_correlate(rmsynth_pixel, rmsf):\n return np.fft.ifft(np.fft.fft(rmsynth_pixel)*np.fft.fft(rmsf[::-1]))","def compute_prf_on_selection(arts, forms_set):\n tp=0\n fn=0\n fp=0\n for article in arts:\n for entity in article.entity_mentions:\n if entity.mention in forms_set:\n if entity.gold_link==entity.sys_link:\n tp+=1\n else:\n if entity.sys_link!='--NME--':\n fp+=1\n if entity.gold_link!='--NME--':\n fn+=1\n print(tp, fp, fn)\n p=tp/(tp+fp)\n r=tp/(tp+fn)\n f1=2*p*r/(p+r)\n print(p,r,f1)\n return f1","def _get_n_gram_fscore(matching_n_grams: Dict[int, Tensor], ref_n_grams: Dict[int, Tensor], hyp_n_grams: Dict[int, Tensor], beta: float) ->Dict[int, Tensor]:\n precision: Dict[int, Tensor] = {n: (matching_n_grams[n] / hyp_n_grams[n] if hyp_n_grams[n] > 0 else tensor(0.0)) for n in matching_n_grams}\n recall: Dict[int, Tensor] = {n: (matching_n_grams[n] / ref_n_grams[n] if ref_n_grams[n] > 0 else tensor(0.0)) for n in matching_n_grams}\n denominator: Dict[int, Tensor] = {n: torch.max(beta ** 2 * precision[n] + recall[n], _EPS_SMOOTHING) for n in matching_n_grams}\n f_score: Dict[int, Tensor] = {n: ((1 + beta ** 2) * precision[n] * recall[n] / denominator[n]) for n in matching_n_grams}\n return f_score","def chromnorm(F, P=2.):\r\n nchr, nbts = F.shape\r\n if not np.isinf(P):\r\n S = np.power(np.sum(np.power(F,P), axis=0),(1./P));\r\n else:\r\n S = F.max()\r\n S = S if S > 0 else 1\r\n # try:\r\n # d = F/S\r\n # except:\r\n # print F, S\r\n return F / S","def fce(B):\n return wce(B)/(2.*np.pi)","def hic_chipseq_r2 (hic, chipseq) :\n hic_rowsum = np.sum(hic,axis=1)/float(np.sum(hic))\n return np.corrcoef(hic_rowsum,chipseq)[0,1]**2","def f_test(chi1,df1,chi2,df2,red_chi = True):\n\n# if chi1/df1 > chi2/df2:\n#\tprob = 2. * f.cdf(chi1/df1, chi2/df2, df1, df2)\n# else:\n#\tprob = 2. * f.cdf(chi2/df2, chi1/df1, df2, df1)\n if red_chi:\n\tfval = (chi1/df1) / (chi2/df2)\n else:\n\tfval = chi1 / chi2\n prob = 2. * f.cdf((chi1/df1) / (chi2/df2), df1, df2)\n if prob > 1.: \n\treturn 2. - prob\n else:\n\treturn prob","def corrigir_doc(frase):\r\n\r\n if not frase or not (isinstance(frase, str) and all(x.isalpha() for x in frase.split())) or ' ' in frase:\r\n raise ValueError('corrigir_doc: argumento invalido')\r\n\r\n palavras, doc_corrigido = frase.split(' '), ''\r\n palavras = list(map(corrigir_palavra, palavras))\r\n\r\n while palavras:\r\n anagrama_teste = palavras.pop(0)\r\n if palavras:\r\n for word in palavras:\r\n if eh_anagrama(anagrama_teste, word) and anagrama_teste.lower() != word.lower():\r\n del palavras[palavras.index(word)]\r\n doc_corrigido += ' ' + anagrama_teste\r\n\r\n return doc_corrigido[1:]","def c2f(t):\r\n return round(9*t/5 + 32)","def qed_cc( s, m, r):\n\n l1_t2 = s + m\n l2 = r + s\n\n if l1_t2 % 2 != 0:\n return 0\n\n denom = factorial(s) * factorial(m) * factorial(r)**2\n nom = double_factorial( l1_t2 - 1 ) * factorial( l2 )\n\n return Fraction( nom, denom )","def phosfracs(h,ks):\n k1p,k2p,k3p = ks\n h3po4 = h*h*h\n h2po4 = k1p*h*h\n hpo4 = k1p*k2p*h\n po4 = k1p*k2p*k3p\n denom = h3po4 + h2po4 + hpo4 + po4\n h3po4 /= denom\n h2po4 /= denom\n hpo4 /= denom\n po4 /= denom\n return h3po4,h2po4,hpo4,po4","def f1_score(confusion):\n s = np.power(sensitivity(confusion), -1)\n p = np.power(precision(confusion), -1)\n return 2 / (s + p)","def _transcode_crf_one(binary: Path, params: str, crf: float, path: Path\n ) -> Dict[str, float]:\n root = Path(f'{path}.temp')\n if root.exists():\n shutil.rmtree(root)\n\n root.mkdir(parents=True)\n out = root / 'out.265'\n csv_log = root / 'log.csv'\n\n # ? Maybe use '--bitrate {bitrate} --pass {i}' with 'pass' in (1, 2)\n cmd = (\n f'{binary} --input {path} --fps 24000/1001'\n f' --crf {crf}'\n f' --profile main10 {params} --ssim-rd --ssim'\n f' --output {out} --csv {csv_log}'\n )\n res = subprocess.run(\n cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,\n shell=True, text=True)\n if res.returncode:\n for f in (res.stdout, res.stderr):\n if f:\n print(f)\n raise RuntimeError(res.args)\n\n with csv_log.open() as fp:\n *_, stats = csv.DictReader(fp, skipinitialspace=True)\n\n return {k: float(stats[k_raw]) for k, k_raw in COLUMNS.items()}","def score(word, f):\n \n #dictionary mapping a to 1, b to 2, c to 3 etc etc\n alphaDict = {'a' : 1, 'b' : 2, 'c' : 3, 'd' : 4, 'e' : 5, 'f' : 6, 'g' : 7, 'h' : 8, 'i' : 9, 'j' : 10, 'k' : 11, 'l' : 12, 'm' : 13,\n 'n' : 14, 'o' : 15, 'p': 16, 'q' : 17, 'r': 18, 's' : 19, 't': 20, 'u' : 21, 'v' : 22, 'w' : 23, 'x': 24, 'y' : 25, 'z' : 26 }\n \n #make the word all lower case\n word = word.lower()\n \n #then get a list of all the letters in word\n letters = []\n for s in word:\n letters.append(s)\n \n #then score based on the position of the letter and what the letter is. store the individual score in a list\n letterScore = []\n \n for i in range(len(letters)):\n letterScore.append(i*alphaDict[letters[i]])\n \n #then sort the list. This will be in descending order so reverse it to find the two highest scores\n letterScore.sort()\n letterScore.reverse()\n \n #return f applied to the two highest score\n return f(letterScore[0], letterScore[1])","def get_f_score(self):\n return self.get_g_score() + self.get_h_score()","def converge_scf(self):\n # run a convergence worklfow\n # Comment: Here we wait, because of run,\n # maybe using a future and submit instead might be better\n #print 'ctx, before scf {} {}'.format(ctx, [a for a in self.ctx])\n inputs = self.get_inputs_scf(self.ctx)\n\n if self.ctx.last_calc2:\n #print 'inputs for convergnce2: {}'.format(inputs)\n res = run(fleur_scf_wc,\n wf_parameters=inputs['wf_parameters'],\n fleurinp=inputs['fleurinp'],\n fleur=inputs['fleur'])\n #inputs)#\n #wf_parameters=wf_para,\n #structure=s,\n #calc_parameters=parameters,\n #inpgen = code,\n #fleur=code2)#, computer=computer)\n else:\n res = run(fleur_scf_wc, wf_parameters=inputs['wf_parameters'],\n structure=inputs['structure'], calc_parameters=inputs['calc_parameters'], inpgen = inputs['inpgen'], fleur=inputs['fleur'] )#inputs)#\n #print 'ctx, after scf {} {}'.format(ctx, [a for a in self.ctx])\n\n #print 'output of convergence: {}'.format(res)\n self.ctx.last_calc2 = res#.get('remote_folder', None)\n #print res\n #return ResultToContext(last_calc2=res)","def calc_chromatic_coupling(self):\n raise NotImplementedError('Chromatic Coupling is not Implemented yet.')","def factor(self):\r\n\t\t\r\n\t\t# get gcf\r\n\t\tg = self.extract()\r\n\t\t\r\n\t\t# invert and multiply\r\n\t\tv = g.invert()\r\n\t\tf = self.multiply(v)\r\n\t\t\r\n\t\treturn f,g","def lerfcc(x):\r\n z = abs(x)\r\n t = 1.0 / (1.0+0.5*z)\r\n ans = t * math.exp(-z*z-1.26551223 + t*(1.00002368+t*(0.37409196+t*(0.09678418+t*(-0.18628806+t*(0.27886807+t*(-1.13520398+t*(1.48851587+t*(-0.82215223+t*0.17087277)))))))))\r\n if x >= 0:\r\n return ans\r\n else:\r\n return 2.0 - ans","def rangerate_from_freq(freq,Fc):\n # print(f'freq {freq} Fc {Fc}')\n dopp_at_IF = freq - Fc\n return dopp_at_IF*scipy.constants.speed_of_light/Fc","def coi(self, s):\n return 2 ** 0.5 * s","def string_f1_score(prediction, ground_truth):\n prediction_tokens = normalize_answer(prediction).split()\n ground_truth_tokens = normalize_answer(ground_truth).split()\n common = collections.Counter(prediction_tokens) & collections.Counter(ground_truth_tokens)\n num_same = sum(common.values())\n if num_same == 0:\n return 0\n precision = 1.0 * num_same / len(prediction_tokens)\n recall = 1.0 * num_same / len(ground_truth_tokens)\n f1 = (2 * precision * recall) / (precision + recall)\n return f1","def calculate(self):\n\n tp = self.confusion_matrix.tp\n tn = self.confusion_matrix.tn\n fp = self.confusion_matrix.fp\n fn = self.confusion_matrix.fn\n\n agreement = tp + tn\n chance0 = (tn + fn) * (tn + fp)\n chance1 = (fp + tp) * (fn + tp)\n sum_ = tn + fn + fp + tp\n chance = (chance0 + chance1) / sum_\n\n return (agreement - chance) / (sum_ - chance)","def compute_f_ColeBrook(self, R, e, D):\n # assume a starting correct value for the \"f\" on the right hand side (RHS)\n # uses friction factor from Barr's equation as the starting value.\n f_initial = self.compute_f_BARR(R, self.e, self.D)\n\n relative_roughness = e / D\n a = relative_roughness / 3.71\n b = 2.51 / (R * sqrt(f_initial))\n\n # Compute the f on the LHS ------ (1) \n f_final = 1 / (-2 * log((a + b), 10))**2\n \n # Make sure friction factor is correct to at least 6 decimal place.\n tolerance = 0.0000001\n \n # if the f on the LHS is not within tolerance limit,\n # replace it on the RHS and recompute the f on the LHS till it's within\n # tolerance limit.\n while abs(f_final - f_initial) >= tolerance:\n f_initial = f_final\n b = 2.51 / (R * sqrt(f_initial))\n f_final = 1 / (-2 * log((a + b), 10))**2\n return f_final","def generate_ctf(p):\n\tfrom EMAN2 import EMAN2Ctf\n\n\tdefocus = p[0]\n\tcs = p[1]\n\tvoltage = p[2]\n\tpixel_size = p[3]\n\tbfactor = p[4]\n\tamp_contrast = p[5]\n\t\n\tif defocus > 100: # which means it is very likely in Angstrom, therefore we are using the old convention\n\t\tdefocus *= 1e-4\n\t\n\tif amp_contrast < 1.0:\n\t\tfrom math import sqrt\n\t\tamp_contrast = amp_contrast*100/sqrt(2*amp_contrast**2-2*amp_contrast+1)\n\n\tctf = EMAN2Ctf()\n\tif(len(p) == 6):\n\t\tctf.from_dict({\"defocus\":defocus, \"cs\":cs, \"voltage\":voltage, \"apix\":pixel_size, \"bfactor\":bfactor, \"ampcont\":amp_contrast})\n\telse:\n\t\tctf.from_dict({\"defocus\":defocus, \"cs\":cs, \"voltage\":voltage, \"apix\":pixel_size, \"bfactor\":bfactor, \"ampcont\":amp_contrast,'dfdiff':p[6],'dfang':p[7]})\n\t\t\n\treturn ctf","def chi2(data, fdata, err):\n return sum(((data-fdata)/err)**2)","def f2c_cml_function():\n import sys\n\n F = float(sys.argv[1])\n C = 5/9.0*F - 32\n print(\"The temperatire in Celcius is {:g}\".format(C))","def _wf(self, p):\n r = self.faces - p\n n = norm(r, axis=2)\n num = row_wise_dot(r[:, 0, :], np.cross(r[:, 1, :], r[:, 2, :]))\n den = n[:, 1] * n[:, 2] * n[:, 0]\n for i in range(3):\n j = (i + 1) % 3\n k = (i + 2) % 3\n den += row_wise_dot(r[:, i, :], r[:, j, :]) * n[:, k]\n return 2*np.arctan2(num, den)","def correlation_spectrum(x1, x2, Fs=2 * np.pi, norm=False):\r\n\r\n x1 = x1 - np.mean(x1)\r\n x2 = x2 - np.mean(x2)\r\n x1_f = fftpack.fft(x1)\r\n x2_f = fftpack.fft(x2)\r\n D = np.sqrt(np.sum(x1 ** 2) * np.sum(x2 ** 2))\r\n n = x1.shape[0]\r\n\r\n ccn = ((np.real(x1_f) * np.real(x2_f) +\r\n np.imag(x1_f) * np.imag(x2_f)) /\r\n (D * n))\r\n\r\n if norm:\r\n ccn = ccn / np.sum(ccn) * 2 # Only half of the sum is sent back\r\n # because of the freq domain symmetry.\r\n # XXX Does normalization make this\r\n # strictly positive?\r\n\r\n f = utils.get_freqs(Fs, n)\r\n return f, ccn[0:(n / 2 + 1)]","def f(chord):\r\n m, length, dim = chord.shape\r\n chord2 = chord.reshape([m*length, dim])\r\n weighted_chords = np.dot(chord2, chord_id2sign)\r\n return weighted_chords.reshape(m, length, 12)","def calculate_coherent_scattering_factor(element, q):\n return current_calculator.get_coherent_scattering_factor(element, q)","def f_2(c):\n Di = calc_R(*c)\n return Di","def lfriedmanchisquare(*args):\r\n k = len(args)\r\n if k < 3:\r\n raise ValueError, 'Less than 3 levels. Friedman test not appropriate.'\r\n n = len(args[0])\r\n data = apply(pstats.abut,tuple(args))\r\n for i in range(len(data)):\r\n data[i] = rankdata(data[i])\r\n ssbn = 0\r\n for i in range(k):\r\n ssbn = ssbn + sum(args[i])**2\r\n chisq = 12.0 / (k*n*(k+1)) * ssbn - 3*n*(k+1)\r\n return chisq, chisqprob(chisq,k-1)","def calc_ent_f1_and_ent_mcc(hyps: List[str], refs: List[str], vocab, c_fun, report_on_canonicals: bool = False, tok_fun=pkt_tokenize):\n\n # requires internal knowledge of the entire universe\n # specifically of names of kb_fields, kbtrv_fields\n\n # FIXME create_KB_on_the_fly and pkt_tokenize \n # are referred to separately in \n # * helpers.py\n # * metrics.py\n # fix this by \n # adding them to cfg\n # or \n # giving it as attribute to the model \n\n\n # define helper functions\n ## eval metrics\n def precision(predictions: List[int], gold_labels: List[int]):\n # TP/(TP+FP) => iterate over positives (predicted)\n positives = len(predictions)\n if positives:\n tp, fp = zip(*[(1,0) if pred in gold_labels else (0,1) for pred in predictions])\n return sum(tp)/positives\n else:\n return 1.\n\n def recall(predictions: List[int], gold_labels: List[int]):\n # TP/(TP+FN) => iterate over ground truths (gold labels)\n truths = len(gold_labels)\n if truths:\n tp, fn = zip(*[(1,0) if gold in predictions else (0,1) for gold in gold_labels])\n return sum(tp)/truths\n else:\n return 1.\n\n f1_ = lambda p, r: 2 * (p*r)/(p+r) if p+r != 0. else 0.\n mcc_ = lambda p, r: sqrt((r+(1/r)-1)*(p+(1/p)-1)) if r != 0. and p != 0. else 0.\n\n # compare ent f1 in trv => lookup vocab indices\n\n f1s = [] # accumulate scores\n mccs = [] # accumulate matthew's correlation coefficients\n num_ents = []\n for i, (hyp,ref) in enumerate(zip(hyps, refs)):\n\n hyp_ents_ref_ents = [] # will hold entity vocabulary indices in the order hyp,ref\n debug = []\n\n for seq in (hyp,ref):\n seq_tokzd = tok_fun(seq)\n canons, indices, matches = c_fun(seq_tokzd) # turn to canonical tokens and return indices that raw tokens were mapped to\n del matches # TODO use matches instead of implementation below FIXME\n\n entities = [\\\n \" \".join([raw for map_idx, raw in zip(indices,seq_tokzd) if map_idx==i])\n for i in range(len((canons)))\n ]\n\n # Filter out tokens that werent changed (noncanonical)\n try:\n canonical_entities, surface_entities = list(zip(*[(c,t) for c,t in zip(canons,entities) if c!=t]))\n except ValueError: # no entities\n canonical_entities, surface_entities = [], []\n \n if report_on_canonicals: \n entities = canonical_entities\n else:\n entities = surface_entities\n \n # record number of decisions made for this hypothesis\n num_ents += [len(entities)]\n\n # Filter out unk IDs\n entities = [tok for tok in entities if not vocab.is_unk(tok)]\n # turn to vocab indices (int)\n seq_enty_voc_indices = [vocab.stoi[entity] for entity in entities]\n\n hyp_ents_ref_ents.append(seq_enty_voc_indices)\n debug.append(entities)\n\n pred, truth = hyp_ents_ref_ents\n\n P = precision(pred,truth)\n R = recall(pred,truth)\n \n f1s.append(f1_(P,R))\n mccs.append(mcc_(P,R))\n\n print(\" ### Validation Classification Metrics Debug ###\\n\"+\\\n f\"hyp: {hyp}\\nref: {ref}\\nentities: {hyp_ents_ref_ents}\\nPrecision: {P}\\nRecall: {R}\"+\\\n \" ### Debug Metrics End ### \")\n \n assert len(hyps) == len(refs) == len(f1s) == len(mccs), (len(hyps), len(refs), len(f1s), len(mccs))\n f1_avg = sum([num_ents[i]*f1s[i] for i in range(len(f1s))]) / sum(num_ents) if len(num_ents) else 0\n mcc_avg = sum([num_ents[i]*mccs[i] for i in range(len(mccs))]) / sum(num_ents) if len(num_ents) else 0\n return f1_avg, mcc_avg","def cd(f, x, h, fl=np.complex_):\n return np.divide(np.subtract(f(np.add(x, h, dtype=fl)), f(np.subtract(x, h, dtype=fl)), dtype=fl), (2*h), dtype=fl)","def compute_prf(self, counts_dict):\n precision = counts_dict[\"correct\"] / counts_dict[\"predicted\"] if counts_dict[\"predicted\"] else 0.0\n recall = counts_dict[\"correct\"] / counts_dict[\"gold\"] if counts_dict[\"gold\"] else 0.0\n fscore = 2 * precision * recall / (precision + recall) if precision + recall else 0.0\n\n return {\"precision\": precision, \"recall\": recall, \"fscore\": fscore}","def fb(lines):\n sl = lines.split()\n nl = map(int, sl)\n i = 0\n while i < len(nl):\n loop = nl[i:i+3]\n for j in range(1,loop[2]+1):\n print (not j % loop[0])*'F' + (not j % loop[1])*'B' or j,\n i = i + 3\n print","def get_fuzz_ratio(first_word, second_word):\n return fuzz.ratio(first_word, second_word), first_word, second_word","async def c(self, f : float):\n c = (f-32) * 5/9\n await self.bot.say(\"{0} Celsius\".format(c))","def k_c(self, tl):\n\t\treturn self.KC0*exp(self.HKC/(R*self.TO)*(1. - self.TO/tl))","def wordSimilarityRatio(sent_1,sent_2):","def kA_char_func(self):\n i1 = self.inl[0].to_flow()\n i2 = self.inl[1].to_flow()\n o1 = self.outl[0].to_flow()\n o2 = self.outl[1].to_flow()\n\n i1_d = self.inl[0].to_flow_design()\n i2_d = self.inl[1].to_flow_design()\n\n T_i1 = T_mix_ph(i1, T0=self.inl[0].T.val_SI)\n T_i2 = T_mix_ph(i2, T0=self.inl[1].T.val_SI)\n T_o1 = T_mix_ph(o1, T0=self.outl[0].T.val_SI)\n T_o2 = T_mix_ph(o2, T0=self.outl[1].T.val_SI)\n\n if T_i1 <= T_o2:\n T_i1 = T_o2 + 0.01\n if T_i1 <= T_o2:\n T_o2 = T_i1 - 0.01\n if T_i1 <= T_o2:\n T_o1 = T_i2 + 0.02\n if T_o1 <= T_i2:\n T_i2 = T_o1 - 0.02\n\n fkA1 = 1\n if self.kA_char1.param == 'm':\n fkA1 = self.kA_char1.func.evaluate(i1[0] / i1_d[0])\n\n fkA2 = 1\n if self.kA_char2.param == 'm':\n fkA2 = self.kA_char2.func.evaluate(i2[0] / i2_d[0])\n\n fkA = 2 / (1 / fkA1 + 1 / fkA2)\n\n td_log = ((T_o1 - T_i2 - T_i1 + T_o2) /\n np.log((T_o1 - T_i2) / (T_i1 - T_o2)))\n return i1[0] * (o1[2] - i1[2]) + self.kA.design * fkA * td_log","def prng_feedback(self, lfsr):\n return str(int(lfsr[0],2) ^ int(lfsr[2],2) ^ int(lfsr[3],2) ^ int(lfsr[5],2))","def calc_process_cohesion(partitions, graph):\n ch = 0\n for part in partitions:\n crc = calc_community_relation_cohesion(part, graph)\n cic = calc_community_information_cohesion(part, graph)\n ch = ch + (crc * cic)\n ch = ch / len(partitions)\n return ch","def calc_pr_rc_F1(GTD, block_occ):\r\n true_pos = ((GTD + block_occ)==2).sum()\r\n false_pos = sum([1 if BI_val==1 and GTD[i]==0 else 0 for i, BI_val in enumerate(block_occ.values)])\r\n precision = float(true_pos/(true_pos+false_pos))\r\n recall = float(true_pos/(GTD.sum()))\r\n if precision == 0:\r\n F1 = 0\r\n else:\r\n F1 = float(2 * (precision * recall) / (precision + recall))\r\n \r\n return precision, recall, F1","def toff(self) -> None:\n\n size = self.circ_size\n self._get_random_input_state(self.seed)\n\n remainder = size % 3\n for layer in range(size):\n leftovers = tuple(random.sample(range(size), remainder))\n candidates = [x for x in range(size) if x not in leftovers]\n\n while candidates:\n current_toff = tuple(random.sample(candidates, 3))\n self.ccx(current_toff[0], current_toff[1], current_toff[2])\n candidates = [x for x in candidates if x not in current_toff]\n\n self.decompose().decompose()\n if self.meas: self.measure(self.qr, self.cr)","def calc(df: pd.DataFrame, step_key: str, jaccard: bool) -> dict:\n\n # Set Output Dictionary\n result_dict = dict()\n # Iterate over DataFrame two rows at a time via index\n for (indx1),(indx2) in zip(df[:-1].index,df[1:].index):\n # Select pairs (a & b)\n if df.loc[indx1].pairing_label.endswith('a') and df.loc[indx2].pairing_label.endswith('b'):\n # save the label and the fulltext depending on pairing (a or b)\n patterna = df.loc[indx1].pairing_label\n patternb = df.loc[indx2].pairing_label\n try:\n # Select preprocessed full_texts \n input_full_a = df.loc[indx1].OneString\n input_full_b = df.loc[indx2].OneString\n except:\n logging.info('For a pair in Calculation, no full_texts could be extracted. Scores will remain empty.')\n result_dict.update({patterna : ''}) \n result_dict.update({patternb : ''})\n pass\n # CALCULATOR\n cosine = formulas.distributor(step_key, input_full_a, input_full_b, jaccard)\n # update dict with cosine for each label\n result_dict.update({patterna : cosine}) \n result_dict.update({patternb : cosine})\n else:\n continue\n return result_dict","def get_coherent_scattering_factor(self, element: str, q):\n if element not in self.coherent_param.index.values:\n raise ElementNotImplementedException(element)\n fs_coh = 0\n s = q / (4 * np.pi)\n for ind in range(1, 5):\n A = self.coherent_param['A' + str(ind)][element]\n B = self.coherent_param['B' + str(ind)][element]\n fs_coh += A * np.exp(-B * s ** 2)\n\n C = self.coherent_param['C'][element]\n fs_coh += C\n return fs_coh","def secondaryLensedForegroundBias(self, fCf, fCkkf, L0):\n # Make L0 a 2d vector, along x-axis\n L0 = np.array([L0, 0.])\n\n def integrand(pars):\n lnLnorm = pars[0]\n thetaL = pars[1]\n lnlnorm = pars[2]\n thetal = pars[3]\n L = np.array([np.exp(lnLnorm) * np.cos(thetaL), np.exp(lnLnorm) * np.sin(thetaL)])\n l = np.array([np.exp(lnlnorm) * np.cos(thetal), np.exp(lnlnorm) * np.sin(thetal)])\n\n # factors in common between term 1 and term 2\n result = self.F_TT_cart(l, L0-l)\n result *= self.F_TT_cart(l-L-L0, L-l)\n result *= self.alpha_cart(L, l-L)\n\n # Term 1: L0\n term1 = self.alpha_cart(-L, l-L0)\n term1 *= self.CMB.funlensedTT(np.sqrt(np.sum((L0-l)**2)))\n term1 *= fCf(np.sqrt(np.sum((l-L)**2)))\n term1 *= fCkkf(np.sqrt(np.sum(L**2)))\n\n # Term 2: L0\n term2 = self.alpha_cart(-L, L0+L-l)\n term2 *= self.CMB.funlensedTT(np.sqrt(np.sum((l-L)**2)))\n term2 *= fCf(np.sqrt(np.sum((l-L-L0)**2)))\n term2 *= fCkkf(np.sqrt(np.sum(L**2)))\n\n # factor from symmetries\n result *= 8. * (term1 + term2)\n # factors of pi from Fourier convention\n result /= (2.*np.pi)**4\n # normalize properly for the phi quadratic estimator squared\n result *= self.fN_phi_TT(L0[0])**2\n # convert from phi squared to kappa squared\n result *= (-L0[0]**2/2.)**2\n # jacobian for polar coordinates, with log norm\n result *= np.exp(lnLnorm)**2\n result *= np.exp(lnlnorm)**2\n # compensate for halving the integration domain\n result *= 2.\n return result\n\n # if first time, initialize integrator\n if not hasattr(self.secondaryLensedForegroundBias.__func__, \"integ\"):\n print \"wah\"\n self.secondaryLensedForegroundBias.__func__.integ = vegas.Integrator([[np.log(1.), np.log(2.*self.CMB.lMaxT)], # L-l is limited: goes into QE\n [0., np.pi], # keep only half the domain (symmetry)\n [np.log(self.CMB.lMin), np.log(self.CMB.lMaxT)], # l is limited: goes into QE\n [0., 2.*np.pi]])\n\n self.secondaryLensedForegroundBias.integ(integrand, nitn=10, neval=1e6) # 7h33m run: 20, 1e5\n print \"hoohoo\"\n result = self.secondaryLensedForegroundBias.integ(integrand, nitn=30, neval=6e6) # 7h33m run: 60, 5e5\n print \"weehee\"\n\n# self.secondaryLensedForegroundBias.integ(integrand, nitn=1, neval=1e4) # 7h33m run: 20, 1e5\n# print \"hoohoo\"\n# result = self.secondaryLensedForegroundBias.integ(integrand, nitn=5, neval=6e4) # 7h33m run: 60, 5e5\n# print \"weehee\"\n\n\n print L0[0], result.sdev/result.mean\n print result.summary()\n return result.mean, result.sdev","def cpgram(ts):\n spectrum = np.fft.fft(ts)\n n = len(ts)\n y = (np.sqrt(spectrum.real**2 + spectrum.imag**2)) ** 2 / n\n if n % 2 == 0:\n n -= 1\n y = y[:n]\n\n freq = np.linspace(0, 0.5, n, endpoint=True)\n crit = 1.358 / (np.sqrt(n) + 0.12 + 0.11 / np.sqrt(n))\n\n return y, freq, crit","def fk_ease(self, doc):\n num_sentences = _get_num_sentences(doc)\n num_words = _get_num_words(doc)\n num_syllables = _get_num_syllables(doc)\n if num_sentences == 0 or num_words == 0 or num_syllables == 0:\n return 0\n words_per_sent = num_words / num_sentences\n syllables_per_word = num_syllables / num_words\n return 206.835 - (1.015 * words_per_sent) - (84.6 * syllables_per_word)","def lchisquare(f_obs,f_exp=None):\r\n k = len(f_obs) # number of groups\r\n if f_exp == None:\r\n f_exp = [sum(f_obs)/float(k)] * len(f_obs) # create k bins with = freq.\r\n chisq = 0\r\n for i in range(len(f_obs)):\r\n chisq = chisq + (f_obs[i]-f_exp[i])**2 / float(f_exp[i])\r\n return chisq, chisqprob(chisq, k-1)","def convolution_cyclopeptide_sequence(self, spectrum, convolution_len, leaderboard_len):\n convolution_dict = defaultdict(int)\n for i in range(len(spectrum)):\n for j in range(i+1, len(spectrum)):\n diff = abs(spectrum[j] - spectrum[i])\n if diff >= 57 and diff <= 200:\n convolution_dict[diff] += 1\n \n print convolution_dict\n # Sort the convolution spectrum find top-most entries\n sorted_convolution_dict = sorted(convolution_dict, key= lambda a: convolution_dict[a], reverse=True)\n convolution_list = list()\n for i in range(min(convolution_len, len(convolution_dict))):\n convolution_list.append(sorted_convolution_dict[i])\n # Add ties\n i = convolution_len\n while i < len(sorted_convolution_dict) and convolution_dict[sorted_convolution_dict[i]] == convolution_dict[sorted_convolution_dict[i-1]]:\n convolution_list.append(sorted_convolution_dict[i])\n i += 1\n \n # Done, now run leaderboard\n return self.leaderboard_cyclopeptide_sequence(leaderboard_len, spectrum, convolution_list)"],"string":"[\n \"def chrf(hypotheses, references):\\n return sacrebleu.corpus_chrf(hypotheses=hypotheses, references=references)\",\n \"def _chrf_score_compute(total_preds_char_n_grams: Dict[int, Tensor], total_preds_word_n_grams: Dict[int, Tensor], total_target_char_n_grams: Dict[int, Tensor], total_target_word_n_grams: Dict[int, Tensor], total_matching_char_n_grams: Dict[int, Tensor], total_matching_word_n_grams: Dict[int, Tensor], n_order: float, beta: float) ->Tensor:\\n chrf_f_score = _calculate_fscore(total_matching_char_n_grams, total_matching_word_n_grams, total_preds_char_n_grams, total_preds_word_n_grams, total_target_char_n_grams, total_target_word_n_grams, n_order, beta)\\n return chrf_f_score\",\n \"def sentence_chrf(hypothesis: str,\\n reference: str,\\n order: int = CHRF_ORDER,\\n beta: float = CHRF_BETA,\\n remove_whitespace: bool = True) -> CHRF:\\n statistics = get_sentence_statistics(hypothesis, reference, order=order, remove_whitespace=remove_whitespace)\\n avg_precision, avg_recall = _avg_precision_and_recall(statistics, order)\\n return CHRF(_chrf(avg_precision, avg_recall, beta=beta))\",\n \"def calculate_flesch_score(text):\\n\\n # Use the given formula and call other functions to get the values\\n score = 206.835 - 1.015 * count_words(text) / count_sentences(text) - 84.6 * count_syllables(text) / count_words(\\n text)\\n\\n return score\",\n \"def _calculate_sentence_level_chrf_score(targets: List[str], pred_char_n_grams_counts: Dict[int, Dict[Tuple[str, ...], Tensor]], pred_word_n_grams_counts: Dict[int, Dict[Tuple[str, ...], Tensor]], preds_char_n_grams: Dict[int, Tensor], preds_word_n_grams: Dict[int, Tensor], n_char_order: int, n_word_order: int, n_order: float, beta: float, lowercase: bool, whitespace: bool) ->Tuple[Tensor, Dict[int, Tensor], Dict[int, Tensor], Dict[int, Tensor], Dict[int, Tensor]]:\\n best_f_score = tensor(0.0)\\n best_matching_char_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\\n best_matching_word_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\\n best_target_char_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\\n best_target_word_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\\n for target in targets:\\n target_char_n_grams_counts, target_word_n_grams_counts, target_char_n_grams, target_word_n_grams = _get_n_grams_counts_and_total_ngrams(target, n_char_order, n_word_order, lowercase, whitespace)\\n matching_char_n_grams = _get_ngram_matches(target_char_n_grams_counts, pred_char_n_grams_counts)\\n matching_word_n_grams = _get_ngram_matches(target_word_n_grams_counts, pred_word_n_grams_counts)\\n f_score = _calculate_fscore(matching_char_n_grams, matching_word_n_grams, preds_char_n_grams, preds_word_n_grams, target_char_n_grams, target_word_n_grams, n_order, beta)\\n if f_score > best_f_score:\\n best_f_score = f_score\\n best_matching_char_n_grams = matching_char_n_grams\\n best_matching_word_n_grams = matching_word_n_grams\\n best_target_char_n_grams = target_char_n_grams\\n best_target_word_n_grams = target_word_n_grams\\n return best_f_score, best_matching_char_n_grams, best_matching_word_n_grams, best_target_char_n_grams, best_target_word_n_grams\",\n \"def _transcode_crf(binary: Path, params: str, crf: float) -> Dict[str, float]:\\n with tqdm(FILES, leave=False, desc=f'Try CRF={crf}') as paths:\\n scores = [_transcode_crf_one(binary, params, crf, p) for p in paths]\\n return {k: hmean([score[k] for score in scores]) for k in COLUMNS}\",\n \"def dcsrbf(r):\\n return 3*(num.power(num.maximum(0, 1-r), 3) - num.power(num.maximum(0, 1-r),2)*(3*r+1))\",\n \"def FtoC(F):\\n c = ((F-32)/9.)*5\\n return c\",\n \"def qed_furry_cc( s, m, r):\\n \\n S1 = [ binomial( r + n - 1, n ) for n in range(s+1) ]\\n S2 = [ Fraction(binomial(2*n,n), 4**n) for n in range(s+1) ]\\n S3 = [ (-1)**n * Fraction(binomial(2*n,n), 4**n) for n in range(s+1) ]\\n\\n C = lConvolute(lConvolute( S1, S2 ), S3)\\n\\n l1_t2 = s + m\\n l2 = r + s\\n\\n if l1_t2 % 2 != 0:\\n return 0\\n\\n denom = factorial(m) * factorial(r)\\n nom = double_factorial( l1_t2 - 1 )\\n\\n return Fraction( nom * C[s], denom )\",\n \"def compute_cramer(contingency_tb, expected_tb):\\n keys_A = contingency_tb.columns[:-1].tolist()\\n keys_B = contingency_tb.index[:-1].tolist()\\n cont_tb = contingency_tb.drop('total',axis=1)\\n cont_tb = cont_tb.drop('total',axis=0)\\n cont_tb[cont_tb.isnull()] = 0\\n chi_2 = sum(((cont_tb - expected_tb) * (cont_tb - expected_tb) / expected_tb).sum(axis=1))\\n \\n l = len(keys_A)\\n c = len(keys_B)\\n n = contingency_tb.ix[len(keys_B),len(keys_A)]\\n chi_2_max = n*(min(l,c)-1)\\n \\n cramer = math.sqrt(float(chi_2)/float(chi_2_max))\\n return cramer\",\n \"def conToCelc(faren):\\n return (faren - 32)*(5/9)\",\n \"def f2chi(f, kptsdf, c, arbfield=1.0):\\n # Since the solution we obtain from cg and from iterative scheme is F_k where chi_k = eE/kT * f0(1-f0) * F_k\\n # then we need to bring these factors back in to get the right units\\n f0 = np.squeeze(kptsdf['k_FD'].values)\\n prefactor = arbfield * c.e / c.kb_joule / c.T * f0 * (1 - f0)\\n chi = np.squeeze(f) * np.squeeze(prefactor)\\n return chi\",\n \"def cry_f(s : str) -> CryptolTerm:\\n return CryptolTerm(to_cryptol_str_customf(s, frames=1))\",\n \"def cramers_v1(confusion_matrix):\\n chi2 = ss.chi2_contingency(confusion_matrix)[0]\\n n = confusion_matrix.sum()\\n phi2 = chi2 / n\\n r, k = confusion_matrix.shape\\n phi2corr = max(0, phi2 - ((k-1)*(r-1))/(n-1))\\n rcorr = r - ((r-1)**2)/(n-1)\\n kcorr = k - ((k-1)**2)/(n-1)\\n return np.sqrt(phi2corr / min((kcorr-1), (rcorr-1)))\",\n \"def corpus_chrf(hypotheses: Iterable[str],\\n references: Iterable[str],\\n order: int = CHRF_ORDER,\\n beta: float = CHRF_BETA,\\n remove_whitespace: bool = True) -> CHRF:\\n corpus_statistics = get_corpus_statistics(hypotheses, references, order=order, remove_whitespace=remove_whitespace)\\n avg_precision, avg_recall = _avg_precision_and_recall(corpus_statistics, order)\\n return CHRF(_chrf(avg_precision, avg_recall, beta=beta))\",\n \"def cramer(colA,colB):\\n contingency_tb = contingency_table(colA,colB)\\n expected_tb = expected_table(contingency_tb)\\n return compute_cramer(contingency_tb, expected_tb)\",\n \"def _calculate_fscore(matching_char_n_grams: Dict[int, Tensor], matching_word_n_grams: Dict[int, Tensor], hyp_char_n_grams: Dict[int, Tensor], hyp_word_n_grams: Dict[int, Tensor], ref_char_n_grams: Dict[int, Tensor], ref_word_n_grams: Dict[int, Tensor], n_order: float, beta: float) ->Tensor:\\n\\n def _get_n_gram_fscore(matching_n_grams: Dict[int, Tensor], ref_n_grams: Dict[int, Tensor], hyp_n_grams: Dict[int, Tensor], beta: float) ->Dict[int, Tensor]:\\n \\\"\\\"\\\"Get n-gram level f-score.\\\"\\\"\\\"\\n precision: Dict[int, Tensor] = {n: (matching_n_grams[n] / hyp_n_grams[n] if hyp_n_grams[n] > 0 else tensor(0.0)) for n in matching_n_grams}\\n recall: Dict[int, Tensor] = {n: (matching_n_grams[n] / ref_n_grams[n] if ref_n_grams[n] > 0 else tensor(0.0)) for n in matching_n_grams}\\n denominator: Dict[int, Tensor] = {n: torch.max(beta ** 2 * precision[n] + recall[n], _EPS_SMOOTHING) for n in matching_n_grams}\\n f_score: Dict[int, Tensor] = {n: ((1 + beta ** 2) * precision[n] * recall[n] / denominator[n]) for n in matching_n_grams}\\n return f_score\\n char_n_gram_f_score = _get_n_gram_fscore(matching_char_n_grams, ref_char_n_grams, hyp_char_n_grams, beta)\\n word_n_gram_f_score = _get_n_gram_fscore(matching_word_n_grams, ref_word_n_grams, hyp_word_n_grams, beta)\\n f_score = (sum(char_n_gram_f_score.values()) + sum(word_n_gram_f_score.values())) / tensor(n_order)\\n return f_score\",\n \"def chi2sf(x, k):\",\n \"def correlation(func, len_Init_val, keystream):\\r\\n val = '1'\\r\\n final_value = '0'\\r\\n while len(val) < len_Init_val:\\r\\n val = '0' + val\\r\\n final_value += '0'\\r\\n\\r\\n while val != final_value:\\r\\n stream = func(val, len(keystream))\\r\\n freq = 0.\\r\\n for i in range(len(keystream)):\\r\\n if stream[i] == keystream[i]:\\r\\n freq += 1\\r\\n freq = freq/len(keystream)\\r\\n print(val + ' : ' + str(freq))\\r\\n val = incr(val)\\r\\n print('')\",\n \"def fkg(word, sent, syll):\\n flesch_kincaid_grade = (0.39* (word / sent)) + (11.8 * (syll / word)) - 15.59\\n return flesch_kincaid_grade\",\n \"def _erfcc(x):\\n z = abs(x)\\n t = 1. / (1. + 0.5 * z)\\n r = t * math.exp(-z * z - 1.26551223 + t * (1.00002368 + t * (.37409196 +\\n t * (.09678418 + t * (-.18628806 + t * (.27886807 +\\n t * (-1.13520398 + t * (1.48851587 + t * (-.82215223 +\\n t * .17087277)))))))))\\n if (x >= 0.):\\n return r\\n else:\\n return 2. - r\",\n \"def fahren_conv(self, c):\\n if c == 0:\\n return 32\\n else:\\n return c * (9.0 / 5.0) + 32\",\n \"def calculate_ac(str1, str2):\\n\\n total_letters = len(str1)\\n ocr_letters = len(str2)\\n if total_letters == 0 and ocr_letters == 0:\\n acc_by_char = 1.0\\n return acc_by_char\\n diff = difflib.SequenceMatcher(None, str1, str2)\\n correct_letters = 0\\n for block in diff.get_matching_blocks():\\n correct_letters = correct_letters + block[2]\\n if ocr_letters == 0:\\n acc_by_char = 0\\n elif correct_letters == 0:\\n acc_by_char = 0\\n else:\\n acc_1 = correct_letters / total_letters\\n acc_2 = correct_letters / ocr_letters\\n acc_by_char = 2 * (acc_1 * acc_2) / (acc_1 + acc_2)\\n\\n return float(acc_by_char)\",\n \"def cofactors(f, g):\\n lev, dom, per, F, G = f.unify(g)\\n h, cff, cfg = dmp_cofactors(F, G, lev, dom)\\n return per(h), per(cff), per(cfg)\",\n \"async def f(self, c : float):\\n f = c * 9/5 + 32\\n await self.bot.say(\\\"{0} Fahrenheit\\\".format(f))\",\n \"def coherence_partial_spec(fxy, fxx, fyy, fxr, fry, frr):\\r\\n coh = coherency_spec\\r\\n Rxr = coh(fxr, fxx, frr)\\r\\n Rry = coh(fry, fyy, frr)\\r\\n Rxy = coh(fxy, fxx, fyy)\\r\\n\\r\\n return (((np.abs(Rxy - Rxr * Rry)) ** 2) /\\r\\n ((1 - ((np.abs(Rxr)) ** 2)) * (1 - ((np.abs(Rry)) ** 2))))\",\n \"def ctof(temp):\\n return temp * 9/5 + 32 # functions should be surrounded by 2 blank lines\",\n \"def cramers_corrected_stat(confusion_matrix):\\n chi2 = ss.chi2_contingency(confusion_matrix)[0]\\n n = confusion_matrix.sum().sum()\\n phi2 = chi2/n\\n r,k = confusion_matrix.shape\\n phi2corr = max(0, phi2 - ((k-1)*(r-1))/(n-1)) \\n rcorr = r - ((r-1)**2)/(n-1)\\n kcorr = k - ((k-1)**2)/(n-1)\\n return np.sqrt(phi2corr / min( (kcorr-1), (rcorr-1)))\",\n \"def chromagram(signal,fs,n_fft=4096, hop_len=64, **kwargs):\\n y_harmonic, y_percussive = librosa.effects.hpss(signal)\\n C = librosa.feature.chromagram(y=y_harmonic, sr=fs, n_fft=n_fft, hop_length=hop_len)\\n return C\",\n \"def ChordMethod(f, a=0.0, b=1.0, x=0.75, tol=1e-10):\\n\\tstart = time()\\n\\n\\t# Initialization of function values and error \\n\\tf_a = f(a)\\n\\tf_b = f(b)\\n\\tf_x = f(x)\\n\\terror = np.abs(f_x)\\n\\n\\t# Initialization of iter number and array of error values\\n\\ti = 0\\n\\terrs = []\\n\\n\\tif f_a*f_b<0:\\n\\t\\twhile error > tol:\\n\\t\\t\\terrs.append(error)\\n\\n\\t\\t\\tif f_a*f_x < 0:\\n\\t\\t\\t\\tx = (x*f_a - a*f_x) / (f_a - f_x)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tx = (x*f_b - b*f_x) / (f_b - f_x)\\n\\n\\t\\t\\tf_x = f(x)\\n\\t\\t\\terror = np.abs(f_x)\\n\\t\\t\\ti = i+1\\n\\telse:\\n\\t\\tprint(\\\"Function values are of the same sign!\\\")\\n\\tend = time()\\n\\treturn x, (end-start), i\",\n \"def compute_ctf(freqs,rots,akv,cs,wgh,dfmid1f,dfmid2f,angastf,dscale,bfactor=None): \\n av = akv * 1e3 # Convert kilovots to volts\\n cs = cs * 1e7 # Convert spherical aberation from mm to A\\n \\n # wavelength of electrons\\n elambda = 12.2643247 / n.sqrt(av + av**2 * 0.978466e-6)\\n \\n wgh1 = dscale*n.sqrt(1.0 - wgh**2)\\n wgh2 = dscale*wgh\\n\\n ix = freqs[:,0]\\n iy = freqs[:,1]\\n freq_radius = n.sqrt(ix**2 + iy**2)\\n\\n angle = elambda*freq_radius\\n angspt = n.arctan2(iy,ix)\\n if rots is not None:\\n angspt = n.mod(angspt.reshape((-1,1)) + rots.reshape((1,-1)),2.0*n.pi)\\n angle = angle.reshape((-1,1)) \\n c1 = 2.0*n.pi*angle**2/(2.0*elambda)\\n c2 = -c1*cs*angle**2/2.0\\n angdif = angspt - angastf\\n ccos = n.cos(2.0*angdif)\\n df = 0.5*(dfmid1f + dfmid2f + ccos*(dfmid1f-dfmid2f))\\n chi = c1*df + c2\\n\\n ctf = -wgh1*n.sin(chi) - wgh2*n.cos(chi)\\n \\n if bfactor is not None:\\n ctf *= envelope_function(freq_radius, bfactor)\\n\\n return n.require(ctf,dtype = freqs.dtype)\",\n \"def cdq2(f, x, h=1e-5):\\n return (f(x+h)-f(x-h))/(2*h)\\n raise NotImplementedError(\\\"Problem 2 Incomplete\\\")\",\n \"def f1_score(confusion):\\n sens = sensitivity(confusion)\\n prec = precision(confusion)\\n return 2 * sens * prec / (sens + prec)\",\n \"def qed_furry_class_coeff( L, rt2, m ):\\n\\n if rt2 % 2 != 0:\\n return 0\\n \\n r = rt2/2\\n s = m + 2*r + 2*(L - 1)\\n \\n if s<0:\\n return 0\\n\\n return qed_furry_cc(s,m,r)\",\n \"def f1_score(confusion):\\n p = precision(confusion)\\n r = sensitivity(confusion)\\n F1 = (2 * p * r) / (p + r)\\n return F1\",\n \"def gen_challange(sk, fid):\\n Lf = poly(sk, fid)\\n r = G.random()\\n xc = G.random() # CAUTION: xc != mi\\n\\n Kf = g ** (r * Lf(xc))\\n H = (g ** r, xc, g ** (r * Lf[0]))\\n return (Kf, H)\",\n \"def f2c(t):\\r\\n return round(5/9 * (t-32))\",\n \"def cntd_qed_furry_class_coeff( L, rt2, m):\\n\\n if rt2 % 2 != 0:\\n return 0\\n \\n r = rt2/2\\n s = m + 2*r + 2*(L - 1)\\n\\n if s<0:\\n return 0\\n\\n A = [ [ [ qed_furry_cc(sp, mp, rp) for mp in range(m+1) ] for rp in range(r+1) ] for sp in range(s+1) ]\\n Alog = lLog( A )\\n \\n return Alog[s][r][m]\",\n \"def convertC(TF):\\r\\n TC = 5.0/9.0*(TF - 32.0)\\r\\n return TC\",\n \"def CesarChiff(message_a_chiff:str, decal:int)->str:\\r\\n mot_crypte = \\\"\\\"\\r\\n for lettre in message_a_chiff:\\r\\n mot_crypte += cryptage(decal, lettre)\\r\\n\\r\\n return mot_crypte\",\n \"def fcp(self, var='x'):\\n return self.charpoly(var).factor()\",\n \"def ForsterCoupling(d1, d2, r):\\n normr = norm(r)\\n rn = r / normr ##Normalized distance vector\\n Coupling = (3 * dot(d1, rn) * dot(d2, rn) - dot(d1, d2)) / normr**3\\n return Coupling\",\n \"def _calc_chromatic_term(self):\\n LOG.debug(\\\"Calculating Chromatic Term.\\\")\\n self._check_k_columns([\\\"K1L\\\", \\\"K2L\\\", \\\"K2SL\\\"])\\n res = self._results_df\\n tw = self.twiss_df\\n\\n with timeit(lambda t: LOG.debug(\\\" Time needed: {:f}\\\".format(t))):\\n mask = (tw['K1L'] != 0) | (tw['K2L'] != 0) | (tw['K2SL'] != 0)\\n if \\\"DX\\\" in tw and \\\"DY\\\" in tw:\\n LOG.debug(\\\"Dispersion values found in model. Used for chromatic calculations\\\")\\n sum_term = tw.loc[mask, 'K1L'] - \\\\\\n (tw.loc[mask, 'K2L'] * tw.loc[mask, 'DX']) + \\\\\\n (tw.loc[mask, 'K2SL'] * tw.loc[mask, 'DY'])\\n else:\\n LOG.info(\\\"Dispersion values NOT found in model. Using analytic values.\\\")\\n if \\\"DX\\\" not in res or \\\"DY\\\" not in res:\\n self.calc_linear_dispersion()\\n sum_term = tw.loc[mask, 'K1L'] - \\\\\\n (tw.loc[mask, 'K2L'] * res.loc[mask, 'DX']) + \\\\\\n (tw.loc[mask, 'K2SL'] * res.loc[mask, 'DY'])\\n\\n res['CHROMX'] = sum_term * tw.loc[mask, 'BETX']\\n res['CHROMY'] = sum_term * tw.loc[mask, 'BETY']\\n\\n LOG.debug(\\\"Chromatic Term Calculated.\\\")\",\n \"def cpred(self, z0, z1, f0, f1):\\n e0 = self.embed(z0)\\n e1 = self.embed(z1)\\n \\n assert f0.shape[1] == z0.shape[1] and f1.shape[1] == z1.shape[1]\\n \\n f0 = self.fseek_emb(f0)\\n f1 = self.fseek_emb(f1)\\n \\n e0 = torch.concat([e0, f0], dim = 2)\\n e1 = torch.concat([e1, f1], dim = 2)\\n \\n B = self.contact.cmap(e0, e1)\\n C = self.contact.predict(B)\\n return C\",\n \"def reactance_to_component(reactance, freq):\\n logger.debug(\\\"reactance_to_component: reactance= %8.3f\\\", reactance)\\n factor = 2*pi*freq\\n if reactance < 0:\\n # compute capacitance\\n return -1/(factor*reactance), \\\"F\\\"\\n else:\\n # compute inductance\\n return reactance/factor, \\\"H\\\"\",\n \"def cmmdc(e, f):\\n if f == 0:\\n if e == 0:\\n return 0\\n else:\\n return e\\n else:\\n r = e % f\\n while r > 0:\\n e = f\\n f = r\\n r = e % f\\n return f\",\n \"def terms_gcd(f):\\n J, F = dmp_terms_gcd(f.rep, f.lev, f.dom)\\n return J, f.per(F)\",\n \"def cross_correlate(rmsynth_pixel, rmsf):\\n return np.fft.ifft(np.fft.fft(rmsynth_pixel)*np.fft.fft(rmsf[::-1]))\",\n \"def compute_prf_on_selection(arts, forms_set):\\n tp=0\\n fn=0\\n fp=0\\n for article in arts:\\n for entity in article.entity_mentions:\\n if entity.mention in forms_set:\\n if entity.gold_link==entity.sys_link:\\n tp+=1\\n else:\\n if entity.sys_link!='--NME--':\\n fp+=1\\n if entity.gold_link!='--NME--':\\n fn+=1\\n print(tp, fp, fn)\\n p=tp/(tp+fp)\\n r=tp/(tp+fn)\\n f1=2*p*r/(p+r)\\n print(p,r,f1)\\n return f1\",\n \"def _get_n_gram_fscore(matching_n_grams: Dict[int, Tensor], ref_n_grams: Dict[int, Tensor], hyp_n_grams: Dict[int, Tensor], beta: float) ->Dict[int, Tensor]:\\n precision: Dict[int, Tensor] = {n: (matching_n_grams[n] / hyp_n_grams[n] if hyp_n_grams[n] > 0 else tensor(0.0)) for n in matching_n_grams}\\n recall: Dict[int, Tensor] = {n: (matching_n_grams[n] / ref_n_grams[n] if ref_n_grams[n] > 0 else tensor(0.0)) for n in matching_n_grams}\\n denominator: Dict[int, Tensor] = {n: torch.max(beta ** 2 * precision[n] + recall[n], _EPS_SMOOTHING) for n in matching_n_grams}\\n f_score: Dict[int, Tensor] = {n: ((1 + beta ** 2) * precision[n] * recall[n] / denominator[n]) for n in matching_n_grams}\\n return f_score\",\n \"def chromnorm(F, P=2.):\\r\\n nchr, nbts = F.shape\\r\\n if not np.isinf(P):\\r\\n S = np.power(np.sum(np.power(F,P), axis=0),(1./P));\\r\\n else:\\r\\n S = F.max()\\r\\n S = S if S > 0 else 1\\r\\n # try:\\r\\n # d = F/S\\r\\n # except:\\r\\n # print F, S\\r\\n return F / S\",\n \"def fce(B):\\n return wce(B)/(2.*np.pi)\",\n \"def hic_chipseq_r2 (hic, chipseq) :\\n hic_rowsum = np.sum(hic,axis=1)/float(np.sum(hic))\\n return np.corrcoef(hic_rowsum,chipseq)[0,1]**2\",\n \"def f_test(chi1,df1,chi2,df2,red_chi = True):\\n\\n# if chi1/df1 > chi2/df2:\\n#\\tprob = 2. * f.cdf(chi1/df1, chi2/df2, df1, df2)\\n# else:\\n#\\tprob = 2. * f.cdf(chi2/df2, chi1/df1, df2, df1)\\n if red_chi:\\n\\tfval = (chi1/df1) / (chi2/df2)\\n else:\\n\\tfval = chi1 / chi2\\n prob = 2. * f.cdf((chi1/df1) / (chi2/df2), df1, df2)\\n if prob > 1.: \\n\\treturn 2. - prob\\n else:\\n\\treturn prob\",\n \"def corrigir_doc(frase):\\r\\n\\r\\n if not frase or not (isinstance(frase, str) and all(x.isalpha() for x in frase.split())) or ' ' in frase:\\r\\n raise ValueError('corrigir_doc: argumento invalido')\\r\\n\\r\\n palavras, doc_corrigido = frase.split(' '), ''\\r\\n palavras = list(map(corrigir_palavra, palavras))\\r\\n\\r\\n while palavras:\\r\\n anagrama_teste = palavras.pop(0)\\r\\n if palavras:\\r\\n for word in palavras:\\r\\n if eh_anagrama(anagrama_teste, word) and anagrama_teste.lower() != word.lower():\\r\\n del palavras[palavras.index(word)]\\r\\n doc_corrigido += ' ' + anagrama_teste\\r\\n\\r\\n return doc_corrigido[1:]\",\n \"def c2f(t):\\r\\n return round(9*t/5 + 32)\",\n \"def qed_cc( s, m, r):\\n\\n l1_t2 = s + m\\n l2 = r + s\\n\\n if l1_t2 % 2 != 0:\\n return 0\\n\\n denom = factorial(s) * factorial(m) * factorial(r)**2\\n nom = double_factorial( l1_t2 - 1 ) * factorial( l2 )\\n\\n return Fraction( nom, denom )\",\n \"def phosfracs(h,ks):\\n k1p,k2p,k3p = ks\\n h3po4 = h*h*h\\n h2po4 = k1p*h*h\\n hpo4 = k1p*k2p*h\\n po4 = k1p*k2p*k3p\\n denom = h3po4 + h2po4 + hpo4 + po4\\n h3po4 /= denom\\n h2po4 /= denom\\n hpo4 /= denom\\n po4 /= denom\\n return h3po4,h2po4,hpo4,po4\",\n \"def f1_score(confusion):\\n s = np.power(sensitivity(confusion), -1)\\n p = np.power(precision(confusion), -1)\\n return 2 / (s + p)\",\n \"def _transcode_crf_one(binary: Path, params: str, crf: float, path: Path\\n ) -> Dict[str, float]:\\n root = Path(f'{path}.temp')\\n if root.exists():\\n shutil.rmtree(root)\\n\\n root.mkdir(parents=True)\\n out = root / 'out.265'\\n csv_log = root / 'log.csv'\\n\\n # ? Maybe use '--bitrate {bitrate} --pass {i}' with 'pass' in (1, 2)\\n cmd = (\\n f'{binary} --input {path} --fps 24000/1001'\\n f' --crf {crf}'\\n f' --profile main10 {params} --ssim-rd --ssim'\\n f' --output {out} --csv {csv_log}'\\n )\\n res = subprocess.run(\\n cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,\\n shell=True, text=True)\\n if res.returncode:\\n for f in (res.stdout, res.stderr):\\n if f:\\n print(f)\\n raise RuntimeError(res.args)\\n\\n with csv_log.open() as fp:\\n *_, stats = csv.DictReader(fp, skipinitialspace=True)\\n\\n return {k: float(stats[k_raw]) for k, k_raw in COLUMNS.items()}\",\n \"def score(word, f):\\n \\n #dictionary mapping a to 1, b to 2, c to 3 etc etc\\n alphaDict = {'a' : 1, 'b' : 2, 'c' : 3, 'd' : 4, 'e' : 5, 'f' : 6, 'g' : 7, 'h' : 8, 'i' : 9, 'j' : 10, 'k' : 11, 'l' : 12, 'm' : 13,\\n 'n' : 14, 'o' : 15, 'p': 16, 'q' : 17, 'r': 18, 's' : 19, 't': 20, 'u' : 21, 'v' : 22, 'w' : 23, 'x': 24, 'y' : 25, 'z' : 26 }\\n \\n #make the word all lower case\\n word = word.lower()\\n \\n #then get a list of all the letters in word\\n letters = []\\n for s in word:\\n letters.append(s)\\n \\n #then score based on the position of the letter and what the letter is. store the individual score in a list\\n letterScore = []\\n \\n for i in range(len(letters)):\\n letterScore.append(i*alphaDict[letters[i]])\\n \\n #then sort the list. This will be in descending order so reverse it to find the two highest scores\\n letterScore.sort()\\n letterScore.reverse()\\n \\n #return f applied to the two highest score\\n return f(letterScore[0], letterScore[1])\",\n \"def get_f_score(self):\\n return self.get_g_score() + self.get_h_score()\",\n \"def converge_scf(self):\\n # run a convergence worklfow\\n # Comment: Here we wait, because of run,\\n # maybe using a future and submit instead might be better\\n #print 'ctx, before scf {} {}'.format(ctx, [a for a in self.ctx])\\n inputs = self.get_inputs_scf(self.ctx)\\n\\n if self.ctx.last_calc2:\\n #print 'inputs for convergnce2: {}'.format(inputs)\\n res = run(fleur_scf_wc,\\n wf_parameters=inputs['wf_parameters'],\\n fleurinp=inputs['fleurinp'],\\n fleur=inputs['fleur'])\\n #inputs)#\\n #wf_parameters=wf_para,\\n #structure=s,\\n #calc_parameters=parameters,\\n #inpgen = code,\\n #fleur=code2)#, computer=computer)\\n else:\\n res = run(fleur_scf_wc, wf_parameters=inputs['wf_parameters'],\\n structure=inputs['structure'], calc_parameters=inputs['calc_parameters'], inpgen = inputs['inpgen'], fleur=inputs['fleur'] )#inputs)#\\n #print 'ctx, after scf {} {}'.format(ctx, [a for a in self.ctx])\\n\\n #print 'output of convergence: {}'.format(res)\\n self.ctx.last_calc2 = res#.get('remote_folder', None)\\n #print res\\n #return ResultToContext(last_calc2=res)\",\n \"def calc_chromatic_coupling(self):\\n raise NotImplementedError('Chromatic Coupling is not Implemented yet.')\",\n \"def factor(self):\\r\\n\\t\\t\\r\\n\\t\\t# get gcf\\r\\n\\t\\tg = self.extract()\\r\\n\\t\\t\\r\\n\\t\\t# invert and multiply\\r\\n\\t\\tv = g.invert()\\r\\n\\t\\tf = self.multiply(v)\\r\\n\\t\\t\\r\\n\\t\\treturn f,g\",\n \"def lerfcc(x):\\r\\n z = abs(x)\\r\\n t = 1.0 / (1.0+0.5*z)\\r\\n ans = t * math.exp(-z*z-1.26551223 + t*(1.00002368+t*(0.37409196+t*(0.09678418+t*(-0.18628806+t*(0.27886807+t*(-1.13520398+t*(1.48851587+t*(-0.82215223+t*0.17087277)))))))))\\r\\n if x >= 0:\\r\\n return ans\\r\\n else:\\r\\n return 2.0 - ans\",\n \"def rangerate_from_freq(freq,Fc):\\n # print(f'freq {freq} Fc {Fc}')\\n dopp_at_IF = freq - Fc\\n return dopp_at_IF*scipy.constants.speed_of_light/Fc\",\n \"def coi(self, s):\\n return 2 ** 0.5 * s\",\n \"def string_f1_score(prediction, ground_truth):\\n prediction_tokens = normalize_answer(prediction).split()\\n ground_truth_tokens = normalize_answer(ground_truth).split()\\n common = collections.Counter(prediction_tokens) & collections.Counter(ground_truth_tokens)\\n num_same = sum(common.values())\\n if num_same == 0:\\n return 0\\n precision = 1.0 * num_same / len(prediction_tokens)\\n recall = 1.0 * num_same / len(ground_truth_tokens)\\n f1 = (2 * precision * recall) / (precision + recall)\\n return f1\",\n \"def calculate(self):\\n\\n tp = self.confusion_matrix.tp\\n tn = self.confusion_matrix.tn\\n fp = self.confusion_matrix.fp\\n fn = self.confusion_matrix.fn\\n\\n agreement = tp + tn\\n chance0 = (tn + fn) * (tn + fp)\\n chance1 = (fp + tp) * (fn + tp)\\n sum_ = tn + fn + fp + tp\\n chance = (chance0 + chance1) / sum_\\n\\n return (agreement - chance) / (sum_ - chance)\",\n \"def compute_f_ColeBrook(self, R, e, D):\\n # assume a starting correct value for the \\\"f\\\" on the right hand side (RHS)\\n # uses friction factor from Barr's equation as the starting value.\\n f_initial = self.compute_f_BARR(R, self.e, self.D)\\n\\n relative_roughness = e / D\\n a = relative_roughness / 3.71\\n b = 2.51 / (R * sqrt(f_initial))\\n\\n # Compute the f on the LHS ------ (1) \\n f_final = 1 / (-2 * log((a + b), 10))**2\\n \\n # Make sure friction factor is correct to at least 6 decimal place.\\n tolerance = 0.0000001\\n \\n # if the f on the LHS is not within tolerance limit,\\n # replace it on the RHS and recompute the f on the LHS till it's within\\n # tolerance limit.\\n while abs(f_final - f_initial) >= tolerance:\\n f_initial = f_final\\n b = 2.51 / (R * sqrt(f_initial))\\n f_final = 1 / (-2 * log((a + b), 10))**2\\n return f_final\",\n \"def generate_ctf(p):\\n\\tfrom EMAN2 import EMAN2Ctf\\n\\n\\tdefocus = p[0]\\n\\tcs = p[1]\\n\\tvoltage = p[2]\\n\\tpixel_size = p[3]\\n\\tbfactor = p[4]\\n\\tamp_contrast = p[5]\\n\\t\\n\\tif defocus > 100: # which means it is very likely in Angstrom, therefore we are using the old convention\\n\\t\\tdefocus *= 1e-4\\n\\t\\n\\tif amp_contrast < 1.0:\\n\\t\\tfrom math import sqrt\\n\\t\\tamp_contrast = amp_contrast*100/sqrt(2*amp_contrast**2-2*amp_contrast+1)\\n\\n\\tctf = EMAN2Ctf()\\n\\tif(len(p) == 6):\\n\\t\\tctf.from_dict({\\\"defocus\\\":defocus, \\\"cs\\\":cs, \\\"voltage\\\":voltage, \\\"apix\\\":pixel_size, \\\"bfactor\\\":bfactor, \\\"ampcont\\\":amp_contrast})\\n\\telse:\\n\\t\\tctf.from_dict({\\\"defocus\\\":defocus, \\\"cs\\\":cs, \\\"voltage\\\":voltage, \\\"apix\\\":pixel_size, \\\"bfactor\\\":bfactor, \\\"ampcont\\\":amp_contrast,'dfdiff':p[6],'dfang':p[7]})\\n\\t\\t\\n\\treturn ctf\",\n \"def chi2(data, fdata, err):\\n return sum(((data-fdata)/err)**2)\",\n \"def f2c_cml_function():\\n import sys\\n\\n F = float(sys.argv[1])\\n C = 5/9.0*F - 32\\n print(\\\"The temperatire in Celcius is {:g}\\\".format(C))\",\n \"def _wf(self, p):\\n r = self.faces - p\\n n = norm(r, axis=2)\\n num = row_wise_dot(r[:, 0, :], np.cross(r[:, 1, :], r[:, 2, :]))\\n den = n[:, 1] * n[:, 2] * n[:, 0]\\n for i in range(3):\\n j = (i + 1) % 3\\n k = (i + 2) % 3\\n den += row_wise_dot(r[:, i, :], r[:, j, :]) * n[:, k]\\n return 2*np.arctan2(num, den)\",\n \"def correlation_spectrum(x1, x2, Fs=2 * np.pi, norm=False):\\r\\n\\r\\n x1 = x1 - np.mean(x1)\\r\\n x2 = x2 - np.mean(x2)\\r\\n x1_f = fftpack.fft(x1)\\r\\n x2_f = fftpack.fft(x2)\\r\\n D = np.sqrt(np.sum(x1 ** 2) * np.sum(x2 ** 2))\\r\\n n = x1.shape[0]\\r\\n\\r\\n ccn = ((np.real(x1_f) * np.real(x2_f) +\\r\\n np.imag(x1_f) * np.imag(x2_f)) /\\r\\n (D * n))\\r\\n\\r\\n if norm:\\r\\n ccn = ccn / np.sum(ccn) * 2 # Only half of the sum is sent back\\r\\n # because of the freq domain symmetry.\\r\\n # XXX Does normalization make this\\r\\n # strictly positive?\\r\\n\\r\\n f = utils.get_freqs(Fs, n)\\r\\n return f, ccn[0:(n / 2 + 1)]\",\n \"def f(chord):\\r\\n m, length, dim = chord.shape\\r\\n chord2 = chord.reshape([m*length, dim])\\r\\n weighted_chords = np.dot(chord2, chord_id2sign)\\r\\n return weighted_chords.reshape(m, length, 12)\",\n \"def calculate_coherent_scattering_factor(element, q):\\n return current_calculator.get_coherent_scattering_factor(element, q)\",\n \"def f_2(c):\\n Di = calc_R(*c)\\n return Di\",\n \"def lfriedmanchisquare(*args):\\r\\n k = len(args)\\r\\n if k < 3:\\r\\n raise ValueError, 'Less than 3 levels. Friedman test not appropriate.'\\r\\n n = len(args[0])\\r\\n data = apply(pstats.abut,tuple(args))\\r\\n for i in range(len(data)):\\r\\n data[i] = rankdata(data[i])\\r\\n ssbn = 0\\r\\n for i in range(k):\\r\\n ssbn = ssbn + sum(args[i])**2\\r\\n chisq = 12.0 / (k*n*(k+1)) * ssbn - 3*n*(k+1)\\r\\n return chisq, chisqprob(chisq,k-1)\",\n \"def calc_ent_f1_and_ent_mcc(hyps: List[str], refs: List[str], vocab, c_fun, report_on_canonicals: bool = False, tok_fun=pkt_tokenize):\\n\\n # requires internal knowledge of the entire universe\\n # specifically of names of kb_fields, kbtrv_fields\\n\\n # FIXME create_KB_on_the_fly and pkt_tokenize \\n # are referred to separately in \\n # * helpers.py\\n # * metrics.py\\n # fix this by \\n # adding them to cfg\\n # or \\n # giving it as attribute to the model \\n\\n\\n # define helper functions\\n ## eval metrics\\n def precision(predictions: List[int], gold_labels: List[int]):\\n # TP/(TP+FP) => iterate over positives (predicted)\\n positives = len(predictions)\\n if positives:\\n tp, fp = zip(*[(1,0) if pred in gold_labels else (0,1) for pred in predictions])\\n return sum(tp)/positives\\n else:\\n return 1.\\n\\n def recall(predictions: List[int], gold_labels: List[int]):\\n # TP/(TP+FN) => iterate over ground truths (gold labels)\\n truths = len(gold_labels)\\n if truths:\\n tp, fn = zip(*[(1,0) if gold in predictions else (0,1) for gold in gold_labels])\\n return sum(tp)/truths\\n else:\\n return 1.\\n\\n f1_ = lambda p, r: 2 * (p*r)/(p+r) if p+r != 0. else 0.\\n mcc_ = lambda p, r: sqrt((r+(1/r)-1)*(p+(1/p)-1)) if r != 0. and p != 0. else 0.\\n\\n # compare ent f1 in trv => lookup vocab indices\\n\\n f1s = [] # accumulate scores\\n mccs = [] # accumulate matthew's correlation coefficients\\n num_ents = []\\n for i, (hyp,ref) in enumerate(zip(hyps, refs)):\\n\\n hyp_ents_ref_ents = [] # will hold entity vocabulary indices in the order hyp,ref\\n debug = []\\n\\n for seq in (hyp,ref):\\n seq_tokzd = tok_fun(seq)\\n canons, indices, matches = c_fun(seq_tokzd) # turn to canonical tokens and return indices that raw tokens were mapped to\\n del matches # TODO use matches instead of implementation below FIXME\\n\\n entities = [\\\\\\n \\\" \\\".join([raw for map_idx, raw in zip(indices,seq_tokzd) if map_idx==i])\\n for i in range(len((canons)))\\n ]\\n\\n # Filter out tokens that werent changed (noncanonical)\\n try:\\n canonical_entities, surface_entities = list(zip(*[(c,t) for c,t in zip(canons,entities) if c!=t]))\\n except ValueError: # no entities\\n canonical_entities, surface_entities = [], []\\n \\n if report_on_canonicals: \\n entities = canonical_entities\\n else:\\n entities = surface_entities\\n \\n # record number of decisions made for this hypothesis\\n num_ents += [len(entities)]\\n\\n # Filter out unk IDs\\n entities = [tok for tok in entities if not vocab.is_unk(tok)]\\n # turn to vocab indices (int)\\n seq_enty_voc_indices = [vocab.stoi[entity] for entity in entities]\\n\\n hyp_ents_ref_ents.append(seq_enty_voc_indices)\\n debug.append(entities)\\n\\n pred, truth = hyp_ents_ref_ents\\n\\n P = precision(pred,truth)\\n R = recall(pred,truth)\\n \\n f1s.append(f1_(P,R))\\n mccs.append(mcc_(P,R))\\n\\n print(\\\" ### Validation Classification Metrics Debug ###\\\\n\\\"+\\\\\\n f\\\"hyp: {hyp}\\\\nref: {ref}\\\\nentities: {hyp_ents_ref_ents}\\\\nPrecision: {P}\\\\nRecall: {R}\\\"+\\\\\\n \\\" ### Debug Metrics End ### \\\")\\n \\n assert len(hyps) == len(refs) == len(f1s) == len(mccs), (len(hyps), len(refs), len(f1s), len(mccs))\\n f1_avg = sum([num_ents[i]*f1s[i] for i in range(len(f1s))]) / sum(num_ents) if len(num_ents) else 0\\n mcc_avg = sum([num_ents[i]*mccs[i] for i in range(len(mccs))]) / sum(num_ents) if len(num_ents) else 0\\n return f1_avg, mcc_avg\",\n \"def cd(f, x, h, fl=np.complex_):\\n return np.divide(np.subtract(f(np.add(x, h, dtype=fl)), f(np.subtract(x, h, dtype=fl)), dtype=fl), (2*h), dtype=fl)\",\n \"def compute_prf(self, counts_dict):\\n precision = counts_dict[\\\"correct\\\"] / counts_dict[\\\"predicted\\\"] if counts_dict[\\\"predicted\\\"] else 0.0\\n recall = counts_dict[\\\"correct\\\"] / counts_dict[\\\"gold\\\"] if counts_dict[\\\"gold\\\"] else 0.0\\n fscore = 2 * precision * recall / (precision + recall) if precision + recall else 0.0\\n\\n return {\\\"precision\\\": precision, \\\"recall\\\": recall, \\\"fscore\\\": fscore}\",\n \"def fb(lines):\\n sl = lines.split()\\n nl = map(int, sl)\\n i = 0\\n while i < len(nl):\\n loop = nl[i:i+3]\\n for j in range(1,loop[2]+1):\\n print (not j % loop[0])*'F' + (not j % loop[1])*'B' or j,\\n i = i + 3\\n print\",\n \"def get_fuzz_ratio(first_word, second_word):\\n return fuzz.ratio(first_word, second_word), first_word, second_word\",\n \"async def c(self, f : float):\\n c = (f-32) * 5/9\\n await self.bot.say(\\\"{0} Celsius\\\".format(c))\",\n \"def k_c(self, tl):\\n\\t\\treturn self.KC0*exp(self.HKC/(R*self.TO)*(1. - self.TO/tl))\",\n \"def wordSimilarityRatio(sent_1,sent_2):\",\n \"def kA_char_func(self):\\n i1 = self.inl[0].to_flow()\\n i2 = self.inl[1].to_flow()\\n o1 = self.outl[0].to_flow()\\n o2 = self.outl[1].to_flow()\\n\\n i1_d = self.inl[0].to_flow_design()\\n i2_d = self.inl[1].to_flow_design()\\n\\n T_i1 = T_mix_ph(i1, T0=self.inl[0].T.val_SI)\\n T_i2 = T_mix_ph(i2, T0=self.inl[1].T.val_SI)\\n T_o1 = T_mix_ph(o1, T0=self.outl[0].T.val_SI)\\n T_o2 = T_mix_ph(o2, T0=self.outl[1].T.val_SI)\\n\\n if T_i1 <= T_o2:\\n T_i1 = T_o2 + 0.01\\n if T_i1 <= T_o2:\\n T_o2 = T_i1 - 0.01\\n if T_i1 <= T_o2:\\n T_o1 = T_i2 + 0.02\\n if T_o1 <= T_i2:\\n T_i2 = T_o1 - 0.02\\n\\n fkA1 = 1\\n if self.kA_char1.param == 'm':\\n fkA1 = self.kA_char1.func.evaluate(i1[0] / i1_d[0])\\n\\n fkA2 = 1\\n if self.kA_char2.param == 'm':\\n fkA2 = self.kA_char2.func.evaluate(i2[0] / i2_d[0])\\n\\n fkA = 2 / (1 / fkA1 + 1 / fkA2)\\n\\n td_log = ((T_o1 - T_i2 - T_i1 + T_o2) /\\n np.log((T_o1 - T_i2) / (T_i1 - T_o2)))\\n return i1[0] * (o1[2] - i1[2]) + self.kA.design * fkA * td_log\",\n \"def prng_feedback(self, lfsr):\\n return str(int(lfsr[0],2) ^ int(lfsr[2],2) ^ int(lfsr[3],2) ^ int(lfsr[5],2))\",\n \"def calc_process_cohesion(partitions, graph):\\n ch = 0\\n for part in partitions:\\n crc = calc_community_relation_cohesion(part, graph)\\n cic = calc_community_information_cohesion(part, graph)\\n ch = ch + (crc * cic)\\n ch = ch / len(partitions)\\n return ch\",\n \"def calc_pr_rc_F1(GTD, block_occ):\\r\\n true_pos = ((GTD + block_occ)==2).sum()\\r\\n false_pos = sum([1 if BI_val==1 and GTD[i]==0 else 0 for i, BI_val in enumerate(block_occ.values)])\\r\\n precision = float(true_pos/(true_pos+false_pos))\\r\\n recall = float(true_pos/(GTD.sum()))\\r\\n if precision == 0:\\r\\n F1 = 0\\r\\n else:\\r\\n F1 = float(2 * (precision * recall) / (precision + recall))\\r\\n \\r\\n return precision, recall, F1\",\n \"def toff(self) -> None:\\n\\n size = self.circ_size\\n self._get_random_input_state(self.seed)\\n\\n remainder = size % 3\\n for layer in range(size):\\n leftovers = tuple(random.sample(range(size), remainder))\\n candidates = [x for x in range(size) if x not in leftovers]\\n\\n while candidates:\\n current_toff = tuple(random.sample(candidates, 3))\\n self.ccx(current_toff[0], current_toff[1], current_toff[2])\\n candidates = [x for x in candidates if x not in current_toff]\\n\\n self.decompose().decompose()\\n if self.meas: self.measure(self.qr, self.cr)\",\n \"def calc(df: pd.DataFrame, step_key: str, jaccard: bool) -> dict:\\n\\n # Set Output Dictionary\\n result_dict = dict()\\n # Iterate over DataFrame two rows at a time via index\\n for (indx1),(indx2) in zip(df[:-1].index,df[1:].index):\\n # Select pairs (a & b)\\n if df.loc[indx1].pairing_label.endswith('a') and df.loc[indx2].pairing_label.endswith('b'):\\n # save the label and the fulltext depending on pairing (a or b)\\n patterna = df.loc[indx1].pairing_label\\n patternb = df.loc[indx2].pairing_label\\n try:\\n # Select preprocessed full_texts \\n input_full_a = df.loc[indx1].OneString\\n input_full_b = df.loc[indx2].OneString\\n except:\\n logging.info('For a pair in Calculation, no full_texts could be extracted. Scores will remain empty.')\\n result_dict.update({patterna : ''}) \\n result_dict.update({patternb : ''})\\n pass\\n # CALCULATOR\\n cosine = formulas.distributor(step_key, input_full_a, input_full_b, jaccard)\\n # update dict with cosine for each label\\n result_dict.update({patterna : cosine}) \\n result_dict.update({patternb : cosine})\\n else:\\n continue\\n return result_dict\",\n \"def get_coherent_scattering_factor(self, element: str, q):\\n if element not in self.coherent_param.index.values:\\n raise ElementNotImplementedException(element)\\n fs_coh = 0\\n s = q / (4 * np.pi)\\n for ind in range(1, 5):\\n A = self.coherent_param['A' + str(ind)][element]\\n B = self.coherent_param['B' + str(ind)][element]\\n fs_coh += A * np.exp(-B * s ** 2)\\n\\n C = self.coherent_param['C'][element]\\n fs_coh += C\\n return fs_coh\",\n \"def secondaryLensedForegroundBias(self, fCf, fCkkf, L0):\\n # Make L0 a 2d vector, along x-axis\\n L0 = np.array([L0, 0.])\\n\\n def integrand(pars):\\n lnLnorm = pars[0]\\n thetaL = pars[1]\\n lnlnorm = pars[2]\\n thetal = pars[3]\\n L = np.array([np.exp(lnLnorm) * np.cos(thetaL), np.exp(lnLnorm) * np.sin(thetaL)])\\n l = np.array([np.exp(lnlnorm) * np.cos(thetal), np.exp(lnlnorm) * np.sin(thetal)])\\n\\n # factors in common between term 1 and term 2\\n result = self.F_TT_cart(l, L0-l)\\n result *= self.F_TT_cart(l-L-L0, L-l)\\n result *= self.alpha_cart(L, l-L)\\n\\n # Term 1: L0\\n term1 = self.alpha_cart(-L, l-L0)\\n term1 *= self.CMB.funlensedTT(np.sqrt(np.sum((L0-l)**2)))\\n term1 *= fCf(np.sqrt(np.sum((l-L)**2)))\\n term1 *= fCkkf(np.sqrt(np.sum(L**2)))\\n\\n # Term 2: L0\\n term2 = self.alpha_cart(-L, L0+L-l)\\n term2 *= self.CMB.funlensedTT(np.sqrt(np.sum((l-L)**2)))\\n term2 *= fCf(np.sqrt(np.sum((l-L-L0)**2)))\\n term2 *= fCkkf(np.sqrt(np.sum(L**2)))\\n\\n # factor from symmetries\\n result *= 8. * (term1 + term2)\\n # factors of pi from Fourier convention\\n result /= (2.*np.pi)**4\\n # normalize properly for the phi quadratic estimator squared\\n result *= self.fN_phi_TT(L0[0])**2\\n # convert from phi squared to kappa squared\\n result *= (-L0[0]**2/2.)**2\\n # jacobian for polar coordinates, with log norm\\n result *= np.exp(lnLnorm)**2\\n result *= np.exp(lnlnorm)**2\\n # compensate for halving the integration domain\\n result *= 2.\\n return result\\n\\n # if first time, initialize integrator\\n if not hasattr(self.secondaryLensedForegroundBias.__func__, \\\"integ\\\"):\\n print \\\"wah\\\"\\n self.secondaryLensedForegroundBias.__func__.integ = vegas.Integrator([[np.log(1.), np.log(2.*self.CMB.lMaxT)], # L-l is limited: goes into QE\\n [0., np.pi], # keep only half the domain (symmetry)\\n [np.log(self.CMB.lMin), np.log(self.CMB.lMaxT)], # l is limited: goes into QE\\n [0., 2.*np.pi]])\\n\\n self.secondaryLensedForegroundBias.integ(integrand, nitn=10, neval=1e6) # 7h33m run: 20, 1e5\\n print \\\"hoohoo\\\"\\n result = self.secondaryLensedForegroundBias.integ(integrand, nitn=30, neval=6e6) # 7h33m run: 60, 5e5\\n print \\\"weehee\\\"\\n\\n# self.secondaryLensedForegroundBias.integ(integrand, nitn=1, neval=1e4) # 7h33m run: 20, 1e5\\n# print \\\"hoohoo\\\"\\n# result = self.secondaryLensedForegroundBias.integ(integrand, nitn=5, neval=6e4) # 7h33m run: 60, 5e5\\n# print \\\"weehee\\\"\\n\\n\\n print L0[0], result.sdev/result.mean\\n print result.summary()\\n return result.mean, result.sdev\",\n \"def cpgram(ts):\\n spectrum = np.fft.fft(ts)\\n n = len(ts)\\n y = (np.sqrt(spectrum.real**2 + spectrum.imag**2)) ** 2 / n\\n if n % 2 == 0:\\n n -= 1\\n y = y[:n]\\n\\n freq = np.linspace(0, 0.5, n, endpoint=True)\\n crit = 1.358 / (np.sqrt(n) + 0.12 + 0.11 / np.sqrt(n))\\n\\n return y, freq, crit\",\n \"def fk_ease(self, doc):\\n num_sentences = _get_num_sentences(doc)\\n num_words = _get_num_words(doc)\\n num_syllables = _get_num_syllables(doc)\\n if num_sentences == 0 or num_words == 0 or num_syllables == 0:\\n return 0\\n words_per_sent = num_words / num_sentences\\n syllables_per_word = num_syllables / num_words\\n return 206.835 - (1.015 * words_per_sent) - (84.6 * syllables_per_word)\",\n \"def lchisquare(f_obs,f_exp=None):\\r\\n k = len(f_obs) # number of groups\\r\\n if f_exp == None:\\r\\n f_exp = [sum(f_obs)/float(k)] * len(f_obs) # create k bins with = freq.\\r\\n chisq = 0\\r\\n for i in range(len(f_obs)):\\r\\n chisq = chisq + (f_obs[i]-f_exp[i])**2 / float(f_exp[i])\\r\\n return chisq, chisqprob(chisq, k-1)\",\n \"def convolution_cyclopeptide_sequence(self, spectrum, convolution_len, leaderboard_len):\\n convolution_dict = defaultdict(int)\\n for i in range(len(spectrum)):\\n for j in range(i+1, len(spectrum)):\\n diff = abs(spectrum[j] - spectrum[i])\\n if diff >= 57 and diff <= 200:\\n convolution_dict[diff] += 1\\n \\n print convolution_dict\\n # Sort the convolution spectrum find top-most entries\\n sorted_convolution_dict = sorted(convolution_dict, key= lambda a: convolution_dict[a], reverse=True)\\n convolution_list = list()\\n for i in range(min(convolution_len, len(convolution_dict))):\\n convolution_list.append(sorted_convolution_dict[i])\\n # Add ties\\n i = convolution_len\\n while i < len(sorted_convolution_dict) and convolution_dict[sorted_convolution_dict[i]] == convolution_dict[sorted_convolution_dict[i-1]]:\\n convolution_list.append(sorted_convolution_dict[i])\\n i += 1\\n \\n # Done, now run leaderboard\\n return self.leaderboard_cyclopeptide_sequence(leaderboard_len, spectrum, convolution_list)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6330933","0.60219","0.5845918","0.5628675","0.55938405","0.55922145","0.55860597","0.5574938","0.555412","0.5540551","0.5536721","0.55080277","0.5410617","0.5399693","0.5389467","0.53649914","0.52740103","0.5269019","0.5247514","0.5240202","0.52391034","0.52340364","0.52185774","0.52039444","0.5185629","0.51644313","0.5126532","0.51243097","0.51182425","0.51133204","0.51091164","0.508285","0.5069857","0.5045514","0.5034894","0.5022134","0.50151706","0.50111306","0.5008077","0.50033796","0.50031054","0.49989137","0.49961323","0.49907514","0.4990441","0.49816576","0.4978658","0.49784613","0.4965747","0.49636805","0.49535576","0.49306503","0.4924271","0.49222463","0.49139994","0.49136776","0.49086085","0.4905116","0.49013743","0.48932508","0.4885198","0.4884606","0.48844248","0.48843223","0.4882601","0.48794028","0.4872914","0.48716137","0.48700455","0.4861972","0.48586345","0.48574","0.48571652","0.48553526","0.48457935","0.48428497","0.4840191","0.48401278","0.48223132","0.4818023","0.4817362","0.48100802","0.48092383","0.48091644","0.48054817","0.48001084","0.47942862","0.4784631","0.47804436","0.47802016","0.47773656","0.4771694","0.47715244","0.47705847","0.47680166","0.47642687","0.47612768","0.4760514","0.47603726","0.4758063"],"string":"[\n \"0.6330933\",\n \"0.60219\",\n \"0.5845918\",\n \"0.5628675\",\n \"0.55938405\",\n \"0.55922145\",\n \"0.55860597\",\n \"0.5574938\",\n \"0.555412\",\n \"0.5540551\",\n \"0.5536721\",\n \"0.55080277\",\n \"0.5410617\",\n \"0.5399693\",\n \"0.5389467\",\n \"0.53649914\",\n \"0.52740103\",\n \"0.5269019\",\n \"0.5247514\",\n \"0.5240202\",\n \"0.52391034\",\n \"0.52340364\",\n \"0.52185774\",\n \"0.52039444\",\n \"0.5185629\",\n \"0.51644313\",\n \"0.5126532\",\n \"0.51243097\",\n \"0.51182425\",\n \"0.51133204\",\n \"0.51091164\",\n \"0.508285\",\n \"0.5069857\",\n \"0.5045514\",\n \"0.5034894\",\n \"0.5022134\",\n \"0.50151706\",\n \"0.50111306\",\n \"0.5008077\",\n \"0.50033796\",\n \"0.50031054\",\n \"0.49989137\",\n \"0.49961323\",\n \"0.49907514\",\n \"0.4990441\",\n \"0.49816576\",\n \"0.4978658\",\n \"0.49784613\",\n \"0.4965747\",\n \"0.49636805\",\n \"0.49535576\",\n \"0.49306503\",\n \"0.4924271\",\n \"0.49222463\",\n \"0.49139994\",\n \"0.49136776\",\n \"0.49086085\",\n \"0.4905116\",\n \"0.49013743\",\n \"0.48932508\",\n \"0.4885198\",\n \"0.4884606\",\n \"0.48844248\",\n \"0.48843223\",\n \"0.4882601\",\n \"0.48794028\",\n \"0.4872914\",\n \"0.48716137\",\n \"0.48700455\",\n \"0.4861972\",\n \"0.48586345\",\n \"0.48574\",\n \"0.48571652\",\n \"0.48553526\",\n \"0.48457935\",\n \"0.48428497\",\n \"0.4840191\",\n \"0.48401278\",\n \"0.48223132\",\n \"0.4818023\",\n \"0.4817362\",\n \"0.48100802\",\n \"0.48092383\",\n \"0.48091644\",\n \"0.48054817\",\n \"0.48001084\",\n \"0.47942862\",\n \"0.4784631\",\n \"0.47804436\",\n \"0.47802016\",\n \"0.47773656\",\n \"0.4771694\",\n \"0.47715244\",\n \"0.47705847\",\n \"0.47680166\",\n \"0.47642687\",\n \"0.47612768\",\n \"0.4760514\",\n \"0.47603726\",\n \"0.4758063\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5269137"},"document_rank":{"kind":"string","value":"17"}}},{"rowIdx":22889,"cells":{"query":{"kind":"string","value":"Extracts all the ngrams (min_order <= n <= max_order) from a sequence of tokens."},"document":{"kind":"string","value":"def extract_ngrams(line, min_order=1, max_order=BLEU.NGRAM_ORDER) -> Counter:\n\n ngrams = Counter() # type: Counter\n tokens = line.split()\n for n in range(min_order, max_order + 1):\n for i in range(0, len(tokens) - n + 1):\n ngram = ' '.join(tokens[i: i + n])\n ngrams[ngram] += 1\n\n return ngrams"},"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 n_grams(tokens, n):\n return zip(*[tokens[i:] for i in range(n)])","def build_ngrams(tokens, n=2):\n ngrams = zip(*(islice(group, idx, None) for idx, group in enumerate(tee(tokens, n))))\n return ngrams","def get_ngrams(tokens, min_n, max_n):\n all_ngrams = list()\n n_tokens = len(tokens)\n for i in range(n_tokens):\n for j in range(i + min_n, min(n_tokens, i + max_n) + 1):\n all_ngrams.append(\" \".join(tokens[i:j]))\n return all_ngrams","def ngrams(words, n=1):\n return [tuple(words[j:j + n]) for j in range(len(words) - n + 1)]","def create_ngrams(self, tokens):\n ngrams = []\n for i in range(len(tokens)- self.N + 1):\n ngrams.append(tuple(tokens[i:i+self.N]))\n return ngrams","def ngrams_(text, n):\n return zip(*[text[i:] for i in range(n)])","def n_grams(tokens, n=1):\n shiftToken = lambda i: (el for j,el in enumerate(tokens) if j>=i)\n shiftedTokens = (shiftToken(i) for i in range(n))\n tupleNGrams = zip(*shiftedTokens)\n return tupleNGrams","def get_ngrams(s, ngram_range=1):\n # tokens = s.split()\n # return filter(lambda token: len(token)>1, tokens)\n # return bigrams(s.split()) # NLTK bigrams method\n words = s.split()\n return [' '.join(words[i:i+ngram_range]) for i in range(len(words)-1)]","def find_all_ngrams(dataset, n):\n return zip(*[dataset[i:] for i in xrange(n)])","def find_ngrams(input_list, n=3):\n return zip(*[input_list[i:] for i in range(n)])","def ngrams(text, n):\n grams = zip(*[text[i:] for i in range(n)])\n return [''.join(gram) for gram in grams]","def word_ngrams(sent, n):\n\t\n\t# EXAMPLES \n\t# > word_ngrams(tokenize('hello world'), 1)\n\t# [('hello',), ('world',)]\n\t# > word_ngrams(tokenize('hello world'), 2)\n\t# [('<s>', 'hello'), ('hello', 'world'), ('world', '</s>')]\n\n\t# YOUR CODE HERE\n\ttokenized_sent = tokenize(sent)\n\tif n != 1:\n\t\ttokenized_sent.insert(0, '<s>')\n\t\ttokenized_sent.append('</s>')\n\treturn [tuple(tokenized_sent[i:i + n]) for i in range(0, len(tokenized_sent)-n+1)]","def get_ngrams(self,\n tokens,\n min_n=1,\n max_n=1):\n ## Check Inputs\n if min_n > max_n:\n raise ValueError(\"min_n must be less than max_n\")\n if min_n == 0:\n raise ValueError(\"min_n should be greater than 0\")\n ## Initialize N-Gram List\n all_ngrams = []\n ## Clean Input Tokens\n tt = \"text_tokenized\"\n cleaned_tokens = self._data_filter.filter_user_data([{tt:tokens}])\n if len(cleaned_tokens) > 0:\n cleaned_tokens = cleaned_tokens[0][tt]\n filtered_tokens = [i for i in tokens if i in self._data_filter.filter_set]\n ## Generate N-Gram Tuples\n for n in range(min_n, max_n+1):\n all_ngrams.extend(list(zip(*[cleaned_tokens[i:] for i in range(n)])))\n if len(filtered_tokens) > 0:\n all_ngrams.extend([(ft, ) for ft in filtered_tokens])\n return all_ngrams","def ngrams(text, n):\n return chain(*[ngrams_(text, i) for i in range(n + 1)])","def range_ngrams(tokens, ngramRange=(1,2)):\n return chain(*(n_grams(tokens, i) for i in range(*ngramRange)))","def get_ngrams(seq, n):\n return","def word2ngrams(text, n=3):\n return [text[i:i+n] for i in range(len(text)-n+1)]","def ngrams(iterable, n=1):\n return zip(*(iterable[i:] for i in range(n)))","def get_ngrams(s, ngmin=1, ngmax=1, tokenizer=list, separator=\"|\"):\n ngrams = [[] for x in range(ngmin, ngmax + 1)]\n s = tokenizer(s)\n for i, ch in enumerate(s):\n for ngsize in range(ngmin, ngmax + 1):\n if (i + ngsize) <= len(s):\n ngrams[ngsize - 1].append(separator.join(s[i:i+ngsize]))\n return ngrams","def extract_ngrams(line, min_order=1, max_order=NGRAM_ORDER) -> Counter:\n\n ngrams = Counter()\n tokens = line.split()\n for n in range(min_order, max_order + 1):\n for i in range(0, len(tokens) - n + 1):\n ngram = ' '.join(tokens[i: i + n])\n ngrams[ngram] += 1\n\n return ngrams","def get_all_ngrams():\n grams = ()\n for i in range(0, 40):\n text_i = read_file(str(i))\n curr_grams = ngramize(text_i, n)\n grams = chain(grams, curr_grams)\n return grams","def generate_ngrams(tokens, ngram_size, *, include_terminator = False):\n \n if ngram_size <= 0:\n raise Exception(\"ngram size must be positive\")\n\n if not include_terminator:\n for token_index in range(len(tokens)):\n leader = get_leader(tokens, token_index, ngram_size - 1)\n token = tokens[token_index]\n \n yield leader, token\n else:\n for token_index in range(len(tokens) + 1):\n leader = get_leader(tokens, token_index, ngram_size - 1)\n token = tokens[token_index] if token_index < len(tokens) else None\n\n yield leader, token","def create_ngrams(word_list, n):\n yield zip(*[word_list[i:] for i in range(n)])","def ngrams(sequence, n):\n # credit: http://stackoverflow.com/questions/2380394/simple-implementation-of-n-gram-tf-idf-and-cosine-similarity-in-python\n sequence = list(sequence)\n count = max(0, len(sequence) - n + 1)\n return [tuple(sequence[i:i+n]) for i in range(count)]","def getgrams(text, tokendict):\n n = len(text)\n grams = []\n # Get lower-case of words\n if n >= 1:\n grams.append(tokendict[text[0]].lemma.lower())\n grams.append(tokendict[text[-1]].lemma.lower())\n grams.append(tokendict[text[0]].pos)\n grams.append(tokendict[text[-1]].pos)\n if n >= 2:\n token = tokendict[text[0]].lemma.lower() \\\n + ' ' + tokendict[text[1]].lemma.lower()\n grams.append(token)\n token = tokendict[text[-2]].lemma.lower() \\\n + ' ' + tokendict[text[-1]].lemma.lower()\n grams.append(token)\n return grams","def ngrams(tokens,lang):\n stopwords = stops.stopwords[lang]\n max = len(tokens)\n ngrams = []\n left_punctuation = '!\"%&\\'()*+,-./:;<=>?[\\\\]^_`{|}~'\n\n for i in range(1,max):\n for j in xrange(0,len(tokens)-(i-1)):\n if __check_features(tokens[j:j+i],stopwords):\n ng_str = \" \".join(tokens[j:j+i])\n ng_str = (ng_str.rstrip(string.punctuation)).lstrip(left_punctuation) \n ngrams.append(ng_str)\n \n ng_str = \" \".join(tokens)\n ng_str = (ng_str.rstrip(string.punctuation)).lstrip(left_punctuation) \n ngrams.append(ng_str)\n return ngrams","def ngrams(name_string, n=3):\n\n string = re.sub(r'[,-./]|\\sBD', r'', name_string)\n n_grams = zip(*[string[i:] for i in range(n)])\n return [''.join(n_gram) for n_gram in n_grams]","def get_ngrams(sequence, n):\n length = len(sequence)\n #if only require 1-gram, then we need to add one START and one END to the sequence. \n if n==1 or n==2:\n sequence=[\"START\"]*n+sequence+[\"STOP\"]\n end = n+1 #end i means that when n==1, we need to read one more data, that is to the end of sequence, which is slightly different from when n>1.\n #if require multi-grams, use the common calculation below.\n else:\n sequence = [\"START\"]*(n-1)+sequence+[\"STOP\"]\n end = 1\n if n==2:\n end = n\n result = []\n temp = ()\n #the process to construct the tuple-based array.\n for i in range(0,length+end):\n temp = tuple(sequence[i:i+n])\n\n result.append(temp)\n return result","def iter_ngrams(self, sentence, n):\n return [tuple(sentence[i : i+n]) for i in range(len(sentence)-n+1)]","def ngrams(word, size):\n expanded = \"^\" + word + \"$\"\n for start in range(len(expanded) - size + 1):\n yield expanded[start:start + size]","def sent2ngrams(text, n=3):\n if n == \"word\":\n return text.split()\n return list(chain(*[word2ngrams(i,n) for i in text.lower().split()]))","def ngrams(word, n):\n word = list(word)\n # insert extra tokens\n word.insert(0, '$')\n word.append('$')\n\n output = []\n for i in range(len(word) - n + 1):\n # print(i)\n # print(word[i:i + n])\n output.append(''.join(word[i:i + n]))\n return output","def _create_ngrams(tokens, n):\n\n ngrams = collections.Counter()\n for ngram in (tuple(tokens[i:i + n]) for i in xrange(len(tokens) - n + 1)):\n ngrams[ngram] += 1\n return ngrams","def n_gram(list, n):\n ngrams = zip(*[list[i:] for i in range(n)])\n return [\" \".join(ngram) for ngram in ngrams]","def generate_ngrams(iterable, n):\n return zip(*[itertools.islice(it, i, None) for i, it in enumerate(itertools.tee(iterable, n))])","def n_grama(sentence, n):\n t = tokenize(sentence)\n n_grams = zip(*[t[i:] for i in range(n)])\n return list(map(lambda n_gram: ' '.join(n_gram), n_grams))","def ngramas(n, string):\n\n ngrams = []\n i = 0\n while i + n < len(string):\n ngrams.append(string[i:i + n])\n i += 1\n\n return ngrams","def get_ngrams(self, n = None):\n if not n:\n n = self.N\n\n temp = []\n for sent in self.get_sentences():\n temp.extend(list(sent))\n\n return nltk.ngrams(temp, n)","def _ngrams(self, string_):\n def find_ngrams(input_list, n):\n return zip(*[input_list[i:] for i in range(n)])\n\n ngrams = []\n tokens = string_.split()\n\n for size in range(1, self._ngram_range + 1):\n tuples = find_ngrams(tokens, size)\n concatenated = [\"_\".join(tuple_) for tuple_ in tuples]\n ngrams.extend(concatenated)\n\n return \" \".join(ngrams)","def sent_to_n_grams(sent: str, n: int) -> Iterator[Tuple[str, ...]]:\n\n words = [word for word in sent.split() if word not in string.punctuation]\n\n rows = [words[i:] for i in range(n)]\n\n return zip(*rows)","def ngramize(items: List[str], ngram_range=(1, 1)) -> Generator[List[str], Any, None]:\n\n ngrams = []\n ranges = [(0, i) for i in range(ngram_range[0], ngram_range[1] + 1)]\n for r in ranges:\n ngrams += list(zip(*[items[j:] for j in range(*r)]))\n\n formatted_ngrams = [' '.join(item) for item in ngrams]\n\n yield formatted_ngrams","def _make_ngrams(self, tokenized_corpus: list, corpus_token_index: int, n: int, make_pre_word_ngram=False):\n ngrams = []\n end_i = 0 if make_pre_word_ngram else -1\n for i in range(n - 1, end_i, -1):\n ngrams.append(tokenized_corpus[corpus_token_index - i])\n return tuple(ngrams)","def get_ngrams(stats,s,t,i):\n #lemma ngrams\n ngram_sizes = [\"bi\", \"tri\"]\n for ngram_size in ngram_sizes:\n lm_ngram = get_lemma_ngrams(s, t, i, ngram_size)\n if lm_ngram:\n put_feature_value_list(stats,\"lemma_\" + ngram_size + \"gr\", lm_ngram)\n\n #POS and deprel bigrams\n if i < s.length-1:\n put_feature_value_list(stats,\"deprels_bigr\", (t.deprel,s.nodes[i+1].deprel))\n put_feature_value_list(stats,\"pos_bigr\", (t.pos,s.nodes[i+1].pos))\n \n #POS and deprel trigrams\n if i < s.length-2:\n put_feature_value_list(stats,\"deprels_trigr\", (t.deprel, s.nodes[i+1].deprel, s.nodes[i+2].deprel))\n put_feature_value_list(stats,\"pos_trigr\", (t.pos, s.nodes[i+1].pos, s.nodes[i+2].pos))\n\n return stats","def get_all(splitted_string, word_ngram, sort_ngrams=False):\n for ngram in range(1, word_ngram + 1):\n for word_pos in range(len(splitted_string) - ngram + 1):\n if sort_ngrams:\n yield (\"_\".join(sorted(splitted_string[word_pos:word_pos + ngram])))\n else:\n yield (\"_\".join(splitted_string[word_pos:word_pos + ngram]))","def everygrams(seq):\n for n in range(1, len(seq) + 1):\n for ng in nltk.util.ngrams(seq, n):\n yield ng","def get_nnp_ngrams(original_text, highlight=4, minsize=0):\n minsize = minsize-1\n if minsize<0:\n minsize = 0 \n \n tokens = nltk.wordpunct_tokenize(original_text)\n tagged = nltk.word_tokenize(original_text)\n tagged = nltk.pos_tag(tokens)\n #for word in tagged:\n # print word\n doc_length = len(tokens)\n counter = 0\n counter2 = 0\n if highlight==0:\n concated_test = doc_length # This is set to doc_length but could be anything recommend 3.\n else:\n concated_test = highlight\n list_of_NNPs = []\n while counter < (doc_length-1):\n while counter2 < concated_test:\n counter2 = counter2+1\n counter3 = 0\n #print '--------------------'\n temp_array = []\n all_nnp = True\n while counter3 < counter2:\n if counter < (doc_length-counter3):\n #print tokens[counter+counter3],tagged[counter+counter3][1]\n temp_array.append(tokens[counter+counter3])\n if tagged[counter+counter3][1] != 'NNP':\n all_nnp = False\n counter3 = counter3+1\n counter3 = 0\n if all_nnp == True:\n if(len(temp_array)>minsize):\n list_of_NNPs.append(temp_array)\n #print 'added to main array'\n #else:\n #print 'not all NNPs'\n counter2 = 0\n counter = counter+1\n #for ngram in list_of_NNPs:\n # print ngram\n import itertools\n list_of_NNPs.sort()\n unique_NNPs = list(list_of_NNPs for list_of_NNPs,_ in itertools.groupby(list_of_NNPs))\n return unique_NNPs","def get_preds_ngram(preds, len_preds, n):\n from utils.dataProcess import get_N_gram\n\n def iter_preds(preds, len_preds):\n for len, utt in zip(len_preds, preds):\n for token in utt[:len]:\n yield token.numpy()\n ngrams = get_N_gram(iter_preds(preds, len_preds), n)\n\n return ngrams","def make_ngrams(texts,n,ngram_mod):\r\n return [turnmod(doc,n,ngram_mod) for doc in texts]","def extract_ngrams(self, sequence):\n sequence = self.prefix + sequence + self.suffix\n for i, event in enumerate(sequence[self.n:], self.n):\n yield event, sequence[i-self.n: i]","def __makeNgrams(self, n):\n # start_time = time.time()\n ngrams = dict()\n itergrams = dict()\n\n for k in range(2,n+1):\n itergrams[k] = list(nltk.ngrams(self.words, k))\n\n for k, grams in itergrams.items():\n kgrams = defaultdict(Counter)\n for gram in grams: \n kgram = list(gram)\n key = ' '.join(kgram[:k-1])\n kgrams[key].update({kgram[-1]})\n ngrams[k] = kgrams\n # print ('finish gen ', k, 'grams at ', time.time()-start_time)\n return ngrams","def extract_n_grams(string, n, overlap=0, unique=True):\n if n > len(string):\n return [] \n\n n_grams = []\n step = n - overlap\n n_grams = [string[i:i+n] for i in range(0, len(string)-step+1, step)]\n\n if unique:\n n_grams = list(set(n_grams))\n\n n_grams = [g+\"\\n\" for g in n_grams]\n\n return n_grams","def get_ngrams(sequence, n):\n\n # Set prefix and postfix\n prefix = \"START\"\n postfix = \"STOP\"\n # Append 1 prefix regardless of value of n\n sequence.insert(0, prefix)\n for i in range(n - 2) :\n sequence.insert(0, prefix)\n sequence.append(postfix)\n\n # Check if 1 <= n <= len(sequence)\n if (n > len(sequence)) :\n print(sequence)\n assert 1 <= n\n assert n <= len(sequence)\n\n # Create n-gram sequence\n n_gram_sequence = []\n for i in range(n, len(sequence) + 1) :\n temp_sequence = []\n for j in range(i - n, i) :\n temp_sequence.append(sequence[j])\n n_gram_sequence.append(tuple(temp_sequence))\n return n_gram_sequence","def ngrams(self, n=1, uncased=False, filter_fn=None, as_strings=True):\n\n def _skip(gram):\n if not filter_fn:\n return False\n return filter_fn(gram)\n\n words = self.words(True)\n ngrams = [(s, e + 1)\n for s in range(len(words))\n for e in range(s, min(s + n, len(words)))\n if not _skip(words[s:e + 1])]\n\n # Concatenate into strings\n if as_strings:\n ngrams = ['{}'.format(' '.join(words[s:e])) for (s, e) in ngrams]\n\n return ngrams","def _get_word_ngrams(n, sentences):\n assert len(sentences) > 0\n assert n > 0\n\n words = split_into_words(sentences)\n return _get_ngrams(n, words)","def get_grams(candidate, n):\n words = candidate.split(' ')\n # print(words)\n grams = list()\n for i in range(len(words) - n + 1):\n # print(words[i:i+n])\n grams.append(' '.join(words[i:i+n]))\n return grams","def _generateNgrams(self,text,n=2):\n token = Utilities.CVTokeniser(text)\n # token = nltk.word_tokenize(text)\n computedNgrams=ngrams(token,n)\n return Counter(computedNgrams)","def ngrams(self, words):\n if words[0] in self._locs:\n for loc in self._locs[words[0]]:\n ngram = NGram.from_loc(len(words), loc)\n if ngram.words == words:\n yield ngram","def generate_ngram(corpus,n=2):\r\n def generate_ngram_str(text,n):\r\n text = tokenizer.tokenize(text)\r\n for i in range(0, len(text)-n+1):\r\n yield text[i:i+n]\r\n if isinstance(corpus,str):\r\n for ngram in generate_ngram_str(corpus,n):\r\n yield ngram\r\n elif isinstance(corpus, (list, types.GeneratorType)):\r\n for text in corpus:\r\n for ngram in generate_ngram_str(text,n):\r\n yield ngram","def _get_word_ngrams(n, sentences):\n assert len(sentences) > 0\n assert n > 0\n\n # words = _split_into_words(sentences)\n\n words = sum(sentences, [])\n # words = [w for w in words if w not in stopwords]\n return _get_ngrams(n, words)","def _get_word_ngrams(n, sentences):\n assert len(sentences) > 0\n assert n > 0\n\n # words = _split_into_words(sentences)\n\n words = sum(sentences, [])\n # words = [w for w in words if w not in stopwords]\n return _get_ngrams(n, words)","def _get_word_ngrams(n, sentences):\n assert len(sentences) > 0\n assert n > 0\n\n words = _split_into_words(sentences)\n return _get_ngrams(n, words)","def _get_word_ngrams(n, sentences):\n assert len(sentences) > 0\n assert n > 0\n\n words = _split_into_words(sentences)\n return _get_ngrams(n, words)","def _get_word_ngrams(n, sentences):\n assert len(sentences) > 0\n assert n > 0\n\n words = _split_into_words(sentences)\n return _get_ngrams(n, words)","def ngrams(self, n=1, uncased=False, filter_fn=None, as_strings=True):\n def _skip(gram):\n if not filter_fn:\n return False\n return filter_fn(gram)\n\n words = self.words(uncased)\n ngrams = [(s, e + 1)\n for s in range(len(words))\n for e in range(s, min(s + n, len(words)))\n if not _skip(words[s:e + 1])]\n\n # Concatenate into strings\n if as_strings:\n ngrams = ['{}'.format(' '.join(words[s:e])) for (s, e) in ngrams]\n\n return ngrams","def get_ngrams(sequence, n):\n # Example: n = 3, length = 4\n # we want 0:3, 1:4\n\n result = []\n if n == 1:\n result.append(tuple([\"START\"]))\n result.append(tuple([\"STOP\"]))\n\n if n == 3 and len(sequence) == 1:\n result.append(tuple([\"START\",\"START\",sequence[0]]))\n result.append(tuple([\"START\",sequence[0],\"STOP\"]))\n return result\n\n if n > 1 :\n for i in range(n-1):\n result.append(tuple([\"START\"]*(n-1-i)+ sequence[:i+1]))\n result.append(tuple(sequence[-n+1:] + [\"STOP\"]))\n\n for i in range(len(sequence)-n+1):\n result.append(tuple(sequence[i:i+n]))\n return result","def ngram(_input: List[str], N: int, skip: Optional[int] = None,\n delim: str = ' ', skip_delim: str = '_') -> List[str]:\n max_len = len(_input)\n # Delimiter must be a string\n # assert isinstance(delim, basestring)\n # assert isinstance(skip_delim, basestring)\n\n ngram_tokens = []\n\n for start in range(max_len):\n for n in range(1, min(N+1, max_len+1)):\n end = start + n\n if end > max_len:\n break\n ngram_tokens.append(delim.join(_input[start:end]))\n\n if skip:\n skipped = skip_delim.join(_input[start:end:(skip+1)])\n # if skipped not in ngram_tokens:\n ngram_tokens.append(skipped)\n\n return ngram_tokens","def words_to_ngrams(words, max_order):\n d = defaultdict(int)\n\n # Iterate over word indices as start pointers\n for i in range(len(words)):\n # Sliding windows\n for j in range(min(max_order, len(words) - i)):\n # Increment counter, keep keys as tuples\n d[tuple(words[i: i+j+1])] += 1\n\n return d","def transform_ngrams(self, words):\n return words if self.n_grams == 1 else [self.connector.join(words[i:i + self.n_grams]) for i in range(len(words) - self.n_grams + 1)]","def ngrams(self):\n return self.__ngrams(())","def get_lemma_ngrams(s, t, i, ngram_size):\n ngrams = {\"uni\":1, \"bi\":2, \"tri\":3}\n if i < s.length-(ngrams[ngram_size]-1):\n lemma_ngrams = []\n for j in range(ngrams[ngram_size]):\n if s.nodes[i+j].lemma:\n lemma_ngrams.append(s.nodes[i+j].lemma[0]) #only keeps the first lemma\n else:\n lemma_ngrams.append(s.nodes[i+j].word + \"*\") #no lemma, word form* instead\n if len(lemma_ngrams) > 1:\n return tuple(lemma_ngrams)\n return lemma_ngrams[0] #or better to keep them all?\n else:\n return []","def _get_ngrams(segments, order):\n ngram_counts = collections.Counter()\n for seg in segments:\n for i in range(0, len(seg) - order + 1):\n ngram = tuple(seg[i:i+order])\n ngram_counts[ngram] += 1\n return ngram_counts","def ngrams(doc, n, filter_stopwords=True, good_tags={'NOUN', 'PROPN', 'ADJ'}):\n ngrams_ = (doc[i:i + n] for i in range(len(doc) - n + 1))\n ngrams_ = (ngram for ngram in ngrams_\n if not any(w.is_space or w.is_punct for w in ngram))\n\n if filter_stopwords:\n ngrams_ = (ngram for ngram in ngrams_\n if not any(w.is_stop for w in ngram))\n if good_tags:\n ngrams_ = (ngram for ngram in ngrams_\n if all(w.pos_ in good_tags for w in ngram))\n\n for ngram in ngrams_:\n yield ngram","def add_ngram(sequences, token_indice, ngram_range=2):\n new_sequences = []\n for input_list in sequences:\n new_list = input_list[:]\n for ngram_value in range(2, ngram_range + 1):\n for i in range(len(new_list) - ngram_value + 1):\n ngram = tuple(new_list[i:i + ngram_value])\n if ngram in token_indice:\n new_list.append(token_indice[ngram])\n new_sequences.append(new_list)\n\n return new_sequences","def ngrams(self):\n return self.root.ngrams()","def add_ngram(sequences, token_indice, ngram_range=2):\n new_sequences = []\n for input_list in sequences:\n new_list = input_list[:]\n for i in range(len(new_list) - ngram_range + 1):\n for ngram_value in range(2, ngram_range + 1):\n ngram = tuple(new_list[i:i + ngram_value])\n if ngram in token_indice:\n new_list.append(token_indice[ngram])\n new_sequences.append(new_list)\n\n return new_sequences","def full_ngrams(items, n):\n ngs = {}\n for i in xrange(1, n+1):\n ngs.update(gen_ngrams(items, i))\n return ngs","def add_ngram(sequences, token_indice, ngram_range=2):\n new_sequences = []\n for input_list in sequences:\n new_list = input_list[:]\n for ngram_value in range(2, ngram_range + 1):\n for i in range(len(new_list) - ngram_value + 1):\n ngram = tuple(new_list[i:i + ngram_value])\n if ngram in token_indice:\n new_list.append(token_indice[ngram])\n new_sequences.append(new_list)\n\n return new_sequences","def create_ngram_set(input_list, ngram_value=2):\n return set(zip(*[input_list[i:] for i in range(ngram_value)]))","def ngrammer(text, gramsize = 3, threshold = 4):\n # we need to import this in order to find the duplicates:\n import nltk\n from nltk.util import ngrams\n from collections import defaultdict\n # get ngrams of gramsize \n if type(text) != list:\n text = tokenised = nltk.word_tokenize(text)\n text = [token for token in text if token.isalnum()]\n # get ngrams of gramsize \n raw_grams = ngrams(text, gramsize)\n \n # a subdefinition to get duplicate lists in a list\n def list_duplicates(seq):\n tally = defaultdict(list)\n for i,item in enumerate(seq):\n tally[item].append(i)\n # return to us the index and the ngram itself:\n return ((len(locs),key) for key,locs in tally.items() \n if len(locs) > threshold)\n\n # use our duplication detector to find duplicates\n dupes = list_duplicates(raw_grams)\n # return them, sorted by most frequent\n return sorted(dupes, reverse = True)","def prepare_tokens(self, tokens: Iterator[Token]) -> List[str]:\n\n\t\tif self.ignore_punctuation:\n\t\t\ttokens = filter(lambda t: t.value not in self.PUNCTUATION, tokens)\n\n\t\tif self.uses_lemma:\n\t\t\ttoken_values = map(lambda t: t.lemma, tokens)\n\t\telse:\n\t\t\ttoken_values = map(lambda t: t.value, tokens)\n\n\t\tif self.caseless:\n\t\t\ttoken_values = map(lambda v: v.lower(), token_values)\n\n\t\tif self.add_pos_tags:\n\t\t\ttoken_values = map(lambda x: \"_\".join(x), zip(token_values, map(lambda t: t.pos, tokens)))\n\n\t\tn_gram_values = self.build_n_grams(tokens=list(token_values), n_gram_size=self.n_gram_size)\n\n\t\treturn n_gram_values","def compute_ngrams(str, n=2):\n #split the string\n st = tuple(str.split())\n #not list of list but list of tuple..\n gram = [st[x:x+n] for x in range(len(st)-n+1)]\n dgram = {}\n #convert ngram into dictionary:\n for key in gram:\n dgram.setdefault(key[0],[]).append(key[1:])\n return dgram","def filter_pos(self):\n all_tokens = []\n for zettel in self.lemma_tokens:\n tokens = []\n for word in zettel:\n if word[1] in ['NN', 'NNS', 'NNP', 'NNPS', 'NG']: # NG = n_gram\n tokens.append(word)\n all_tokens.append(tokens)\n self.lemma_tokens = all_tokens","def gen_ngrams(items, n):\n ngs = {}\n ilen = len(items)\n for i in xrange(ilen-n+1):\n ng = tuple(items[i:i+n])\n ngs[ng] = ngs.get(ng, 0) + 1\n return ngs","def precook(s, n=4, out=False):\n words = s.split()\n counts = defaultdict(int)\n for k in xrange(1,n+1):\n for i in xrange(len(words)-k+1):\n ngram = tuple(words[i:i+k])\n counts[ngram] += 1\n return counts","def create_ngram_set(input_list, ngram_value=2):\n return set(zip(*[input_list[i:] for i in range(ngram_value)]))","def ngramify(word: str,\n max_ngram_size: int):\n chars = list(word)\n ngram_tuples = []\n ngrams = []\n # Take all n-grams with length in [2, max_ngram_size]\n for i in range(2, max_ngram_size + 1):\n pw = list(pairwise(chars, i))\n ngram_tuples += pw\n for e in ngram_tuples:\n if None not in e:\n ngrams.append(''.join(e))\n # Append the list of characters, to avoid an unnecessary call for pairwise(_, 1).\n return list(word) + ngrams","def get_ngramlogprobs_fromcorpus(tokenizedseqs, n):\n return","def get_ngrams(self, s, ngmin, ngmax, separator=\"\",\n bos=\"<\", eos=\">\", suffix=\"\", flatten=True):\n\n # return a single dummy feature if there are no applicable ngrams\n # probably resulting in a mojority-class classifier\n if ngmax == 0 or (ngmax - ngmin < 0) :\n return ['__dummy__']\n\n ngrams = [[] for x in range(1, ngmax + 1)]\n s = [bos] + s + [eos]\n for i, ch in enumerate(s):\n for ngsize in range(ngmin, ngmax + 1):\n if (i + ngsize) <= len(s):\n ngrams[ngsize - 1].append(\n separator.join(s[i:i+ngsize]) + suffix)\n if flatten:\n ngrams = [ng for nglist in ngrams for ng in nglist]\n return ngrams","def build_ngram_vocab(self, n):\n max_ngram_per_word = 0\n ngram_dict = collections.defaultdict(int)\n for word in self.train_data:\n if word == self.eos or word == self.sos:\n continue\n _word = '^' + word + '$'\n ngram_counts = len(_word) - n + 1\n if ngram_counts > max_ngram_per_word:\n max_ngram_per_word = ngram_counts\n for i in range(ngram_counts):\n ngram = _word[i:i + n]\n ngram_dict[ngram] += 1\n\n unk_ngram_list = set()\n item_to_id = dict()\n item_to_id[constants.PAD_ITEM] = len(item_to_id)\n item_to_id[constants.UNK_ITEM] = len(item_to_id)\n sorted_dict = sorted(ngram_dict.items(), key=operator.itemgetter(1), reverse=True)\n for token, freq in sorted_dict:\n if freq == 1:\n unk_ngram_list.add(token)\n if token not in item_to_id:\n item_to_id[token] = len(item_to_id)\n return item_to_id, unk_ngram_list, max_ngram_per_word","def n_gram(data, headers, cat_labels, num_labels):\n\t\tn_grammed = []\n\n\t\tfor i, tok in enumerate(data):\n\t\t\tif i == 0:\n\t\t\t\tn_grammed.append(data[-1]+tok+data[i+1])\n\t\t\telif i == len(data) - 1:\n\t\t\t\tn_grammed.append(data[i-1]+tok+data[0])\n\t\t\telse:\n\t\t\t\tn_grammed.append(data[i-1]+tok+data[i+1])\n\n\t\tn_grammed_headers = [header + \"_min1\" for header in headers] + headers + [header + \"_pls1\" for header in headers]\n\t\tn_grammed_cat_labels = [lab + \"_min1\" for lab in cat_labels] + cat_labels + [lab + \"_pls1\" for lab in cat_labels]\n\t\tn_grammed_num_labels = [lab + \"_min1\" for lab in num_labels] + num_labels + [lab + \"_pls1\" for lab in num_labels]\n\n\t\treturn n_grammed, n_grammed_headers, n_grammed_cat_labels, n_grammed_num_labels","def _get_bag_of_pos_ngram(words, index, window_size, N):\n bos = DummyWord(pos=utils.BEGIN_OF_SENTENCE, upos=utils.BEGIN_OF_SENTENCE, dependency_relation=utils.BEGIN_OF_SENTENCE)\n eos = DummyWord(pos=utils.END_OF_SENTENCE, upos=utils.END_OF_SENTENCE, dependency_relation=utils.END_OF_SENTENCE)\n words = [bos] * (window_size + N) + words + [eos] * (window_size + N)\n index += (window_size + N)\n return [\n \"_\".join([_get_word_feature(w) for w in words[i:i+N]])\n for i in range(index-window_size, index+window_size+1)]","def get_terms(corpus, n=4000):\n\n stop = StopLexicon()\n scrabble = ScrabbleLexicon()\n\n ngrams = defaultdict(set)\n citations = defaultdict(set)\n\n for doc in corpus:\n for ng in get_ngrams([doc.title]):\n if good_ngram(ng, scrabble, stop):\n ngrams[ng].add(doc.id)\n for ref in doc.references:\n citations[doc.id].add(ref)\n citations[ref].add(doc.id)\n\n ngrams = filter_plurals(ngrams)\n\n ngram_counts = {x: len(ngrams[x]) for x in ngrams}\n filtered = filter_subsumed(ngram_counts)\n\n if citations:\n ngrams = score_ngrams(ngrams, citations)\n ngrams = filter_subsumed(ngrams)\n return [' '.join(x) for x in sorted(ngrams, key=lambda x: ngrams[x],\n reverse=True) if x in filtered][:n]\n else:\n return [' '.join(x) for x in sorted(filtered, key=lambda x: filtered[x],\n reverse=True)][:n]","def filter_n_grams(self, n_grams, min_freq, n):\n all_n_grams = []\n for zettel in n_grams:\n cur_n_grams = []\n for gram in zettel:\n if zettel.count(gram) >= min_freq:\n if gram not in cur_n_grams:\n cur_n_grams.append(gram)\n all_n_grams.append(cur_n_grams)\n self.swap_n_grams(all_n_grams, n)","def ngramify(corpus, n):\r\n unlist = 0\r\n if type(corpus[0]) is not list:\r\n corpus = [corpus]\r\n unlist = 1\r\n new_corpus = []\r\n for line in corpus:\r\n new_line = []\r\n for gram in range(len(line) - n + 1):\r\n new_gram = \"\"\r\n for i in range(n):\r\n if i != 0:\r\n new_gram += \" \"\r\n new_gram += line[gram + i]\r\n new_line.append(new_gram)\r\n new_corpus.append(new_line)\r\n if unlist:\r\n return new_corpus[0]\r\n return new_corpus","def make_ngrams_and_pre_word_ngrams(self, tokenized_corpus: list, n: int):\n ngrams_and_pre_words = {}\n first_word_i = n - 1\n end_i = len(tokenized_corpus) - 1\n for i in range(first_word_i, end_i):\n if i - (n - 1) < 0:\n continue\n pre_words_ngrams = self._make_ngrams(tokenized_corpus, i, n, make_pre_word_ngram=True)\n current_token = (tokenized_corpus[i],)\n ngrams = pre_words_ngrams + current_token\n if self.TOKENS.END.value in ngrams:\n continue\n else:\n ngrams_and_pre_words[ngrams] = tuple(pre_words_ngrams)\n return ngrams_and_pre_words","def ngram_search(words, n=2):\n N = len(words)\n # Queries are the first 1 to N words\n queries = [' '.join(words[i:i + n]) for i in range(N - n + 1)]\n # Create multiple threads to parallelize querying\n p = Pool(4)\n results = p.map(search_tracks, queries)\n p.close()\n p.join()\n # Merge results and sort in popularity order (descending) to ensure that\n # more popular songs are selected for play lists\n merged = reduce(list.__add__, results)\n songs = sorted(merged, key=lambda x: x.Popularity, reverse=True)\n return songs","def add_ngram(self, sequences, token_indice, ngram_range=2):\n new_sequences = []\n for input_list in sequences:\n new_list = input_list[:]\n for ngram_value in range(2, ngram_range + 1):\n for i in range(len(new_list) - ngram_value + 1):\n ngram = tuple(new_list[i:i + ngram_value])\n if ngram in token_indice:\n new_list.append(token_indice[ngram])\n new_sequences.append(new_list)\n\n return new_sequences","def n_grammize(role):\n ngrams = []\n if isinstance(role,str):\n role = role.lower()\n role = role.split()\n if len(role)>2:\n for i in range(2, len(role)):\n ngrams.append((role[i-2], role[i-1], role[i]))\n if len(role)>1:\n for i in range(1, len(role)):\n ngrams.append((role[i-1], role[i]))\n for i in range(len(role)):\n ngrams.append(role[i])\n return ngrams","def ngrams(n, target):\n chars = collections.deque()\n while True:\n chars.append((yield))\n if len(chars) == n: \n target.send(chars)\n chars.popleft()","def get_bigrams(self, tokens):\n return [a + \" \" + b for a, b in zip(tokens, tokens[1:])]"],"string":"[\n \"def n_grams(tokens, n):\\n return zip(*[tokens[i:] for i in range(n)])\",\n \"def build_ngrams(tokens, n=2):\\n ngrams = zip(*(islice(group, idx, None) for idx, group in enumerate(tee(tokens, n))))\\n return ngrams\",\n \"def get_ngrams(tokens, min_n, max_n):\\n all_ngrams = list()\\n n_tokens = len(tokens)\\n for i in range(n_tokens):\\n for j in range(i + min_n, min(n_tokens, i + max_n) + 1):\\n all_ngrams.append(\\\" \\\".join(tokens[i:j]))\\n return all_ngrams\",\n \"def ngrams(words, n=1):\\n return [tuple(words[j:j + n]) for j in range(len(words) - n + 1)]\",\n \"def create_ngrams(self, tokens):\\n ngrams = []\\n for i in range(len(tokens)- self.N + 1):\\n ngrams.append(tuple(tokens[i:i+self.N]))\\n return ngrams\",\n \"def ngrams_(text, n):\\n return zip(*[text[i:] for i in range(n)])\",\n \"def n_grams(tokens, n=1):\\n shiftToken = lambda i: (el for j,el in enumerate(tokens) if j>=i)\\n shiftedTokens = (shiftToken(i) for i in range(n))\\n tupleNGrams = zip(*shiftedTokens)\\n return tupleNGrams\",\n \"def get_ngrams(s, ngram_range=1):\\n # tokens = s.split()\\n # return filter(lambda token: len(token)>1, tokens)\\n # return bigrams(s.split()) # NLTK bigrams method\\n words = s.split()\\n return [' '.join(words[i:i+ngram_range]) for i in range(len(words)-1)]\",\n \"def find_all_ngrams(dataset, n):\\n return zip(*[dataset[i:] for i in xrange(n)])\",\n \"def find_ngrams(input_list, n=3):\\n return zip(*[input_list[i:] for i in range(n)])\",\n \"def ngrams(text, n):\\n grams = zip(*[text[i:] for i in range(n)])\\n return [''.join(gram) for gram in grams]\",\n \"def word_ngrams(sent, n):\\n\\t\\n\\t# EXAMPLES \\n\\t# > word_ngrams(tokenize('hello world'), 1)\\n\\t# [('hello',), ('world',)]\\n\\t# > word_ngrams(tokenize('hello world'), 2)\\n\\t# [('<s>', 'hello'), ('hello', 'world'), ('world', '</s>')]\\n\\n\\t# YOUR CODE HERE\\n\\ttokenized_sent = tokenize(sent)\\n\\tif n != 1:\\n\\t\\ttokenized_sent.insert(0, '<s>')\\n\\t\\ttokenized_sent.append('</s>')\\n\\treturn [tuple(tokenized_sent[i:i + n]) for i in range(0, len(tokenized_sent)-n+1)]\",\n \"def get_ngrams(self,\\n tokens,\\n min_n=1,\\n max_n=1):\\n ## Check Inputs\\n if min_n > max_n:\\n raise ValueError(\\\"min_n must be less than max_n\\\")\\n if min_n == 0:\\n raise ValueError(\\\"min_n should be greater than 0\\\")\\n ## Initialize N-Gram List\\n all_ngrams = []\\n ## Clean Input Tokens\\n tt = \\\"text_tokenized\\\"\\n cleaned_tokens = self._data_filter.filter_user_data([{tt:tokens}])\\n if len(cleaned_tokens) > 0:\\n cleaned_tokens = cleaned_tokens[0][tt]\\n filtered_tokens = [i for i in tokens if i in self._data_filter.filter_set]\\n ## Generate N-Gram Tuples\\n for n in range(min_n, max_n+1):\\n all_ngrams.extend(list(zip(*[cleaned_tokens[i:] for i in range(n)])))\\n if len(filtered_tokens) > 0:\\n all_ngrams.extend([(ft, ) for ft in filtered_tokens])\\n return all_ngrams\",\n \"def ngrams(text, n):\\n return chain(*[ngrams_(text, i) for i in range(n + 1)])\",\n \"def range_ngrams(tokens, ngramRange=(1,2)):\\n return chain(*(n_grams(tokens, i) for i in range(*ngramRange)))\",\n \"def get_ngrams(seq, n):\\n return\",\n \"def word2ngrams(text, n=3):\\n return [text[i:i+n] for i in range(len(text)-n+1)]\",\n \"def ngrams(iterable, n=1):\\n return zip(*(iterable[i:] for i in range(n)))\",\n \"def get_ngrams(s, ngmin=1, ngmax=1, tokenizer=list, separator=\\\"|\\\"):\\n ngrams = [[] for x in range(ngmin, ngmax + 1)]\\n s = tokenizer(s)\\n for i, ch in enumerate(s):\\n for ngsize in range(ngmin, ngmax + 1):\\n if (i + ngsize) <= len(s):\\n ngrams[ngsize - 1].append(separator.join(s[i:i+ngsize]))\\n return ngrams\",\n \"def extract_ngrams(line, min_order=1, max_order=NGRAM_ORDER) -> Counter:\\n\\n ngrams = Counter()\\n tokens = line.split()\\n for n in range(min_order, max_order + 1):\\n for i in range(0, len(tokens) - n + 1):\\n ngram = ' '.join(tokens[i: i + n])\\n ngrams[ngram] += 1\\n\\n return ngrams\",\n \"def get_all_ngrams():\\n grams = ()\\n for i in range(0, 40):\\n text_i = read_file(str(i))\\n curr_grams = ngramize(text_i, n)\\n grams = chain(grams, curr_grams)\\n return grams\",\n \"def generate_ngrams(tokens, ngram_size, *, include_terminator = False):\\n \\n if ngram_size <= 0:\\n raise Exception(\\\"ngram size must be positive\\\")\\n\\n if not include_terminator:\\n for token_index in range(len(tokens)):\\n leader = get_leader(tokens, token_index, ngram_size - 1)\\n token = tokens[token_index]\\n \\n yield leader, token\\n else:\\n for token_index in range(len(tokens) + 1):\\n leader = get_leader(tokens, token_index, ngram_size - 1)\\n token = tokens[token_index] if token_index < len(tokens) else None\\n\\n yield leader, token\",\n \"def create_ngrams(word_list, n):\\n yield zip(*[word_list[i:] for i in range(n)])\",\n \"def ngrams(sequence, n):\\n # credit: http://stackoverflow.com/questions/2380394/simple-implementation-of-n-gram-tf-idf-and-cosine-similarity-in-python\\n sequence = list(sequence)\\n count = max(0, len(sequence) - n + 1)\\n return [tuple(sequence[i:i+n]) for i in range(count)]\",\n \"def getgrams(text, tokendict):\\n n = len(text)\\n grams = []\\n # Get lower-case of words\\n if n >= 1:\\n grams.append(tokendict[text[0]].lemma.lower())\\n grams.append(tokendict[text[-1]].lemma.lower())\\n grams.append(tokendict[text[0]].pos)\\n grams.append(tokendict[text[-1]].pos)\\n if n >= 2:\\n token = tokendict[text[0]].lemma.lower() \\\\\\n + ' ' + tokendict[text[1]].lemma.lower()\\n grams.append(token)\\n token = tokendict[text[-2]].lemma.lower() \\\\\\n + ' ' + tokendict[text[-1]].lemma.lower()\\n grams.append(token)\\n return grams\",\n \"def ngrams(tokens,lang):\\n stopwords = stops.stopwords[lang]\\n max = len(tokens)\\n ngrams = []\\n left_punctuation = '!\\\"%&\\\\'()*+,-./:;<=>?[\\\\\\\\]^_`{|}~'\\n\\n for i in range(1,max):\\n for j in xrange(0,len(tokens)-(i-1)):\\n if __check_features(tokens[j:j+i],stopwords):\\n ng_str = \\\" \\\".join(tokens[j:j+i])\\n ng_str = (ng_str.rstrip(string.punctuation)).lstrip(left_punctuation) \\n ngrams.append(ng_str)\\n \\n ng_str = \\\" \\\".join(tokens)\\n ng_str = (ng_str.rstrip(string.punctuation)).lstrip(left_punctuation) \\n ngrams.append(ng_str)\\n return ngrams\",\n \"def ngrams(name_string, n=3):\\n\\n string = re.sub(r'[,-./]|\\\\sBD', r'', name_string)\\n n_grams = zip(*[string[i:] for i in range(n)])\\n return [''.join(n_gram) for n_gram in n_grams]\",\n \"def get_ngrams(sequence, n):\\n length = len(sequence)\\n #if only require 1-gram, then we need to add one START and one END to the sequence. \\n if n==1 or n==2:\\n sequence=[\\\"START\\\"]*n+sequence+[\\\"STOP\\\"]\\n end = n+1 #end i means that when n==1, we need to read one more data, that is to the end of sequence, which is slightly different from when n>1.\\n #if require multi-grams, use the common calculation below.\\n else:\\n sequence = [\\\"START\\\"]*(n-1)+sequence+[\\\"STOP\\\"]\\n end = 1\\n if n==2:\\n end = n\\n result = []\\n temp = ()\\n #the process to construct the tuple-based array.\\n for i in range(0,length+end):\\n temp = tuple(sequence[i:i+n])\\n\\n result.append(temp)\\n return result\",\n \"def iter_ngrams(self, sentence, n):\\n return [tuple(sentence[i : i+n]) for i in range(len(sentence)-n+1)]\",\n \"def ngrams(word, size):\\n expanded = \\\"^\\\" + word + \\\"$\\\"\\n for start in range(len(expanded) - size + 1):\\n yield expanded[start:start + size]\",\n \"def sent2ngrams(text, n=3):\\n if n == \\\"word\\\":\\n return text.split()\\n return list(chain(*[word2ngrams(i,n) for i in text.lower().split()]))\",\n \"def ngrams(word, n):\\n word = list(word)\\n # insert extra tokens\\n word.insert(0, '$')\\n word.append('$')\\n\\n output = []\\n for i in range(len(word) - n + 1):\\n # print(i)\\n # print(word[i:i + n])\\n output.append(''.join(word[i:i + n]))\\n return output\",\n \"def _create_ngrams(tokens, n):\\n\\n ngrams = collections.Counter()\\n for ngram in (tuple(tokens[i:i + n]) for i in xrange(len(tokens) - n + 1)):\\n ngrams[ngram] += 1\\n return ngrams\",\n \"def n_gram(list, n):\\n ngrams = zip(*[list[i:] for i in range(n)])\\n return [\\\" \\\".join(ngram) for ngram in ngrams]\",\n \"def generate_ngrams(iterable, n):\\n return zip(*[itertools.islice(it, i, None) for i, it in enumerate(itertools.tee(iterable, n))])\",\n \"def n_grama(sentence, n):\\n t = tokenize(sentence)\\n n_grams = zip(*[t[i:] for i in range(n)])\\n return list(map(lambda n_gram: ' '.join(n_gram), n_grams))\",\n \"def ngramas(n, string):\\n\\n ngrams = []\\n i = 0\\n while i + n < len(string):\\n ngrams.append(string[i:i + n])\\n i += 1\\n\\n return ngrams\",\n \"def get_ngrams(self, n = None):\\n if not n:\\n n = self.N\\n\\n temp = []\\n for sent in self.get_sentences():\\n temp.extend(list(sent))\\n\\n return nltk.ngrams(temp, n)\",\n \"def _ngrams(self, string_):\\n def find_ngrams(input_list, n):\\n return zip(*[input_list[i:] for i in range(n)])\\n\\n ngrams = []\\n tokens = string_.split()\\n\\n for size in range(1, self._ngram_range + 1):\\n tuples = find_ngrams(tokens, size)\\n concatenated = [\\\"_\\\".join(tuple_) for tuple_ in tuples]\\n ngrams.extend(concatenated)\\n\\n return \\\" \\\".join(ngrams)\",\n \"def sent_to_n_grams(sent: str, n: int) -> Iterator[Tuple[str, ...]]:\\n\\n words = [word for word in sent.split() if word not in string.punctuation]\\n\\n rows = [words[i:] for i in range(n)]\\n\\n return zip(*rows)\",\n \"def ngramize(items: List[str], ngram_range=(1, 1)) -> Generator[List[str], Any, None]:\\n\\n ngrams = []\\n ranges = [(0, i) for i in range(ngram_range[0], ngram_range[1] + 1)]\\n for r in ranges:\\n ngrams += list(zip(*[items[j:] for j in range(*r)]))\\n\\n formatted_ngrams = [' '.join(item) for item in ngrams]\\n\\n yield formatted_ngrams\",\n \"def _make_ngrams(self, tokenized_corpus: list, corpus_token_index: int, n: int, make_pre_word_ngram=False):\\n ngrams = []\\n end_i = 0 if make_pre_word_ngram else -1\\n for i in range(n - 1, end_i, -1):\\n ngrams.append(tokenized_corpus[corpus_token_index - i])\\n return tuple(ngrams)\",\n \"def get_ngrams(stats,s,t,i):\\n #lemma ngrams\\n ngram_sizes = [\\\"bi\\\", \\\"tri\\\"]\\n for ngram_size in ngram_sizes:\\n lm_ngram = get_lemma_ngrams(s, t, i, ngram_size)\\n if lm_ngram:\\n put_feature_value_list(stats,\\\"lemma_\\\" + ngram_size + \\\"gr\\\", lm_ngram)\\n\\n #POS and deprel bigrams\\n if i < s.length-1:\\n put_feature_value_list(stats,\\\"deprels_bigr\\\", (t.deprel,s.nodes[i+1].deprel))\\n put_feature_value_list(stats,\\\"pos_bigr\\\", (t.pos,s.nodes[i+1].pos))\\n \\n #POS and deprel trigrams\\n if i < s.length-2:\\n put_feature_value_list(stats,\\\"deprels_trigr\\\", (t.deprel, s.nodes[i+1].deprel, s.nodes[i+2].deprel))\\n put_feature_value_list(stats,\\\"pos_trigr\\\", (t.pos, s.nodes[i+1].pos, s.nodes[i+2].pos))\\n\\n return stats\",\n \"def get_all(splitted_string, word_ngram, sort_ngrams=False):\\n for ngram in range(1, word_ngram + 1):\\n for word_pos in range(len(splitted_string) - ngram + 1):\\n if sort_ngrams:\\n yield (\\\"_\\\".join(sorted(splitted_string[word_pos:word_pos + ngram])))\\n else:\\n yield (\\\"_\\\".join(splitted_string[word_pos:word_pos + ngram]))\",\n \"def everygrams(seq):\\n for n in range(1, len(seq) + 1):\\n for ng in nltk.util.ngrams(seq, n):\\n yield ng\",\n \"def get_nnp_ngrams(original_text, highlight=4, minsize=0):\\n minsize = minsize-1\\n if minsize<0:\\n minsize = 0 \\n \\n tokens = nltk.wordpunct_tokenize(original_text)\\n tagged = nltk.word_tokenize(original_text)\\n tagged = nltk.pos_tag(tokens)\\n #for word in tagged:\\n # print word\\n doc_length = len(tokens)\\n counter = 0\\n counter2 = 0\\n if highlight==0:\\n concated_test = doc_length # This is set to doc_length but could be anything recommend 3.\\n else:\\n concated_test = highlight\\n list_of_NNPs = []\\n while counter < (doc_length-1):\\n while counter2 < concated_test:\\n counter2 = counter2+1\\n counter3 = 0\\n #print '--------------------'\\n temp_array = []\\n all_nnp = True\\n while counter3 < counter2:\\n if counter < (doc_length-counter3):\\n #print tokens[counter+counter3],tagged[counter+counter3][1]\\n temp_array.append(tokens[counter+counter3])\\n if tagged[counter+counter3][1] != 'NNP':\\n all_nnp = False\\n counter3 = counter3+1\\n counter3 = 0\\n if all_nnp == True:\\n if(len(temp_array)>minsize):\\n list_of_NNPs.append(temp_array)\\n #print 'added to main array'\\n #else:\\n #print 'not all NNPs'\\n counter2 = 0\\n counter = counter+1\\n #for ngram in list_of_NNPs:\\n # print ngram\\n import itertools\\n list_of_NNPs.sort()\\n unique_NNPs = list(list_of_NNPs for list_of_NNPs,_ in itertools.groupby(list_of_NNPs))\\n return unique_NNPs\",\n \"def get_preds_ngram(preds, len_preds, n):\\n from utils.dataProcess import get_N_gram\\n\\n def iter_preds(preds, len_preds):\\n for len, utt in zip(len_preds, preds):\\n for token in utt[:len]:\\n yield token.numpy()\\n ngrams = get_N_gram(iter_preds(preds, len_preds), n)\\n\\n return ngrams\",\n \"def make_ngrams(texts,n,ngram_mod):\\r\\n return [turnmod(doc,n,ngram_mod) for doc in texts]\",\n \"def extract_ngrams(self, sequence):\\n sequence = self.prefix + sequence + self.suffix\\n for i, event in enumerate(sequence[self.n:], self.n):\\n yield event, sequence[i-self.n: i]\",\n \"def __makeNgrams(self, n):\\n # start_time = time.time()\\n ngrams = dict()\\n itergrams = dict()\\n\\n for k in range(2,n+1):\\n itergrams[k] = list(nltk.ngrams(self.words, k))\\n\\n for k, grams in itergrams.items():\\n kgrams = defaultdict(Counter)\\n for gram in grams: \\n kgram = list(gram)\\n key = ' '.join(kgram[:k-1])\\n kgrams[key].update({kgram[-1]})\\n ngrams[k] = kgrams\\n # print ('finish gen ', k, 'grams at ', time.time()-start_time)\\n return ngrams\",\n \"def extract_n_grams(string, n, overlap=0, unique=True):\\n if n > len(string):\\n return [] \\n\\n n_grams = []\\n step = n - overlap\\n n_grams = [string[i:i+n] for i in range(0, len(string)-step+1, step)]\\n\\n if unique:\\n n_grams = list(set(n_grams))\\n\\n n_grams = [g+\\\"\\\\n\\\" for g in n_grams]\\n\\n return n_grams\",\n \"def get_ngrams(sequence, n):\\n\\n # Set prefix and postfix\\n prefix = \\\"START\\\"\\n postfix = \\\"STOP\\\"\\n # Append 1 prefix regardless of value of n\\n sequence.insert(0, prefix)\\n for i in range(n - 2) :\\n sequence.insert(0, prefix)\\n sequence.append(postfix)\\n\\n # Check if 1 <= n <= len(sequence)\\n if (n > len(sequence)) :\\n print(sequence)\\n assert 1 <= n\\n assert n <= len(sequence)\\n\\n # Create n-gram sequence\\n n_gram_sequence = []\\n for i in range(n, len(sequence) + 1) :\\n temp_sequence = []\\n for j in range(i - n, i) :\\n temp_sequence.append(sequence[j])\\n n_gram_sequence.append(tuple(temp_sequence))\\n return n_gram_sequence\",\n \"def ngrams(self, n=1, uncased=False, filter_fn=None, as_strings=True):\\n\\n def _skip(gram):\\n if not filter_fn:\\n return False\\n return filter_fn(gram)\\n\\n words = self.words(True)\\n ngrams = [(s, e + 1)\\n for s in range(len(words))\\n for e in range(s, min(s + n, len(words)))\\n if not _skip(words[s:e + 1])]\\n\\n # Concatenate into strings\\n if as_strings:\\n ngrams = ['{}'.format(' '.join(words[s:e])) for (s, e) in ngrams]\\n\\n return ngrams\",\n \"def _get_word_ngrams(n, sentences):\\n assert len(sentences) > 0\\n assert n > 0\\n\\n words = split_into_words(sentences)\\n return _get_ngrams(n, words)\",\n \"def get_grams(candidate, n):\\n words = candidate.split(' ')\\n # print(words)\\n grams = list()\\n for i in range(len(words) - n + 1):\\n # print(words[i:i+n])\\n grams.append(' '.join(words[i:i+n]))\\n return grams\",\n \"def _generateNgrams(self,text,n=2):\\n token = Utilities.CVTokeniser(text)\\n # token = nltk.word_tokenize(text)\\n computedNgrams=ngrams(token,n)\\n return Counter(computedNgrams)\",\n \"def ngrams(self, words):\\n if words[0] in self._locs:\\n for loc in self._locs[words[0]]:\\n ngram = NGram.from_loc(len(words), loc)\\n if ngram.words == words:\\n yield ngram\",\n \"def generate_ngram(corpus,n=2):\\r\\n def generate_ngram_str(text,n):\\r\\n text = tokenizer.tokenize(text)\\r\\n for i in range(0, len(text)-n+1):\\r\\n yield text[i:i+n]\\r\\n if isinstance(corpus,str):\\r\\n for ngram in generate_ngram_str(corpus,n):\\r\\n yield ngram\\r\\n elif isinstance(corpus, (list, types.GeneratorType)):\\r\\n for text in corpus:\\r\\n for ngram in generate_ngram_str(text,n):\\r\\n yield ngram\",\n \"def _get_word_ngrams(n, sentences):\\n assert len(sentences) > 0\\n assert n > 0\\n\\n # words = _split_into_words(sentences)\\n\\n words = sum(sentences, [])\\n # words = [w for w in words if w not in stopwords]\\n return _get_ngrams(n, words)\",\n \"def _get_word_ngrams(n, sentences):\\n assert len(sentences) > 0\\n assert n > 0\\n\\n # words = _split_into_words(sentences)\\n\\n words = sum(sentences, [])\\n # words = [w for w in words if w not in stopwords]\\n return _get_ngrams(n, words)\",\n \"def _get_word_ngrams(n, sentences):\\n assert len(sentences) > 0\\n assert n > 0\\n\\n words = _split_into_words(sentences)\\n return _get_ngrams(n, words)\",\n \"def _get_word_ngrams(n, sentences):\\n assert len(sentences) > 0\\n assert n > 0\\n\\n words = _split_into_words(sentences)\\n return _get_ngrams(n, words)\",\n \"def _get_word_ngrams(n, sentences):\\n assert len(sentences) > 0\\n assert n > 0\\n\\n words = _split_into_words(sentences)\\n return _get_ngrams(n, words)\",\n \"def ngrams(self, n=1, uncased=False, filter_fn=None, as_strings=True):\\n def _skip(gram):\\n if not filter_fn:\\n return False\\n return filter_fn(gram)\\n\\n words = self.words(uncased)\\n ngrams = [(s, e + 1)\\n for s in range(len(words))\\n for e in range(s, min(s + n, len(words)))\\n if not _skip(words[s:e + 1])]\\n\\n # Concatenate into strings\\n if as_strings:\\n ngrams = ['{}'.format(' '.join(words[s:e])) for (s, e) in ngrams]\\n\\n return ngrams\",\n \"def get_ngrams(sequence, n):\\n # Example: n = 3, length = 4\\n # we want 0:3, 1:4\\n\\n result = []\\n if n == 1:\\n result.append(tuple([\\\"START\\\"]))\\n result.append(tuple([\\\"STOP\\\"]))\\n\\n if n == 3 and len(sequence) == 1:\\n result.append(tuple([\\\"START\\\",\\\"START\\\",sequence[0]]))\\n result.append(tuple([\\\"START\\\",sequence[0],\\\"STOP\\\"]))\\n return result\\n\\n if n > 1 :\\n for i in range(n-1):\\n result.append(tuple([\\\"START\\\"]*(n-1-i)+ sequence[:i+1]))\\n result.append(tuple(sequence[-n+1:] + [\\\"STOP\\\"]))\\n\\n for i in range(len(sequence)-n+1):\\n result.append(tuple(sequence[i:i+n]))\\n return result\",\n \"def ngram(_input: List[str], N: int, skip: Optional[int] = None,\\n delim: str = ' ', skip_delim: str = '_') -> List[str]:\\n max_len = len(_input)\\n # Delimiter must be a string\\n # assert isinstance(delim, basestring)\\n # assert isinstance(skip_delim, basestring)\\n\\n ngram_tokens = []\\n\\n for start in range(max_len):\\n for n in range(1, min(N+1, max_len+1)):\\n end = start + n\\n if end > max_len:\\n break\\n ngram_tokens.append(delim.join(_input[start:end]))\\n\\n if skip:\\n skipped = skip_delim.join(_input[start:end:(skip+1)])\\n # if skipped not in ngram_tokens:\\n ngram_tokens.append(skipped)\\n\\n return ngram_tokens\",\n \"def words_to_ngrams(words, max_order):\\n d = defaultdict(int)\\n\\n # Iterate over word indices as start pointers\\n for i in range(len(words)):\\n # Sliding windows\\n for j in range(min(max_order, len(words) - i)):\\n # Increment counter, keep keys as tuples\\n d[tuple(words[i: i+j+1])] += 1\\n\\n return d\",\n \"def transform_ngrams(self, words):\\n return words if self.n_grams == 1 else [self.connector.join(words[i:i + self.n_grams]) for i in range(len(words) - self.n_grams + 1)]\",\n \"def ngrams(self):\\n return self.__ngrams(())\",\n \"def get_lemma_ngrams(s, t, i, ngram_size):\\n ngrams = {\\\"uni\\\":1, \\\"bi\\\":2, \\\"tri\\\":3}\\n if i < s.length-(ngrams[ngram_size]-1):\\n lemma_ngrams = []\\n for j in range(ngrams[ngram_size]):\\n if s.nodes[i+j].lemma:\\n lemma_ngrams.append(s.nodes[i+j].lemma[0]) #only keeps the first lemma\\n else:\\n lemma_ngrams.append(s.nodes[i+j].word + \\\"*\\\") #no lemma, word form* instead\\n if len(lemma_ngrams) > 1:\\n return tuple(lemma_ngrams)\\n return lemma_ngrams[0] #or better to keep them all?\\n else:\\n return []\",\n \"def _get_ngrams(segments, order):\\n ngram_counts = collections.Counter()\\n for seg in segments:\\n for i in range(0, len(seg) - order + 1):\\n ngram = tuple(seg[i:i+order])\\n ngram_counts[ngram] += 1\\n return ngram_counts\",\n \"def ngrams(doc, n, filter_stopwords=True, good_tags={'NOUN', 'PROPN', 'ADJ'}):\\n ngrams_ = (doc[i:i + n] for i in range(len(doc) - n + 1))\\n ngrams_ = (ngram for ngram in ngrams_\\n if not any(w.is_space or w.is_punct for w in ngram))\\n\\n if filter_stopwords:\\n ngrams_ = (ngram for ngram in ngrams_\\n if not any(w.is_stop for w in ngram))\\n if good_tags:\\n ngrams_ = (ngram for ngram in ngrams_\\n if all(w.pos_ in good_tags for w in ngram))\\n\\n for ngram in ngrams_:\\n yield ngram\",\n \"def add_ngram(sequences, token_indice, ngram_range=2):\\n new_sequences = []\\n for input_list in sequences:\\n new_list = input_list[:]\\n for ngram_value in range(2, ngram_range + 1):\\n for i in range(len(new_list) - ngram_value + 1):\\n ngram = tuple(new_list[i:i + ngram_value])\\n if ngram in token_indice:\\n new_list.append(token_indice[ngram])\\n new_sequences.append(new_list)\\n\\n return new_sequences\",\n \"def ngrams(self):\\n return self.root.ngrams()\",\n \"def add_ngram(sequences, token_indice, ngram_range=2):\\n new_sequences = []\\n for input_list in sequences:\\n new_list = input_list[:]\\n for i in range(len(new_list) - ngram_range + 1):\\n for ngram_value in range(2, ngram_range + 1):\\n ngram = tuple(new_list[i:i + ngram_value])\\n if ngram in token_indice:\\n new_list.append(token_indice[ngram])\\n new_sequences.append(new_list)\\n\\n return new_sequences\",\n \"def full_ngrams(items, n):\\n ngs = {}\\n for i in xrange(1, n+1):\\n ngs.update(gen_ngrams(items, i))\\n return ngs\",\n \"def add_ngram(sequences, token_indice, ngram_range=2):\\n new_sequences = []\\n for input_list in sequences:\\n new_list = input_list[:]\\n for ngram_value in range(2, ngram_range + 1):\\n for i in range(len(new_list) - ngram_value + 1):\\n ngram = tuple(new_list[i:i + ngram_value])\\n if ngram in token_indice:\\n new_list.append(token_indice[ngram])\\n new_sequences.append(new_list)\\n\\n return new_sequences\",\n \"def create_ngram_set(input_list, ngram_value=2):\\n return set(zip(*[input_list[i:] for i in range(ngram_value)]))\",\n \"def ngrammer(text, gramsize = 3, threshold = 4):\\n # we need to import this in order to find the duplicates:\\n import nltk\\n from nltk.util import ngrams\\n from collections import defaultdict\\n # get ngrams of gramsize \\n if type(text) != list:\\n text = tokenised = nltk.word_tokenize(text)\\n text = [token for token in text if token.isalnum()]\\n # get ngrams of gramsize \\n raw_grams = ngrams(text, gramsize)\\n \\n # a subdefinition to get duplicate lists in a list\\n def list_duplicates(seq):\\n tally = defaultdict(list)\\n for i,item in enumerate(seq):\\n tally[item].append(i)\\n # return to us the index and the ngram itself:\\n return ((len(locs),key) for key,locs in tally.items() \\n if len(locs) > threshold)\\n\\n # use our duplication detector to find duplicates\\n dupes = list_duplicates(raw_grams)\\n # return them, sorted by most frequent\\n return sorted(dupes, reverse = True)\",\n \"def prepare_tokens(self, tokens: Iterator[Token]) -> List[str]:\\n\\n\\t\\tif self.ignore_punctuation:\\n\\t\\t\\ttokens = filter(lambda t: t.value not in self.PUNCTUATION, tokens)\\n\\n\\t\\tif self.uses_lemma:\\n\\t\\t\\ttoken_values = map(lambda t: t.lemma, tokens)\\n\\t\\telse:\\n\\t\\t\\ttoken_values = map(lambda t: t.value, tokens)\\n\\n\\t\\tif self.caseless:\\n\\t\\t\\ttoken_values = map(lambda v: v.lower(), token_values)\\n\\n\\t\\tif self.add_pos_tags:\\n\\t\\t\\ttoken_values = map(lambda x: \\\"_\\\".join(x), zip(token_values, map(lambda t: t.pos, tokens)))\\n\\n\\t\\tn_gram_values = self.build_n_grams(tokens=list(token_values), n_gram_size=self.n_gram_size)\\n\\n\\t\\treturn n_gram_values\",\n \"def compute_ngrams(str, n=2):\\n #split the string\\n st = tuple(str.split())\\n #not list of list but list of tuple..\\n gram = [st[x:x+n] for x in range(len(st)-n+1)]\\n dgram = {}\\n #convert ngram into dictionary:\\n for key in gram:\\n dgram.setdefault(key[0],[]).append(key[1:])\\n return dgram\",\n \"def filter_pos(self):\\n all_tokens = []\\n for zettel in self.lemma_tokens:\\n tokens = []\\n for word in zettel:\\n if word[1] in ['NN', 'NNS', 'NNP', 'NNPS', 'NG']: # NG = n_gram\\n tokens.append(word)\\n all_tokens.append(tokens)\\n self.lemma_tokens = all_tokens\",\n \"def gen_ngrams(items, n):\\n ngs = {}\\n ilen = len(items)\\n for i in xrange(ilen-n+1):\\n ng = tuple(items[i:i+n])\\n ngs[ng] = ngs.get(ng, 0) + 1\\n return ngs\",\n \"def precook(s, n=4, out=False):\\n words = s.split()\\n counts = defaultdict(int)\\n for k in xrange(1,n+1):\\n for i in xrange(len(words)-k+1):\\n ngram = tuple(words[i:i+k])\\n counts[ngram] += 1\\n return counts\",\n \"def create_ngram_set(input_list, ngram_value=2):\\n return set(zip(*[input_list[i:] for i in range(ngram_value)]))\",\n \"def ngramify(word: str,\\n max_ngram_size: int):\\n chars = list(word)\\n ngram_tuples = []\\n ngrams = []\\n # Take all n-grams with length in [2, max_ngram_size]\\n for i in range(2, max_ngram_size + 1):\\n pw = list(pairwise(chars, i))\\n ngram_tuples += pw\\n for e in ngram_tuples:\\n if None not in e:\\n ngrams.append(''.join(e))\\n # Append the list of characters, to avoid an unnecessary call for pairwise(_, 1).\\n return list(word) + ngrams\",\n \"def get_ngramlogprobs_fromcorpus(tokenizedseqs, n):\\n return\",\n \"def get_ngrams(self, s, ngmin, ngmax, separator=\\\"\\\",\\n bos=\\\"<\\\", eos=\\\">\\\", suffix=\\\"\\\", flatten=True):\\n\\n # return a single dummy feature if there are no applicable ngrams\\n # probably resulting in a mojority-class classifier\\n if ngmax == 0 or (ngmax - ngmin < 0) :\\n return ['__dummy__']\\n\\n ngrams = [[] for x in range(1, ngmax + 1)]\\n s = [bos] + s + [eos]\\n for i, ch in enumerate(s):\\n for ngsize in range(ngmin, ngmax + 1):\\n if (i + ngsize) <= len(s):\\n ngrams[ngsize - 1].append(\\n separator.join(s[i:i+ngsize]) + suffix)\\n if flatten:\\n ngrams = [ng for nglist in ngrams for ng in nglist]\\n return ngrams\",\n \"def build_ngram_vocab(self, n):\\n max_ngram_per_word = 0\\n ngram_dict = collections.defaultdict(int)\\n for word in self.train_data:\\n if word == self.eos or word == self.sos:\\n continue\\n _word = '^' + word + '$'\\n ngram_counts = len(_word) - n + 1\\n if ngram_counts > max_ngram_per_word:\\n max_ngram_per_word = ngram_counts\\n for i in range(ngram_counts):\\n ngram = _word[i:i + n]\\n ngram_dict[ngram] += 1\\n\\n unk_ngram_list = set()\\n item_to_id = dict()\\n item_to_id[constants.PAD_ITEM] = len(item_to_id)\\n item_to_id[constants.UNK_ITEM] = len(item_to_id)\\n sorted_dict = sorted(ngram_dict.items(), key=operator.itemgetter(1), reverse=True)\\n for token, freq in sorted_dict:\\n if freq == 1:\\n unk_ngram_list.add(token)\\n if token not in item_to_id:\\n item_to_id[token] = len(item_to_id)\\n return item_to_id, unk_ngram_list, max_ngram_per_word\",\n \"def n_gram(data, headers, cat_labels, num_labels):\\n\\t\\tn_grammed = []\\n\\n\\t\\tfor i, tok in enumerate(data):\\n\\t\\t\\tif i == 0:\\n\\t\\t\\t\\tn_grammed.append(data[-1]+tok+data[i+1])\\n\\t\\t\\telif i == len(data) - 1:\\n\\t\\t\\t\\tn_grammed.append(data[i-1]+tok+data[0])\\n\\t\\t\\telse:\\n\\t\\t\\t\\tn_grammed.append(data[i-1]+tok+data[i+1])\\n\\n\\t\\tn_grammed_headers = [header + \\\"_min1\\\" for header in headers] + headers + [header + \\\"_pls1\\\" for header in headers]\\n\\t\\tn_grammed_cat_labels = [lab + \\\"_min1\\\" for lab in cat_labels] + cat_labels + [lab + \\\"_pls1\\\" for lab in cat_labels]\\n\\t\\tn_grammed_num_labels = [lab + \\\"_min1\\\" for lab in num_labels] + num_labels + [lab + \\\"_pls1\\\" for lab in num_labels]\\n\\n\\t\\treturn n_grammed, n_grammed_headers, n_grammed_cat_labels, n_grammed_num_labels\",\n \"def _get_bag_of_pos_ngram(words, index, window_size, N):\\n bos = DummyWord(pos=utils.BEGIN_OF_SENTENCE, upos=utils.BEGIN_OF_SENTENCE, dependency_relation=utils.BEGIN_OF_SENTENCE)\\n eos = DummyWord(pos=utils.END_OF_SENTENCE, upos=utils.END_OF_SENTENCE, dependency_relation=utils.END_OF_SENTENCE)\\n words = [bos] * (window_size + N) + words + [eos] * (window_size + N)\\n index += (window_size + N)\\n return [\\n \\\"_\\\".join([_get_word_feature(w) for w in words[i:i+N]])\\n for i in range(index-window_size, index+window_size+1)]\",\n \"def get_terms(corpus, n=4000):\\n\\n stop = StopLexicon()\\n scrabble = ScrabbleLexicon()\\n\\n ngrams = defaultdict(set)\\n citations = defaultdict(set)\\n\\n for doc in corpus:\\n for ng in get_ngrams([doc.title]):\\n if good_ngram(ng, scrabble, stop):\\n ngrams[ng].add(doc.id)\\n for ref in doc.references:\\n citations[doc.id].add(ref)\\n citations[ref].add(doc.id)\\n\\n ngrams = filter_plurals(ngrams)\\n\\n ngram_counts = {x: len(ngrams[x]) for x in ngrams}\\n filtered = filter_subsumed(ngram_counts)\\n\\n if citations:\\n ngrams = score_ngrams(ngrams, citations)\\n ngrams = filter_subsumed(ngrams)\\n return [' '.join(x) for x in sorted(ngrams, key=lambda x: ngrams[x],\\n reverse=True) if x in filtered][:n]\\n else:\\n return [' '.join(x) for x in sorted(filtered, key=lambda x: filtered[x],\\n reverse=True)][:n]\",\n \"def filter_n_grams(self, n_grams, min_freq, n):\\n all_n_grams = []\\n for zettel in n_grams:\\n cur_n_grams = []\\n for gram in zettel:\\n if zettel.count(gram) >= min_freq:\\n if gram not in cur_n_grams:\\n cur_n_grams.append(gram)\\n all_n_grams.append(cur_n_grams)\\n self.swap_n_grams(all_n_grams, n)\",\n \"def ngramify(corpus, n):\\r\\n unlist = 0\\r\\n if type(corpus[0]) is not list:\\r\\n corpus = [corpus]\\r\\n unlist = 1\\r\\n new_corpus = []\\r\\n for line in corpus:\\r\\n new_line = []\\r\\n for gram in range(len(line) - n + 1):\\r\\n new_gram = \\\"\\\"\\r\\n for i in range(n):\\r\\n if i != 0:\\r\\n new_gram += \\\" \\\"\\r\\n new_gram += line[gram + i]\\r\\n new_line.append(new_gram)\\r\\n new_corpus.append(new_line)\\r\\n if unlist:\\r\\n return new_corpus[0]\\r\\n return new_corpus\",\n \"def make_ngrams_and_pre_word_ngrams(self, tokenized_corpus: list, n: int):\\n ngrams_and_pre_words = {}\\n first_word_i = n - 1\\n end_i = len(tokenized_corpus) - 1\\n for i in range(first_word_i, end_i):\\n if i - (n - 1) < 0:\\n continue\\n pre_words_ngrams = self._make_ngrams(tokenized_corpus, i, n, make_pre_word_ngram=True)\\n current_token = (tokenized_corpus[i],)\\n ngrams = pre_words_ngrams + current_token\\n if self.TOKENS.END.value in ngrams:\\n continue\\n else:\\n ngrams_and_pre_words[ngrams] = tuple(pre_words_ngrams)\\n return ngrams_and_pre_words\",\n \"def ngram_search(words, n=2):\\n N = len(words)\\n # Queries are the first 1 to N words\\n queries = [' '.join(words[i:i + n]) for i in range(N - n + 1)]\\n # Create multiple threads to parallelize querying\\n p = Pool(4)\\n results = p.map(search_tracks, queries)\\n p.close()\\n p.join()\\n # Merge results and sort in popularity order (descending) to ensure that\\n # more popular songs are selected for play lists\\n merged = reduce(list.__add__, results)\\n songs = sorted(merged, key=lambda x: x.Popularity, reverse=True)\\n return songs\",\n \"def add_ngram(self, sequences, token_indice, ngram_range=2):\\n new_sequences = []\\n for input_list in sequences:\\n new_list = input_list[:]\\n for ngram_value in range(2, ngram_range + 1):\\n for i in range(len(new_list) - ngram_value + 1):\\n ngram = tuple(new_list[i:i + ngram_value])\\n if ngram in token_indice:\\n new_list.append(token_indice[ngram])\\n new_sequences.append(new_list)\\n\\n return new_sequences\",\n \"def n_grammize(role):\\n ngrams = []\\n if isinstance(role,str):\\n role = role.lower()\\n role = role.split()\\n if len(role)>2:\\n for i in range(2, len(role)):\\n ngrams.append((role[i-2], role[i-1], role[i]))\\n if len(role)>1:\\n for i in range(1, len(role)):\\n ngrams.append((role[i-1], role[i]))\\n for i in range(len(role)):\\n ngrams.append(role[i])\\n return ngrams\",\n \"def ngrams(n, target):\\n chars = collections.deque()\\n while True:\\n chars.append((yield))\\n if len(chars) == n: \\n target.send(chars)\\n chars.popleft()\",\n \"def get_bigrams(self, tokens):\\n return [a + \\\" \\\" + b for a, b in zip(tokens, tokens[1:])]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8024978","0.78923404","0.7772897","0.75658435","0.75516206","0.7496225","0.7459337","0.7409229","0.7395054","0.7372828","0.7341489","0.728606","0.7244324","0.7237867","0.72247565","0.7176616","0.7175382","0.71394616","0.71245074","0.71214175","0.71136826","0.70588833","0.70456195","0.70117605","0.69914657","0.6989067","0.6978474","0.69763386","0.69357574","0.6929052","0.68813527","0.6864753","0.6851413","0.68506646","0.6811221","0.6800407","0.67860436","0.6783203","0.67816883","0.676378","0.67530626","0.6737946","0.672258","0.6694","0.6636544","0.66183126","0.6610607","0.65649545","0.6562271","0.6516324","0.650895","0.64937145","0.6479274","0.647557","0.64755154","0.6471171","0.6467313","0.6465966","0.64577484","0.64577484","0.6452088","0.6443014","0.6443014","0.6442396","0.6442385","0.6421984","0.6409418","0.6381562","0.63710403","0.63505805","0.6342985","0.6321089","0.6300666","0.62674826","0.62632245","0.6244138","0.6198541","0.6187936","0.61789846","0.61732316","0.6116585","0.6105726","0.6096094","0.60592514","0.6055564","0.6049875","0.60362136","0.60360837","0.6035505","0.60296565","0.60212624","0.6018957","0.5998522","0.5988775","0.59795356","0.59794885","0.59756273","0.59749925","0.5966345","0.5964572"],"string":"[\n \"0.8024978\",\n \"0.78923404\",\n \"0.7772897\",\n \"0.75658435\",\n \"0.75516206\",\n \"0.7496225\",\n \"0.7459337\",\n \"0.7409229\",\n \"0.7395054\",\n \"0.7372828\",\n \"0.7341489\",\n \"0.728606\",\n \"0.7244324\",\n \"0.7237867\",\n \"0.72247565\",\n \"0.7176616\",\n \"0.7175382\",\n \"0.71394616\",\n \"0.71245074\",\n \"0.71214175\",\n \"0.71136826\",\n \"0.70588833\",\n \"0.70456195\",\n \"0.70117605\",\n \"0.69914657\",\n \"0.6989067\",\n \"0.6978474\",\n \"0.69763386\",\n \"0.69357574\",\n \"0.6929052\",\n \"0.68813527\",\n \"0.6864753\",\n \"0.6851413\",\n \"0.68506646\",\n \"0.6811221\",\n \"0.6800407\",\n \"0.67860436\",\n \"0.6783203\",\n \"0.67816883\",\n \"0.676378\",\n \"0.67530626\",\n \"0.6737946\",\n \"0.672258\",\n \"0.6694\",\n \"0.6636544\",\n \"0.66183126\",\n \"0.6610607\",\n \"0.65649545\",\n \"0.6562271\",\n \"0.6516324\",\n \"0.650895\",\n \"0.64937145\",\n \"0.6479274\",\n \"0.647557\",\n \"0.64755154\",\n \"0.6471171\",\n \"0.6467313\",\n \"0.6465966\",\n \"0.64577484\",\n \"0.64577484\",\n \"0.6452088\",\n \"0.6443014\",\n \"0.6443014\",\n \"0.6442396\",\n \"0.6442385\",\n \"0.6421984\",\n \"0.6409418\",\n \"0.6381562\",\n \"0.63710403\",\n \"0.63505805\",\n \"0.6342985\",\n \"0.6321089\",\n \"0.6300666\",\n \"0.62674826\",\n \"0.62632245\",\n \"0.6244138\",\n \"0.6198541\",\n \"0.6187936\",\n \"0.61789846\",\n \"0.61732316\",\n \"0.6116585\",\n \"0.6105726\",\n \"0.6096094\",\n \"0.60592514\",\n \"0.6055564\",\n \"0.6049875\",\n \"0.60362136\",\n \"0.60360837\",\n \"0.6035505\",\n \"0.60296565\",\n \"0.60212624\",\n \"0.6018957\",\n \"0.5998522\",\n \"0.5988775\",\n \"0.59795356\",\n \"0.59794885\",\n \"0.59756273\",\n \"0.59749925\",\n \"0.5966345\",\n \"0.5964572\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7025471"},"document_rank":{"kind":"string","value":"23"}}},{"rowIdx":22890,"cells":{"query":{"kind":"string","value":"Extracts reference statistics for a given segment."},"document":{"kind":"string","value":"def reference_stats(refs, output_len):\n\n ngrams = Counter()\n closest_diff = None\n closest_len = None\n\n for ref in refs:\n tokens = ref.split()\n reflen = len(tokens)\n diff = abs(output_len - reflen)\n if closest_diff is None or diff < closest_diff:\n closest_diff = diff\n closest_len = reflen\n elif diff == closest_diff:\n if reflen < closest_len:\n closest_len = reflen\n\n ngrams_ref = CachedBLEU.extract_ngrams(ref)\n for ngram in ngrams_ref.keys():\n ngrams[ngram] = max(ngrams[ngram], ngrams_ref[ngram])\n\n return ngrams, closest_diff, closest_len"},"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_all_references(alignedsegment):\n \n references = [alignedsegment.reference_name]\n \n # Some reads don't have secondary hits\n if not alignedsegment.has_tag('XA'):\n return references\n \n # XA is a string contigname1,<other info>;contigname2,<other info>; ...\n secondary_alignment_string = alignedsegment.get_tag('XA')\n secondary_alignments = secondary_alignment_string.split(';')[:-1]\n \n for secondary_alignment in secondary_alignments:\n references.append(secondary_alignment.partition(',')[0])\n \n return references","def metric_halstats(hal_filename, reference_id=\"ref\"):\n \n # Get the list of dicts of per-genome stats.\n status_list = get_halstats_stats(hal_filename)\n \n # Throw out non-leaves\n status_list = [entry for entry in status_list if entry[\"NumChildren\"] == 0]\n \n # Grab all the genome names\n genome_names = [entry[\"GenomeName\"] for entry in status_list]\n \n # Get the dict from genome name to total bases from that genome aligned to\n # the reference at all, and the dict of N compositions, in parallel.\n coverage_dict, basecomp_dict = in_parallel(\n lambda: get_halstats_coverage(hal_filename, genome_names, reference_id),\n lambda: get_halstats_basecomps(hal_filename, genome_names))\n \n for entry in status_list:\n # For each genome, we want the coverage against the reference.\n \n # Grab the genome name\n genome_name = entry[\"GenomeName\"]\n \n if not coverage_dict.has_key(genome_name):\n # This is probably the root sequence and didn't get a coverage for\n # some reason. At any rate, the root sequence would be all Ns\n continue\n \n # Figure out how much of it is not Ns\n non_n = basecomp_dict[genome_name]\n \n # How many bases are eligible?\n eligible = float(entry[\"Length\"] * non_n)\n \n if eligible == 0:\n # No coverage is defined\n entry[\"Coverage\"] = float(\"NaN\")\n continue\n \n # Compute and save the coverage for each entry, by dividing bases\n # aligned by bases eligible.\n entry[\"Coverage\"] = coverage_dict[genome_name] / eligible\n \n # Return the results\n return status_list","def parse_halstats_coverage(stream, reference_id):\n \n # Get a reader and skip the first line\n reader = csv.reader(stream)\n for i in xrange(1):\n next(reader)\n \n for data in reader:\n if len(data) == 0:\n # We finished the table\n break\n \n \n # Drop all the whitespace\n data = [x.strip() for x in data]\n \n if data[0] == reference_id:\n if len(data) > 1:\n # We have some bases aligned\n return float(data[1])\n else:\n # We had no bases aligned\n return 0.0\n \n raise RuntimeError(\"Could not find coverage against {}\".format(\n reference_id))","def fetch(self, segment):\n pass","def stats(self, s_sample, d_sample, x_sample, wav_len):\n\t\ts_STDCT_sample, d_STDCT_sample, x_STDCT_sample = self.transfrom_stats(s_sample,\n\t\t\td_sample, x_sample, wav_len)\n\t\txi_sample = self.xi(s_STDCT_sample, d_STDCT_sample)\n\t\tself.xi_map.stats(xi_sample)\n\t\tcd_sample = self.cd(s_STDCT_sample, d_STDCT_sample)\n\t\tself.cd_map.stats(cd_sample)","def stats(self, s_sample, d_sample, x_sample, wav_len):\n\t\ts_STMS_sample, d_STMS_sample, x_STMS_sample = self.transfrom_stats(s_sample,\n\t\t\td_sample, x_sample, wav_len)\n\t\tself.mag_map.stats(s_STMS_sample)","def get_word_stats(segments, feats_dict):\r\n word_count_list = []\r\n word_lengths = []\r\n long_count = 0\r\n for segment in segments:\r\n word_count_list.append(len(segment))\r\n for word in segment:\r\n word_lengths.append(len(word))\r\n if len(word) > 6:\r\n long_count += 1\r\n # Compute segment level statistics\r\n feats_dict['wc_mean'] = np.mean(word_count_list) if word_count_list else float('nan')\r\n feats_dict['wc_median'] = np.median(word_count_list) if word_count_list else float('nan')\r\n feats_dict['wc_stdev'] = np.std(word_count_list) if word_count_list else float('nan')\r\n feats_dict['wc_min'] = min(word_count_list) if word_count_list else float('nan')\r\n feats_dict['wc_max'] = max(word_count_list) if word_count_list else float('nan')\r\n feats_dict['total_count'] = sum(word_count_list) if word_count_list else float('nan')\r\n\r\n # Compute fraction of words across whole call that are long (i.e. 6+ words)\r\n feats_dict['lw_count'] = (long_count / feats_dict['total_count']) if feats_dict['total_count'] else float('nan')\r\n # Compute mean length of any word used\r\n feats_dict['word_len'] = np.mean(word_lengths) if word_lengths else float('nan')","def stats(self, s_sample, d_sample, x_sample, wav_len):\n\t\tpass\n\t\t# s_STMS_sample, d_STMS_sample, x_STMS_sample = self.transfrom_stats(s_sample,\n\t\t# \td_sample, x_sample, wav_len)\n\t\t# smm_sample = tf.math.truediv(s_STMS_sample, x_STMS_sample)\n\t\t# self.smm_map.stats(smm_sample)","def calculate_stats(\n dataloader: AtomsLoader,\n divide_by_atoms: Dict[str, bool],\n atomref: Dict[str, torch.Tensor] = None,\n) -> Dict[str, Tuple[torch.Tensor, torch.Tensor]]:\n property_names = list(divide_by_atoms.keys())\n norm_mask = torch.tensor(\n [float(divide_by_atoms[p]) for p in property_names], dtype=torch.float64\n )\n\n count = 0\n mean = torch.zeros_like(norm_mask)\n M2 = torch.zeros_like(norm_mask)\n\n for props in tqdm(dataloader):\n sample_values = []\n for p in property_names:\n val = props[p][None, :]\n if atomref and p in atomref.keys():\n ar = atomref[p]\n ar = ar[props[structure.Z]]\n idx_m = props[structure.idx_m]\n tmp = torch.zeros((idx_m[-1] + 1,), dtype=ar.dtype, device=ar.device)\n v0 = tmp.index_add(0, idx_m, ar)\n val -= v0\n\n sample_values.append(val)\n sample_values = torch.cat(sample_values, dim=0)\n\n batch_size = sample_values.shape[1]\n new_count = count + batch_size\n\n norm = norm_mask[:, None] * props[structure.n_atoms][None, :] + (\n 1 - norm_mask[:, None]\n )\n sample_values /= norm\n\n sample_mean = torch.mean(sample_values, dim=1)\n sample_m2 = torch.sum((sample_values - sample_mean[:, None]) ** 2, dim=1)\n\n delta = sample_mean - mean\n mean += delta * batch_size / new_count\n corr = batch_size * count / new_count\n M2 += sample_m2 + delta**2 * corr\n count = new_count\n\n stddev = torch.sqrt(M2 / count)\n stats = {pn: (mu, std) for pn, mu, std in zip(property_names, mean, stddev)}\n return stats","def read_segment(st, segment, cfile=None, timeout=10):\n\n # assumed read shape (st.readints, st.nbl, st.metadata.nchan_orig, st.npol)\n logger.info(\"Reading segment {0} of datasetId {1}\"\n .format(segment, st.metadata.datasetId))\n if st.metadata.datasource == 'sdm':\n data_read = read_bdf_segment(st, segment)\n elif st.metadata.datasource == 'vys':\n data_read = read_vys_segment(st, segment, cfile=cfile, timeout=timeout)\n elif st.metadata.datasource == 'sim':\n simseg = segment if cfile else None\n data_read = simulate_segment(st, segment=simseg)\n elif st.metadata.datasource == 'vyssim':\n data_read = read_vys_segment(st, segment, cfile=cfile, timeout=timeout,\n returnsim=True)\n else:\n logger.error('Datasource {0} not recognized.'\n .format(st.metadata.datasource))\n\n # report bad values\n if np.any(np.isnan(data_read)):\n logger.warning(\"Read data has some NaNs\")\n if np.any(np.isinf(data_read)):\n logger.warning(\"Read data has some Infs\")\n if np.any(np.abs(data_read) > 1e20):\n logger.warning(\"Read data has values larger than 1e20\")\n\n if not np.any(data_read):\n logger.info('Read data are all zeros for segment {0}.'.format(segment))\n return np.array([])\n else:\n logger.info('Read data with zero fraction of {0:.3f} for segment {1}'\n .format(1-np.count_nonzero(data_read)/data_read.size,\n segment))\n return data_read","def collectGeneralStats(stats: DocStats, service):\n # Call the data from the api.\n file_meta = service.files().get(fileId=stats.general.id).execute()\n # Load in file stats\n stats.general.name = file_meta.get('title')\n stats.general.link = file_meta.get('selfLink')\n stats.general.creationDate = file_meta.get('createdDate')\n\n stats.timeline.setTimelineStart(stats.general.creationDate)","def stats(self, s_sample, d_sample, x_sample, wav_len):\n\t\ts_STMS_sample, d_STMS_sample, x_STMS_sample = self.transfrom_stats(s_sample,\n\t\t\td_sample, x_sample, wav_len)\n\t\txi_sample = self.xi(s_STMS_sample, d_STMS_sample)\n\t\tself.xi_map.stats(xi_sample)\n\t\tgamma_sample = self.gamma(x_STMS_sample, d_STMS_sample)\n\t\tself.gamma_map.stats(gamma_sample)","def getStatistics(data, reference_column=\"time\", compareWith=50):\n overlaps_diff = []\n overlaps = []\n sample_info = {}\n s_info = defaultdict(list)\n n_windows = len(data[reference_column])\n for i in range(n_windows):\n if i != n_windows - 1:\n if data[reference_column][i] == [] or data[reference_column][i+1] == []:\n raise ValueError(\"\\tFile has empty tagged windows. Skipping...\")\n overlap = len(set(data[reference_column][i]) & set(data[reference_column][i + 1])) / \\\n float(len(set(data[reference_column][i + 1]))) * 100\n overlaps.append(overlap)\n overlaps_diff.append(overlap - compareWith)\n\n for k in data.keys():\n s_info[k].append(sum([1 for j in data[k][i] if j != \"\"]))\n\n for k in data.keys():\n sample_info[k] = np.mean(s_info[k])\n\n return overlaps, n_windows, sample_info, np.mean(overlaps), np.mean(overlaps_diff)","def stats(self, s_sample, d_sample, x_sample, wav_len):\n\t\ts_STMS_sample, d_STMS_sample, x_STMS_sample = self.transfrom_stats(s_sample,\n\t\t\td_sample, x_sample, wav_len)\n\t\txi_sample = self.xi(s_STMS_sample, d_STMS_sample)\n\t\tself.xi_map.stats(xi_sample)","def stats(self, s_sample, d_sample, x_sample, wav_len):\n\t\ts_STMS_sample, d_STMS_sample, x_STMS_sample = self.transfrom_stats(s_sample,\n\t\t\td_sample, x_sample, wav_len)\n\t\txi_sample = self.xi(s_STMS_sample, d_STMS_sample)\n\t\tself.xi_map.stats(xi_sample)","def stats(self, s_sample, d_sample, x_sample, wav_len):\n\t\ts_STMS_sample, d_STMS_sample, x_STMS_sample = self.transfrom_stats(s_sample,\n\t\t\td_sample, x_sample, wav_len)\n\t\tgamma_sample = self.gamma(x_STMS_sample, d_STMS_sample)\n\t\tself.gamma_map.stats(gamma_sample)","def GetStats(self):\r\n\t\tArg1 = self.href\r\n\t\treturn self._execute('GetStats', payload=locals(), response_object=None)","def get_stats(inp_fn):\n ent_pred_cnts = []\n ent_gold_cnts = []\n ent_intr_cnts = []\n ccs = ConllCorefScores()\n jsons = [json.loads(line) for line in open(inp_fn, encoding = \"utf8\")]\n for doc_dict in jsons:\n cur_doc = nlp(\" \".join(doc_dict[\"document\"]))\n gold_clusts = doc_dict[\"gold_clusters\"]\n pred_clusts = doc_dict[\"clusters\"]\n\n gold_ent_clusts = get_entities(cur_doc, gold_clusts)\n pred_ent_clusts = get_entities(cur_doc, pred_clusts)\n\n gold_clusts_pronouns = [gold_clust\n for gold_clust, gold_ent_clust\n in zip(gold_clusts, gold_ent_clusts)\n if contains_pronoun(gold_ent_clust)]\n\n pred_clusts_pronouns = [pred_clust\n for pred_clust, pred_ent_clust\n in zip(pred_clusts, pred_ent_clusts)\n if contains_pronoun(pred_ent_clust)]\n\n update_avg_f1(ccs, gold_clusts_pronouns, pred_clusts_pronouns)\n\n pred_ents = set(map(str, flatten(pred_ent_clusts)))\n gold_ents = set(map(str, flatten(gold_ent_clusts)))\n if (not pred_ents) and (not gold_ents):\n #TODO: what's going on in these instances?\n continue\n\n ent_pred_cnts.append(len(pred_ents))\n ent_gold_cnts.append(len(gold_ents))\n ent_intr_cnts.append(len(pred_ents & gold_ents))\n\n ent_micro = micro_f1(ent_pred_cnts, ent_gold_cnts, ent_intr_cnts)\n ent_macro = macro_f1(ent_pred_cnts, ent_gold_cnts, ent_intr_cnts)\n ret_dict = {\"ent_micro\": ent_micro,\n \"ent_macro\": ent_macro,\n \"pronoun_avg_f1\": get_avg_f1(ccs)}\n\n logging.debug(f\"micro = {ent_micro['f1']:.2f}, macro = {ent_macro['f1']:.2f}\")\n\n return ret_dict","def get_rec_stats(village, u, s, r, stim, GS, HC, hc_ro, vS, dlS, data,\n co_occ_pars, idx=None):\n\n res = {}\n\n if 'anim_data' in data:\n # Externally observable variables: action, state, reward, x-y position.\n x, y = village.animal_coords()\n res['anim_data'] = {'u': u, 's': s, 'r': r, 'x': x, 'y': y}\n\n if 'stim_data' in data:\n # Stimuli: motor feedback and visual input, both noise-free and noisy.\n res['stim_data'] = stim\n\n if 'gs_state' in data:\n # Instantaneous GS activity.\n res['gs_state'] = GS.P.copy()\n\n if 'hc_state' in data:\n # Instantaneous HC state estimate (full).\n res['hc_state'] = utils.get_copy(HC.s)\n\n if 'hc_ro' in data:\n # Instantaneous HC state estimate (read-out only).\n res['hc_ro'] = hc_ro.copy()\n\n if 'vs_state' in data:\n # Full vS reward estimate across all states.\n res['vs_state'] = vS.r.copy()\n\n if 'dls_state' in data:\n # Full dlS habit matrix across all states and actions.\n res['dls_state'] = dlS.Q.copy()\n\n if 'co_occs' in data:\n # Real location - HC state co-occurance frequency in last n steps.\n co_occ_pars['idx'] = update_co_occ_mat(hc_ro, village.S.index(s),\n **co_occ_pars)\n res['co_occs'] = co_occ_pars['co_occs'].copy()\n\n if 'gs_hc_pos' in data:\n # Mean position of GS - HC connectivity, per HC unit.\n C, xv, yv, circ = HC.GS_HC, GS.xvec, GS.yvec, GS.circular\n res['gs_hc_pos'] = analysis.GS_HC_conn_mean(C, xv, yv, circ)\n\n if 'gs_hc_max' in data:\n # Max value of GS - HC connectivity, per HC unit (proxy of spread).\n # Entropy calculation takes a lot of time --> approximated by max.\n # gs_hc_h = utils.entropy(HC.GS_HC.reshape((len(HC.s_names), -1)).T)\n res['gs_hc_max'] = HC.GS_HC.max(axis=(1, 2))\n\n # Put collected results into data object.\n for k, v in res.items():\n if idx is not None:\n data[k][idx] = v\n else:\n data[k] = v\n\n return","def get_file_mod_stats_for_upstream_refs(file_name, mod_stats_map):\n with open(file_name) as f:\n lines = f.readlines()\n upstream_ref = None\n upstream_start_line = None\n for line_number, line in enumerate(lines):\n if REGION_START_TAG in line:\n tag, ref_name = _extract_tag_and_ref_name_from_line(line, False)\n if REGION_UPSTREAM_TAG in tag:\n upstream_ref = ref_name\n upstream_start_line = line_number\n elif REGION_END_TAG in line and upstream_ref:\n mod_stats = mod_stats_map[upstream_ref]\n mod_stats.mod_count += 1\n mod_stats.line_count += line_number - upstream_start_line - 1\n upstream_ref = None\n upstream_start_line = None","def bleu_stats(hypo, ref, bleu_len=5):\n stats = list()\n stats.append(len(hypo))\n stats.append(len(ref))\n for n in range(1, bleu_len):\n s_ngrams = Counter([tuple(hypo[i:i+n]) for i in range(len(hypo)+1-n)])\n r_ngrams = Counter([tuple(ref[i:i+n]) for i in range(len(ref)+1-n)])\n stats.append(max([sum((s_ngrams & r_ngrams).values()), 0]))\n stats.append(max([len(hypo) + 1-n, 0]))\n return stats","def cal_sdri(src_ref, src_est, mix):\r\n src_anchor = np.stack([mix, mix], axis=0)\r\n sdr, sir, sar, popt = bss_eval_sources(src_ref, src_est)\r\n sdr0, sir0, sar0, popt0 = bss_eval_sources(src_ref, src_anchor)\r\n avg_sdri = ((sdr[0]-sdr0[0]) + (sdr[1]-sdr0[1])) / 2\r\n return avg_sdri","def stats(self, s_sample, d_sample, x_sample, wav_len):\n\t\tpass","def getReferenceDetails(soup):\n refDict = {}\n refs = soup.find_all('edmx:reference')\n for ref in refs:\n includes = ref.find_all('edmx:include')\n for item in includes:\n if item.get('namespace') is None or ref.get('uri') is None:\n rsvLogger.error(\"Reference incorrect for: \", item)\n continue\n if item.get('alias') is not None:\n refDict[item['alias']] = (item['namespace'], ref['uri'])\n else:\n refDict[item['namespace']] = (item['namespace'], ref['uri'])\n refDict[item['namespace'].split('.')[0]] = (item['namespace'], ref['uri'])\n return refDict","def get_verbosity_stats(segments):\r\n # break up segments into words\r\n segments = [s.split(\" \") for s in segments]\r\n feats_dict = {}\r\n get_word_stats(segments, feats_dict)\r\n get_syll_stats(segments, feats_dict)\r\n return feats_dict","def test_getting_segment_details(self):\n pass","def get_halstats_coverage(hal_filename, other_genomes, reference_id):\n \n print(\"Getting mapping counts\")\n \n def get_coverage_for_genome(other_genome):\n # Set up the arguments\n args = [\"halStats\", hal_filename, \"--coverage\", other_genome]\n\n # Open the process\n process = subprocess.Popen(args, stdout=subprocess.PIPE)\n \n # Get the number of bases of the other genome that are aligned to\n # anywhere (or any set of more than one place) in the reference genome.\n coverage = parse_halstats_coverage(process.stdout, reference_id)\n \n if process.wait() != 0:\n raise RuntimeError(\"halStats --coverage failed\")\n \n # Give back the coverage (in columns)\n return coverage\n \n # Get all the coverages in order, and in parallel.\n coverages = ThreadPool(len(other_genomes)).map(get_coverage_for_genome, \n other_genomes) \n \n return dict(itertools.izip(other_genomes, coverages))","def get_section_stats(bd, section_rows, section_cols, parameter_object, section_counter):\r\n\r\n if parameter_object.trigger in ['pantex', 'lac']:\r\n out_d_range = (0, 31)\r\n else:\r\n out_d_range = (0, 255)\r\n\r\n # Scale the data to an 8-bit range.\r\n if (bd.dtype != 'uint8') and (parameter_object.trigger not in parameter_object.spectral_indices):\r\n\r\n bd = np.uint8(rescale_intensity(bd,\r\n in_range=(parameter_object.image_min,\r\n parameter_object.image_max),\r\n out_range=out_d_range))\r\n\r\n # Apply histogram equalization.\r\n if parameter_object.trigger != 'dmp':\r\n\r\n if parameter_object.equalize:\r\n bd = equalize_hist(bd, nbins=256)\r\n\r\n elif parameter_object.equalize_adapt:\r\n \r\n bd = equalize_adapthist(bd,\r\n kernel_size=(int(section_rows / 128),\r\n int(section_cols / 128)),\r\n clip_limit=.05,\r\n nbins=256)\r\n\r\n if parameter_object.equalize or parameter_object.equalize_adapt:\r\n\r\n bd = np.uint8(rescale_intensity(bd,\r\n in_range=(0., 1.0),\r\n out_range=(0, 255)))\r\n\r\n # Remove image noise.\r\n if parameter_object.smooth > 0:\r\n bd = np.uint8(cv2.bilateralFilter(bd, parameter_object.smooth, 0.1, 0.1))\r\n\r\n # elif parameter_object.trigger == 'lbp':\r\n #\r\n # if parameter_object.visualize:\r\n # bdOrig = bd.copy()\r\n #\r\n # elif parameter_object.trigger == 'hough':\r\n #\r\n # # for display (testing) purposes only\r\n # if parameter_object.visualize:\r\n # bdOrig = bd.copy()\r\n #\r\n # # test canny and hough lines\r\n # if parameter_object.visualize:\r\n #\r\n # # for display purposes only\r\n # bdOrig = bd.copy()\r\n #\r\n # test_plot(bd, bdOrig, parameter_object.trigger, parameter_object)\r\n\r\n # Get the row and column section chunk indices.\r\n # chunk_indices = get_chunk_indices(section_rows,\r\n # section_cols,\r\n # parameter_object.block,\r\n # parameter_object.chunk_size,\r\n # parameter_object.scales[-1])\r\n\r\n func_dict = dict(dmp=dict(name='Differential Morphological Profiles',\r\n args=dict()),\r\n evi2=dict(name='Two-band Enhanced Vegetation Index',\r\n args=dict()),\r\n fourier=dict(name='Fourier transfrom',\r\n args=dict()),\r\n gabor=dict(name='Gabor filters',\r\n args=dict()),\r\n gndvi=dict(name='Green Normalized Difference Vegetation Index',\r\n args=dict()),\r\n grad=dict(name='Gradient magnitude',\r\n args=dict()),\r\n hog=dict(name='Histogram of Oriented Gradients',\r\n args=dict()),\r\n lac=dict(name='Lacunarity',\r\n args=dict(lac_r=parameter_object.lac_r)),\r\n lbp=dict(name='Local Binary Patterns',\r\n args=dict()),\r\n lbpm=dict(name='Local Binary Patterns moments',\r\n args=dict()),\r\n lsr=dict(name='Line support regions',\r\n args=dict()),\r\n mean=dict(name='Mean',\r\n args=dict()),\r\n ndvi=dict(name='Normalized Difference Vegetation Index',\r\n args=dict()),\r\n pantex=dict(name='PanTex',\r\n args=dict(weight=parameter_object.weight)),\r\n orb=dict(name='Oriented FAST and Rotated BRIEF key points',\r\n args=dict()),\r\n saliency=dict(name='Image saliency',\r\n args=dict()),\r\n seg=dict(name='Segmentation',\r\n args=dict()),\r\n sfs=dict(name='Structural Feature Sets',\r\n args=dict(sfs_threshold=parameter_object.sfs_threshold,\r\n sfs_skip=parameter_object.sfs_skip)))\r\n\r\n for idx in parameter_object.spectral_indices:\r\n if idx not in func_dict:\r\n func_dict[idx] = {'name': idx, 'args': {}}\r\n\r\n logger.info(' Processing {} for section {:,d} of {:,d} ...'.format(func_dict[parameter_object.trigger]['name'],\r\n section_counter,\r\n parameter_object.n_sects))\r\n\r\n other_args = func_dict[parameter_object.trigger]['args']\r\n\r\n if parameter_object.trigger in parameter_object.spectral_indices:\r\n trigger = 'mean'\r\n else:\r\n trigger = parameter_object.trigger\r\n\r\n return call_func(bd,\r\n parameter_object.block,\r\n parameter_object.scales,\r\n parameter_object.scales[-1],\r\n trigger,\r\n **other_args)\r\n\r\n # return Parallel(n_jobs=parameter_object.n_jobs_chunk,\r\n # max_nbytes=None)(delayed(call_func)(bd[chi[0]:chi[1],\r\n # chi[2]:chi[3]],\r\n # parameter_object.block,\r\n # parameter_object.scales,\r\n # parameter_object.scales[-1],\r\n # parameter_object.trigger,\r\n # **other_args) for chi in chunk_indices)\r","def compute_stats(self, dataset, portion):\n with torch.no_grad():\n specgrams = []\n samples = 5000\n for i_batch, (mix, _, _) in enumerate(dataset):\n mix = mix[portion]\n spec = self.calculate_mag(mix, db_conversion=True)\n specgrams.append(spec)\n if (i_batch + 1) * mix.shape[0] > samples:\n break\n specgrams = torch.cat(specgrams, 0)\n self.mean.data = specgrams.mean(dim=(0, 2), keepdim=True)\n self.std.data = specgrams.std(dim=(0, 2), keepdim=True)\n None","def get_svalex2_stats(self, t, svalex2_list):\n if self.params:\n diff_info, level = get_svalex2_info(t, svalex2_list, self.params.get(\"target_cefr\",\"B1\"))\n else:\n diff_info, level = get_svalex2_info(t, svalex2_list, self.sent.level)\n self.stats[\"voc_cefr_svalex2\"][level] += 1.0\n if t.pos in [\"NN\", \"VB\"] and (diff_info == \"above\"):\n put_feature_value(self.stats, \"diff_NNVB_svalex2\", 1.0)\n if diff_info == \"above\": \n put_feature_value_list(self.stats,\"diff_voc_svalex2\", t.word)\n return self.stats","def bleu_stats(hypothesis, reference):\n stats = []\n stats.append(len(hypothesis))\n stats.append(len(reference))\n for n in range(1, 5):\n s_ngrams = Counter(\n [tuple(hypothesis[i:i + n]) for i in range(len(hypothesis) + 1 - n)]\n )\n r_ngrams = Counter(\n [tuple(reference[i:i + n]) for i in range(len(reference) + 1 - n)]\n )\n stats.append(max([sum((s_ngrams & r_ngrams).values()), 0]))\n stats.append(max([len(hypothesis) + 1 - n, 0]))\n return stats","def bleu_stats(hypothesis, reference):\n stats = []\n stats.append(len(hypothesis))\n stats.append(len(reference))\n for n in range(1, 5):\n s_ngrams = Counter(\n [tuple(hypothesis[i:i + n]) for i in range(len(hypothesis) + 1 - n)]\n )\n r_ngrams = Counter(\n [tuple(reference[i:i + n]) for i in range(len(reference) + 1 - n)]\n )\n stats.append(max([sum((s_ngrams & r_ngrams).values()), 0]))\n stats.append(max([len(hypothesis) + 1 - n, 0]))\n return stats","def stats(stats_var):\n place_dcids = request.args.getlist('dcid')\n return get_stats_wrapper('^'.join(place_dcids), stats_var)","def read_segment_counters(device, ls_number):\n return LumiSegment(\n ls_number=ls_number,\n rates_before_prescaler=blockread(device, \"gt_mp7_gtlfdl.rate_cnt_before_prescaler\"),\n rates_after_prescaler=blockread(device, \"gt_mp7_gtlfdl.rate_cnt_after_prescaler\"),\n deadtime_counters=blockread(device, \"gt_mp7_gtlfdl.rate_cnt_post_dead_time\"),\n l1a_rate=read(args.device, \"gt_mp7_gtlfdl.rate_cnt_l1a\")\n )","def calculate_number_of_references(div):\n n_publication_ref = len(\n [ref for ref in div.find_all(\"ref\") if ref.attrs.get(\"type\") == \"bibr\"]\n )\n n_figure_ref = len(\n [ref for ref in div.find_all(\"ref\") if ref.attrs.get(\"type\") == \"figure\"]\n )\n return {\"n_publication_ref\": n_publication_ref, \"n_figure_ref\": n_figure_ref}","def compute_statistics(self):","def calls_to_site_stats(\n config: BamExtractConfig, sites: typing.List[vcf.Site], calls_vcf: str\n) -> typing.List[vcf.SiteStats]:\n variant_stats = {site.short_notation: vcf.VariantStats() for site in sites}\n genome_release = sites[0].genome_release\n\n with vcfpy.Reader.from_path(calls_vcf) as reader:\n for record in reader:\n key = \"-\".join(map(str, (genome_release, record.CHROM, record.POS)))\n dp = record.INFO.get(\"DP\")\n if record.ALT:\n ad = record.calls[0].data.get(\"AD\")[1]\n else:\n ad = record.calls[0].data.get(\"AD\")[0]\n gt = vcf.Genotype.from_value(record.calls[0].data.get(\"GT\"))\n variant_stats[key] = vcf.VariantStats(genotype=gt, total_cov=dp, alt_cov=ad,)\n\n return [vcf.SiteStats(site=site, stats=variant_stats[site.short_notation],) for site in sites]","def get_member_stats(self):\n self.mstats = {}\n # add in members from expanded_def (which includes any merges)\n for qid in self.expanded_def.keys():\n # check for trailing quantity specifier (!, *, +, ?). Not for name space.\n # ! - required (default), * - 0 or more, + - 1 or more, ? - 0 or 1\n id, qty = self.file.parse_qty(qid, \"!\")\n if id in self.mstats.keys():\n print \"** Error, duplicate (%s) id in group\" % id\n traceback.print_stack()\n sys.exit(1)\n type = 'group' if id.endswith('/') else 'dataset'\n self.mstats[id] = { 'ns': self.sdef['ns'], 'qty': qty,\n 'df': self.expanded_def[qid], 'created': [], 'type': type }\n # add in members from any includes\n # print \"** processing includes\"\n for qidq in self.includes:\n qid, qty = self.file.parse_qty(qidq, \"!\")\n # print \"processing include\", qid\n sdef = self.file.get_sdef(qid, self.sdef['ns'], \"Referenced in include\")\n # print \"obtained sdef:\"\n # pp.pprint(sdef)\n modifiers = self.includes[qidq]\n if len(modifiers) > 0:\n # need to incorporate modifications to definition of included child members\n df = copy.deepcopy(sdef['df'])\n # self.modify(df, modifiers)\n self.merge(df, modifiers) # merges modifiers into definition\n # print \"df after merging modifiers:\"\n else:\n df = sdef['df']\n # print \"df after copy:\"\n id = sdef['id']\n type = sdef['type']\n # pp.pprint(df)\n # qty = '!' # assume includes are required\n if id in self.mstats.keys():\n print \"** Error, duplicate (%s) id in group, referenced by include\" % id\n traceback.print_stack()\n sys.exit(1)\n self.mstats[id] = { 'ns': self.sdef['ns'], 'qty': qty,\n 'df': df, 'created': [], 'type': type }\n # print \"after processing all includes, mstats is:\"\n # pp.pprint(self.mstats)","def oversegmentation_statistics(seg, n_bins):\n\n def extract_segs_in_slice(z):\n # 2d blocking representing the patches\n seg_z = seg[:,:,z]\n return np.unique(seg_z).shape[0]\n\n # parallel\n with futures.ThreadPoolExecutor(max_workers=8) as executor:\n tasks = []\n for z in xrange(seg.shape[2]):\n tasks.append(executor.submit(extract_segs_in_slice, z))\n segs_per_slice = [fut.result() for fut in tasks]\n\n # calculate histogram to have a closer look at the stats\n histo, bin_edges = np.histogram(segs_per_slice, bins = n_bins)\n # we only need the bin_edges\n return bin_edges","def get_ref_values(sbf):\n\n filename = path.join(REFERENCE_DIR, \"{}.npy\".format(sbf))\n values = np.split(np.load(filename), ANGULAR_POINTS + 1)\n return values[0], values[1:]","def get_svalex_stats(self,t, svalex_list):\n if t.pos in [\"NN\", \"VB\", \"JJ\", \"AB\"]:\n svalex_info = get_svalex_info(svalex_list, t, self.params.get(\"target_cefr\",\"any\"))\n svalex_fr,out_of_svalex = svalex_info[0], svalex_info[1]\n put_feature_value_list(self.stats,\"svalex_fr\", svalex_fr)\n if out_of_svalex:\n put_feature_value_list(self.stats,\"out_of_svalex\", t.word)\n return self.stats","def getStartAndEndCoordinates(alignedSegment):\n return alignedSegment.reference_start, getFirstNonClippedPositionInRead(alignedSegment, readSeq), \\\n alignedSegment.reference_end-1, getLastNonClippedPositionInRead(alignedSegment, readSeq)","def gather_sample(self, stat_file, collector=None):\n\n if not collector:\n collector = {}\n\n for line in stat_file:\n # Each line has a format of:\n # Tag: Value\n #\n # We parse out all lines looking like that and match the stats we care about.\n m = re.search(r\"^(\\w+):\\s*(\\d+)\", line)\n if m is None:\n continue\n\n field_name = m.group(1)\n int_value = int(m.group(2))\n # FDSize is not the same as the number of open file descriptors. Disable\n # for now.\n # if field_name == \"FDSize\":\n # self.print_sample(\"app.fd\", int_value)\n if field_name == \"VmSize\":\n collector.update({Metric(\"app.mem.bytes\", \"vmsize\"): int_value * 1024})\n elif field_name == \"VmPeak\":\n collector.update(\n {Metric(\"app.mem.bytes\", \"peak_vmsize\"): int_value * 1024}\n )\n elif field_name == \"VmRSS\":\n collector.update(\n {Metric(\"app.mem.bytes\", \"resident\"): int_value * 1024}\n )\n elif field_name == \"VmHWM\":\n collector.update(\n {Metric(\"app.mem.bytes\", \"peak_resident\"): int_value * 1024}\n )\n return collector","async def get_formatted_stats(self, stats) -> dict:\n # get all patients\n all_patients = [key for key in stats['patients']['process']]\n all_patients.sort(key= lambda p: int(p[-1]))\n # get all processes in sorted order\n processes = self.nodes_in_bfs_order()\n patient_headers = [\"Patient ID\"]\n app.logger.info(stats)\n # set up patient.csv headers\n for process in processes:\n patient_headers.append(process + \"_process_time\")\n patient_headers.append(process + \"_wait_time\")\n patient_csv = [patient_headers]\n for patient in all_patients:\n res = [patient]\n for process in processes:\n # for each patient add the process time and wait time for each process\n if patient in stats['patients']['process'] and process in stats['patients']['process'][patient]:\n process_time = stats['patients']['process'][patient][process]\n else:\n # patient did not visit this process\n process_time = \"None\"\n if patient in stats['patients']['wait'] and process in stats['patients']['wait'][patient]:\n wait_time = stats['patients']['wait'][patient][process]\n else:\n # patient did not wait in this process\n wait_time = \"None\"\n res.append(process_time)\n res.append(wait_time)\n patient_csv.append(res)\n # get all doctors\n all_doctors = [key for key in stats['doctors']['seen']]\n doctor_headers = [\"Doctor ID\", \"seen\"]\n for patient in all_patients:\n doctor_headers.append(patient)\n doctor_csv = [doctor_headers]\n for doctor in all_doctors:\n res = [doctor, stats['doctors']['seen'][doctor]]\n # for each doctor get the time spent with each patient\n for patient in all_patients:\n if patient in stats['doctors']['length'][doctor]:\n res.append(str(stats['doctors']['length'][doctor][patient]))\n else:\n res.append(\"None\")\n doctor_csv.append(res)\n\n hospital_headers = [key for key in stats['hospital']]\n hosptial_csv = [hospital_headers]\n hospital_data = []\n for k, value in stats[\"hospital\"].items():\n hospital_data.append(value)\n\n hosptial_csv.append(hospital_data)\n util_headers = []\n util_body = []\n # format resource utilization\n for resource in processes:\n if resource in stats[\"util\"]:\n util_headers.append(resource)\n util_body.append(stats[\"util\"][resource])\n util_csv = [util_headers, util_body]\n\n formatted_stats = {\"stats\": stats[\"stats\"], \"hospital\": hosptial_csv, \"doctors\": doctor_csv, \"patients\": patient_csv, \"util\": util_csv}\n return formatted_stats","def getSegmentCount(self) -> int:\n ...","def stats(self):","def get_syll_stats(segments, feats_dict):\r\n syll_count_list = []\r\n for segment in segments:\r\n for word in segment:\r\n syll_count_list.append(textstat.syllable_count(word))\r\n feats_dict['syll_mean'] = np.mean(syll_count_list) if syll_count_list else float('nan')\r\n feats_dict['syll_median'] = np.median(syll_count_list) if syll_count_list else float('nan')\r\n feats_dict['syll_stdev'] = np.std(syll_count_list) if syll_count_list else float('nan')\r\n feats_dict['syll_min'] = min(syll_count_list) if syll_count_list else float('nan')\r\n feats_dict['syll_max'] = max(syll_count_list) if syll_count_list else float('nan')","def _get_urls_drs(file_type, id, reference_name = None, start = None, end = None):\n\n file_exists = file_exists_drs(id)\n if file_exists:\n file_format = \"VCF\" \n urls = _create_slices(CHUNK_SIZE, id, reference_name, start, end)\n response = {\n 'htsget': {\n 'format': file_format,\n 'urls': urls \n }\n }\n return {\"response\": response, \"http_status_code\": 200}\n else:\n err = f\"No {file_type} found for id: {id}\" \n return {\"response\": err, \"http_status_code\": 404}","def get_ref_of_region(self, contig, site):\n return self.FastaFile.fetch(region=contig+site).upper()","def read_bdf_segment(st, segment):\n\n assert segment < st.nsegment, ('segment {0} is too big for nsegment {1}'\n .format(segment, st.nsegment))\n\n # define integration range\n nskip = (24*3600*(st.segmenttimes[segment, 0]\n - st.metadata.starttime_mjd)/st.metadata.inttime).astype(int)\n logger.info('Reading scan {0}, segment {1}/{2}, times {3} to {4}'\n .format(st.metadata.scan, segment, len(st.segmenttimes)-1,\n qa.time(qa.quantity(st.segmenttimes[segment, 0], 'd'),\n form=['hms'], prec=9)[0],\n qa.time(qa.quantity(st.segmenttimes[segment, 1], 'd'),\n form=['hms'], prec=9)[0]))\n data = read_bdf(st, nskip=nskip).astype('complex64')\n\n return data","def get_campaign_stat_by_referrals(self, id):\n logger.info(\"Function call: get_campaign_stat_by_referrals from: '{}'\".format(id, ))\n return self.__handle_error(\"Empty campaign id\") if not id else self.__handle_result(self.__send_request('campaigns/{}/referrals'.format(id, )))","def get_gc_content(cst, nmsk, segs):\n assert isinstance(cst, ChromStruct)\n\n # load the reference chromosome\n # ref = fasta_array(cst.chrom, cst.refg_files)\n ref = fasta_array(cst.chrom, cst.ancs_files)\n\n # get the GC content at neutral sites for each segment\n gc = []\n for (start, end) in segs:\n cur_msk = nmsk[start:end]\n if not np.sum(cur_msk > 0):\n gc.append(0)\n else:\n cur_ref = ref[start:end]\n cur_neut = cur_ref[cur_msk > 0]\n gc_count = np.sum(np.in1d(cur_neut, ['C', 'G']))\n gc_fract = 1.0 * gc_count / len(cur_neut)\n gc.append(gc_fract)\n\n return np.array(gc)","def extract_ref(line, refType):\n target = '\\\\' + refType + '{'\n\n start = line.find(target)\n for i in range(start, len(line)):\n if line[i] == '}':\n ref = line[start + len(target) : i]\n break\n return ref","def stats(self):\n stats = {\n 'lines' : '', # This will count the lines under each split\n 'status_code': self.status_code,\n 'content_type': self.mime,\n 'hop': self.hop_path[-1:],\n 'sum:content_length': self.content_length,\n 'host': self.host(),\n 'source': self.source\n }\n # Add in annotations:\n for annot in self.annotations:\n # Set a prefix based on what it is:\n prefix = ''\n if self.re_tries.match(annot):\n prefix = 'tries:'\n elif self.re_ip.match(annot):\n prefix = \"ip:\"\n # Only emit lines with annotations:\n if annot != \"-\":\n stats[\"%s%s\" % (prefix, annot)] = \"\"\n return stats","def outputSegmentStat(self, param_combo2array_id2no_of_segments):\n\t\tparam_combo_ls = param_combo2array_id2no_of_segments.keys()\n\t\tparam_combo_ls.sort()\n\t\tfor param_combo in param_combo_ls:\n\t\t\tarray_id2no_of_segments = param_combo2array_id2no_of_segments.get(param_combo)\n\t\t\tno_of_arrays = len(array_id2no_of_segments)\n\t\t\tno_of_segments_ls = array_id2no_of_segments.values()\n\t\t\tno_of_segments_per_array = sum(no_of_segments_ls)/float(no_of_arrays)\n\t\t\tsys.stderr.write(\"Param-combo (a, T, M) %s: %s segments per array.\\n\"%(repr(param_combo), no_of_segments_per_array))","def getReferenceIndividualCount(self, sample_id):\r\n if sample_id in self._data:\r\n return self._data[sample_id][0]\r\n else:\r\n raise ValueError(\"Unknown sample '%s'.\" % sample_id)","def read_refcopy(f):\n\n d_refcopy = {}\n for n, line in enumerate(open(f)):\n if line.startswith('#'):\n continue\n\n line = line.rstrip()\n if line == '':\n continue\n\n _lis = line.split('\\t')\n taxa, num, = _lis[:2]\n skip = False\n for word in EXCLUDE:\n if word in taxa:\n skip = True\n break\n\n if skip:\n continue \n\n # the parsing of taxa works for both mothur output and this\n taxa = taxa.rstrip(';') # for mothur classfy.seqs output\n lis = taxa.split(';')\n lis2 = []\n for item in lis:\n item = item.strip() # for copyrigher copy table ' ;' separater\n if item.endswith(')'):\n item = item.rsplit('(', 1)[0].strip()\n\n # remove taxon level prefix, e.g. 'p__Firmicutes'\n if '__' in item:\n item = item.split('__', 1)[1]\n\n #item = item.strip('\"')\n\n # green gene taxonomy has sapce\n item = item.replace(' ', '_')\n\n item = item.lower()\n if item in ['', 'unknown', 'other', 'unassigned']:\n item = 'Unclassifed'\n\n item = item.capitalize()\n lis2.append(item)\n\n length = len(lis2)\n assert length <= LEVELS, '> {} levels found ({})'.format(\n LEVELS, length)\n if length != LEVELS:\n lis2 = lis2 + ['Unclassified']*(LEVELS - length)\n\n tu = tuple(lis2)\n d_refcopy[tu] = float(num)\n\n return d_refcopy","def unpack_segment(self, segment: bytes) -> dict:\n unpacked = struct.unpack(HEADER_FORMAT + DATA_FORMAT, segment)\n unpacked = dict(zip(SEGMENT_KEYS, unpacked))\n unpacked['flag'] = Flag(unpacked['flag'])\n return unpacked","def get_statistic_section(self,section):\n\n if section==\"summary\":\n return {\n 'data': {\n 'videos':len(self.videos),\n 'meta':self.count_video_meta(),\n 'dash':self.count_dash(),\n 'comments':self.count_comments(),\n },\n 'global': {\n 'videos':YoutubeVideo.query.count(),\n 'meta':YoutubeVideoMeta.query.count(),\n }\n }\n elif section==\"publishedAt\":\n return self.get_statistics_dayHistogram()\n\n elif section==\"intersection\":\n return self.get_statistics_assocQuery()\n\n elif section==\"statistics_likeCount\" or section==\"statistics_dislikeCount\" or section==\"statistics_commentCount\" or section==\"statistics_viewCount\":\n table = YoutubeVideoMeta\n if section==\"statistics_likeCount\":\n field = YoutubeVideoMeta.statistics_likeCount\n elif section==\"statistics_dislikeCount\":\n field = YoutubeVideoMeta.statistics_dislikeCount\n elif section==\"statistics_commentCount\":\n field = YoutubeVideoMeta.statistics_commentCount\n elif section==\"statistics_viewCount\":\n field = YoutubeVideoMeta.statistics_viewCount\n elif section==\"dash_representations\":\n return self.get_statistics_dash()\n\n globalStat = self.getAggregations(table,field,forQuery=False)\n queryStat = self.getAggregations(table,field,forQuery=True)\n #queryPercentile = self.get_statistics_percentile(table,field)\n return {\n section:{\n 'data':{\n 'max':queryStat.max,\n 'min':queryStat.min,\n 'sum':queryStat.sum,\n 'avg':queryStat.avg,\n 'stdev':queryStat.stdev\n },\n #'percentile': queryPercentile,\n 'global':{\n 'max':globalStat.max,\n 'min':globalStat.min,\n 'sum':globalStat.sum,\n 'avg':globalStat.avg,\n 'stdev':globalStat.stdev\n }\n }\n }\n elif section==\"category\":\n categories = self.get_statistic_categories()\n return categories","def get_doc_stats(site_name, docname, dirname=''):\n if not dirname:\n dirname = '/'\n doc_name = pathlib.Path(docname).stem\n siteid = _get_site_id(site_name)\n if siteid is None:\n raise FileNotFoundError('no_site')\n dirid = _get_dir_id(siteid, dirname)\n if dirid is None:\n raise FileNotFoundError('no_subdir')\n doc_id = _get_doc_ids(dirid, doc_name)[0]\n if doc_id is None:\n raise FileNotFoundError(\"no_document\")\n\n querystring = 'select source_updated, target_updated, mirror_updated from {} where id = %s;'\n result = execute_query(querystring.format(TABLES[3]), (doc_id,))\n docinfo = result[0]\n return _get_stats(docinfo)","def _GetRefdat(self):\n for rfile in self.refdats.keys():\n# Get times for ref.dat files with a time-stamp.\n words = rfile.replace('.','_').split('_')\n if len(words) == 6 and words[-2].count(':') == 20:\n# This file was time-stamped by the sequence. Get the\n# date and time. file name format:\n# ref_Sep_9_2007_11:28:32.dat\n rtime[rfile] = hms_to_secs(words[-2])\n for pfile in self.pfiles:\n min_difftime = 1.e20\n self.info[pfile]['refdat'] = None\n for rfile in self.refdats.keys():\n if rfile[:3] == 'ref' and 'dat' in rfile:\n# This is a reference data file. First see if the orientation is\n# appended. If the file has neither a time-stamp nor a plane and\n# there is more than one ref.dat, the epi reconstruction will\n# be aborted.\n rinfo = {}\n ref_file = None\n if 'sag' in rfile and self.info[pfile]['plane'] == 'sagittal':\n# self.info[pfile]['refdat'] = rfile\n ref_file = rfile\n break\n elif 'cor' in rfile and self.info[pfile]['plane'] == 'coronal':\n# self.info[pfile]['refdat'] = rfile\n ref_file = rfile\n break\n elif 'axial' in rfile and self.info[pfile]['plane'] == 'axial':\n# self.info[pfile]['refdat'] = rfile\n ref_file = rfile\n break\n elif len(self.refdats.keys()) == 1:\n# Use the only one if that is all there is.\n ref_file = rfile\n epi_time = hms_to_secs(self.info[pfile]['acqtime'].split()[-2])\n if epi_time - rtime[rfile] < min_difftime and \\\n rftime[rfile] > epi_time:\n# Use the reference file that acquired nearest to the EPI\n# but before it.\n min_difftime = epi_time - rtime[rfile]\n# self.info[pfile]['refdat'] = rfile\n ref_file = rfile\n if ref_file:\n# Found a candidate.\n if not self.info[pfile]['refdat']:\n# Haven't found one yet, use it.\n self.info[pfile]['refdat'] = ref_file\n else:\n# Found two. Choose one in the same directory.\n oldpath = os.path.dirname(self.info[pfile]['refdat'])\n newpath = os.path.dirname(ref_file)\n pfile_path = os.path.dirname(pfile)\n if oldpath == newpath:\n# Same path, use the old one.\n self.info[pfile]['refdat'] = ref_file\n elif newpath == pfile_path:\n self.info[pfile]['refdat'] = ref_file\n# else Do nothing, use existing choice.\n elif not os.path.exists(rfile):\n self.info[pfile]['refdat'] = None\n elif os.stat(rfile).st_size > 0:\n# This path is taken if no info is encoded in the file name.\n# Don't use empty ref.dat files.\n self.info[pfile]['refdat'] = rfile","def get_info(line, bit_thresh):\n if len(line) >= 18: # output is from cmsearch\n id, model, bit, inc = line[0].split()[0], line[2], float(line[14]), line[16]\n sstart, send, strand = int(line[7]), int(line[8]), line[9]\n mstart, mend = int(line[5]), int(line[6])\n elif len(line) == 9: # output is from ssu-cmsearch\n if bit_thresh == 0:\n print('# ssu-cmsearch does not include a model-specific inclusion threshold, ', file=sys.stderr)\n print('# please specify a bit score threshold', file=sys.stderr)\n exit()\n id, model, bit = line[1].split()[0], line[0], float(line[6])\n inc = '!' # this is not a feature of ssu-cmsearch\n sstart, send = int(line[2]), int(line[3])\n mstart, mend = int(4), int(5)\n if send >= sstart:\n strand = '+'\n else:\n strand = '-'\n else:\n print('# unsupported hmm format:', file=sys.stderr)\n print('# provide tabular output from ssu-cmsearch and cmsearch supported', file=sys.stderr)\n exit()\n coords = [sstart, send]\n sstart, send = min(coords), max(coords)\n mcoords = [mstart, mend]\n mstart, mend = min(mcoords), max(mcoords)\n return id, model, bit, sstart, send, mstart, mend, strand, inc","def collectStat(self, thread):\n\t\t# update average page load time\n\t\tif self.updated_count == 0:\n\t\t\tself.average_time = thread.load_time\n\t\telse:\n\t\t\tself.average_time = (self.average_time * self.updated_count + thread.load_time) / (self.updated_count + 1)\n\t\t# update stitistics by HTTP code\n\t\tif thread.code not in self.code_statistics:\n\t\t\tself.code_statistics[thread.code] = 1 \n\t\telse:\n\t\t\tself.code_statistics[thread.code] += 1\n\t\t# update count of processed pages\n\t\tself.updated_count += 1","def getSegment(self):\n return self.segment","def get_reference_data(ref_name):\n\n conn = r.connect(host=HOST, port=PORT, db=DB)\n ref_data = r.table(FINGERPRINT_TABLE).get(ref_name).run(conn)\n\n try:\n return ref_data[\"distance\"], ref_data[\"spl\"], ref_data[\"fingerprint\"]\n except KeyError:\n raise LookupError(\"Database does not have the requested reference\")","def get_coverage_stats(\n contig_depth_file, contig_fasta, contig_read_counts_file, contig_stats_out\n):\n print(\"getting coverage stats\")\n # add other files if requested\n # read counts\n logger.info(\"Parsing read count file: {}\".format(contig_read_counts_file))\n read_count_table = pandas.read_csv(\n contig_read_counts_file, delim_whitespace=True, names=[\"ReadCount\", \"Contig\"]\n ).set_index(\"Contig\")\n\n # convert base by base depth data into coverage\n logger.info(\"Parsing read depth file: {}\".format(contig_depth_file))\n mapping_depth_table = get_samtool_depth_table(contig_depth_file, contig_fasta,)\n contig_stats = mapping_depth_table.join(read_count_table, how=\"left\").fillna(0)\n\n for col in [\"Length\", \"ReadCount\", \"MaxCov\", \"MinCov\", \"CumuLength\"]:\n if col in contig_stats.columns:\n contig_stats[col] = contig_stats[col].astype(int)\n\n logger.info(\"Writing coverage table to: {}\".format(contig_stats_out))\n contig_stats.to_csv(contig_stats_out, sep=\"\\t\", float_format=\"%0.2f\")","def computeSegmentsAttributes(mergedSegments,updatedSpeed):\n \n mergedSegments=mergedSegments.assign(nonNullProp = updatedSpeed.notna().sum(axis=1)/updatedSpeed.columns.size)\n mergedSegments=mergedSegments.assign( edges = mergedSegments.nodes.apply(lambda x : np.array([x[0],x[-1]])))\n mergedSegments=mergedSegments.assign( cosHead = mergedSegments['loc'].apply(lambda x :np.cos(np.deg2rad(get_north_azimut([x['coordinates'][-2],x['coordinates'][-1]])))))\n mergedSegments=mergedSegments.assign( sinHead = mergedSegments['loc'].apply(lambda x :np.sin(np.deg2rad(get_north_azimut([x['coordinates'][-2],x['coordinates'][-1]])))))\n mergedSegments=mergedSegments.assign( cosTail = mergedSegments['loc'].apply(lambda x :np.cos(np.deg2rad(get_north_azimut([x['coordinates'][0],x['coordinates'][1]])))))\n mergedSegments=mergedSegments.assign( sinTail = mergedSegments['loc'].apply(lambda x :np.sin(np.deg2rad(get_north_azimut([x['coordinates'][0],x['coordinates'][1]])))))\n mergedSegments=mergedSegments.assign( head = mergedSegments.nodes.apply(lambda x : x[-1]))\n mergedSegments=mergedSegments.assign( tail = mergedSegments.nodes.apply(lambda x : x[0]))\n return mergedSegments","def annotate_copy_number(pos, seg, columns=['major', 'minor'], sample_col='sample_id'):\n results = []\n\n for sample_id in seg[sample_col].unique():\n sample_pos = pos[pos[sample_col] == sample_id]\n sample_seg = seg[seg[sample_col] == sample_id]\n\n for chrom in seg['chr'].unique():\n _pos = sample_pos[sample_pos['chrom'] == chrom]\n _seg = sample_seg[sample_seg['chr'] == chrom]\n\n results.append(find_overlapping_segments(_pos, _seg, columns))\n\n return pd.concat(results)","def get_stat(address, stat):\n base_url = 'https://pkt.cash/api/v1/PKT/pkt/address/'\n request_url = base_url + address\n addrStats = url_to_dict(request_url)\n return int(addrStats[stat])","def fetch_data(self, document, line):\n index = self.resolve_ref(document)\n return line[index]","def get_data(self, fragment, number):\n if self.has_data(fragment, number):\n return self.mdv[fragment][number]['ratio'], self.mdv[fragment][number]['std'], self.mdv[fragment][number]['use']\n return False, False, False","def Read_MapGen(filename,stats = False):\n from numpy import array\n with open(filename,'rt') as file_:\n data = [s.strip() for s in file_.readlines()]\n\n Shorelines = []\n segment = []\n for line in data:\n if line == \"# -b\": #New segment beginning\n if segment: Shorelines.append(array(segment))\n segment = []\n else:\n segment.append(map(float,string.split(line)))\n if segment: Shorelines.append(array(segment))\n\n if stats:\n NumSegments = len(Shorelines)\n NumPoints = False\n for segment in Shorelines:\n NumPoints = NumPoints + len(segment)\n AvgPoints = NumPoints / NumSegments\n print(\"Number of Segments: \", NumSegments)\n print(\"Average Number of Points per segment: \", AvgPoints)\n\n return Shorelines","def getStats(self):\n\n raise NotImplementedError","def get_index_stats(self):\n\n assert self._check_idx, 'No index available'\n idx_stats = []\n for ref in range(self._header.n_refs):\n try:\n mapped = self._index.unmapped[ref].n_mapped\n unmapped = self._index.unmapped[ref].n_unmapped\n idx_stats.append((mapped, unmapped, mapped + unmapped))\n except KeyError:\n idx_stats.append((0, 0, 0))\n return idx_stats","def stats(short_url):\n stats = get_stats(short_url)\n click.echo(stats)","def get_summary_stats(self, output_csv=None):\n\n contig_size_list = []\n\n self.summary_info[\"ncontigs\"] = len(self.contigs)\n\n for contig_id, sequence in self.contigs.items():\n\n logger.debug(\"Processing contig: {}\".format(contig_id))\n\n # Get contig sequence size\n contig_len = len(sequence)\n\n # Add size for average contig size\n contig_size_list.append(contig_len)\n\n # Add to total assembly length\n self.summary_info[\"total_len\"] += contig_len\n\n # Add to average gc\n self.summary_info[\"avg_gc\"].append(\n sum(map(sequence.count, [\"G\", \"C\"])) / contig_len\n )\n\n # Add to missing data\n self.summary_info[\"missing_data\"] += sequence.count(\"N\")\n\n # Get average contig size\n logger.debug(\"Getting average contig size\")\n self.summary_info[\"avg_contig_size\"] = \\\n sum(contig_size_list) / len(contig_size_list)\n\n # Get average gc content\n logger.debug(\"Getting average GC content\")\n self.summary_info[\"avg_gc\"] = \\\n sum(self.summary_info[\"avg_gc\"]) / len(self.summary_info[\"avg_gc\"])\n\n # Get N50\n logger.debug(\"Getting N50\")\n cum_size = 0\n for l in sorted(contig_size_list, reverse=True):\n cum_size += l\n if cum_size >= self.summary_info[\"total_len\"] / 2:\n self.summary_info[\"n50\"] = l\n break\n\n if output_csv:\n logger.debug(\"Writing report to csv\")\n # Write summary info to CSV\n with open(output_csv, \"w\") as fh:\n summary_line = \"{}, {}\\\\n\".format(\n self.sample, \",\".join(\n [str(x) for x in self.summary_info.values()]))\n fh.write(summary_line)","def getStats(self, f, aligned=None):\n regex = re.compile('([\\d|.%]+)')\n input = regex.search(f.next()).group(1)\n mapped = regex.search(f.next()).group(1)\n multiple = regex.search(f.next()).group(1)\n\n if aligned:\n \"\"\"\n things are done differently here\n \"\"\"\n aligned_pairs = regex.search(aligned).group(1)\n return { 'Aligned' : int(aligned_pairs), 'Multiple' : int(input), 'Discordant' : int(mapped)}\n return { 'Input' : int(input), 'Mapped' : int(mapped), 'Multiple' : int(multiple) }","def _get_stats_record(proc_info: psutil.Process) -> ResourceStats:\n return ResourceStats(\n time.time(),\n proc_info.cpu_percent(),\n memory_profiler.memory_usage(proc_info.pid, max_usage=True),\n )","def scanstats(self):\n assert 'masscan' in self._scan_result, 'Do a scan before trying to get result !'\n assert 'scanstats' in self._scan_result['masscan'], 'Do a scan before trying to get result !'\n\n return self._scan_result['masscan']['scanstats']","def stats(self):\n if self.__cache:\n return {\n \"size\": self.__cache.currsize,\n \"maxsize\": self.__cache.maxsize,\n \"hits\": self._hits._value.get(),\n \"miss\": self._misses._value.get(),\n }\n else:\n return super(MemoryCache, self).stats()","def sum_dstats(self, stats, smetrics):\n avg = {}\n\n for disk, metrics in stats.iteritems():\n for mname, metric in metrics.iteritems():\n if mname not in smetrics:\n continue\n if mname in avg:\n avg[mname] += metric\n else:\n avg[mname] = metric\n\n return avg","def getsegs (bounds, split):\n segmentslist=bisect_rectange(split, bounds[0], bounds[1], bounds[2], bounds[3])\n count=1\n segpass=0\n \n #Get list of segment ids currently in database\n query=\"\"\"select seg_id from segment;\"\"\"\n df = pd.read_sql_query(query,con=engine)\n segids=set(df.seg_id)\n \n while count < len(segmentslist):\n try:\n for i in segmentslist:\n segments=getsegmentinfo(i)\n \n \n for seg in segments:\n #If running function several times for different splits, this ignores existing segments and prints a message\n if seg.id in segids: \n segpass+=1\n if (segpass % 10 == 0): \n print (\"{} segments already exist\".format(segpass))\n #Else this is a new segment, so get details from the strava and geocodio apis and save them to a dataframe and eventually to the database\n else:\n location = geocodio_client.reverse((seg.start_latlng[0], seg.start_latlng[1]))\n zipcode=location['results'][0]['address_components']['zip']\n \n newrow = {'seg_id' : seg.id,\n 'resource_state': seg.resource_state,\n 'climb_category':seg.climb_category,\n 'climb_category_desc':seg.climb_category_desc,\n 'average_grade':seg.avg_grade,\n 'elev_difference': str(seg.elev_difference).split()[0],\n 'distance': str(seg.distance).split()[0],\n 'name' : seg.name,\n 'start_lat' : seg.start_latlng[0],\n 'start_long' : seg.start_latlng[1],\n 'end_lat' : seg.end_latlng[0],\n 'end_long' : seg.end_latlng[1],\n 'points' : seg.points,\n 'starred':seg.starred,\n 'zipcode':zipcode\n }\n df=pd.DataFrame(newrow, index=[0])\n \n try:\n #Save dataframe to database\n df.to_sql('segment', engine,index=False,if_exists='append')\n except:\n pass\n\n #Prints message which keeps track of number of sub bounds completed \n if (count % 10) == 0:\n print (\"Getting segments in bound {} of {}\".format(count, len(segmentslist)))\n count+=1\n except Exception as inst:\n print (inst) \n return None","def motif_report(chrom, cluster):\n\tsmallest_ref_pos = min([x[0] for x in cluster])\n\tupper_bound_ref = max([x[0] + len(x[1]) - 1 for x in cluster])\n\toriginal_region = get_region_from_das(assembly, chrom, smallest_ref_pos, upper_bound_ref).upper()\n\trefseq = original_region\n\tif not refseq or len(refseq)==0:\n\t\tprint \" problem obtaining region on the reference sequence:\"\n\t\tprint assembly, chrom, smallest_ref_pos, upper_bound_ref\n\t\treturn None, None\n\n\tseqinfo = []\n\tmotifs = []\n\talignment = []\n\t# I don't really need the alignment here, but since I have it implemented ...\n\talt = [smallest_ref_pos, refseq[0], refseq[0], 1, 1, 1, None]\n\talignment.append(refseq)\n\tseqinfo.append(alt)\n\tfor v in cluster:\n\t\t[pos, ref, alts, var_counts, total_count, max_reach] = v\n\t\tif alts=='' or var_counts=='': continue\n\t\trelative_pos = pos - smallest_ref_pos\n\t\tcounts = var_counts.split(\",\")\n\t\talternatives = alts.split(\",\")\n\t\ta = -1 # index of the alternative sequence fo this position\n\t\tfor sequence in alternatives:\n\t\t\ta += 1\n\t\t\tmotif = find_motif_in_pair(sequence, ref)\n\t\t\tif motif and not motif in motifs: motifs.append(motif)\n\t\t\talt = [pos, ref, sequence, int(counts[a]), total_count, len(ref), motif]\n\t\t\tseqinfo.append(alt)\n\t\t\tadd_modified_seq(alignment, sequence, ref, relative_pos)\n\traw_seqs = [original_region]\n\tfreq = {}\n\tfreq[original_region] = \"1:1\"\n\tfor s in range(1,len(alignment)):\n\t\tmodified_seq = alignment[s]\n\t\t[pos, ref, sequence, count, total_count, max_reach, motif] = seqinfo[s]\n\t\traw_seq = modified_seq.replace('-','')\n\t\t# it seemed to me at one point that eac might have duplicates, but they seem\n\t\t# to have caught them and assigned them a frequency of 0\n\t\tif count==0: continue\n\t\tif raw_seq in raw_seqs:\n\t\t\tpass\n\t\telse:\n\t\t\traw_seqs.append(raw_seq)\n\t\tfreq[raw_seq] = \"%d:%d\" % (count,total_count)\n\n\t########### REPORT/STORE TO DB ##########################\n\t# never mind the clustering - I am not sure any more that it helps\n\t# motif counting though should protect me from counting as diffent\n\t# variants when a motif indel is assigned to a different place in the repeat expansion\n\t# as different a variant\n\t#for cluster in find_comparable_patterns(raw_seqs, motifs):\n\treport_items= []\n\tfor seq in raw_seqs:\n\t\tpattern = decomposition(seq, motifs)\n\t\treport_items.append(prettyprint(pattern) + \",\" + freq[to_string(pattern)])\n\n\n\treturn \",\".join(motifs), \";\".join(report_items)","def _getPlaneRef(self, tracker, station, plane):\n ref = plane + (station-1 + tracker*N_Station)*N_Plane\n return ref","def _ReplicaStats(self, myreplica):\n \n means=[None]*len(myreplica) # creating an empty list for the means with the length of my timepoints indexes\n std=[None]*len(myreplica) # creating an empty list for the std\n for i in range(len(myreplica)):\n means[i]=np.mean(myreplica[i]) # numpy is calculating the means and std for every row and then add it to the list\n std[i]=np.std(myreplica[i])\n #print(means, std)\n return means, std","def extract(\n args: argparse.Namespace,\n input_vcf: str,\n input_bam: str,\n out_file=sys.stdout,\n max_reads: int = None,\n ac: int = None,\n sample: Sample = None,\n force_variant: Variant = None,\n insert_hist: bool = True,\n):\n # Print header line as requested\n if args.header:\n Features.header(out_file, ac)\n\n if sample is not None:\n pass\n elif args.stats_path is not None:\n sample = Sample.from_npsv(args.stats_path, bam_path=input_bam)\n elif None not in (\n args.fragment_mean,\n args.fragment_sd,\n args.read_length,\n args.depth,\n ):\n sample = Sample.from_distribution(\n input_bam,\n args.fragment_mean,\n args.fragment_sd,\n args.read_length,\n mean_coverage=args.depth,\n )\n else:\n raise ValueError(\"Library distribution must be provided\")\n\n # Extract features for all SVs\n vcf_reader = vcf.Reader(filename=input_vcf)\n for record in vcf_reader:\n variant = Variant.from_pyvcf(record, args.reference)\n if variant is None:\n logging.warning(\"Variant type or VCF record not supported for %s. Skipping.\", record.ID)\n\n features = extract_features(\n args,\n variant,\n input_bam,\n sample,\n max_reads=max_reads,\n insert_hist=insert_hist,\n )\n\n # Print features\n features.print_features(\n out_file, force_variant=force_variant, ac=ac,\n )","def gather(ref_gatherer, reference_node, constraints_as_spans, concept_graph):\n my_span = Span('my', 'my', 2, 3, 0, 0, 1)\n very_span = Span('very', 'very', 3, 4, 0, 0, 1)\n red_span = Span('red', 'red', 4, 5, 0, 0, 1)\n car_span = Span('car', 'car', 5, 6, 0, 0, 1)\n graph = ConceptGraph(predicates=[\n ('user', 'possess', 'c1', 'upc'),\n ('c1', 'type', 'car', 'ctc'),\n ('user', 'like', 'c1', 'ulc'),\n ('c1', 'property', 'red', 'cpr'),\n ('cpr', 'property', 'very', 'rpv'),\n ('u1', 'type', 'extra', 'extra1'),\n ('c1', 'focus', None, 'prim1'),\n (my_span.to_string(), 'ref', 'upc'),\n (very_span.to_string(), 'ref', 'rpv'),\n (red_span.to_string(), 'ref', 'cpr'),\n (car_span.to_string(), 'ref', 'c1')\n ])\n graph.features['upc']['comps'] = set()\n graph.features['rpv']['comps'] = set()\n graph.features['cpr']['comps'] = {'prim1'}\n graph.features['c1']['comps'] = {'ctc', 'extra1'}\n constraints_as_spans = {my_span.to_string(), very_span.to_string(),\n red_span.to_string()}\n\n assert ref_gatherer.gather('c1', constraints_as_spans, graph) == \\\n {'upc', 'rpv', 'cpr', 'ctc'}","def segment(data):","def get_alignment_statistics(infile, outfile):\n statement = 'picard CollectAlignmentSummaryMetrics R=%(picard_ref)s I=%(infile)s O=%(outfile)s'\n P.run(statement,\n job_queue = P.PARAMS['queue'],\n job_memory = P.PARAMS['memory'])","def stats():\n global CACHE, STATS_MISSES, STATS_HITS, STATS_KEYS_COUNT\n memory_address = \"0x\" + str(\"%X\" % id( CACHE )).zfill(16)\n return {'cache_memory_address': memory_address,\n 'hits': STATS_HITS,\n 'misses': STATS_MISSES ,\n 'keys_count': STATS_KEYS_COUNT,\n }","def get_semantic_stats(self,t):\n # nr of senses per word and noun\n put_feature_value_list(self.stats, \"senses/w\", len(t.saldo))\n if t.pos == \"NN\":\n put_feature_value_list(self.stats, \"nn_senses/nn\", len(t.saldo))\n return self.stats","def parse_ref_file(file, start_pos=2, end_pos=7):\n data = []\n ref_dict = {}\n try:\n with open(file) as f:\n content = f.read()\n data = [word for lines in content.split(';')[start_pos: end_pos] for word in lines.splitlines(True) if '=' in word]\n for item in data:\n k = item.split('=')[0].strip().strip(\"'\")\n v = item.split('=')[1].strip().strip(\"'\") \n if k not in ref_dict:\n ref_dict[k] = v\n except Exception as e:\n logger.info('Failed to parse SAS dictionary...')\n return {}\n return ref_dict","def fetch_counts(datestruct):\n response = call_responder('elasticsearch', 'query/daily_proofreader_hits')\n for rec in response['result']['hits']['hits']:\n data = rec['_source']\n if data['user'] not in datestruct:\n datestruct[data['user']] = {\"cleave\": 0, \"merge\": 0,\n \"split-supervoxel\": 0}\n if '/cleave/' in data['uri']:\n datestruct[data['user']]['cleave'] += 1\n elif '/merge' in data['uri']:\n datestruct[data['user']]['merge'] += 1\n elif '/split-supervoxel' in data['uri']:\n datestruct[data['user']]['split-supervoxel'] += 1","def gather_sample(self, stat_file, collector=None):\n\n if not collector:\n collector = {}\n\n for line in stat_file:\n # We just look for the different \"inuse\" lines and output their\n # socket type along with the count.\n m = re.search(r\"(\\w+): inuse (\\d+)\", line)\n if m is not None:\n collector.update(\n {\n Metric(\"app.net.sockets_in_use\", m.group(1).lower()): int(\n m.group(2)\n )\n }\n )\n return collector","async def get_segment(lang: str, key: str) -> Dict[str, str]:\n try:\n collection = get_collection(lang)\n segment = collection[key]\n return {\n \"segmentnr\": segment[\"segmentnr\"],\n \"segment\": segment[\"segment\"],\n \"lang\": segment[\"lang\"],\n }\n except (DocumentNotFoundError, KeyError) as error:\n return error","def extract_variant_info(variant):\n var_regex = re.compile(\n r'(?P<ref>[A-Za-z]+)(?P<position>[-0-9]+)(?P<alt>[A-Za-z]+)$')\n match = var_regex.search(variant)\n reference = match.group('ref')\n position = int(match.group('position'))\n alternate = match.group('alt')\n return reference, position, alternate","def parse_stats(output):\n lines = [line for line in output if \"[Stats]\" in line]\n stats = {\n 'totals': {'time': 0, 'tasks': 0, 'avg': 0}\n }\n for line in lines:\n m = re.search(r'\\((\\d+) ms\\).+\\((\\d+)\\).+\\((\\d+) us.+\\)', line)\n if not m:\n continue\n dt, tasks, avg = map(int, m.groups())\n if 'totals' in line:\n stats['totals'] = {'time': dt, 'tasks': tasks, 'avg': avg}\n return stats","def metadata(self):\n metadata_dict = {}\n for lbl_value, seginfo in self.infos.items():\n prefix = f'Segment{lbl_value}_'\n metadata_dict.update(seginfo.to_dict('slicer', prefix))\n return metadata_dict","def extract_references_from_txt(filename):\n file = open(filename)\n references_section = \"\"\n references_section_found = False\n for line in file:\n if \"REFERENCE\" in line:\n references_section_found = True\n if references_section_found:\n references_section+=line + \" \"\n references_section = references_section.replace('\\n','')\n refs = extract_references(references_section)\n return refs","def getStcStats(self):\n return (self._totalSentences,\n float(self._totalWords) / float(self._totalSentences))"],"string":"[\n \"def get_all_references(alignedsegment):\\n \\n references = [alignedsegment.reference_name]\\n \\n # Some reads don't have secondary hits\\n if not alignedsegment.has_tag('XA'):\\n return references\\n \\n # XA is a string contigname1,<other info>;contigname2,<other info>; ...\\n secondary_alignment_string = alignedsegment.get_tag('XA')\\n secondary_alignments = secondary_alignment_string.split(';')[:-1]\\n \\n for secondary_alignment in secondary_alignments:\\n references.append(secondary_alignment.partition(',')[0])\\n \\n return references\",\n \"def metric_halstats(hal_filename, reference_id=\\\"ref\\\"):\\n \\n # Get the list of dicts of per-genome stats.\\n status_list = get_halstats_stats(hal_filename)\\n \\n # Throw out non-leaves\\n status_list = [entry for entry in status_list if entry[\\\"NumChildren\\\"] == 0]\\n \\n # Grab all the genome names\\n genome_names = [entry[\\\"GenomeName\\\"] for entry in status_list]\\n \\n # Get the dict from genome name to total bases from that genome aligned to\\n # the reference at all, and the dict of N compositions, in parallel.\\n coverage_dict, basecomp_dict = in_parallel(\\n lambda: get_halstats_coverage(hal_filename, genome_names, reference_id),\\n lambda: get_halstats_basecomps(hal_filename, genome_names))\\n \\n for entry in status_list:\\n # For each genome, we want the coverage against the reference.\\n \\n # Grab the genome name\\n genome_name = entry[\\\"GenomeName\\\"]\\n \\n if not coverage_dict.has_key(genome_name):\\n # This is probably the root sequence and didn't get a coverage for\\n # some reason. At any rate, the root sequence would be all Ns\\n continue\\n \\n # Figure out how much of it is not Ns\\n non_n = basecomp_dict[genome_name]\\n \\n # How many bases are eligible?\\n eligible = float(entry[\\\"Length\\\"] * non_n)\\n \\n if eligible == 0:\\n # No coverage is defined\\n entry[\\\"Coverage\\\"] = float(\\\"NaN\\\")\\n continue\\n \\n # Compute and save the coverage for each entry, by dividing bases\\n # aligned by bases eligible.\\n entry[\\\"Coverage\\\"] = coverage_dict[genome_name] / eligible\\n \\n # Return the results\\n return status_list\",\n \"def parse_halstats_coverage(stream, reference_id):\\n \\n # Get a reader and skip the first line\\n reader = csv.reader(stream)\\n for i in xrange(1):\\n next(reader)\\n \\n for data in reader:\\n if len(data) == 0:\\n # We finished the table\\n break\\n \\n \\n # Drop all the whitespace\\n data = [x.strip() for x in data]\\n \\n if data[0] == reference_id:\\n if len(data) > 1:\\n # We have some bases aligned\\n return float(data[1])\\n else:\\n # We had no bases aligned\\n return 0.0\\n \\n raise RuntimeError(\\\"Could not find coverage against {}\\\".format(\\n reference_id))\",\n \"def fetch(self, segment):\\n pass\",\n \"def stats(self, s_sample, d_sample, x_sample, wav_len):\\n\\t\\ts_STDCT_sample, d_STDCT_sample, x_STDCT_sample = self.transfrom_stats(s_sample,\\n\\t\\t\\td_sample, x_sample, wav_len)\\n\\t\\txi_sample = self.xi(s_STDCT_sample, d_STDCT_sample)\\n\\t\\tself.xi_map.stats(xi_sample)\\n\\t\\tcd_sample = self.cd(s_STDCT_sample, d_STDCT_sample)\\n\\t\\tself.cd_map.stats(cd_sample)\",\n \"def stats(self, s_sample, d_sample, x_sample, wav_len):\\n\\t\\ts_STMS_sample, d_STMS_sample, x_STMS_sample = self.transfrom_stats(s_sample,\\n\\t\\t\\td_sample, x_sample, wav_len)\\n\\t\\tself.mag_map.stats(s_STMS_sample)\",\n \"def get_word_stats(segments, feats_dict):\\r\\n word_count_list = []\\r\\n word_lengths = []\\r\\n long_count = 0\\r\\n for segment in segments:\\r\\n word_count_list.append(len(segment))\\r\\n for word in segment:\\r\\n word_lengths.append(len(word))\\r\\n if len(word) > 6:\\r\\n long_count += 1\\r\\n # Compute segment level statistics\\r\\n feats_dict['wc_mean'] = np.mean(word_count_list) if word_count_list else float('nan')\\r\\n feats_dict['wc_median'] = np.median(word_count_list) if word_count_list else float('nan')\\r\\n feats_dict['wc_stdev'] = np.std(word_count_list) if word_count_list else float('nan')\\r\\n feats_dict['wc_min'] = min(word_count_list) if word_count_list else float('nan')\\r\\n feats_dict['wc_max'] = max(word_count_list) if word_count_list else float('nan')\\r\\n feats_dict['total_count'] = sum(word_count_list) if word_count_list else float('nan')\\r\\n\\r\\n # Compute fraction of words across whole call that are long (i.e. 6+ words)\\r\\n feats_dict['lw_count'] = (long_count / feats_dict['total_count']) if feats_dict['total_count'] else float('nan')\\r\\n # Compute mean length of any word used\\r\\n feats_dict['word_len'] = np.mean(word_lengths) if word_lengths else float('nan')\",\n \"def stats(self, s_sample, d_sample, x_sample, wav_len):\\n\\t\\tpass\\n\\t\\t# s_STMS_sample, d_STMS_sample, x_STMS_sample = self.transfrom_stats(s_sample,\\n\\t\\t# \\td_sample, x_sample, wav_len)\\n\\t\\t# smm_sample = tf.math.truediv(s_STMS_sample, x_STMS_sample)\\n\\t\\t# self.smm_map.stats(smm_sample)\",\n \"def calculate_stats(\\n dataloader: AtomsLoader,\\n divide_by_atoms: Dict[str, bool],\\n atomref: Dict[str, torch.Tensor] = None,\\n) -> Dict[str, Tuple[torch.Tensor, torch.Tensor]]:\\n property_names = list(divide_by_atoms.keys())\\n norm_mask = torch.tensor(\\n [float(divide_by_atoms[p]) for p in property_names], dtype=torch.float64\\n )\\n\\n count = 0\\n mean = torch.zeros_like(norm_mask)\\n M2 = torch.zeros_like(norm_mask)\\n\\n for props in tqdm(dataloader):\\n sample_values = []\\n for p in property_names:\\n val = props[p][None, :]\\n if atomref and p in atomref.keys():\\n ar = atomref[p]\\n ar = ar[props[structure.Z]]\\n idx_m = props[structure.idx_m]\\n tmp = torch.zeros((idx_m[-1] + 1,), dtype=ar.dtype, device=ar.device)\\n v0 = tmp.index_add(0, idx_m, ar)\\n val -= v0\\n\\n sample_values.append(val)\\n sample_values = torch.cat(sample_values, dim=0)\\n\\n batch_size = sample_values.shape[1]\\n new_count = count + batch_size\\n\\n norm = norm_mask[:, None] * props[structure.n_atoms][None, :] + (\\n 1 - norm_mask[:, None]\\n )\\n sample_values /= norm\\n\\n sample_mean = torch.mean(sample_values, dim=1)\\n sample_m2 = torch.sum((sample_values - sample_mean[:, None]) ** 2, dim=1)\\n\\n delta = sample_mean - mean\\n mean += delta * batch_size / new_count\\n corr = batch_size * count / new_count\\n M2 += sample_m2 + delta**2 * corr\\n count = new_count\\n\\n stddev = torch.sqrt(M2 / count)\\n stats = {pn: (mu, std) for pn, mu, std in zip(property_names, mean, stddev)}\\n return stats\",\n \"def read_segment(st, segment, cfile=None, timeout=10):\\n\\n # assumed read shape (st.readints, st.nbl, st.metadata.nchan_orig, st.npol)\\n logger.info(\\\"Reading segment {0} of datasetId {1}\\\"\\n .format(segment, st.metadata.datasetId))\\n if st.metadata.datasource == 'sdm':\\n data_read = read_bdf_segment(st, segment)\\n elif st.metadata.datasource == 'vys':\\n data_read = read_vys_segment(st, segment, cfile=cfile, timeout=timeout)\\n elif st.metadata.datasource == 'sim':\\n simseg = segment if cfile else None\\n data_read = simulate_segment(st, segment=simseg)\\n elif st.metadata.datasource == 'vyssim':\\n data_read = read_vys_segment(st, segment, cfile=cfile, timeout=timeout,\\n returnsim=True)\\n else:\\n logger.error('Datasource {0} not recognized.'\\n .format(st.metadata.datasource))\\n\\n # report bad values\\n if np.any(np.isnan(data_read)):\\n logger.warning(\\\"Read data has some NaNs\\\")\\n if np.any(np.isinf(data_read)):\\n logger.warning(\\\"Read data has some Infs\\\")\\n if np.any(np.abs(data_read) > 1e20):\\n logger.warning(\\\"Read data has values larger than 1e20\\\")\\n\\n if not np.any(data_read):\\n logger.info('Read data are all zeros for segment {0}.'.format(segment))\\n return np.array([])\\n else:\\n logger.info('Read data with zero fraction of {0:.3f} for segment {1}'\\n .format(1-np.count_nonzero(data_read)/data_read.size,\\n segment))\\n return data_read\",\n \"def collectGeneralStats(stats: DocStats, service):\\n # Call the data from the api.\\n file_meta = service.files().get(fileId=stats.general.id).execute()\\n # Load in file stats\\n stats.general.name = file_meta.get('title')\\n stats.general.link = file_meta.get('selfLink')\\n stats.general.creationDate = file_meta.get('createdDate')\\n\\n stats.timeline.setTimelineStart(stats.general.creationDate)\",\n \"def stats(self, s_sample, d_sample, x_sample, wav_len):\\n\\t\\ts_STMS_sample, d_STMS_sample, x_STMS_sample = self.transfrom_stats(s_sample,\\n\\t\\t\\td_sample, x_sample, wav_len)\\n\\t\\txi_sample = self.xi(s_STMS_sample, d_STMS_sample)\\n\\t\\tself.xi_map.stats(xi_sample)\\n\\t\\tgamma_sample = self.gamma(x_STMS_sample, d_STMS_sample)\\n\\t\\tself.gamma_map.stats(gamma_sample)\",\n \"def getStatistics(data, reference_column=\\\"time\\\", compareWith=50):\\n overlaps_diff = []\\n overlaps = []\\n sample_info = {}\\n s_info = defaultdict(list)\\n n_windows = len(data[reference_column])\\n for i in range(n_windows):\\n if i != n_windows - 1:\\n if data[reference_column][i] == [] or data[reference_column][i+1] == []:\\n raise ValueError(\\\"\\\\tFile has empty tagged windows. Skipping...\\\")\\n overlap = len(set(data[reference_column][i]) & set(data[reference_column][i + 1])) / \\\\\\n float(len(set(data[reference_column][i + 1]))) * 100\\n overlaps.append(overlap)\\n overlaps_diff.append(overlap - compareWith)\\n\\n for k in data.keys():\\n s_info[k].append(sum([1 for j in data[k][i] if j != \\\"\\\"]))\\n\\n for k in data.keys():\\n sample_info[k] = np.mean(s_info[k])\\n\\n return overlaps, n_windows, sample_info, np.mean(overlaps), np.mean(overlaps_diff)\",\n \"def stats(self, s_sample, d_sample, x_sample, wav_len):\\n\\t\\ts_STMS_sample, d_STMS_sample, x_STMS_sample = self.transfrom_stats(s_sample,\\n\\t\\t\\td_sample, x_sample, wav_len)\\n\\t\\txi_sample = self.xi(s_STMS_sample, d_STMS_sample)\\n\\t\\tself.xi_map.stats(xi_sample)\",\n \"def stats(self, s_sample, d_sample, x_sample, wav_len):\\n\\t\\ts_STMS_sample, d_STMS_sample, x_STMS_sample = self.transfrom_stats(s_sample,\\n\\t\\t\\td_sample, x_sample, wav_len)\\n\\t\\txi_sample = self.xi(s_STMS_sample, d_STMS_sample)\\n\\t\\tself.xi_map.stats(xi_sample)\",\n \"def stats(self, s_sample, d_sample, x_sample, wav_len):\\n\\t\\ts_STMS_sample, d_STMS_sample, x_STMS_sample = self.transfrom_stats(s_sample,\\n\\t\\t\\td_sample, x_sample, wav_len)\\n\\t\\tgamma_sample = self.gamma(x_STMS_sample, d_STMS_sample)\\n\\t\\tself.gamma_map.stats(gamma_sample)\",\n \"def GetStats(self):\\r\\n\\t\\tArg1 = self.href\\r\\n\\t\\treturn self._execute('GetStats', payload=locals(), response_object=None)\",\n \"def get_stats(inp_fn):\\n ent_pred_cnts = []\\n ent_gold_cnts = []\\n ent_intr_cnts = []\\n ccs = ConllCorefScores()\\n jsons = [json.loads(line) for line in open(inp_fn, encoding = \\\"utf8\\\")]\\n for doc_dict in jsons:\\n cur_doc = nlp(\\\" \\\".join(doc_dict[\\\"document\\\"]))\\n gold_clusts = doc_dict[\\\"gold_clusters\\\"]\\n pred_clusts = doc_dict[\\\"clusters\\\"]\\n\\n gold_ent_clusts = get_entities(cur_doc, gold_clusts)\\n pred_ent_clusts = get_entities(cur_doc, pred_clusts)\\n\\n gold_clusts_pronouns = [gold_clust\\n for gold_clust, gold_ent_clust\\n in zip(gold_clusts, gold_ent_clusts)\\n if contains_pronoun(gold_ent_clust)]\\n\\n pred_clusts_pronouns = [pred_clust\\n for pred_clust, pred_ent_clust\\n in zip(pred_clusts, pred_ent_clusts)\\n if contains_pronoun(pred_ent_clust)]\\n\\n update_avg_f1(ccs, gold_clusts_pronouns, pred_clusts_pronouns)\\n\\n pred_ents = set(map(str, flatten(pred_ent_clusts)))\\n gold_ents = set(map(str, flatten(gold_ent_clusts)))\\n if (not pred_ents) and (not gold_ents):\\n #TODO: what's going on in these instances?\\n continue\\n\\n ent_pred_cnts.append(len(pred_ents))\\n ent_gold_cnts.append(len(gold_ents))\\n ent_intr_cnts.append(len(pred_ents & gold_ents))\\n\\n ent_micro = micro_f1(ent_pred_cnts, ent_gold_cnts, ent_intr_cnts)\\n ent_macro = macro_f1(ent_pred_cnts, ent_gold_cnts, ent_intr_cnts)\\n ret_dict = {\\\"ent_micro\\\": ent_micro,\\n \\\"ent_macro\\\": ent_macro,\\n \\\"pronoun_avg_f1\\\": get_avg_f1(ccs)}\\n\\n logging.debug(f\\\"micro = {ent_micro['f1']:.2f}, macro = {ent_macro['f1']:.2f}\\\")\\n\\n return ret_dict\",\n \"def get_rec_stats(village, u, s, r, stim, GS, HC, hc_ro, vS, dlS, data,\\n co_occ_pars, idx=None):\\n\\n res = {}\\n\\n if 'anim_data' in data:\\n # Externally observable variables: action, state, reward, x-y position.\\n x, y = village.animal_coords()\\n res['anim_data'] = {'u': u, 's': s, 'r': r, 'x': x, 'y': y}\\n\\n if 'stim_data' in data:\\n # Stimuli: motor feedback and visual input, both noise-free and noisy.\\n res['stim_data'] = stim\\n\\n if 'gs_state' in data:\\n # Instantaneous GS activity.\\n res['gs_state'] = GS.P.copy()\\n\\n if 'hc_state' in data:\\n # Instantaneous HC state estimate (full).\\n res['hc_state'] = utils.get_copy(HC.s)\\n\\n if 'hc_ro' in data:\\n # Instantaneous HC state estimate (read-out only).\\n res['hc_ro'] = hc_ro.copy()\\n\\n if 'vs_state' in data:\\n # Full vS reward estimate across all states.\\n res['vs_state'] = vS.r.copy()\\n\\n if 'dls_state' in data:\\n # Full dlS habit matrix across all states and actions.\\n res['dls_state'] = dlS.Q.copy()\\n\\n if 'co_occs' in data:\\n # Real location - HC state co-occurance frequency in last n steps.\\n co_occ_pars['idx'] = update_co_occ_mat(hc_ro, village.S.index(s),\\n **co_occ_pars)\\n res['co_occs'] = co_occ_pars['co_occs'].copy()\\n\\n if 'gs_hc_pos' in data:\\n # Mean position of GS - HC connectivity, per HC unit.\\n C, xv, yv, circ = HC.GS_HC, GS.xvec, GS.yvec, GS.circular\\n res['gs_hc_pos'] = analysis.GS_HC_conn_mean(C, xv, yv, circ)\\n\\n if 'gs_hc_max' in data:\\n # Max value of GS - HC connectivity, per HC unit (proxy of spread).\\n # Entropy calculation takes a lot of time --> approximated by max.\\n # gs_hc_h = utils.entropy(HC.GS_HC.reshape((len(HC.s_names), -1)).T)\\n res['gs_hc_max'] = HC.GS_HC.max(axis=(1, 2))\\n\\n # Put collected results into data object.\\n for k, v in res.items():\\n if idx is not None:\\n data[k][idx] = v\\n else:\\n data[k] = v\\n\\n return\",\n \"def get_file_mod_stats_for_upstream_refs(file_name, mod_stats_map):\\n with open(file_name) as f:\\n lines = f.readlines()\\n upstream_ref = None\\n upstream_start_line = None\\n for line_number, line in enumerate(lines):\\n if REGION_START_TAG in line:\\n tag, ref_name = _extract_tag_and_ref_name_from_line(line, False)\\n if REGION_UPSTREAM_TAG in tag:\\n upstream_ref = ref_name\\n upstream_start_line = line_number\\n elif REGION_END_TAG in line and upstream_ref:\\n mod_stats = mod_stats_map[upstream_ref]\\n mod_stats.mod_count += 1\\n mod_stats.line_count += line_number - upstream_start_line - 1\\n upstream_ref = None\\n upstream_start_line = None\",\n \"def bleu_stats(hypo, ref, bleu_len=5):\\n stats = list()\\n stats.append(len(hypo))\\n stats.append(len(ref))\\n for n in range(1, bleu_len):\\n s_ngrams = Counter([tuple(hypo[i:i+n]) for i in range(len(hypo)+1-n)])\\n r_ngrams = Counter([tuple(ref[i:i+n]) for i in range(len(ref)+1-n)])\\n stats.append(max([sum((s_ngrams & r_ngrams).values()), 0]))\\n stats.append(max([len(hypo) + 1-n, 0]))\\n return stats\",\n \"def cal_sdri(src_ref, src_est, mix):\\r\\n src_anchor = np.stack([mix, mix], axis=0)\\r\\n sdr, sir, sar, popt = bss_eval_sources(src_ref, src_est)\\r\\n sdr0, sir0, sar0, popt0 = bss_eval_sources(src_ref, src_anchor)\\r\\n avg_sdri = ((sdr[0]-sdr0[0]) + (sdr[1]-sdr0[1])) / 2\\r\\n return avg_sdri\",\n \"def stats(self, s_sample, d_sample, x_sample, wav_len):\\n\\t\\tpass\",\n \"def getReferenceDetails(soup):\\n refDict = {}\\n refs = soup.find_all('edmx:reference')\\n for ref in refs:\\n includes = ref.find_all('edmx:include')\\n for item in includes:\\n if item.get('namespace') is None or ref.get('uri') is None:\\n rsvLogger.error(\\\"Reference incorrect for: \\\", item)\\n continue\\n if item.get('alias') is not None:\\n refDict[item['alias']] = (item['namespace'], ref['uri'])\\n else:\\n refDict[item['namespace']] = (item['namespace'], ref['uri'])\\n refDict[item['namespace'].split('.')[0]] = (item['namespace'], ref['uri'])\\n return refDict\",\n \"def get_verbosity_stats(segments):\\r\\n # break up segments into words\\r\\n segments = [s.split(\\\" \\\") for s in segments]\\r\\n feats_dict = {}\\r\\n get_word_stats(segments, feats_dict)\\r\\n get_syll_stats(segments, feats_dict)\\r\\n return feats_dict\",\n \"def test_getting_segment_details(self):\\n pass\",\n \"def get_halstats_coverage(hal_filename, other_genomes, reference_id):\\n \\n print(\\\"Getting mapping counts\\\")\\n \\n def get_coverage_for_genome(other_genome):\\n # Set up the arguments\\n args = [\\\"halStats\\\", hal_filename, \\\"--coverage\\\", other_genome]\\n\\n # Open the process\\n process = subprocess.Popen(args, stdout=subprocess.PIPE)\\n \\n # Get the number of bases of the other genome that are aligned to\\n # anywhere (or any set of more than one place) in the reference genome.\\n coverage = parse_halstats_coverage(process.stdout, reference_id)\\n \\n if process.wait() != 0:\\n raise RuntimeError(\\\"halStats --coverage failed\\\")\\n \\n # Give back the coverage (in columns)\\n return coverage\\n \\n # Get all the coverages in order, and in parallel.\\n coverages = ThreadPool(len(other_genomes)).map(get_coverage_for_genome, \\n other_genomes) \\n \\n return dict(itertools.izip(other_genomes, coverages))\",\n \"def get_section_stats(bd, section_rows, section_cols, parameter_object, section_counter):\\r\\n\\r\\n if parameter_object.trigger in ['pantex', 'lac']:\\r\\n out_d_range = (0, 31)\\r\\n else:\\r\\n out_d_range = (0, 255)\\r\\n\\r\\n # Scale the data to an 8-bit range.\\r\\n if (bd.dtype != 'uint8') and (parameter_object.trigger not in parameter_object.spectral_indices):\\r\\n\\r\\n bd = np.uint8(rescale_intensity(bd,\\r\\n in_range=(parameter_object.image_min,\\r\\n parameter_object.image_max),\\r\\n out_range=out_d_range))\\r\\n\\r\\n # Apply histogram equalization.\\r\\n if parameter_object.trigger != 'dmp':\\r\\n\\r\\n if parameter_object.equalize:\\r\\n bd = equalize_hist(bd, nbins=256)\\r\\n\\r\\n elif parameter_object.equalize_adapt:\\r\\n \\r\\n bd = equalize_adapthist(bd,\\r\\n kernel_size=(int(section_rows / 128),\\r\\n int(section_cols / 128)),\\r\\n clip_limit=.05,\\r\\n nbins=256)\\r\\n\\r\\n if parameter_object.equalize or parameter_object.equalize_adapt:\\r\\n\\r\\n bd = np.uint8(rescale_intensity(bd,\\r\\n in_range=(0., 1.0),\\r\\n out_range=(0, 255)))\\r\\n\\r\\n # Remove image noise.\\r\\n if parameter_object.smooth > 0:\\r\\n bd = np.uint8(cv2.bilateralFilter(bd, parameter_object.smooth, 0.1, 0.1))\\r\\n\\r\\n # elif parameter_object.trigger == 'lbp':\\r\\n #\\r\\n # if parameter_object.visualize:\\r\\n # bdOrig = bd.copy()\\r\\n #\\r\\n # elif parameter_object.trigger == 'hough':\\r\\n #\\r\\n # # for display (testing) purposes only\\r\\n # if parameter_object.visualize:\\r\\n # bdOrig = bd.copy()\\r\\n #\\r\\n # # test canny and hough lines\\r\\n # if parameter_object.visualize:\\r\\n #\\r\\n # # for display purposes only\\r\\n # bdOrig = bd.copy()\\r\\n #\\r\\n # test_plot(bd, bdOrig, parameter_object.trigger, parameter_object)\\r\\n\\r\\n # Get the row and column section chunk indices.\\r\\n # chunk_indices = get_chunk_indices(section_rows,\\r\\n # section_cols,\\r\\n # parameter_object.block,\\r\\n # parameter_object.chunk_size,\\r\\n # parameter_object.scales[-1])\\r\\n\\r\\n func_dict = dict(dmp=dict(name='Differential Morphological Profiles',\\r\\n args=dict()),\\r\\n evi2=dict(name='Two-band Enhanced Vegetation Index',\\r\\n args=dict()),\\r\\n fourier=dict(name='Fourier transfrom',\\r\\n args=dict()),\\r\\n gabor=dict(name='Gabor filters',\\r\\n args=dict()),\\r\\n gndvi=dict(name='Green Normalized Difference Vegetation Index',\\r\\n args=dict()),\\r\\n grad=dict(name='Gradient magnitude',\\r\\n args=dict()),\\r\\n hog=dict(name='Histogram of Oriented Gradients',\\r\\n args=dict()),\\r\\n lac=dict(name='Lacunarity',\\r\\n args=dict(lac_r=parameter_object.lac_r)),\\r\\n lbp=dict(name='Local Binary Patterns',\\r\\n args=dict()),\\r\\n lbpm=dict(name='Local Binary Patterns moments',\\r\\n args=dict()),\\r\\n lsr=dict(name='Line support regions',\\r\\n args=dict()),\\r\\n mean=dict(name='Mean',\\r\\n args=dict()),\\r\\n ndvi=dict(name='Normalized Difference Vegetation Index',\\r\\n args=dict()),\\r\\n pantex=dict(name='PanTex',\\r\\n args=dict(weight=parameter_object.weight)),\\r\\n orb=dict(name='Oriented FAST and Rotated BRIEF key points',\\r\\n args=dict()),\\r\\n saliency=dict(name='Image saliency',\\r\\n args=dict()),\\r\\n seg=dict(name='Segmentation',\\r\\n args=dict()),\\r\\n sfs=dict(name='Structural Feature Sets',\\r\\n args=dict(sfs_threshold=parameter_object.sfs_threshold,\\r\\n sfs_skip=parameter_object.sfs_skip)))\\r\\n\\r\\n for idx in parameter_object.spectral_indices:\\r\\n if idx not in func_dict:\\r\\n func_dict[idx] = {'name': idx, 'args': {}}\\r\\n\\r\\n logger.info(' Processing {} for section {:,d} of {:,d} ...'.format(func_dict[parameter_object.trigger]['name'],\\r\\n section_counter,\\r\\n parameter_object.n_sects))\\r\\n\\r\\n other_args = func_dict[parameter_object.trigger]['args']\\r\\n\\r\\n if parameter_object.trigger in parameter_object.spectral_indices:\\r\\n trigger = 'mean'\\r\\n else:\\r\\n trigger = parameter_object.trigger\\r\\n\\r\\n return call_func(bd,\\r\\n parameter_object.block,\\r\\n parameter_object.scales,\\r\\n parameter_object.scales[-1],\\r\\n trigger,\\r\\n **other_args)\\r\\n\\r\\n # return Parallel(n_jobs=parameter_object.n_jobs_chunk,\\r\\n # max_nbytes=None)(delayed(call_func)(bd[chi[0]:chi[1],\\r\\n # chi[2]:chi[3]],\\r\\n # parameter_object.block,\\r\\n # parameter_object.scales,\\r\\n # parameter_object.scales[-1],\\r\\n # parameter_object.trigger,\\r\\n # **other_args) for chi in chunk_indices)\\r\",\n \"def compute_stats(self, dataset, portion):\\n with torch.no_grad():\\n specgrams = []\\n samples = 5000\\n for i_batch, (mix, _, _) in enumerate(dataset):\\n mix = mix[portion]\\n spec = self.calculate_mag(mix, db_conversion=True)\\n specgrams.append(spec)\\n if (i_batch + 1) * mix.shape[0] > samples:\\n break\\n specgrams = torch.cat(specgrams, 0)\\n self.mean.data = specgrams.mean(dim=(0, 2), keepdim=True)\\n self.std.data = specgrams.std(dim=(0, 2), keepdim=True)\\n None\",\n \"def get_svalex2_stats(self, t, svalex2_list):\\n if self.params:\\n diff_info, level = get_svalex2_info(t, svalex2_list, self.params.get(\\\"target_cefr\\\",\\\"B1\\\"))\\n else:\\n diff_info, level = get_svalex2_info(t, svalex2_list, self.sent.level)\\n self.stats[\\\"voc_cefr_svalex2\\\"][level] += 1.0\\n if t.pos in [\\\"NN\\\", \\\"VB\\\"] and (diff_info == \\\"above\\\"):\\n put_feature_value(self.stats, \\\"diff_NNVB_svalex2\\\", 1.0)\\n if diff_info == \\\"above\\\": \\n put_feature_value_list(self.stats,\\\"diff_voc_svalex2\\\", t.word)\\n return self.stats\",\n \"def bleu_stats(hypothesis, reference):\\n stats = []\\n stats.append(len(hypothesis))\\n stats.append(len(reference))\\n for n in range(1, 5):\\n s_ngrams = Counter(\\n [tuple(hypothesis[i:i + n]) for i in range(len(hypothesis) + 1 - n)]\\n )\\n r_ngrams = Counter(\\n [tuple(reference[i:i + n]) for i in range(len(reference) + 1 - n)]\\n )\\n stats.append(max([sum((s_ngrams & r_ngrams).values()), 0]))\\n stats.append(max([len(hypothesis) + 1 - n, 0]))\\n return stats\",\n \"def bleu_stats(hypothesis, reference):\\n stats = []\\n stats.append(len(hypothesis))\\n stats.append(len(reference))\\n for n in range(1, 5):\\n s_ngrams = Counter(\\n [tuple(hypothesis[i:i + n]) for i in range(len(hypothesis) + 1 - n)]\\n )\\n r_ngrams = Counter(\\n [tuple(reference[i:i + n]) for i in range(len(reference) + 1 - n)]\\n )\\n stats.append(max([sum((s_ngrams & r_ngrams).values()), 0]))\\n stats.append(max([len(hypothesis) + 1 - n, 0]))\\n return stats\",\n \"def stats(stats_var):\\n place_dcids = request.args.getlist('dcid')\\n return get_stats_wrapper('^'.join(place_dcids), stats_var)\",\n \"def read_segment_counters(device, ls_number):\\n return LumiSegment(\\n ls_number=ls_number,\\n rates_before_prescaler=blockread(device, \\\"gt_mp7_gtlfdl.rate_cnt_before_prescaler\\\"),\\n rates_after_prescaler=blockread(device, \\\"gt_mp7_gtlfdl.rate_cnt_after_prescaler\\\"),\\n deadtime_counters=blockread(device, \\\"gt_mp7_gtlfdl.rate_cnt_post_dead_time\\\"),\\n l1a_rate=read(args.device, \\\"gt_mp7_gtlfdl.rate_cnt_l1a\\\")\\n )\",\n \"def calculate_number_of_references(div):\\n n_publication_ref = len(\\n [ref for ref in div.find_all(\\\"ref\\\") if ref.attrs.get(\\\"type\\\") == \\\"bibr\\\"]\\n )\\n n_figure_ref = len(\\n [ref for ref in div.find_all(\\\"ref\\\") if ref.attrs.get(\\\"type\\\") == \\\"figure\\\"]\\n )\\n return {\\\"n_publication_ref\\\": n_publication_ref, \\\"n_figure_ref\\\": n_figure_ref}\",\n \"def compute_statistics(self):\",\n \"def calls_to_site_stats(\\n config: BamExtractConfig, sites: typing.List[vcf.Site], calls_vcf: str\\n) -> typing.List[vcf.SiteStats]:\\n variant_stats = {site.short_notation: vcf.VariantStats() for site in sites}\\n genome_release = sites[0].genome_release\\n\\n with vcfpy.Reader.from_path(calls_vcf) as reader:\\n for record in reader:\\n key = \\\"-\\\".join(map(str, (genome_release, record.CHROM, record.POS)))\\n dp = record.INFO.get(\\\"DP\\\")\\n if record.ALT:\\n ad = record.calls[0].data.get(\\\"AD\\\")[1]\\n else:\\n ad = record.calls[0].data.get(\\\"AD\\\")[0]\\n gt = vcf.Genotype.from_value(record.calls[0].data.get(\\\"GT\\\"))\\n variant_stats[key] = vcf.VariantStats(genotype=gt, total_cov=dp, alt_cov=ad,)\\n\\n return [vcf.SiteStats(site=site, stats=variant_stats[site.short_notation],) for site in sites]\",\n \"def get_member_stats(self):\\n self.mstats = {}\\n # add in members from expanded_def (which includes any merges)\\n for qid in self.expanded_def.keys():\\n # check for trailing quantity specifier (!, *, +, ?). Not for name space.\\n # ! - required (default), * - 0 or more, + - 1 or more, ? - 0 or 1\\n id, qty = self.file.parse_qty(qid, \\\"!\\\")\\n if id in self.mstats.keys():\\n print \\\"** Error, duplicate (%s) id in group\\\" % id\\n traceback.print_stack()\\n sys.exit(1)\\n type = 'group' if id.endswith('/') else 'dataset'\\n self.mstats[id] = { 'ns': self.sdef['ns'], 'qty': qty,\\n 'df': self.expanded_def[qid], 'created': [], 'type': type }\\n # add in members from any includes\\n # print \\\"** processing includes\\\"\\n for qidq in self.includes:\\n qid, qty = self.file.parse_qty(qidq, \\\"!\\\")\\n # print \\\"processing include\\\", qid\\n sdef = self.file.get_sdef(qid, self.sdef['ns'], \\\"Referenced in include\\\")\\n # print \\\"obtained sdef:\\\"\\n # pp.pprint(sdef)\\n modifiers = self.includes[qidq]\\n if len(modifiers) > 0:\\n # need to incorporate modifications to definition of included child members\\n df = copy.deepcopy(sdef['df'])\\n # self.modify(df, modifiers)\\n self.merge(df, modifiers) # merges modifiers into definition\\n # print \\\"df after merging modifiers:\\\"\\n else:\\n df = sdef['df']\\n # print \\\"df after copy:\\\"\\n id = sdef['id']\\n type = sdef['type']\\n # pp.pprint(df)\\n # qty = '!' # assume includes are required\\n if id in self.mstats.keys():\\n print \\\"** Error, duplicate (%s) id in group, referenced by include\\\" % id\\n traceback.print_stack()\\n sys.exit(1)\\n self.mstats[id] = { 'ns': self.sdef['ns'], 'qty': qty,\\n 'df': df, 'created': [], 'type': type }\\n # print \\\"after processing all includes, mstats is:\\\"\\n # pp.pprint(self.mstats)\",\n \"def oversegmentation_statistics(seg, n_bins):\\n\\n def extract_segs_in_slice(z):\\n # 2d blocking representing the patches\\n seg_z = seg[:,:,z]\\n return np.unique(seg_z).shape[0]\\n\\n # parallel\\n with futures.ThreadPoolExecutor(max_workers=8) as executor:\\n tasks = []\\n for z in xrange(seg.shape[2]):\\n tasks.append(executor.submit(extract_segs_in_slice, z))\\n segs_per_slice = [fut.result() for fut in tasks]\\n\\n # calculate histogram to have a closer look at the stats\\n histo, bin_edges = np.histogram(segs_per_slice, bins = n_bins)\\n # we only need the bin_edges\\n return bin_edges\",\n \"def get_ref_values(sbf):\\n\\n filename = path.join(REFERENCE_DIR, \\\"{}.npy\\\".format(sbf))\\n values = np.split(np.load(filename), ANGULAR_POINTS + 1)\\n return values[0], values[1:]\",\n \"def get_svalex_stats(self,t, svalex_list):\\n if t.pos in [\\\"NN\\\", \\\"VB\\\", \\\"JJ\\\", \\\"AB\\\"]:\\n svalex_info = get_svalex_info(svalex_list, t, self.params.get(\\\"target_cefr\\\",\\\"any\\\"))\\n svalex_fr,out_of_svalex = svalex_info[0], svalex_info[1]\\n put_feature_value_list(self.stats,\\\"svalex_fr\\\", svalex_fr)\\n if out_of_svalex:\\n put_feature_value_list(self.stats,\\\"out_of_svalex\\\", t.word)\\n return self.stats\",\n \"def getStartAndEndCoordinates(alignedSegment):\\n return alignedSegment.reference_start, getFirstNonClippedPositionInRead(alignedSegment, readSeq), \\\\\\n alignedSegment.reference_end-1, getLastNonClippedPositionInRead(alignedSegment, readSeq)\",\n \"def gather_sample(self, stat_file, collector=None):\\n\\n if not collector:\\n collector = {}\\n\\n for line in stat_file:\\n # Each line has a format of:\\n # Tag: Value\\n #\\n # We parse out all lines looking like that and match the stats we care about.\\n m = re.search(r\\\"^(\\\\w+):\\\\s*(\\\\d+)\\\", line)\\n if m is None:\\n continue\\n\\n field_name = m.group(1)\\n int_value = int(m.group(2))\\n # FDSize is not the same as the number of open file descriptors. Disable\\n # for now.\\n # if field_name == \\\"FDSize\\\":\\n # self.print_sample(\\\"app.fd\\\", int_value)\\n if field_name == \\\"VmSize\\\":\\n collector.update({Metric(\\\"app.mem.bytes\\\", \\\"vmsize\\\"): int_value * 1024})\\n elif field_name == \\\"VmPeak\\\":\\n collector.update(\\n {Metric(\\\"app.mem.bytes\\\", \\\"peak_vmsize\\\"): int_value * 1024}\\n )\\n elif field_name == \\\"VmRSS\\\":\\n collector.update(\\n {Metric(\\\"app.mem.bytes\\\", \\\"resident\\\"): int_value * 1024}\\n )\\n elif field_name == \\\"VmHWM\\\":\\n collector.update(\\n {Metric(\\\"app.mem.bytes\\\", \\\"peak_resident\\\"): int_value * 1024}\\n )\\n return collector\",\n \"async def get_formatted_stats(self, stats) -> dict:\\n # get all patients\\n all_patients = [key for key in stats['patients']['process']]\\n all_patients.sort(key= lambda p: int(p[-1]))\\n # get all processes in sorted order\\n processes = self.nodes_in_bfs_order()\\n patient_headers = [\\\"Patient ID\\\"]\\n app.logger.info(stats)\\n # set up patient.csv headers\\n for process in processes:\\n patient_headers.append(process + \\\"_process_time\\\")\\n patient_headers.append(process + \\\"_wait_time\\\")\\n patient_csv = [patient_headers]\\n for patient in all_patients:\\n res = [patient]\\n for process in processes:\\n # for each patient add the process time and wait time for each process\\n if patient in stats['patients']['process'] and process in stats['patients']['process'][patient]:\\n process_time = stats['patients']['process'][patient][process]\\n else:\\n # patient did not visit this process\\n process_time = \\\"None\\\"\\n if patient in stats['patients']['wait'] and process in stats['patients']['wait'][patient]:\\n wait_time = stats['patients']['wait'][patient][process]\\n else:\\n # patient did not wait in this process\\n wait_time = \\\"None\\\"\\n res.append(process_time)\\n res.append(wait_time)\\n patient_csv.append(res)\\n # get all doctors\\n all_doctors = [key for key in stats['doctors']['seen']]\\n doctor_headers = [\\\"Doctor ID\\\", \\\"seen\\\"]\\n for patient in all_patients:\\n doctor_headers.append(patient)\\n doctor_csv = [doctor_headers]\\n for doctor in all_doctors:\\n res = [doctor, stats['doctors']['seen'][doctor]]\\n # for each doctor get the time spent with each patient\\n for patient in all_patients:\\n if patient in stats['doctors']['length'][doctor]:\\n res.append(str(stats['doctors']['length'][doctor][patient]))\\n else:\\n res.append(\\\"None\\\")\\n doctor_csv.append(res)\\n\\n hospital_headers = [key for key in stats['hospital']]\\n hosptial_csv = [hospital_headers]\\n hospital_data = []\\n for k, value in stats[\\\"hospital\\\"].items():\\n hospital_data.append(value)\\n\\n hosptial_csv.append(hospital_data)\\n util_headers = []\\n util_body = []\\n # format resource utilization\\n for resource in processes:\\n if resource in stats[\\\"util\\\"]:\\n util_headers.append(resource)\\n util_body.append(stats[\\\"util\\\"][resource])\\n util_csv = [util_headers, util_body]\\n\\n formatted_stats = {\\\"stats\\\": stats[\\\"stats\\\"], \\\"hospital\\\": hosptial_csv, \\\"doctors\\\": doctor_csv, \\\"patients\\\": patient_csv, \\\"util\\\": util_csv}\\n return formatted_stats\",\n \"def getSegmentCount(self) -> int:\\n ...\",\n \"def stats(self):\",\n \"def get_syll_stats(segments, feats_dict):\\r\\n syll_count_list = []\\r\\n for segment in segments:\\r\\n for word in segment:\\r\\n syll_count_list.append(textstat.syllable_count(word))\\r\\n feats_dict['syll_mean'] = np.mean(syll_count_list) if syll_count_list else float('nan')\\r\\n feats_dict['syll_median'] = np.median(syll_count_list) if syll_count_list else float('nan')\\r\\n feats_dict['syll_stdev'] = np.std(syll_count_list) if syll_count_list else float('nan')\\r\\n feats_dict['syll_min'] = min(syll_count_list) if syll_count_list else float('nan')\\r\\n feats_dict['syll_max'] = max(syll_count_list) if syll_count_list else float('nan')\",\n \"def _get_urls_drs(file_type, id, reference_name = None, start = None, end = None):\\n\\n file_exists = file_exists_drs(id)\\n if file_exists:\\n file_format = \\\"VCF\\\" \\n urls = _create_slices(CHUNK_SIZE, id, reference_name, start, end)\\n response = {\\n 'htsget': {\\n 'format': file_format,\\n 'urls': urls \\n }\\n }\\n return {\\\"response\\\": response, \\\"http_status_code\\\": 200}\\n else:\\n err = f\\\"No {file_type} found for id: {id}\\\" \\n return {\\\"response\\\": err, \\\"http_status_code\\\": 404}\",\n \"def get_ref_of_region(self, contig, site):\\n return self.FastaFile.fetch(region=contig+site).upper()\",\n \"def read_bdf_segment(st, segment):\\n\\n assert segment < st.nsegment, ('segment {0} is too big for nsegment {1}'\\n .format(segment, st.nsegment))\\n\\n # define integration range\\n nskip = (24*3600*(st.segmenttimes[segment, 0]\\n - st.metadata.starttime_mjd)/st.metadata.inttime).astype(int)\\n logger.info('Reading scan {0}, segment {1}/{2}, times {3} to {4}'\\n .format(st.metadata.scan, segment, len(st.segmenttimes)-1,\\n qa.time(qa.quantity(st.segmenttimes[segment, 0], 'd'),\\n form=['hms'], prec=9)[0],\\n qa.time(qa.quantity(st.segmenttimes[segment, 1], 'd'),\\n form=['hms'], prec=9)[0]))\\n data = read_bdf(st, nskip=nskip).astype('complex64')\\n\\n return data\",\n \"def get_campaign_stat_by_referrals(self, id):\\n logger.info(\\\"Function call: get_campaign_stat_by_referrals from: '{}'\\\".format(id, ))\\n return self.__handle_error(\\\"Empty campaign id\\\") if not id else self.__handle_result(self.__send_request('campaigns/{}/referrals'.format(id, )))\",\n \"def get_gc_content(cst, nmsk, segs):\\n assert isinstance(cst, ChromStruct)\\n\\n # load the reference chromosome\\n # ref = fasta_array(cst.chrom, cst.refg_files)\\n ref = fasta_array(cst.chrom, cst.ancs_files)\\n\\n # get the GC content at neutral sites for each segment\\n gc = []\\n for (start, end) in segs:\\n cur_msk = nmsk[start:end]\\n if not np.sum(cur_msk > 0):\\n gc.append(0)\\n else:\\n cur_ref = ref[start:end]\\n cur_neut = cur_ref[cur_msk > 0]\\n gc_count = np.sum(np.in1d(cur_neut, ['C', 'G']))\\n gc_fract = 1.0 * gc_count / len(cur_neut)\\n gc.append(gc_fract)\\n\\n return np.array(gc)\",\n \"def extract_ref(line, refType):\\n target = '\\\\\\\\' + refType + '{'\\n\\n start = line.find(target)\\n for i in range(start, len(line)):\\n if line[i] == '}':\\n ref = line[start + len(target) : i]\\n break\\n return ref\",\n \"def stats(self):\\n stats = {\\n 'lines' : '', # This will count the lines under each split\\n 'status_code': self.status_code,\\n 'content_type': self.mime,\\n 'hop': self.hop_path[-1:],\\n 'sum:content_length': self.content_length,\\n 'host': self.host(),\\n 'source': self.source\\n }\\n # Add in annotations:\\n for annot in self.annotations:\\n # Set a prefix based on what it is:\\n prefix = ''\\n if self.re_tries.match(annot):\\n prefix = 'tries:'\\n elif self.re_ip.match(annot):\\n prefix = \\\"ip:\\\"\\n # Only emit lines with annotations:\\n if annot != \\\"-\\\":\\n stats[\\\"%s%s\\\" % (prefix, annot)] = \\\"\\\"\\n return stats\",\n \"def outputSegmentStat(self, param_combo2array_id2no_of_segments):\\n\\t\\tparam_combo_ls = param_combo2array_id2no_of_segments.keys()\\n\\t\\tparam_combo_ls.sort()\\n\\t\\tfor param_combo in param_combo_ls:\\n\\t\\t\\tarray_id2no_of_segments = param_combo2array_id2no_of_segments.get(param_combo)\\n\\t\\t\\tno_of_arrays = len(array_id2no_of_segments)\\n\\t\\t\\tno_of_segments_ls = array_id2no_of_segments.values()\\n\\t\\t\\tno_of_segments_per_array = sum(no_of_segments_ls)/float(no_of_arrays)\\n\\t\\t\\tsys.stderr.write(\\\"Param-combo (a, T, M) %s: %s segments per array.\\\\n\\\"%(repr(param_combo), no_of_segments_per_array))\",\n \"def getReferenceIndividualCount(self, sample_id):\\r\\n if sample_id in self._data:\\r\\n return self._data[sample_id][0]\\r\\n else:\\r\\n raise ValueError(\\\"Unknown sample '%s'.\\\" % sample_id)\",\n \"def read_refcopy(f):\\n\\n d_refcopy = {}\\n for n, line in enumerate(open(f)):\\n if line.startswith('#'):\\n continue\\n\\n line = line.rstrip()\\n if line == '':\\n continue\\n\\n _lis = line.split('\\\\t')\\n taxa, num, = _lis[:2]\\n skip = False\\n for word in EXCLUDE:\\n if word in taxa:\\n skip = True\\n break\\n\\n if skip:\\n continue \\n\\n # the parsing of taxa works for both mothur output and this\\n taxa = taxa.rstrip(';') # for mothur classfy.seqs output\\n lis = taxa.split(';')\\n lis2 = []\\n for item in lis:\\n item = item.strip() # for copyrigher copy table ' ;' separater\\n if item.endswith(')'):\\n item = item.rsplit('(', 1)[0].strip()\\n\\n # remove taxon level prefix, e.g. 'p__Firmicutes'\\n if '__' in item:\\n item = item.split('__', 1)[1]\\n\\n #item = item.strip('\\\"')\\n\\n # green gene taxonomy has sapce\\n item = item.replace(' ', '_')\\n\\n item = item.lower()\\n if item in ['', 'unknown', 'other', 'unassigned']:\\n item = 'Unclassifed'\\n\\n item = item.capitalize()\\n lis2.append(item)\\n\\n length = len(lis2)\\n assert length <= LEVELS, '> {} levels found ({})'.format(\\n LEVELS, length)\\n if length != LEVELS:\\n lis2 = lis2 + ['Unclassified']*(LEVELS - length)\\n\\n tu = tuple(lis2)\\n d_refcopy[tu] = float(num)\\n\\n return d_refcopy\",\n \"def unpack_segment(self, segment: bytes) -> dict:\\n unpacked = struct.unpack(HEADER_FORMAT + DATA_FORMAT, segment)\\n unpacked = dict(zip(SEGMENT_KEYS, unpacked))\\n unpacked['flag'] = Flag(unpacked['flag'])\\n return unpacked\",\n \"def get_statistic_section(self,section):\\n\\n if section==\\\"summary\\\":\\n return {\\n 'data': {\\n 'videos':len(self.videos),\\n 'meta':self.count_video_meta(),\\n 'dash':self.count_dash(),\\n 'comments':self.count_comments(),\\n },\\n 'global': {\\n 'videos':YoutubeVideo.query.count(),\\n 'meta':YoutubeVideoMeta.query.count(),\\n }\\n }\\n elif section==\\\"publishedAt\\\":\\n return self.get_statistics_dayHistogram()\\n\\n elif section==\\\"intersection\\\":\\n return self.get_statistics_assocQuery()\\n\\n elif section==\\\"statistics_likeCount\\\" or section==\\\"statistics_dislikeCount\\\" or section==\\\"statistics_commentCount\\\" or section==\\\"statistics_viewCount\\\":\\n table = YoutubeVideoMeta\\n if section==\\\"statistics_likeCount\\\":\\n field = YoutubeVideoMeta.statistics_likeCount\\n elif section==\\\"statistics_dislikeCount\\\":\\n field = YoutubeVideoMeta.statistics_dislikeCount\\n elif section==\\\"statistics_commentCount\\\":\\n field = YoutubeVideoMeta.statistics_commentCount\\n elif section==\\\"statistics_viewCount\\\":\\n field = YoutubeVideoMeta.statistics_viewCount\\n elif section==\\\"dash_representations\\\":\\n return self.get_statistics_dash()\\n\\n globalStat = self.getAggregations(table,field,forQuery=False)\\n queryStat = self.getAggregations(table,field,forQuery=True)\\n #queryPercentile = self.get_statistics_percentile(table,field)\\n return {\\n section:{\\n 'data':{\\n 'max':queryStat.max,\\n 'min':queryStat.min,\\n 'sum':queryStat.sum,\\n 'avg':queryStat.avg,\\n 'stdev':queryStat.stdev\\n },\\n #'percentile': queryPercentile,\\n 'global':{\\n 'max':globalStat.max,\\n 'min':globalStat.min,\\n 'sum':globalStat.sum,\\n 'avg':globalStat.avg,\\n 'stdev':globalStat.stdev\\n }\\n }\\n }\\n elif section==\\\"category\\\":\\n categories = self.get_statistic_categories()\\n return categories\",\n \"def get_doc_stats(site_name, docname, dirname=''):\\n if not dirname:\\n dirname = '/'\\n doc_name = pathlib.Path(docname).stem\\n siteid = _get_site_id(site_name)\\n if siteid is None:\\n raise FileNotFoundError('no_site')\\n dirid = _get_dir_id(siteid, dirname)\\n if dirid is None:\\n raise FileNotFoundError('no_subdir')\\n doc_id = _get_doc_ids(dirid, doc_name)[0]\\n if doc_id is None:\\n raise FileNotFoundError(\\\"no_document\\\")\\n\\n querystring = 'select source_updated, target_updated, mirror_updated from {} where id = %s;'\\n result = execute_query(querystring.format(TABLES[3]), (doc_id,))\\n docinfo = result[0]\\n return _get_stats(docinfo)\",\n \"def _GetRefdat(self):\\n for rfile in self.refdats.keys():\\n# Get times for ref.dat files with a time-stamp.\\n words = rfile.replace('.','_').split('_')\\n if len(words) == 6 and words[-2].count(':') == 20:\\n# This file was time-stamped by the sequence. Get the\\n# date and time. file name format:\\n# ref_Sep_9_2007_11:28:32.dat\\n rtime[rfile] = hms_to_secs(words[-2])\\n for pfile in self.pfiles:\\n min_difftime = 1.e20\\n self.info[pfile]['refdat'] = None\\n for rfile in self.refdats.keys():\\n if rfile[:3] == 'ref' and 'dat' in rfile:\\n# This is a reference data file. First see if the orientation is\\n# appended. If the file has neither a time-stamp nor a plane and\\n# there is more than one ref.dat, the epi reconstruction will\\n# be aborted.\\n rinfo = {}\\n ref_file = None\\n if 'sag' in rfile and self.info[pfile]['plane'] == 'sagittal':\\n# self.info[pfile]['refdat'] = rfile\\n ref_file = rfile\\n break\\n elif 'cor' in rfile and self.info[pfile]['plane'] == 'coronal':\\n# self.info[pfile]['refdat'] = rfile\\n ref_file = rfile\\n break\\n elif 'axial' in rfile and self.info[pfile]['plane'] == 'axial':\\n# self.info[pfile]['refdat'] = rfile\\n ref_file = rfile\\n break\\n elif len(self.refdats.keys()) == 1:\\n# Use the only one if that is all there is.\\n ref_file = rfile\\n epi_time = hms_to_secs(self.info[pfile]['acqtime'].split()[-2])\\n if epi_time - rtime[rfile] < min_difftime and \\\\\\n rftime[rfile] > epi_time:\\n# Use the reference file that acquired nearest to the EPI\\n# but before it.\\n min_difftime = epi_time - rtime[rfile]\\n# self.info[pfile]['refdat'] = rfile\\n ref_file = rfile\\n if ref_file:\\n# Found a candidate.\\n if not self.info[pfile]['refdat']:\\n# Haven't found one yet, use it.\\n self.info[pfile]['refdat'] = ref_file\\n else:\\n# Found two. Choose one in the same directory.\\n oldpath = os.path.dirname(self.info[pfile]['refdat'])\\n newpath = os.path.dirname(ref_file)\\n pfile_path = os.path.dirname(pfile)\\n if oldpath == newpath:\\n# Same path, use the old one.\\n self.info[pfile]['refdat'] = ref_file\\n elif newpath == pfile_path:\\n self.info[pfile]['refdat'] = ref_file\\n# else Do nothing, use existing choice.\\n elif not os.path.exists(rfile):\\n self.info[pfile]['refdat'] = None\\n elif os.stat(rfile).st_size > 0:\\n# This path is taken if no info is encoded in the file name.\\n# Don't use empty ref.dat files.\\n self.info[pfile]['refdat'] = rfile\",\n \"def get_info(line, bit_thresh):\\n if len(line) >= 18: # output is from cmsearch\\n id, model, bit, inc = line[0].split()[0], line[2], float(line[14]), line[16]\\n sstart, send, strand = int(line[7]), int(line[8]), line[9]\\n mstart, mend = int(line[5]), int(line[6])\\n elif len(line) == 9: # output is from ssu-cmsearch\\n if bit_thresh == 0:\\n print('# ssu-cmsearch does not include a model-specific inclusion threshold, ', file=sys.stderr)\\n print('# please specify a bit score threshold', file=sys.stderr)\\n exit()\\n id, model, bit = line[1].split()[0], line[0], float(line[6])\\n inc = '!' # this is not a feature of ssu-cmsearch\\n sstart, send = int(line[2]), int(line[3])\\n mstart, mend = int(4), int(5)\\n if send >= sstart:\\n strand = '+'\\n else:\\n strand = '-'\\n else:\\n print('# unsupported hmm format:', file=sys.stderr)\\n print('# provide tabular output from ssu-cmsearch and cmsearch supported', file=sys.stderr)\\n exit()\\n coords = [sstart, send]\\n sstart, send = min(coords), max(coords)\\n mcoords = [mstart, mend]\\n mstart, mend = min(mcoords), max(mcoords)\\n return id, model, bit, sstart, send, mstart, mend, strand, inc\",\n \"def collectStat(self, thread):\\n\\t\\t# update average page load time\\n\\t\\tif self.updated_count == 0:\\n\\t\\t\\tself.average_time = thread.load_time\\n\\t\\telse:\\n\\t\\t\\tself.average_time = (self.average_time * self.updated_count + thread.load_time) / (self.updated_count + 1)\\n\\t\\t# update stitistics by HTTP code\\n\\t\\tif thread.code not in self.code_statistics:\\n\\t\\t\\tself.code_statistics[thread.code] = 1 \\n\\t\\telse:\\n\\t\\t\\tself.code_statistics[thread.code] += 1\\n\\t\\t# update count of processed pages\\n\\t\\tself.updated_count += 1\",\n \"def getSegment(self):\\n return self.segment\",\n \"def get_reference_data(ref_name):\\n\\n conn = r.connect(host=HOST, port=PORT, db=DB)\\n ref_data = r.table(FINGERPRINT_TABLE).get(ref_name).run(conn)\\n\\n try:\\n return ref_data[\\\"distance\\\"], ref_data[\\\"spl\\\"], ref_data[\\\"fingerprint\\\"]\\n except KeyError:\\n raise LookupError(\\\"Database does not have the requested reference\\\")\",\n \"def get_coverage_stats(\\n contig_depth_file, contig_fasta, contig_read_counts_file, contig_stats_out\\n):\\n print(\\\"getting coverage stats\\\")\\n # add other files if requested\\n # read counts\\n logger.info(\\\"Parsing read count file: {}\\\".format(contig_read_counts_file))\\n read_count_table = pandas.read_csv(\\n contig_read_counts_file, delim_whitespace=True, names=[\\\"ReadCount\\\", \\\"Contig\\\"]\\n ).set_index(\\\"Contig\\\")\\n\\n # convert base by base depth data into coverage\\n logger.info(\\\"Parsing read depth file: {}\\\".format(contig_depth_file))\\n mapping_depth_table = get_samtool_depth_table(contig_depth_file, contig_fasta,)\\n contig_stats = mapping_depth_table.join(read_count_table, how=\\\"left\\\").fillna(0)\\n\\n for col in [\\\"Length\\\", \\\"ReadCount\\\", \\\"MaxCov\\\", \\\"MinCov\\\", \\\"CumuLength\\\"]:\\n if col in contig_stats.columns:\\n contig_stats[col] = contig_stats[col].astype(int)\\n\\n logger.info(\\\"Writing coverage table to: {}\\\".format(contig_stats_out))\\n contig_stats.to_csv(contig_stats_out, sep=\\\"\\\\t\\\", float_format=\\\"%0.2f\\\")\",\n \"def computeSegmentsAttributes(mergedSegments,updatedSpeed):\\n \\n mergedSegments=mergedSegments.assign(nonNullProp = updatedSpeed.notna().sum(axis=1)/updatedSpeed.columns.size)\\n mergedSegments=mergedSegments.assign( edges = mergedSegments.nodes.apply(lambda x : np.array([x[0],x[-1]])))\\n mergedSegments=mergedSegments.assign( cosHead = mergedSegments['loc'].apply(lambda x :np.cos(np.deg2rad(get_north_azimut([x['coordinates'][-2],x['coordinates'][-1]])))))\\n mergedSegments=mergedSegments.assign( sinHead = mergedSegments['loc'].apply(lambda x :np.sin(np.deg2rad(get_north_azimut([x['coordinates'][-2],x['coordinates'][-1]])))))\\n mergedSegments=mergedSegments.assign( cosTail = mergedSegments['loc'].apply(lambda x :np.cos(np.deg2rad(get_north_azimut([x['coordinates'][0],x['coordinates'][1]])))))\\n mergedSegments=mergedSegments.assign( sinTail = mergedSegments['loc'].apply(lambda x :np.sin(np.deg2rad(get_north_azimut([x['coordinates'][0],x['coordinates'][1]])))))\\n mergedSegments=mergedSegments.assign( head = mergedSegments.nodes.apply(lambda x : x[-1]))\\n mergedSegments=mergedSegments.assign( tail = mergedSegments.nodes.apply(lambda x : x[0]))\\n return mergedSegments\",\n \"def annotate_copy_number(pos, seg, columns=['major', 'minor'], sample_col='sample_id'):\\n results = []\\n\\n for sample_id in seg[sample_col].unique():\\n sample_pos = pos[pos[sample_col] == sample_id]\\n sample_seg = seg[seg[sample_col] == sample_id]\\n\\n for chrom in seg['chr'].unique():\\n _pos = sample_pos[sample_pos['chrom'] == chrom]\\n _seg = sample_seg[sample_seg['chr'] == chrom]\\n\\n results.append(find_overlapping_segments(_pos, _seg, columns))\\n\\n return pd.concat(results)\",\n \"def get_stat(address, stat):\\n base_url = 'https://pkt.cash/api/v1/PKT/pkt/address/'\\n request_url = base_url + address\\n addrStats = url_to_dict(request_url)\\n return int(addrStats[stat])\",\n \"def fetch_data(self, document, line):\\n index = self.resolve_ref(document)\\n return line[index]\",\n \"def get_data(self, fragment, number):\\n if self.has_data(fragment, number):\\n return self.mdv[fragment][number]['ratio'], self.mdv[fragment][number]['std'], self.mdv[fragment][number]['use']\\n return False, False, False\",\n \"def Read_MapGen(filename,stats = False):\\n from numpy import array\\n with open(filename,'rt') as file_:\\n data = [s.strip() for s in file_.readlines()]\\n\\n Shorelines = []\\n segment = []\\n for line in data:\\n if line == \\\"# -b\\\": #New segment beginning\\n if segment: Shorelines.append(array(segment))\\n segment = []\\n else:\\n segment.append(map(float,string.split(line)))\\n if segment: Shorelines.append(array(segment))\\n\\n if stats:\\n NumSegments = len(Shorelines)\\n NumPoints = False\\n for segment in Shorelines:\\n NumPoints = NumPoints + len(segment)\\n AvgPoints = NumPoints / NumSegments\\n print(\\\"Number of Segments: \\\", NumSegments)\\n print(\\\"Average Number of Points per segment: \\\", AvgPoints)\\n\\n return Shorelines\",\n \"def getStats(self):\\n\\n raise NotImplementedError\",\n \"def get_index_stats(self):\\n\\n assert self._check_idx, 'No index available'\\n idx_stats = []\\n for ref in range(self._header.n_refs):\\n try:\\n mapped = self._index.unmapped[ref].n_mapped\\n unmapped = self._index.unmapped[ref].n_unmapped\\n idx_stats.append((mapped, unmapped, mapped + unmapped))\\n except KeyError:\\n idx_stats.append((0, 0, 0))\\n return idx_stats\",\n \"def stats(short_url):\\n stats = get_stats(short_url)\\n click.echo(stats)\",\n \"def get_summary_stats(self, output_csv=None):\\n\\n contig_size_list = []\\n\\n self.summary_info[\\\"ncontigs\\\"] = len(self.contigs)\\n\\n for contig_id, sequence in self.contigs.items():\\n\\n logger.debug(\\\"Processing contig: {}\\\".format(contig_id))\\n\\n # Get contig sequence size\\n contig_len = len(sequence)\\n\\n # Add size for average contig size\\n contig_size_list.append(contig_len)\\n\\n # Add to total assembly length\\n self.summary_info[\\\"total_len\\\"] += contig_len\\n\\n # Add to average gc\\n self.summary_info[\\\"avg_gc\\\"].append(\\n sum(map(sequence.count, [\\\"G\\\", \\\"C\\\"])) / contig_len\\n )\\n\\n # Add to missing data\\n self.summary_info[\\\"missing_data\\\"] += sequence.count(\\\"N\\\")\\n\\n # Get average contig size\\n logger.debug(\\\"Getting average contig size\\\")\\n self.summary_info[\\\"avg_contig_size\\\"] = \\\\\\n sum(contig_size_list) / len(contig_size_list)\\n\\n # Get average gc content\\n logger.debug(\\\"Getting average GC content\\\")\\n self.summary_info[\\\"avg_gc\\\"] = \\\\\\n sum(self.summary_info[\\\"avg_gc\\\"]) / len(self.summary_info[\\\"avg_gc\\\"])\\n\\n # Get N50\\n logger.debug(\\\"Getting N50\\\")\\n cum_size = 0\\n for l in sorted(contig_size_list, reverse=True):\\n cum_size += l\\n if cum_size >= self.summary_info[\\\"total_len\\\"] / 2:\\n self.summary_info[\\\"n50\\\"] = l\\n break\\n\\n if output_csv:\\n logger.debug(\\\"Writing report to csv\\\")\\n # Write summary info to CSV\\n with open(output_csv, \\\"w\\\") as fh:\\n summary_line = \\\"{}, {}\\\\\\\\n\\\".format(\\n self.sample, \\\",\\\".join(\\n [str(x) for x in self.summary_info.values()]))\\n fh.write(summary_line)\",\n \"def getStats(self, f, aligned=None):\\n regex = re.compile('([\\\\d|.%]+)')\\n input = regex.search(f.next()).group(1)\\n mapped = regex.search(f.next()).group(1)\\n multiple = regex.search(f.next()).group(1)\\n\\n if aligned:\\n \\\"\\\"\\\"\\n things are done differently here\\n \\\"\\\"\\\"\\n aligned_pairs = regex.search(aligned).group(1)\\n return { 'Aligned' : int(aligned_pairs), 'Multiple' : int(input), 'Discordant' : int(mapped)}\\n return { 'Input' : int(input), 'Mapped' : int(mapped), 'Multiple' : int(multiple) }\",\n \"def _get_stats_record(proc_info: psutil.Process) -> ResourceStats:\\n return ResourceStats(\\n time.time(),\\n proc_info.cpu_percent(),\\n memory_profiler.memory_usage(proc_info.pid, max_usage=True),\\n )\",\n \"def scanstats(self):\\n assert 'masscan' in self._scan_result, 'Do a scan before trying to get result !'\\n assert 'scanstats' in self._scan_result['masscan'], 'Do a scan before trying to get result !'\\n\\n return self._scan_result['masscan']['scanstats']\",\n \"def stats(self):\\n if self.__cache:\\n return {\\n \\\"size\\\": self.__cache.currsize,\\n \\\"maxsize\\\": self.__cache.maxsize,\\n \\\"hits\\\": self._hits._value.get(),\\n \\\"miss\\\": self._misses._value.get(),\\n }\\n else:\\n return super(MemoryCache, self).stats()\",\n \"def sum_dstats(self, stats, smetrics):\\n avg = {}\\n\\n for disk, metrics in stats.iteritems():\\n for mname, metric in metrics.iteritems():\\n if mname not in smetrics:\\n continue\\n if mname in avg:\\n avg[mname] += metric\\n else:\\n avg[mname] = metric\\n\\n return avg\",\n \"def getsegs (bounds, split):\\n segmentslist=bisect_rectange(split, bounds[0], bounds[1], bounds[2], bounds[3])\\n count=1\\n segpass=0\\n \\n #Get list of segment ids currently in database\\n query=\\\"\\\"\\\"select seg_id from segment;\\\"\\\"\\\"\\n df = pd.read_sql_query(query,con=engine)\\n segids=set(df.seg_id)\\n \\n while count < len(segmentslist):\\n try:\\n for i in segmentslist:\\n segments=getsegmentinfo(i)\\n \\n \\n for seg in segments:\\n #If running function several times for different splits, this ignores existing segments and prints a message\\n if seg.id in segids: \\n segpass+=1\\n if (segpass % 10 == 0): \\n print (\\\"{} segments already exist\\\".format(segpass))\\n #Else this is a new segment, so get details from the strava and geocodio apis and save them to a dataframe and eventually to the database\\n else:\\n location = geocodio_client.reverse((seg.start_latlng[0], seg.start_latlng[1]))\\n zipcode=location['results'][0]['address_components']['zip']\\n \\n newrow = {'seg_id' : seg.id,\\n 'resource_state': seg.resource_state,\\n 'climb_category':seg.climb_category,\\n 'climb_category_desc':seg.climb_category_desc,\\n 'average_grade':seg.avg_grade,\\n 'elev_difference': str(seg.elev_difference).split()[0],\\n 'distance': str(seg.distance).split()[0],\\n 'name' : seg.name,\\n 'start_lat' : seg.start_latlng[0],\\n 'start_long' : seg.start_latlng[1],\\n 'end_lat' : seg.end_latlng[0],\\n 'end_long' : seg.end_latlng[1],\\n 'points' : seg.points,\\n 'starred':seg.starred,\\n 'zipcode':zipcode\\n }\\n df=pd.DataFrame(newrow, index=[0])\\n \\n try:\\n #Save dataframe to database\\n df.to_sql('segment', engine,index=False,if_exists='append')\\n except:\\n pass\\n\\n #Prints message which keeps track of number of sub bounds completed \\n if (count % 10) == 0:\\n print (\\\"Getting segments in bound {} of {}\\\".format(count, len(segmentslist)))\\n count+=1\\n except Exception as inst:\\n print (inst) \\n return None\",\n \"def motif_report(chrom, cluster):\\n\\tsmallest_ref_pos = min([x[0] for x in cluster])\\n\\tupper_bound_ref = max([x[0] + len(x[1]) - 1 for x in cluster])\\n\\toriginal_region = get_region_from_das(assembly, chrom, smallest_ref_pos, upper_bound_ref).upper()\\n\\trefseq = original_region\\n\\tif not refseq or len(refseq)==0:\\n\\t\\tprint \\\" problem obtaining region on the reference sequence:\\\"\\n\\t\\tprint assembly, chrom, smallest_ref_pos, upper_bound_ref\\n\\t\\treturn None, None\\n\\n\\tseqinfo = []\\n\\tmotifs = []\\n\\talignment = []\\n\\t# I don't really need the alignment here, but since I have it implemented ...\\n\\talt = [smallest_ref_pos, refseq[0], refseq[0], 1, 1, 1, None]\\n\\talignment.append(refseq)\\n\\tseqinfo.append(alt)\\n\\tfor v in cluster:\\n\\t\\t[pos, ref, alts, var_counts, total_count, max_reach] = v\\n\\t\\tif alts=='' or var_counts=='': continue\\n\\t\\trelative_pos = pos - smallest_ref_pos\\n\\t\\tcounts = var_counts.split(\\\",\\\")\\n\\t\\talternatives = alts.split(\\\",\\\")\\n\\t\\ta = -1 # index of the alternative sequence fo this position\\n\\t\\tfor sequence in alternatives:\\n\\t\\t\\ta += 1\\n\\t\\t\\tmotif = find_motif_in_pair(sequence, ref)\\n\\t\\t\\tif motif and not motif in motifs: motifs.append(motif)\\n\\t\\t\\talt = [pos, ref, sequence, int(counts[a]), total_count, len(ref), motif]\\n\\t\\t\\tseqinfo.append(alt)\\n\\t\\t\\tadd_modified_seq(alignment, sequence, ref, relative_pos)\\n\\traw_seqs = [original_region]\\n\\tfreq = {}\\n\\tfreq[original_region] = \\\"1:1\\\"\\n\\tfor s in range(1,len(alignment)):\\n\\t\\tmodified_seq = alignment[s]\\n\\t\\t[pos, ref, sequence, count, total_count, max_reach, motif] = seqinfo[s]\\n\\t\\traw_seq = modified_seq.replace('-','')\\n\\t\\t# it seemed to me at one point that eac might have duplicates, but they seem\\n\\t\\t# to have caught them and assigned them a frequency of 0\\n\\t\\tif count==0: continue\\n\\t\\tif raw_seq in raw_seqs:\\n\\t\\t\\tpass\\n\\t\\telse:\\n\\t\\t\\traw_seqs.append(raw_seq)\\n\\t\\tfreq[raw_seq] = \\\"%d:%d\\\" % (count,total_count)\\n\\n\\t########### REPORT/STORE TO DB ##########################\\n\\t# never mind the clustering - I am not sure any more that it helps\\n\\t# motif counting though should protect me from counting as diffent\\n\\t# variants when a motif indel is assigned to a different place in the repeat expansion\\n\\t# as different a variant\\n\\t#for cluster in find_comparable_patterns(raw_seqs, motifs):\\n\\treport_items= []\\n\\tfor seq in raw_seqs:\\n\\t\\tpattern = decomposition(seq, motifs)\\n\\t\\treport_items.append(prettyprint(pattern) + \\\",\\\" + freq[to_string(pattern)])\\n\\n\\n\\treturn \\\",\\\".join(motifs), \\\";\\\".join(report_items)\",\n \"def _getPlaneRef(self, tracker, station, plane):\\n ref = plane + (station-1 + tracker*N_Station)*N_Plane\\n return ref\",\n \"def _ReplicaStats(self, myreplica):\\n \\n means=[None]*len(myreplica) # creating an empty list for the means with the length of my timepoints indexes\\n std=[None]*len(myreplica) # creating an empty list for the std\\n for i in range(len(myreplica)):\\n means[i]=np.mean(myreplica[i]) # numpy is calculating the means and std for every row and then add it to the list\\n std[i]=np.std(myreplica[i])\\n #print(means, std)\\n return means, std\",\n \"def extract(\\n args: argparse.Namespace,\\n input_vcf: str,\\n input_bam: str,\\n out_file=sys.stdout,\\n max_reads: int = None,\\n ac: int = None,\\n sample: Sample = None,\\n force_variant: Variant = None,\\n insert_hist: bool = True,\\n):\\n # Print header line as requested\\n if args.header:\\n Features.header(out_file, ac)\\n\\n if sample is not None:\\n pass\\n elif args.stats_path is not None:\\n sample = Sample.from_npsv(args.stats_path, bam_path=input_bam)\\n elif None not in (\\n args.fragment_mean,\\n args.fragment_sd,\\n args.read_length,\\n args.depth,\\n ):\\n sample = Sample.from_distribution(\\n input_bam,\\n args.fragment_mean,\\n args.fragment_sd,\\n args.read_length,\\n mean_coverage=args.depth,\\n )\\n else:\\n raise ValueError(\\\"Library distribution must be provided\\\")\\n\\n # Extract features for all SVs\\n vcf_reader = vcf.Reader(filename=input_vcf)\\n for record in vcf_reader:\\n variant = Variant.from_pyvcf(record, args.reference)\\n if variant is None:\\n logging.warning(\\\"Variant type or VCF record not supported for %s. Skipping.\\\", record.ID)\\n\\n features = extract_features(\\n args,\\n variant,\\n input_bam,\\n sample,\\n max_reads=max_reads,\\n insert_hist=insert_hist,\\n )\\n\\n # Print features\\n features.print_features(\\n out_file, force_variant=force_variant, ac=ac,\\n )\",\n \"def gather(ref_gatherer, reference_node, constraints_as_spans, concept_graph):\\n my_span = Span('my', 'my', 2, 3, 0, 0, 1)\\n very_span = Span('very', 'very', 3, 4, 0, 0, 1)\\n red_span = Span('red', 'red', 4, 5, 0, 0, 1)\\n car_span = Span('car', 'car', 5, 6, 0, 0, 1)\\n graph = ConceptGraph(predicates=[\\n ('user', 'possess', 'c1', 'upc'),\\n ('c1', 'type', 'car', 'ctc'),\\n ('user', 'like', 'c1', 'ulc'),\\n ('c1', 'property', 'red', 'cpr'),\\n ('cpr', 'property', 'very', 'rpv'),\\n ('u1', 'type', 'extra', 'extra1'),\\n ('c1', 'focus', None, 'prim1'),\\n (my_span.to_string(), 'ref', 'upc'),\\n (very_span.to_string(), 'ref', 'rpv'),\\n (red_span.to_string(), 'ref', 'cpr'),\\n (car_span.to_string(), 'ref', 'c1')\\n ])\\n graph.features['upc']['comps'] = set()\\n graph.features['rpv']['comps'] = set()\\n graph.features['cpr']['comps'] = {'prim1'}\\n graph.features['c1']['comps'] = {'ctc', 'extra1'}\\n constraints_as_spans = {my_span.to_string(), very_span.to_string(),\\n red_span.to_string()}\\n\\n assert ref_gatherer.gather('c1', constraints_as_spans, graph) == \\\\\\n {'upc', 'rpv', 'cpr', 'ctc'}\",\n \"def segment(data):\",\n \"def get_alignment_statistics(infile, outfile):\\n statement = 'picard CollectAlignmentSummaryMetrics R=%(picard_ref)s I=%(infile)s O=%(outfile)s'\\n P.run(statement,\\n job_queue = P.PARAMS['queue'],\\n job_memory = P.PARAMS['memory'])\",\n \"def stats():\\n global CACHE, STATS_MISSES, STATS_HITS, STATS_KEYS_COUNT\\n memory_address = \\\"0x\\\" + str(\\\"%X\\\" % id( CACHE )).zfill(16)\\n return {'cache_memory_address': memory_address,\\n 'hits': STATS_HITS,\\n 'misses': STATS_MISSES ,\\n 'keys_count': STATS_KEYS_COUNT,\\n }\",\n \"def get_semantic_stats(self,t):\\n # nr of senses per word and noun\\n put_feature_value_list(self.stats, \\\"senses/w\\\", len(t.saldo))\\n if t.pos == \\\"NN\\\":\\n put_feature_value_list(self.stats, \\\"nn_senses/nn\\\", len(t.saldo))\\n return self.stats\",\n \"def parse_ref_file(file, start_pos=2, end_pos=7):\\n data = []\\n ref_dict = {}\\n try:\\n with open(file) as f:\\n content = f.read()\\n data = [word for lines in content.split(';')[start_pos: end_pos] for word in lines.splitlines(True) if '=' in word]\\n for item in data:\\n k = item.split('=')[0].strip().strip(\\\"'\\\")\\n v = item.split('=')[1].strip().strip(\\\"'\\\") \\n if k not in ref_dict:\\n ref_dict[k] = v\\n except Exception as e:\\n logger.info('Failed to parse SAS dictionary...')\\n return {}\\n return ref_dict\",\n \"def fetch_counts(datestruct):\\n response = call_responder('elasticsearch', 'query/daily_proofreader_hits')\\n for rec in response['result']['hits']['hits']:\\n data = rec['_source']\\n if data['user'] not in datestruct:\\n datestruct[data['user']] = {\\\"cleave\\\": 0, \\\"merge\\\": 0,\\n \\\"split-supervoxel\\\": 0}\\n if '/cleave/' in data['uri']:\\n datestruct[data['user']]['cleave'] += 1\\n elif '/merge' in data['uri']:\\n datestruct[data['user']]['merge'] += 1\\n elif '/split-supervoxel' in data['uri']:\\n datestruct[data['user']]['split-supervoxel'] += 1\",\n \"def gather_sample(self, stat_file, collector=None):\\n\\n if not collector:\\n collector = {}\\n\\n for line in stat_file:\\n # We just look for the different \\\"inuse\\\" lines and output their\\n # socket type along with the count.\\n m = re.search(r\\\"(\\\\w+): inuse (\\\\d+)\\\", line)\\n if m is not None:\\n collector.update(\\n {\\n Metric(\\\"app.net.sockets_in_use\\\", m.group(1).lower()): int(\\n m.group(2)\\n )\\n }\\n )\\n return collector\",\n \"async def get_segment(lang: str, key: str) -> Dict[str, str]:\\n try:\\n collection = get_collection(lang)\\n segment = collection[key]\\n return {\\n \\\"segmentnr\\\": segment[\\\"segmentnr\\\"],\\n \\\"segment\\\": segment[\\\"segment\\\"],\\n \\\"lang\\\": segment[\\\"lang\\\"],\\n }\\n except (DocumentNotFoundError, KeyError) as error:\\n return error\",\n \"def extract_variant_info(variant):\\n var_regex = re.compile(\\n r'(?P<ref>[A-Za-z]+)(?P<position>[-0-9]+)(?P<alt>[A-Za-z]+)$')\\n match = var_regex.search(variant)\\n reference = match.group('ref')\\n position = int(match.group('position'))\\n alternate = match.group('alt')\\n return reference, position, alternate\",\n \"def parse_stats(output):\\n lines = [line for line in output if \\\"[Stats]\\\" in line]\\n stats = {\\n 'totals': {'time': 0, 'tasks': 0, 'avg': 0}\\n }\\n for line in lines:\\n m = re.search(r'\\\\((\\\\d+) ms\\\\).+\\\\((\\\\d+)\\\\).+\\\\((\\\\d+) us.+\\\\)', line)\\n if not m:\\n continue\\n dt, tasks, avg = map(int, m.groups())\\n if 'totals' in line:\\n stats['totals'] = {'time': dt, 'tasks': tasks, 'avg': avg}\\n return stats\",\n \"def metadata(self):\\n metadata_dict = {}\\n for lbl_value, seginfo in self.infos.items():\\n prefix = f'Segment{lbl_value}_'\\n metadata_dict.update(seginfo.to_dict('slicer', prefix))\\n return metadata_dict\",\n \"def extract_references_from_txt(filename):\\n file = open(filename)\\n references_section = \\\"\\\"\\n references_section_found = False\\n for line in file:\\n if \\\"REFERENCE\\\" in line:\\n references_section_found = True\\n if references_section_found:\\n references_section+=line + \\\" \\\"\\n references_section = references_section.replace('\\\\n','')\\n refs = extract_references(references_section)\\n return refs\",\n \"def getStcStats(self):\\n return (self._totalSentences,\\n float(self._totalWords) / float(self._totalSentences))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5470782","0.53688884","0.53582793","0.53248024","0.5299202","0.5170791","0.5132248","0.5121406","0.51021016","0.504924","0.5033814","0.5031647","0.5017428","0.4956699","0.4956699","0.4898067","0.4897853","0.48240963","0.4789918","0.47849065","0.47824642","0.47254935","0.47238782","0.47151285","0.47142345","0.47132733","0.47005463","0.46889856","0.46835116","0.4677565","0.46387053","0.46387053","0.46301696","0.4623957","0.46220338","0.461532","0.46091482","0.4599634","0.45982924","0.4594371","0.45871893","0.45854864","0.45838818","0.45800498","0.45769656","0.45714954","0.4570649","0.4553686","0.45361114","0.45360112","0.45220196","0.45161587","0.45109278","0.45083305","0.45082545","0.45079485","0.45077547","0.45046338","0.44924426","0.4472949","0.44712493","0.4455881","0.44519973","0.44470036","0.44425932","0.44396865","0.44387224","0.44366637","0.4431542","0.44291002","0.4424432","0.44208032","0.44169766","0.44161412","0.44159338","0.44037735","0.43989414","0.43977132","0.4397462","0.43959102","0.4395084","0.43948382","0.4379841","0.43790427","0.43721992","0.43701455","0.43626377","0.43601957","0.43591788","0.43506387","0.43458605","0.43448803","0.43444365","0.4343975","0.434073","0.43402317","0.4338596","0.43347567","0.43320876","0.43312016"],"string":"[\n \"0.5470782\",\n \"0.53688884\",\n \"0.53582793\",\n \"0.53248024\",\n \"0.5299202\",\n \"0.5170791\",\n \"0.5132248\",\n \"0.5121406\",\n \"0.51021016\",\n \"0.504924\",\n \"0.5033814\",\n \"0.5031647\",\n \"0.5017428\",\n \"0.4956699\",\n \"0.4956699\",\n \"0.4898067\",\n \"0.4897853\",\n \"0.48240963\",\n \"0.4789918\",\n \"0.47849065\",\n \"0.47824642\",\n \"0.47254935\",\n \"0.47238782\",\n \"0.47151285\",\n \"0.47142345\",\n \"0.47132733\",\n \"0.47005463\",\n \"0.46889856\",\n \"0.46835116\",\n \"0.4677565\",\n \"0.46387053\",\n \"0.46387053\",\n \"0.46301696\",\n \"0.4623957\",\n \"0.46220338\",\n \"0.461532\",\n \"0.46091482\",\n \"0.4599634\",\n \"0.45982924\",\n \"0.4594371\",\n \"0.45871893\",\n \"0.45854864\",\n \"0.45838818\",\n \"0.45800498\",\n \"0.45769656\",\n \"0.45714954\",\n \"0.4570649\",\n \"0.4553686\",\n \"0.45361114\",\n \"0.45360112\",\n \"0.45220196\",\n \"0.45161587\",\n \"0.45109278\",\n \"0.45083305\",\n \"0.45082545\",\n \"0.45079485\",\n \"0.45077547\",\n \"0.45046338\",\n \"0.44924426\",\n \"0.4472949\",\n \"0.44712493\",\n \"0.4455881\",\n \"0.44519973\",\n \"0.44470036\",\n \"0.44425932\",\n \"0.44396865\",\n \"0.44387224\",\n \"0.44366637\",\n \"0.4431542\",\n \"0.44291002\",\n \"0.4424432\",\n \"0.44208032\",\n \"0.44169766\",\n \"0.44161412\",\n \"0.44159338\",\n \"0.44037735\",\n \"0.43989414\",\n \"0.43977132\",\n \"0.4397462\",\n \"0.43959102\",\n \"0.4395084\",\n \"0.43948382\",\n \"0.4379841\",\n \"0.43790427\",\n \"0.43721992\",\n \"0.43701455\",\n \"0.43626377\",\n \"0.43601957\",\n \"0.43591788\",\n \"0.43506387\",\n \"0.43458605\",\n \"0.43448803\",\n \"0.43444365\",\n \"0.4343975\",\n \"0.434073\",\n \"0.43402317\",\n \"0.4338596\",\n \"0.43347567\",\n \"0.43320876\",\n \"0.43312016\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.48478"},"document_rank":{"kind":"string","value":"17"}}},{"rowIdx":22891,"cells":{"query":{"kind":"string","value":"Produces BLEU scores along with its sufficient statistics from a source against one or more references."},"document":{"kind":"string","value":"def corpus_score(self, sys_stream: Union[str, Iterable[str]],\n ref_streams: Union[str, List[Iterable[str]]],\n use_effective_order: bool = False) -> BLEUScore:\n\n # Add some robustness to the input arguments\n if isinstance(sys_stream, str):\n sys_stream = [sys_stream]\n\n if isinstance(ref_streams, str):\n ref_streams = [[ref_streams]]\n\n sys_len = 0\n ref_len = 0\n\n correct = [0 for n in range(self.NGRAM_ORDER)]\n total = [0 for n in range(self.NGRAM_ORDER)]\n\n # look for already-tokenized sentences\n tokenized_count = 0\n\n fhs = [sys_stream] + ref_streams\n for lines in zip_longest(*fhs):\n if None in lines:\n raise EOFError(\"Source and reference streams have different lengths!\")\n\n if self.lc:\n lines = [x.lower() for x in lines]\n\n if not (self.force or self.tokenizer.signature() == 'none') and lines[0].rstrip().endswith(' .'):\n tokenized_count += 1\n\n output, *refs = [self.tokenizer(x.rstrip()) for x in lines]\n\n output_len = len(output.split())\n ref_ngrams, closest_diff, closest_len = CachedBLEU.reference_stats(refs, output_len)\n\n sys_len += output_len\n ref_len += closest_len\n\n sys_ngrams = CachedBLEU.extract_ngrams(output)\n for ngram in sys_ngrams.keys():\n n = len(ngram.split())\n correct[n - 1] += min(sys_ngrams[ngram], ref_ngrams.get(ngram, 0))\n total[n - 1] += sys_ngrams[ngram]\n\n # Get BLEUScore object\n score = self.compute_bleu(\n correct, total, sys_len, ref_len,\n smooth_method=self.smooth_method, smooth_value=self.smooth_value,\n use_effective_order=use_effective_order)\n\n return score"},"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 bleu_score(references, generated, n_gram=4, smooth=False):\r\n formatted_ref = [[ref] for ref in references]\r\n bleu_s, _, _, _, _, _ = compute_bleu(formatted_ref, generated, n_gram, smooth)\r\n return bleu_s * 100","def bleu_stats(hypothesis, reference):\n stats = []\n stats.append(len(hypothesis))\n stats.append(len(reference))\n for n in range(1, 5):\n s_ngrams = Counter(\n [tuple(hypothesis[i:i + n]) for i in range(len(hypothesis) + 1 - n)]\n )\n r_ngrams = Counter(\n [tuple(reference[i:i + n]) for i in range(len(reference) + 1 - n)]\n )\n stats.append(max([sum((s_ngrams & r_ngrams).values()), 0]))\n stats.append(max([len(hypothesis) + 1 - n, 0]))\n return stats","def bleu_stats(hypothesis, reference):\n stats = []\n stats.append(len(hypothesis))\n stats.append(len(reference))\n for n in range(1, 5):\n s_ngrams = Counter(\n [tuple(hypothesis[i:i + n]) for i in range(len(hypothesis) + 1 - n)]\n )\n r_ngrams = Counter(\n [tuple(reference[i:i + n]) for i in range(len(reference) + 1 - n)]\n )\n stats.append(max([sum((s_ngrams & r_ngrams).values()), 0]))\n stats.append(max([len(hypothesis) + 1 - n, 0]))\n return stats","def reference_stats(refs, output_len):\n\n ngrams = Counter()\n closest_diff = None\n closest_len = None\n\n for ref in refs:\n tokens = ref.split()\n reflen = len(tokens)\n diff = abs(output_len - reflen)\n if closest_diff is None or diff < closest_diff:\n closest_diff = diff\n closest_len = reflen\n elif diff == closest_diff:\n if reflen < closest_len:\n closest_len = reflen\n\n ngrams_ref = CachedBLEU.extract_ngrams(ref)\n for ngram in ngrams_ref.keys():\n ngrams[ngram] = max(ngrams[ngram], ngrams_ref[ngram])\n\n return ngrams, closest_diff, closest_len","def bleu_stats(hypo, ref, bleu_len=5):\n stats = list()\n stats.append(len(hypo))\n stats.append(len(ref))\n for n in range(1, bleu_len):\n s_ngrams = Counter([tuple(hypo[i:i+n]) for i in range(len(hypo)+1-n)])\n r_ngrams = Counter([tuple(ref[i:i+n]) for i in range(len(ref)+1-n)])\n stats.append(max([sum((s_ngrams & r_ngrams).values()), 0]))\n stats.append(max([len(hypo) + 1-n, 0]))\n return stats","def classify(self, source1, source2):\n scores1 = self.similarity_scores(source1)\n scores2 = self.similarity_scores(source2)\n\n print(\"scores for\", source1.name, \":\", [round(number, 2) for number in scores1])\n print(\"scores for\", source2.name, \":\", [round(number, 2) for number in scores2])\n\n s1 = 0\n s2 = 0\n for x in range(len(scores1)):\n if scores1[x] >= scores2[x]:\n s1 += 1\n else:\n s2 += 1\n \n if s1 > s2:\n print(self.name, \"is more likely to have come from \", source1.name)\n print()\n else:\n print(self.name, \"is more likely to have come from \", source2.name)\n print()","def classify(self, source1, source2):\n scores1 = self.similarity_scores(source1)\n scores2 = self.similarity_scores(source2)\n for i in range(len(scores1)):\n scores1[i] = round(scores1[i], 2)\n scores2[i] = round(scores2[i], 2)\n \n print('scores for source1: ', scores1, '\\n', \\\n 'scores for source2: ', scores2)\n num_larger1 = 0\n num_larger2 = 0\n for i in range(len(scores1)):\n if scores1[i] > scores2[i]:\n num_larger1 += 1\n else:\n num_larger2 += 1\n if num_larger1 > num_larger2:\n print(self.name, 'is more likely to have come from source1')\n else:\n print(self.name, 'is more likely to have come from source2')","def bleu_score(ref_file, hyp_file):\n command = 'perl scripts/multi-bleu.pl ' + ref_file + ' < ' + hyp_file\n c = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)\n details, error = c.communicate()\n details, error = details.decode('utf-8'), error.decode('utf-8')\n if not details.startswith('BLEU ='):\n raise ValueError('Error in BLEU score computation:\\n%s' % error)\n else:\n BLEU_str = details.split(' ')[2][:-1]\n BLEU = float(BLEU_str)\n return BLEU, details","def metric_halstats(hal_filename, reference_id=\"ref\"):\n \n # Get the list of dicts of per-genome stats.\n status_list = get_halstats_stats(hal_filename)\n \n # Throw out non-leaves\n status_list = [entry for entry in status_list if entry[\"NumChildren\"] == 0]\n \n # Grab all the genome names\n genome_names = [entry[\"GenomeName\"] for entry in status_list]\n \n # Get the dict from genome name to total bases from that genome aligned to\n # the reference at all, and the dict of N compositions, in parallel.\n coverage_dict, basecomp_dict = in_parallel(\n lambda: get_halstats_coverage(hal_filename, genome_names, reference_id),\n lambda: get_halstats_basecomps(hal_filename, genome_names))\n \n for entry in status_list:\n # For each genome, we want the coverage against the reference.\n \n # Grab the genome name\n genome_name = entry[\"GenomeName\"]\n \n if not coverage_dict.has_key(genome_name):\n # This is probably the root sequence and didn't get a coverage for\n # some reason. At any rate, the root sequence would be all Ns\n continue\n \n # Figure out how much of it is not Ns\n non_n = basecomp_dict[genome_name]\n \n # How many bases are eligible?\n eligible = float(entry[\"Length\"] * non_n)\n \n if eligible == 0:\n # No coverage is defined\n entry[\"Coverage\"] = float(\"NaN\")\n continue\n \n # Compute and save the coverage for each entry, by dividing bases\n # aligned by bases eligible.\n entry[\"Coverage\"] = coverage_dict[genome_name] / eligible\n \n # Return the results\n return status_list","def eval_accuracies(hypotheses, references, sources=None, filename=None, mode='dev'):\n assert (sorted(references.keys()) == sorted(hypotheses.keys()))\n\n # Compute BLEU scores\n _, bleu, ind_bleu = corpus_bleu(hypotheses, references)\n\n # Compute ROUGE scores\n rouge_calculator = Rouge()\n rouge_l, ind_rouge = rouge_calculator.compute_score(references, hypotheses)\n\n # Compute METEOR scores\n if mode == 'test':\n meteor_calculator = Meteor()\n meteor, _ = meteor_calculator.compute_score(references, hypotheses)\n else:\n meteor = 0\n\n fw = open(filename, 'w') if filename else None\n for key in references.keys():\n if fw:\n pred_i = hypotheses[key]\n\n logobj = OrderedDict()\n logobj['id'] = key\n if sources is not None:\n logobj['code'] = sources[key]\n logobj['predictions'] = pred_i\n logobj['references'] = references[key]\n logobj['bleu'] = ind_bleu[key]\n logobj['rouge_l'] = ind_rouge[key]\n print(json.dumps(logobj), file=fw)\n\n if fw: fw.close()\n return bleu * 100, rouge_l * 100, meteor * 100","def summary_source(classes_fold_score_list, classes_periods, classes): \n scores = []\n for idx in range(len(classes_periods)):\n temp = pd.concat([classes_fold_score_list[idx], classes_periods[idx].source], axis=1)\n temp = temp.groupby(['source', 'catalog']).size().unstack(fill_value=0).T\n scores.append(temp)\n score_df = pd.concat(scores, keys=classes)\n score_df.index.set_levels([\"Wrong\", \"Right\", \"Multiply\"], \n level=1,\n inplace=True)\n score_df = (score_df.T.fillna(0))\n dividend = score_df.iloc[:, score_df.columns.get_level_values(1)==\"Right\"].T.droplevel(-1).T\n divisor = score_df.T.groupby(level=0).sum().T.loc[:,[\"RRL\",\"Ceph\",\"LPV\",\"DSCT\",\"EB\"]]\n return dividend.divide(divisor).round(2).mean(axis=1)","def bleu(hypotheses, references):\n return sacrebleu.raw_corpus_bleu(sys_stream=hypotheses,\n ref_streams=[references]).score","def get_user_referrals(self, username, metric='source', start_date=None, end_date=None):\n\tif not start_date and not end_date:\n\t if metric == 'source':\n\t\tunique_sources = db.session.query(GoogleAnalyticsReferralsModel.source.distinct().label('source')).all()\n\t\tsources = [GoogleAnalyticsReferralsModel.query.filter_by(username=username, source=source).all() for source in unique_sources]\n\t\tsource_counts = []\n\t\tfor source in sources:\n\t\t counts = [s.sessions for s in source]\n\t\t count = sum(counts)\n\t\t source_counts.append(count)\n\t\tsource_names = [source[0].source for source in sources]\n\t\tprint source_counts\n\t\tprint source_names\n\t\tsource_count_list = []\n\t\tfor i in range(len(source_counts)):\n\t\t source_count_dict = {}\n\t\t source = source_names[i]\n\t\t source_count = source_counts[i]\n\t\t source_count_dict['key'] = source\n\t\t source_count_dict['y'] = source_count\n\t\t source_count_list.append(source_count_dict)\n\t\treturn make_response(dumps(source_count_list))\n\n\t elif metric == \"mediums\":\n\t\tunique_mediums = db.session.query(GoogleAnalyticsReferralsModel.medium.distinct().label('medium')).all()\n\t\tmediums = [GoogleAnalyticsReferralsModel.query.filter_by(username=username, medium=medium).all() for medium in unique_mediums]\n\t\tmedium_counts = []\n\t\tfor medium in mediums:\n\t\t counts = [m.sessions for m in medium]\n\t\t count = sum(counts)\n\t\t medium_counts.append(count)\n\t\tmedium_names = [medium[0].medium for medium in mediums]\n\t\tprint medium_counts\n\t\tprint medium_names\n\t\treturn ''","def calculate_bleu(output_lns, refs_lns, **kwargs) -> dict:\n return {\"bleu\": round(corpus_bleu(output_lns, [refs_lns], **kwargs).score, 4)}","def calculate_bleu(output_lns, refs_lns, **kwargs) -> dict:\n return {\"bleu\": round(corpus_bleu(output_lns, [refs_lns], **kwargs).score, 4)}","def get_bleu(hypotheses, reference):\n stats = np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])\n for hyp, ref in zip(hypotheses, reference):\n stats += np.array(bleu_stats(hyp, ref))\n return 100 * bleu(stats)","def classify(self, source1, source2):\n\n scores1 = self.similarity_scores(source1)\n scores2 = self.similarity_scores(source2)\n \n print('scores for ' + source1.name +':' + str(self.similarity_scores(source1)))\n print('scores for ' + source2.name +':' + str(self.similarity_scores(source2)))\n \n source1_score=0\n source2_score=0\n\n for i in range(len(scores1)):\n if scores1[i]> scores2[i]:\n source1_score+=1\n elif scores2[i]>scores1[i]:\n source2_score+=1\n \n if source1_score > source2_score:\n win=source1.name\n else:\n win=source2.name\n\n print(self.name + ' is more likely to have come from ' + win)","def get_stats(inp_fn):\n ent_pred_cnts = []\n ent_gold_cnts = []\n ent_intr_cnts = []\n ccs = ConllCorefScores()\n jsons = [json.loads(line) for line in open(inp_fn, encoding = \"utf8\")]\n for doc_dict in jsons:\n cur_doc = nlp(\" \".join(doc_dict[\"document\"]))\n gold_clusts = doc_dict[\"gold_clusters\"]\n pred_clusts = doc_dict[\"clusters\"]\n\n gold_ent_clusts = get_entities(cur_doc, gold_clusts)\n pred_ent_clusts = get_entities(cur_doc, pred_clusts)\n\n gold_clusts_pronouns = [gold_clust\n for gold_clust, gold_ent_clust\n in zip(gold_clusts, gold_ent_clusts)\n if contains_pronoun(gold_ent_clust)]\n\n pred_clusts_pronouns = [pred_clust\n for pred_clust, pred_ent_clust\n in zip(pred_clusts, pred_ent_clusts)\n if contains_pronoun(pred_ent_clust)]\n\n update_avg_f1(ccs, gold_clusts_pronouns, pred_clusts_pronouns)\n\n pred_ents = set(map(str, flatten(pred_ent_clusts)))\n gold_ents = set(map(str, flatten(gold_ent_clusts)))\n if (not pred_ents) and (not gold_ents):\n #TODO: what's going on in these instances?\n continue\n\n ent_pred_cnts.append(len(pred_ents))\n ent_gold_cnts.append(len(gold_ents))\n ent_intr_cnts.append(len(pred_ents & gold_ents))\n\n ent_micro = micro_f1(ent_pred_cnts, ent_gold_cnts, ent_intr_cnts)\n ent_macro = macro_f1(ent_pred_cnts, ent_gold_cnts, ent_intr_cnts)\n ret_dict = {\"ent_micro\": ent_micro,\n \"ent_macro\": ent_macro,\n \"pronoun_avg_f1\": get_avg_f1(ccs)}\n\n logging.debug(f\"micro = {ent_micro['f1']:.2f}, macro = {ent_macro['f1']:.2f}\")\n\n return ret_dict","def rouge_score(references, generated):\r\n score = rouge(generated, references)\r\n rouge_s = {k: (v * 100) for (k, v) in score.items()}\r\n '''\r\n \"rouge_1/f_score\": rouge_1_f,\r\n \"rouge_1/r_score\": rouge_1_r,\r\n \"rouge_1/p_score\": rouge_1_p,\r\n \"rouge_2/f_score\": rouge_2_f,\r\n \"rouge_2/r_score\": rouge_2_r,\r\n \"rouge_2/p_score\": rouge_2_p,\r\n \"rouge_l/f_score\": rouge_l_f,\r\n \"rouge_l/r_score\": rouge_l_r,\r\n \"rouge_l/p_score\": rouge_l_p,\r\n '''\r\n return rouge_s","def make_ungrounded_stats():\n def get_ungrounded_stats(stmts):\n # What fraction of statements grounded?\n all_ungrounded = 0\n any_ungrounded = 0\n for stmt in stmts:\n agents_ungrounded = []\n for ag in stmt.agent_list():\n if ag is not None and list(ag.db_refs.keys()) == ['TEXT']:\n agents_ungrounded.append(True)\n else:\n agents_ungrounded.append(False)\n if all(agents_ungrounded):\n all_ungrounded += 1\n if any(agents_ungrounded):\n any_ungrounded += 1\n all_ungrounded_ratio = 100 * (all_ungrounded / float(len(stmts)))\n any_ungrounded_ratio = 100 * (any_ungrounded / float(len(stmts)))\n return all_ungrounded_ratio, any_ungrounded_ratio\n\n def get_agent_counts(stmts):\n agents = gm.ungrounded_texts(stmts)\n agent_counts = [t[1] for t in agents]\n return agent_counts\n\n fname = '../step3_sample_training_test/famplex_test_stmts_mapped.pkl'\n stmts = ac.load_statements(fname)\n allu_test, anyu_test = get_ungrounded_stats(stmts)\n counts_test = get_agent_counts(stmts)\n\n fname = '../step3_sample_training_test/training_pmid_stmts.pkl'\n stmts = ac.load_statements(fname)\n allu_train, anyu_train = get_ungrounded_stats(stmts)\n counts_train = get_agent_counts(stmts)\n\n return (allu_test, anyu_test, allu_train, anyu_train,\n counts_train, counts_test)","def calculate_bleu(output_lns, refs_lns):\n return round(corpus_bleu(output_lns, [refs_lns]).score, 4)","def bleu_score(output, reference):\n num_sentences = min(len(output), len(reference))\n for i in range(num_sentences):\n if i == 5:\n print(\"Do you want to calculate all sentences? (y/n)\")\n answer = input()\n if answer.lower() == 'n':\n break\n out_sentence, ref_sentence = output[i], reference[i]\n bleu_score = calculate_bleu(out_sentence, ref_sentence)\n print(\n f\"Sentence {i + 1}, Score: {bleu_score}\")","def _compute_score(self):\n\n sgml_path = str(self.sgml_file.name)\n text_path = sgml_path.replace('.sgm', '.txt')\n ref_path = 'testsets/wmt18.ende.ref.txt'\n\n from sacrebleu import process_to_text, corpus_bleu\n from pathlib import Path\n\n if not Path(text_path).exists():\n process_to_text(sgml_path, text_path)\n\n hyp_stream = [x for x in open(text_path, encoding='utf-8')]\n ref_stream = [r for r in open(ref_path, encoding='utf-8')]\n\n bleu = corpus_bleu(hyp_stream, [ref_stream])\n\n self.score = bleu.score\n self.save()","def get_usage(self, source):\n return sum(i.quantity for i in self.items.all() if i.source == source)","def get_bleu(hypo, ref, seq_len=10, bleu_len=5):\n stats = np.array([0.]*seq_len)\n for h, r in zip(hypo, ref):\n h = np.trim_zeros(h)\n r = np.trim_zeros(r)\n stats += np.array(bleu_stats(h, r, bleu_len))\n return 100 * bleu(stats)","def references(df, sort='rank', ascending=True, output='list', limit=-1):\n \n ref_counts = list(df['references'].value_counts().items())\\\n\n if output == 'string':\n ref_string = \"\"\n if sort == 'rank':\n if ascending:\n ref_number = 1\n else:\n ref_number = len(ref_counts) + 1\n for ref_pair in ref_counts:\n if (ascending == True) and (limit != -1) and (ref_number > limit):\n break\n elif (ascending == False) and (limit != -1) and (ref_number < (len(ref_counts) + 1 - limit)):\n break\n ref_string += '--------\\n'\n ref_string += f\"Most common reference {ref_number}\\n\"\n ref_string += '\\n'\n source_number = 1\n for ref in ref_pair[0]:\n ref_string += f\"Source number: {source_number}\\n\"\n ref_string += f\"Title: {ref['title']}\\n\"\n ref_string += f\"Author: {ref['author']}\\n\"\n ref_string += f\"Publisher: {ref['publisher']}\\n\"\n ref_string += f\"Publisher Location: {ref['publisherLocation']}\\n\"\n ref_string += f\"Year: {ref['year']}\\n\"\n ref_string += f\"Reference Type: {ref['refType']}\\n\"\n ref_string += f\"Reference Key: {ref['key']}\\n\"\n ref_string += '\\n'\n source_number += 1\n ref_string += f\"Total Occurrences: {ref_pair[1]}\\n\"\n ref_string += '--------\\n'\n ref_string += '\\n'\n if ascending: \n ref_number += 1\n else:\n ref_number -= 1\n elif sort == 'alphabet':\n # TODO: alphabetical sorting\n pass\n else:\n raise ValueError(f\"Invalid parameter for sort '{sort}' - Accepted values are 'rank' or 'alphabet'\")\n return ref_string\n elif output == 'list':\n return ref_counts\n else:\n raise ValueError(f\"Invalid parameter for output '{output}' - Accepted values are 'list' or 'string'\")","def get_score(src_ref, src_est, eps=1e-8):\n\n # Expected inputs of size (nsrc x nsamples)\n if src_ref.shape[0] > src_ref.shape[1]:\n src_ref = src_ref.T\n src_est = src_est.T\n\n # Get the SDR only for the first (=speech) source\n sdr = 10 * np.log10(np.sum(src_ref[0, :] ** 2) / (np.sum((src_ref[0, :] - src_est[0, :]) ** 2) + eps))\n\n return sdr","def compute_statistics(self):","def compute_statistic(path_user, path_refs, tp_consensus='mean', path_dataset=None,\n path_visu=None):\n assert path_user and path_refs, 'missing user or reference annotation'\n lnds_user, _ = create_consensus_landmarks([path_user])\n lnds_refs, _ = create_consensus_landmarks(path_refs, method=tp_consensus)\n\n list_stats = []\n name_set, name_user_scale = path_user.split(os.sep)[-2:]\n user, scale = parse_path_user_scale(name_user_scale)\n for csv_name in lnds_user:\n if csv_name not in lnds_refs:\n continue\n im_size = find_image_full_size(path_dataset, name_set,\n os.path.splitext(csv_name)[0])\n d_stat = compute_landmarks_statistic(lnds_refs[csv_name],\n lnds_user[csv_name],\n use_affine=False, im_size=im_size)\n d_stat.update({'image_set': name_set,\n 'user': user,\n 'scale': scale,\n 'landmarks': csv_name})\n list_stats.append(d_stat)\n if path_visu is not None and os.path.isdir(path_visu):\n img_name = os.path.splitext(csv_name)[0]\n visual_coannotation(lnds_user[csv_name], lnds_refs[csv_name], path_dataset,\n path_user, img_name, path_visu)\n return list_stats","def get_bleu(hypotheses, reference):\n stats = np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])\n for hyp, ref in zip(hypotheses, reference):\n stats += np.array(bleu_stats(hyp, ref))\n return bleu(stats)","def compute_metrics_from_files(p_path_to_reference_file,\r\n p_path_to_candidate_file,\r\n p_max_bleu_order):\r\n\r\n reference_dictionary, reference_no_answer_query_ids = \\\r\n load_file(p_path_to_reference_file)\r\n candidate_dictionary, candidate_no_answer_query_ids = load_file(p_path_to_candidate_file)\r\n query_id_answerable = set(reference_dictionary.keys())-reference_no_answer_query_ids\r\n query_id_answerable_candidate = set(candidate_dictionary.keys())-candidate_no_answer_query_ids\r\n \r\n true_positives = len(query_id_answerable_candidate.intersection(query_id_answerable))\r\n false_negatives = len(query_id_answerable)-true_positives\r\n true_negatives = len(candidate_no_answer_query_ids.intersection(reference_no_answer_query_ids))\r\n false_positives = len(reference_no_answer_query_ids)-true_negatives\r\n precision = float(true_positives)/(true_positives+false_positives) if (true_positives+false_positives)>0 else 1.\r\n recall = float(true_positives)/(true_positives+false_negatives) if (true_positives+false_negatives)>0 else 1.\r\n F1 = 2 *((precision*recall)/(precision+recall))\r\n filtered_reference_dictionary = \\\r\n {key: value for key, value in reference_dictionary.items() \\\r\n if key not in reference_no_answer_query_ids}\r\n\r\n filtered_candidate_dictionary = \\\r\n {key: value for key, value in candidate_dictionary.items() \\\r\n if key not in reference_no_answer_query_ids}\r\n\r\n for query_id, answers in filtered_candidate_dictionary.items():\r\n assert \\\r\n len(answers) <= 1, \\\r\n 'query_id %d contains more than 1 answer \\\"%s\\\" in candidate file' % \\\r\n (query_id, str(answers))\r\n\r\n reference_query_ids = set(filtered_reference_dictionary.keys())\r\n candidate_query_ids = set(filtered_candidate_dictionary.keys())\r\n common_query_ids = reference_query_ids.intersection(candidate_query_ids)\r\n assert (len(common_query_ids) == len(reference_query_ids)) and \\\r\n (len(common_query_ids) == len(candidate_query_ids)), \\\r\n 'Reference and candidate files must share same query ids'\r\n\r\n all_scores = {}\r\n bleu_scores, _ = \\\r\n Bleu(p_max_bleu_order).compute_score(filtered_reference_dictionary, \\\r\n filtered_candidate_dictionary)\r\n for i, bleu_score in enumerate(bleu_scores):\r\n all_scores['bleu_%d' % (i+1)] = bleu_score\r\n\r\n rouge_score, _ = Rouge().compute_score(filtered_reference_dictionary, \\\r\n filtered_candidate_dictionary)\r\n all_scores['rouge_l'] = rouge_score\r\n all_scores['F1'] = F1\r\n similarity = 0\r\n for key in filtered_reference_dictionary:\r\n candidate_answer = nlp(filtered_candidate_dictionary[key][0])\r\n reference_answer = filtered_reference_dictionary[key]\r\n answersimilarity = 0\r\n for answer in reference_answer:\r\n answersimilarity += candidate_answer.similarity(nlp(answer))\r\n similarity += answersimilarity/len(reference_answer)\r\n semantic_similarity = similarity/len(filtered_reference_dictionary)\r\n all_scores['Semantic_Similarity'] = semantic_similarity\r\n return all_scores","def get_reliability_table_for_source(source):\n dq_file = 'DQ_Reliability_Scores_Table3-3fromERGreport.csv'\n df = (pd.read_csv(DATA_PATH.joinpath(dq_file),\n usecols=['Source', 'Code', 'DQI Reliability Score'])\n .query('Source == @source')\n .reset_index(drop=True)\n .drop(columns='Source'))\n return df","def _cmd_reference(args):\n usage_err_msg = \"Give .cnn samples OR targets and (optionally) antitargets.\"\n if args.targets:\n # Flat reference\n assert not args.references, usage_err_msg\n ref_probes = reference.do_reference_flat(\n args.targets, args.antitargets, args.fasta, args.male_reference\n )\n elif args.references:\n # Pooled reference\n assert not args.targets and not args.antitargets, usage_err_msg\n filenames = []\n for path in args.references:\n if os.path.isdir(path):\n filenames.extend(\n os.path.join(path, f)\n for f in os.listdir(path)\n if f.endswith(\"targetcoverage.cnn\")\n )\n else:\n filenames.append(path)\n targets = [f for f in filenames if \"antitarget\" not in f]\n antitargets = [f for f in filenames if \"antitarget\" in f]\n logging.info(\n \"Number of target and antitarget files: %d, %d\",\n len(targets),\n len(antitargets),\n )\n female_samples = (\n (args.sample_sex.lower() not in [\"y\", \"m\", \"male\"])\n if args.sample_sex\n else None\n )\n ref_probes = reference.do_reference(\n targets,\n antitargets,\n args.fasta,\n args.male_reference,\n args.diploid_parx_genome,\n female_samples,\n args.do_gc,\n args.do_edge,\n args.do_rmask,\n args.cluster,\n args.min_cluster_size,\n )\n else:\n raise ValueError(usage_err_msg)\n\n ref_fname = args.output or \"cnv_reference.cnn\"\n core.ensure_path(ref_fname)\n tabio.write(ref_probes, ref_fname)","def compute_bleu_rouge(pred_dict, ref_dict, bleu_order=4):\n assert set(pred_dict.keys()) == set(ref_dict.keys()), \\\n \"missing keys: {}\".format(set(ref_dict.keys()) - set(pred_dict.keys()))\n scores = {}\n bleu_scores, _ = Bleu(bleu_order).compute_score(ref_dict, pred_dict)\n for i, bleu_score in enumerate(bleu_scores):\n scores['Bleu-%d' % (i + 1)] = bleu_score\n rouge_score, _ = Rouge().compute_score(ref_dict, pred_dict)\n scores['Rouge-L'] = rouge_score\n return scores","def __score_by_support(self, source_iceberg, iceberg_to_score, iceberg_to_score_owner, simulation_data):\n game = self.__game\n is_belong_to_me = iceberg_to_score_owner.equals(game.get_myself())\n score = 0\n is_closest_to_enemy, avr_distance_from_enemy = self.__is_destination_closest_to_enemy(source_iceberg,\n iceberg_to_score,\n simulation_data)\n if is_belong_to_me and is_closest_to_enemy:\n if not iceberg_to_score is game.get_bonus_iceberg():\n score += (self.__max_distance - avr_distance_from_enemy) * SUPPORT_SCORE_FACTOR\n else:\n score += CANT_DO_ACTION_SCORE\n elif is_belong_to_me:\n score += OUR_DESTINATION_ICEBERG_FAR_FROM_ENEMY_SCORE\n return score","def parse_halstats_coverage(stream, reference_id):\n \n # Get a reader and skip the first line\n reader = csv.reader(stream)\n for i in xrange(1):\n next(reader)\n \n for data in reader:\n if len(data) == 0:\n # We finished the table\n break\n \n \n # Drop all the whitespace\n data = [x.strip() for x in data]\n \n if data[0] == reference_id:\n if len(data) > 1:\n # We have some bases aligned\n return float(data[1])\n else:\n # We had no bases aligned\n return 0.0\n \n raise RuntimeError(\"Could not find coverage against {}\".format(\n reference_id))","def get_halstats_coverage(hal_filename, other_genomes, reference_id):\n \n print(\"Getting mapping counts\")\n \n def get_coverage_for_genome(other_genome):\n # Set up the arguments\n args = [\"halStats\", hal_filename, \"--coverage\", other_genome]\n\n # Open the process\n process = subprocess.Popen(args, stdout=subprocess.PIPE)\n \n # Get the number of bases of the other genome that are aligned to\n # anywhere (or any set of more than one place) in the reference genome.\n coverage = parse_halstats_coverage(process.stdout, reference_id)\n \n if process.wait() != 0:\n raise RuntimeError(\"halStats --coverage failed\")\n \n # Give back the coverage (in columns)\n return coverage\n \n # Get all the coverages in order, and in parallel.\n coverages = ThreadPool(len(other_genomes)).map(get_coverage_for_genome, \n other_genomes) \n \n return dict(itertools.izip(other_genomes, coverages))","def enable_source(self, source, geometries):\n if source in self._counts.keys():\n for geometry_key in self._counts[source].keys():\n if geometries[geometry_key].is_checked:\n self._total_count += self._counts[source][geometry_key]\n self.change_text()","def calculate_single_cycle_gan_metrics(source, target):\n metric_results = MetricsContainer(len(source))\n for i, x in enumerate(source):\n scores = torch.mean(torch.abs(x.view(1, -1) - target), dim=1)\n _, indices = torch.sort(scores, descending=False)\n indices = indices.cpu().numpy()\n rank = np.nonzero(indices == i)[0][0] + 1\n metric_results.update(rank)\n return metric_results.get_results()","async def fetch_referrals(self):\n data = await self.http.get_referral_statistics()","def assemble_stats(lma_sum, mma_sum, hma_sum, peer_lma_sum, peer_mma_sum, peer_hma_sum):\n lma_pct = 0.0\n mma_pct = 0.0\n hma_pct = 0.0\n\n peer_lma_pct = 0.0\n peer_mma_pct = 0.0\n peer_hma_pct = 0.0\n\n stats = {}\n\n target_lar_total = lma_sum + mma_sum + hma_sum\n if target_lar_total:\n lma_pct = round(1.0 * lma_sum / target_lar_total, 3)\n mma_pct = round(1.0 * mma_sum / target_lar_total, 3)\n hma_pct = round(1.0 * hma_sum / target_lar_total, 3)\n maj_pct = round(mma_pct + hma_pct, 3)\n stats.update({\n 'lma': lma_sum, \n 'lma_pct': lma_pct, \n 'mma': mma_sum,\n 'mma_pct': mma_pct,\n 'hma': hma_sum,\n 'hma_pct': hma_pct,\n 'maj_pct': maj_pct,\n 'lar_total': target_lar_total\n })\n else:\n stats.update({\n 'lar_total': 0,\n 'lma': 0, \n 'lma_pct': 0, \n 'mma': 0,\n 'mma_pct': 0,\n 'hma': 0,\n 'hma_pct': 0\n })\n #assemble peer data\n peer_lar_total = peer_lma_sum + peer_mma_sum + peer_hma_sum\n if peer_lar_total:\n peer_lma_pct = round(1.0 * peer_lma_sum / peer_lar_total, 3)\n peer_mma_pct = round(1.0 * peer_mma_sum / peer_lar_total, 3)\n peer_hma_pct = round(1.0 * peer_hma_sum / peer_lar_total, 3)\n peer_maj_pct = round(peer_mma_pct + peer_hma_pct, 3)\n stats.update({\n 'peer_lma': peer_lma_sum, \n 'peer_lma_pct': peer_lma_pct, \n 'peer_mma': peer_mma_sum,\n 'peer_mma_pct': peer_mma_pct,\n 'peer_hma': peer_hma_sum,\n 'peer_hma_pct': peer_hma_pct,\n 'peer_maj_pct': peer_maj_pct,\n 'peer_lar_total': peer_lar_total\n })\n else:\n stats.update({\n 'peer_lma': 0,\n 'peer_lma_pct': 0, \n 'peer_mma': 0, \n 'peer_mma_pct': 0,\n 'peer_hma': 0,\n 'peer_hma_pct': 0,\n 'peer_lar_total': 0\n })\n odds_lma = odds_ratio(lma_pct, peer_lma_pct)\n odds_mma = odds_ratio(mma_pct, peer_mma_pct)\n odds_hma = odds_ratio(hma_pct, peer_hma_pct)\n odds_maj = odds_ratio(mma_pct+hma_pct, peer_mma_pct+peer_hma_pct)\n stats.update({\n 'odds_lma':odds_lma,\n 'odds_mma':odds_mma,\n 'odds_hma':odds_hma,\n 'odds_maj':odds_maj\n })\n return stats","def _rouge(ref_file, summarization_file, subword_option=None):\n\n references = []\n with codecs.getreader(\"utf-8\")(tf.gfile.GFile(ref_file, \"rb\")) as fh:\n for line in fh:\n references.append(_clean(line, subword_option))\n\n hypotheses = []\n with codecs.getreader(\"utf-8\")(\n tf.gfile.GFile(summarization_file, \"rb\")) as fh:\n for line in fh:\n hypotheses.append(_clean(line, subword_option=subword_option))\n\n rouge_score_map = rouge.rouge(hypotheses, references)\n return 100 * rouge_score_map[\"rouge_l/f_score\"]","def compute_bleu(self, ref_ids_list: Iterable[Iterable[int]], hyp_ids_list: Iterable[Iterable[int]],\n ref_is_tensor: bool = False, hyp_is_tensor: bool = False,\n reader_level: ReaderLevel=ReaderLevel.WORD) -> Tuple[float, str, str]:\n assert len(ref_ids_list) == len(hyp_ids_list)\n refs = self.target_sentensify_all(ref_ids_list, input_is_tensor=ref_is_tensor, reader_level=reader_level)\n hyps = self.target_sentensify_all(hyp_ids_list, input_is_tensor=hyp_is_tensor, reader_level=reader_level)\n scores = [sentence_bleu(hyps[sid], refs[sid]) for sid in range(len(ref_ids_list))]\n random_index = choice(range(len(refs)))\n return sum(scores) / len(scores), refs[random_index], hyps[random_index]","def advancedStats():","def optimize_reference(self, num_targets):\n \n target_weights = np.ones(num_targets)\n target_weights = target_weights/sum(target_weights)\n \n #target_weights = [0.8,0.2]\n\n x0 = np.asarray(np.insert(np.zeros(self._refs.shape[0]-len(target_weights)),0,target_weights))\n print(x0)\n \n # num_weights = self._refs.shape[0]\n # x0 = np.ones(num_weights)/sum(np.ones(num_weights))\n\n #x0 = np.asarray([0.8,0.2,0,0,0,0,0,0])\n\n assert num_targets >= 1, 'num_targets >= 1'\n assert num_targets <= len(x0), 'num_targets < len(x0)'\n\n\n lsq = sciopt.least_squares(self.residual, \n x0, \n #args=(np.reshape(self._true, (1,36)), num_targets), \n args=(self._true, num_targets), \n bounds=(0,1), \n method='trf', \n tr_solver='lsmr', \n diff_step=0.1, \n loss='soft_l1',\n tr_options={'damp':1.0},\n ftol=1e-6,\n verbose=2) #diff_step=0.2, verbose=2)#, loss='linear')\n\n return (lsq.x/sum(lsq.x), lsq)","def get_score(self):\n files_flare = self.generate_flare_set()\n files_non_flare = self.generate_non_flare_set()\n timeseries = []\n y = []\n scores = {}\n column_mapping = self.__get_column_mapping()\n for col in tqdm(range(1, 25)):\n for file in tqdm(files_flare):\n s = Sample(\"FL\", file).get_data().iloc[:, col].values\n y.append(self.mapping[file[0]])\n timeseries.append(s)\n\n for file in tqdm(files_non_flare):\n s = Sample(\"NF\", file).get_data().iloc[:, col].values\n y.append(self.mapping[file[0]])\n timeseries.append(s)\n embed = self.get_embed_vector(timeseries)\n\n embed_y = KMeans(n_clusters=5).fit_predict(embed)\n y = np.array(y).flatten()\n scores[column_mapping[col]] = self.relevance_score(embed_y, y)\n timeseries = []\n y = []\n scores_data = pd.DataFrame.from_dict(scores, orient='index', columns=['Relevance Score']).sort_values(\n by='Relevance Score', ascending=False)\n return scores_data","def gw_heritability(\n input_snp_filename: \"Data Input, use the SNPs file from dataParse\",\n output_summary_filename: 'output file for the genomewide results summary, use .csv',\n logger_filename: 'file for the logger, use a txt',\n sweeps: \"number of samples for each chain\" = 1000,\n burnin: \"number of burnin samples\" = 1000,\n n_chains: \"number of chains of the sampler\" = 4,\n n_cores: \"number of parallel cores to use\" = 4,\n N_1kG: \"number of SNPs onwhich the LD-score is calculates\" = 1290028,\n chromosome: \"chromosome on which the analysis is run\" = \"all\",\n sep: \"separator for the input files, use t for tab separated (not \\t)\" = \",\",\n model: 'regression model'='normal',\n fix_intercept = False,\n ):\n\n # Initialisation of the logger\n output_logger = log.setup_logger(\"output_logger\", logger_filename)\n log.initialise_log(output_logger,\n 'genome-wide regression, model: %s' %model,\n [input_snp_filename],\n [output_summary_filename],\n sweeps,\n burnin,\n chromosome = str(chromosome),\n other_params_diz = {'chains': n_chains, 'cores': n_cores})\n\n # Initialisation function, it reads the summary stats file, filters the SNPs,\n # creates the output files\n\n logging.info(\"Start Analysis\")\n\n snps = s.Snps()\n # read table\n snps.read_table(input_snp_filename, separator=sep)\n # generate chi squared stats\n snps.generate_stats()\n # update the summary stats\n snps.update_summary()\n output_logger.info(\" Sample size \" + str(snps.n_patients) + \"\\n\")\n\n\n snps.apply_filter_table(s.baghera_filter)\n snps.update_summary()\n output_logger.info(\"After baghera init filter.\\nNumber of SNPs: %s\\nNumber of genes: %s\\n\" \\\n %(str(snps.n_snps), str(snps.n_genes)) )\n\n # Non coding SNPs are assigned to a dummy gene, such that the regression is done on the entire SNPs' set\n snps.rename_non_annotated(name='NonCoding')\n\n if chromosome != \"all\":\n snps.apply_filter_table(snps.cut_single_chrom, **{'chromosome': chromosome})\n output_logger.info(\n \"Analysis restricted to chr %s\" %str(chromosome) )\n\n snps.update_summary()\n output_logger.info(\"Analysis. Number of SNPs: %s\\n, Number of genes: %s\\n\" \\\n %(str(snps.n_snps), str(snps.n_genes)) )\n\n\n if model =='normal':\n [intercept, slope] = heritability.gw_normal(snps, output_summary_filename, output_logger,\n sweeps, burnin, n_chains, n_cores, N_1kG, fix_intercept)\n elif model=='gamma':\n [intercept, slope] = heritability.gw_normal(snps, output_summary_filename, output_logger,\n sweeps, burnin, n_chains, n_cores, N_1kG, fix_intercept)\n else:\n logging.info('Normal model by default')\n [intercept, slope] = heritability.gw_normal(snps, output_summary_filename, output_logger,\n sweeps, burnin, n_chains, n_cores, N_1kG, fix_intercept)\n logging.info(\"Analysis complete\")","def _run():\n matching_terms = {'a', 'b'}\n source_counts = {'a': 10, 'b': 50, 'c': 25}\n target_counts = {'a': 4, 'b': 73, 'c': 15}\n source_chunk = ['a', 'b']\n target_chunk = ['a', 'c', 'b']\n source_distance = score.find_distance(\n matching_terms, source_chunk, source_counts)\n target_distance = score.find_distance(\n matching_terms, target_chunk, target_counts)\n match_score = score.vanilla(\n matching_terms, source_distance, target_distance, source_counts,\n target_counts)\n print('Calculated score:', match_score)","def read_result(result_file, source2target):\n result_index = defaultdict(lambda: [])\n \n with open(result_file) as tsvfile:\n tsvreader = csv.reader(tsvfile, delimiter='\\t')\n for row in tsvreader: \n source = row[0]\n target = row[1]\n score = float(row[2])\n\n if source in source2target:\n result_index[source].append((target, score))\n else:\n logging.warning('Source term \"%s\" not found in the gold standard' % source)\n\n return result_index","def all_raw_stats(r1_stats, r2_stats, name):\n raw_output= name + \"_raw_read_counts.txt\"\n raw_R1_reads, raw_R1_bases, Q20_R1_bp, Q20_R1_percent, Q30_R1_bp, Q30_R1_percent = get_raw_stats(r1_stats)\n raw_R2_reads, raw_R2_bases, Q20_R2_bp, Q20_R2_percent, Q30_R2_bp, Q30_R2_percent = get_raw_stats(r2_stats)\n write_raw_stats(raw_R1_reads, raw_R1_bases, Q20_R1_bp, Q20_R1_percent, Q30_R1_bp, Q30_R1_percent, raw_R2_reads, raw_R2_bases, Q20_R2_bp, Q20_R2_percent, Q30_R2_bp, Q30_R2_percent, raw_output, name)","def calculate_stats(team_id, current_matches, prev_matches, stats, targets):\n\n # Features\n current_formation = None\n opp_formation = None\n win = 0\n loss = 0\n recent_wins = 0\n recent_losses = 0\n prev_opp = []\n current_opp = 0\n total_goals = 0\n goals_for = 0\n goals_against = 0\n goal_diff = 0\n total_points = 0\n count = 1\n played = float(0)\n goal_efficiency = 0\n\n # Game Features\n game_features = {'possession': [], 'attacks': [], 'dangerous_attacks': [], 'yellow_cards': [],\n 'corner_kicks': [], 'shots_on_target': [], 'shots_total': [], 'ball_safe': [],\n 'goal_attempts': [], 'goal_attempts_allowed': [], 'saves': [], 'first_half_goals': [], 'sec_half_goals': [], 'goal_kicks': []}\n\n # Targets\n points = 0\n goals = 0\n opp_goals = 0\n\n goals_home = 0\n goals_away = 0\n opp_goals_at_home = 0 # Opponent goals when CURRENT team is AT Home\n opp_goals_at_away = 0 # Opponent goals when CURRENT team is Away\n\n total_games = len(prev_matches)\n # Pulling Data for PREVIOUS Matches\n for index, game in prev_matches.iterrows():\n\n # Home Wins and Road Losses are .8 while Road Wins and Home Losses are 1.2 / Draws remain the same\n if team_id == game['home_id']:\n\n if game['home_points'] == 3:\n win += .8\n\n elif game['home_points'] == 1:\n win += .5\n loss += .5\n\n else:\n loss += 1.2\n\n total_goals += game['home_score']\n goals_for += game['home_score']\n goals_against += game['away_score']\n goal_diff += game['home_score'] - game['away_score']\n total_points += game['home_points']\n\n goals_home += game['home_points']\n opp_goals_at_away += game['away_points']\n\n current_formation = game['home_formation']\n opp_formation = game['away_formation']\n\n prev_opp.append(game['away_id'])\n\n game_features['possession'].append(game['home_possession'])\n game_features['attacks'].append(game['home_attacks'])\n game_features['dangerous_attacks'].append(game['home_dangerous_attacks'])\n game_features['yellow_cards'].append(game['home_yellow_card'])\n game_features['corner_kicks'].append(game['home_corner_kicks'])\n game_features['shots_on_target'].append(game['home_shots_on_target'])\n game_features['shots_total'].append(game['home_shots_total'])\n game_features['ball_safe'].append(game['home_ball_safe'])\n game_features['goal_attempts'].append(game['home_goal_attempts'])\n game_features['goal_attempts_allowed'].append(game['away_goal_attempts'])\n game_features['saves'].append(game['home_saves'])\n game_features['first_half_goals'].append(game['home_first_half_score'])\n game_features['sec_half_goals'].append(game['home_second_half_score'])\n game_features['goal_kicks'].append(game['home_goal_kicks'])\n\n else:\n team_name = game[\"away_team\"]\n\n if game['away_points'] == 3:\n win += 1.2\n\n elif game['away_points'] == 1:\n win += .5\n loss += .5\n\n else:\n loss += .8\n\n total_goals += game['away_score']\n goals_for += game['away_score']\n goals_against += game['home_score']\n goal_diff += game['away_score'] - game['home_score']\n total_points += game['away_points']\n\n goals_away += game['away_points']\n opp_goals_at_home += game['home_points']\n\n current_formation = game['away_formation']\n opp_formation = game['home_formation']\n\n prev_opp.append(game['home_id'])\n\n game_features['possession'].append(game['away_possession'])\n game_features['attacks'].append(game['away_attacks'])\n game_features['dangerous_attacks'].append(game['away_dangerous_attacks'])\n game_features['yellow_cards'].append(game['away_yellow_card'])\n game_features['corner_kicks'].append(game['away_corner_kicks'])\n game_features['shots_on_target'].append(game['away_shots_on_target'])\n game_features['shots_total'].append(game['away_shots_total'])\n game_features['ball_safe'].append(game['away_ball_safe'])\n game_features['goal_attempts'].append(game['away_goal_attempts'])\n game_features['goal_attempts_allowed'].append(game['home_goal_attempts'])\n game_features['saves'].append(game['away_saves'])\n game_features['first_half_goals'].append(game['away_first_half_score'])\n game_features['sec_half_goals'].append(game['away_second_half_score'])\n game_features['goal_kicks'].append(game['away_goal_kicks'])\n\n played += 1\n count += 1\n\n # Pulling the data for the CURRENT MATCH\n for index, cur_game in current_matches.iterrows():\n\n match_id = cur_game[\"match_id\"]\n scheduled = cur_game[\"scheduled\"]\n if team_id == cur_game['home_id']:\n is_home = True\n team_name = cur_game[\"home_team\"]\n current_opp = cur_game['away_id']\n\n if targets:\n # Targets\n points = cur_game['home_points']\n goals = cur_game['home_score']\n opp_goals = cur_game['away_score']\n\n else:\n\n is_home = False\n team_name = cur_game[\"away_team\"]\n current_opp = cur_game['home_id']\n\n if targets:\n # Targets\n points = cur_game['away_points']\n goals = cur_game['away_score']\n opp_goals = cur_game['home_score']\n\n for k, v in game_features.items():\n game_features[k] = np.sum(np.array(v))\n \"\"\"if len(v) != 0:\n game_features[k] = np.nanmean(np.array(v))\n else:\n game_features[k] = np.nan\"\"\"\n\n\n if stats:\n print(\" ========================== \")\n print(\"Team Id : {} - Name : {}\".format(team_id, team_name))\n print(\"Prev Opponent Ids : {}\".format(prev_opp))\n print(\"FEATURES (Stats from * 3 Previous Matches)\")\n print(\"Total Goals : {}\".format(total_goals))\n print(\"Total Points : {}\".format(total_points))\n # print(\"Win Points : {}\".format(win))\n # print(\"Loss Points : {}\".format(loss))\n print(\"Played : {}\".format(played))\n print(\"Goal Diff : {}\".format(goal_diff))\n print(\"Margin : {}\".format(np.divide(goal_diff, played)))\n print(\"\")\n\n if targets:\n # Still can weight games more on most recent games\n print(\"\\nTARGETS (RESULTS OF CURRENT MATCH)\")\n print(\"Points : {}\".format(points))\n print(\"Goals : {}\".format(goals))\n print(\"Opp_Goals : {}\".format(opp_goals))\n\n return match_id, team_id, team_name, scheduled, int(is_home == True), total_points, \\\n goals_for, goals_against, goal_diff, goal_efficiency, played, win, loss, recent_wins, recent_losses, prev_opp, \\\n current_opp, points, goals, opp_goals, current_formation, opp_formation, game_features","def score_summary(self, summary, references, summary_id='A'):\n try:\n self._write_config(references, Doc(summary_id, summary))\n output = self._run_rouge()\n output = output.decode(\"utf-8\")\n return self._parse_output(output)\n except CalledProcessError as e:\n print(\"Rouge returned a non-zero error code. Output was: \", file=sys.stderr)\n print(\"BEGIN OUTPUT \", file=sys.stderr)\n print(e.output, file=sys.stderr)\n print(\"END OUTPUT\", file=sys.stderr)\n raise e\n finally:\n self._cleanup()","def stats(self):","def get_bleu(ref, hyp, tokenization=\"intl\"):\n BLEU = corpus_bleu(hyp, [ref], tokenize=tokenization)\n return BLEU.score","def _calc_refs(counts):\n refs = 0\n for allele in counts.keys():\n refs += counts[allele]\n return refs","def summarize(self, field=None):\n\n # Check extra-dependency for computing the bleu score\n try:\n import sacrebleu\n except ImportError:\n print(\n \"Please install sacrebleu (https://pypi.org/project/sacrebleu/) in order to use the BLEU metric\"\n )\n\n scores = sacrebleu.corpus_bleu(self.predicts, self.targets)\n details = {}\n details[\"BLEU\"] = scores.score\n details[\"BP\"] = scores.bp\n details[\"ratio\"] = scores.sys_len / scores.ref_len\n details[\"hyp_len\"] = scores.sys_len\n details[\"ref_len\"] = scores.ref_len\n details[\"precisions\"] = scores.precisions\n\n self.scores = scores\n self.summary = details\n\n # Add additional, more generic key\n self.summary[\"bleu_score\"] = self.summary[\"BLEU\"]\n\n if field is not None:\n return self.summary[field]\n else:\n return self.summary","def _estimate_stats_with_rel_info(self):\r\n nonrel_list = []\r\n rel_list = []\r\n for ele in self._ranking_list:\r\n score = ele[0]\r\n rel = ele[1]\r\n if rel:\r\n rel_list.append(score)\r\n else:\r\n nonrel_list.append(score)\r\n m1,v1 = self._compute_stat_from_list(rel_list) \r\n m0,v0 = self._compute_stat_from_list(nonrel_list)\r\n estimated_lambda = len(rel_list)*1.0/len(self._ranking_list)\r\n\r\n self._m1 = m1\r\n self._v1 = v1\r\n self._m0 = m0\r\n self._v0 = v0\r\n self._lambda = estimated_lambda\r\n\r\n if self._debug :\r\n print \"m1: %f, v1: %f, m0: %f, v0: %f\" %(self._m1,self._v1,self._m0,self._v0)\r\n print \"lambda: %f\" %(estimated_lambda)","def get_scores(self):\n\n\t\tscores = np.dot(self.rankings, self.weights)\n\t\tranked_indices = np.argsort(scores)\n\t\tranked_sources = self.source_names[ranked_indices]\n\t\tranked_scores = sorted(scores)\n\t\tself.scores = {source:score for source, score in zip(ranked_sources, ranked_scores)}\n\n\t\treturn self.scores","def score(self):\n\n self.link()\n roc, _ = self.aggregate()\n\n return roc","def rouge_l_summary_level(evaluated_sentences, reference_sentences):\n if len(evaluated_sentences) <= 0 or len(reference_sentences) <= 0:\n raise ValueError(\"Collections must contain at least 1 sentence.\")\n\n # total number of words in reference sentences\n m = len(_split_into_words(reference_sentences))\n\n # total number of words in evaluated sentences\n n = len(_split_into_words(evaluated_sentences))\n\n union_lcs_sum_across_all_references = 0\n for ref_s in reference_sentences:\n union_lcs_sum_across_all_references += _union_lcs(evaluated_sentences,\n ref_s)\n return _f_p_r_lcs(union_lcs_sum_across_all_references, m, n)","def calc_difference_from_reference(inputs, outputs, verbose=True):\n\n # Get a list of reference input/output files\n filename_ref_inputs = glob.glob(lal_cuda.full_path_datafile(\"inputs.dat*\"))\n filename_ref_outputs = [\n filename_ref_input_i.replace(\n \"inputs.dat\",\n \"outputs.dat\") for filename_ref_input_i in filename_ref_inputs]\n\n # Look to see if the given inputs are in the stored reference inputs\n filename_ref_output = None\n for filename_ref_input_i, filename_ref_output_i in zip(filename_ref_inputs, filename_ref_outputs):\n inputs_i = inputs.read(filename_ref_input_i)\n\n # Check to see if this set of inputs matches the set that has been passed\n if(inputs_i == inputs):\n inputs_ref = inputs_i\n filename_ref_output = filename_ref_output_i\n break\n\n # Perform check if a match has been found\n if(not filename_ref_output):\n lal_cuda.log.warning(\n \"Checking could not be performed: reference data set with given inputs (%s) not found.\" %\n (inputs))\n else:\n if(verbose):\n lal_cuda.log.open('Performing test...')\n\n # Read reference dataset's outputs\n outputs_ref = outputs.read(filename_ref_output)\n\n # Compute statistics of difference from test reference\n hpval_real_diff_avg = 0.\n hpval_imag_diff_avg = 0.\n hcval_real_diff_avg = 0.\n hcval_imag_diff_avg = 0.\n hpval_real_diff_max = 0.\n hpval_imag_diff_max = 0.\n hcval_real_diff_max = 0.\n hcval_imag_diff_max = 0.\n for (hp_i, hc_i, hp_ref_i, hc_ref_i) in zip(outputs.hp, outputs.hc, outputs_ref.hp, outputs_ref.hc):\n hpval_real_diff_i = calc_frac_diff(hp_i.real, hp_ref_i.real)\n hpval_imag_diff_i = calc_frac_diff(hp_i.imag, hp_ref_i.imag)\n hcval_real_diff_i = calc_frac_diff(hc_i.real, hc_ref_i.real)\n hcval_imag_diff_i = calc_frac_diff(hc_i.imag, hc_ref_i.imag)\n hpval_real_diff_avg += hpval_real_diff_i\n hpval_imag_diff_avg += hpval_imag_diff_i\n hcval_real_diff_avg += hcval_real_diff_i\n hcval_imag_diff_avg += hcval_imag_diff_i\n hpval_real_diff_max = max([hpval_real_diff_max, hpval_real_diff_i])\n hpval_imag_diff_max = max([hpval_imag_diff_max, hpval_imag_diff_i])\n hcval_real_diff_max = max([hcval_real_diff_max, hcval_real_diff_i])\n hcval_imag_diff_max = max([hcval_imag_diff_max, hcval_imag_diff_i])\n hpval_real_diff_avg /= float(len(outputs.hp))\n hpval_imag_diff_avg /= float(len(outputs.hp))\n hcval_real_diff_avg /= float(len(outputs.hc))\n hcval_imag_diff_avg /= float(len(outputs.hc))\n\n # Report results\n if(verbose):\n lal_cuda.log.comment(' Average/maximum real(hp) fractional difference: %.2e/%.2e' %\n (hpval_real_diff_avg, hpval_real_diff_max))\n lal_cuda.log.comment(' Average/maximum imag(hp) fractional difference: %.2e/%.2e' %\n (hpval_imag_diff_avg, hpval_imag_diff_max))\n lal_cuda.log.comment(' Average/maximum real(hc) fractional difference: %.2e/%.2e' %\n (hcval_real_diff_avg, hcval_real_diff_max))\n lal_cuda.log.comment(' Average/maximum imag(hc) fractional difference: %.2e/%.2e' %\n (hcval_imag_diff_avg, hcval_imag_diff_max))\n lal_cuda.log.close(\"Done.\")\n\n return {\n 'hpval_real_diff_avg': hpval_real_diff_avg,\n 'hpval_real_diff_max': hpval_real_diff_max,\n 'hpval_imag_diff_avg': hpval_imag_diff_avg,\n 'hpval_imag_diff_max': hpval_imag_diff_max,\n 'hcval_real_diff_avg': hcval_real_diff_avg,\n 'hcval_real_diff_max': hcval_real_diff_max,\n 'hcval_imag_diff_avg': hcval_imag_diff_avg,\n 'hcval_imag_diff_max': hcval_imag_diff_max}","def table_stats(self, db, dest, kvargs, lines):\n if 'table' in kvargs:\n tables = [db.get_table(kvargs['table'])]\n else:\n tables = db.tables()\n options = kvargs.get('options','')\n done = False\n for table in db.tables():\n print(\"======================= {} =======================\".format(table.name))\n if 'dump' in options:\n print(\"schema dump:\")\n table.dump()\n print(\"\")\n if 'head' in options:\n print(\"First 5 records:\")\n for source_record in db.read_records_as_dicts(tablename=table.name, limit=5):\n print(source_record)\n print(\"\")\n # Compute single-variable stats on each of the variables\n sw = stopwatch().start()\n print(\"Computing statistics...\")\n stats = {}\n census_checksum = 0\n \n if self.spark_context:\n print(\"Using spark to read {} ... assuming first line has headings\".format(table.filename))\n sc = self.spark_context\n data = sc.textFile(table.filename)\n header = data.first() # extract the header\n stats = data.filter(lambda row:row!=header).map(table.parse_line_to_dict).reduce(stats_reducer)\n else:\n try:\n for source_record in db.read_records_as_dicts(tablename=table.name,limit=self.limit):\n if source_record['RECTYPE']=='P':\n census_checksum += census_person_polynominal(source_record)\n stats = stats_reducer(source_record, stats)\n except KeyboardInterrupt as e:\n print(\"*** KeyboardInterrupt at count: {}\".format(stats[':count']))\n done = True\n if stats:\n print(\"total records: {} speed: {:8.0f} records/sec\".format( stats[':count'], stats[':count']/sw.elapsed()))\n tt = tytable.ttable()\n tt.add_head(['variable','min','avg','max'])\n tt.set_col_alignment(1,tytable.ttable.RIGHT)\n tt.set_col_alignment(2,tytable.ttable.RIGHT)\n tt.set_col_alignment(3,tytable.ttable.RIGHT)\n for key in stats_variable_names(stats):\n try:\n tt.add_data([key, stats[key+\":min\"], stats[key+\":sum\"] / stats[':count'], stats[key+\":max\"]])\n except TypeError:\n tt.add_data([key, stats[key+\":min\"], \"\", stats[key+\":max\"]])\n print(tt.typeset(mode=tytable.TEXT))\n if census_checksum:\n print(\"Census checksum: {}\".format(census_checksum))\n print(\"\")\n if done:\n return True # had the keyboard abort\n return True","def rouge_l_summary_level(evaluated_sentences, reference_sentences):\n if len(evaluated_sentences) <= 0 or len(reference_sentences) <= 0:\n raise ValueError(\"Collections must contain at least 1 sentence.\")\n\n # total number of words in reference sentences\n m = len(_split_into_words(reference_sentences))\n\n # total number of words in evaluated sentences\n n = len(_split_into_words(evaluated_sentences))\n\n union_lcs_sum_across_all_references = 0\n for ref_s in reference_sentences:\n union_lcs_sum_across_all_references += _union_lcs(evaluated_sentences,\n ref_s)\n return _f_p_r_lcs(union_lcs_sum_across_all_references, m, n)","def evaluate_rouge_match(ref_data, pred_data, align=\"rouge\"):\n\n scorer = RougeScorer([\"rougeL\"])\n agg = scoring.BootstrapAggregator(confidence_interval=0.95)\n sample_evaluated = 0\n\n for tid in tqdm(pred_data):\n cur_sys = pred_data[tid][\"pred\"]\n if not tid in ref_data: continue\n cur_ref_lst = [x[\"tgt_words\"] for x in ref_data[tid]]\n if len(cur_ref_lst) > 0:\n if align == \"rouge\":\n best_rouge_scrs = __rouge_pairs(cur_sys, cur_ref_lst, scorer)\n agg.add_scores(best_rouge_scrs)\n else:\n best_paired_ref, _ = utils.pair_ref_sys_by_coverage(cur_sys, cur_ref_lst)\n agg.add_scores(scorer.score(best_paired_ref, cur_sys))\n sample_evaluated += 1\n\n print(sample_evaluated)\n result = agg.aggregate()\n for rouge_type in result:\n print(rouge_type)\n print(result[rouge_type].mid)\n\n print(agg.aggregate())\n return","def get_rouge(ref_path, pred_path):\n print(\"###########cal rouge###############\")\n source_lines = [line.strip() for line in codecs.open(ref_path, \"r\", \"utf-8\").readlines()]\n pred_lines = [ pred.strip() for pred in codecs.open(pred_path, \"r\", \"utf-8\").readlines() ]\n assert len(source_lines) == len(pred_lines)\n rou = rouge.Rouge()\n scores = rou.get_scores(pred_lines, source_lines)\n ave_scores = rou.get_scores(pred_lines, source_lines, avg=True)\n result = OrderedDict()\n result[\"ave_scores\"] = ave_scores\n result[\"detail_scores\"] = scores\n print(ave_scores)\n print(\"############end rouge#############\\n\")\n return result","def test_add_two_sources(self):\n metric = self.metric()\n measurement = self.measurement(\n metric,\n sources=[self.source(metric, value=\"10\"), self.source(metric, value=\"20\")],\n )\n self.assertEqual(\"30\", measurement[\"count\"][\"value\"])","def general_stats():\n\n setproctitle(f\"RNANet statistics.py general_stats()\")\n\n reqs = [\n # unique unmapped chains with no issues\n \"\"\" SELECT distinct pdb_id, chain_name, exp_method, resolution\n FROM chain JOIN structure ON chain.structure_id = structure.pdb_id\n WHERE rfam_acc = 'unmappd' AND ISSUE=0;\"\"\",\n\n # unique mapped chains with no issues\n \"\"\" SELECT distinct pdb_id, chain_name, exp_method, resolution\n FROM chain JOIN structure ON chain.structure_id = structure.pdb_id\n WHERE rfam_acc != 'unmappd' AND ISSUE=0;\"\"\",\n\n # mapped chains with no issues\n \"\"\" SELECT pdb_id, chain_name, inferred, rfam_acc, pdb_start, pdb_end, exp_method, resolution\n FROM chain JOIN structure ON chain.structure_id = structure.pdb_id\n WHERE rfam_acc != 'unmappd' AND ISSUE=0;\"\"\",\n\n # mapped chains with no issues that are all inferred\n \"\"\" SELECT DISTINCT pdb_id, c.chain_name, exp_method, resolution\n FROM (\n SELECT inferred, rfam_acc, pdb_start, pdb_end, chain.structure_id, chain.chain_name, r.redundancy, r.inf_redundancy\n FROM chain \n JOIN (SELECT structure_id, chain_name, COUNT(distinct rfam_acc) AS redundancy, SUM(inferred) AS inf_redundancy \n FROM chain \n WHERE rfam_acc != 'unmappd' AND issue=0 \n GROUP BY structure_id, chain_name\n ) AS r ON chain.structure_id=r.structure_id AND chain.chain_name = r.chain_name \n WHERE r.redundancy=r.inf_redundancy AND rfam_acc != 'unmappd' and issue=0\n ) AS c\n JOIN structure ON c.structure_id=structure.pdb_id;\"\"\",\n\n # Number of mapped chains (not inferred)\n \"\"\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 0);\"\"\",\n\n # Number of unique mapped chains (not inferred)\n \"\"\"SELECT count(*) FROM (SELECT DISTINCT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 0);\"\"\",\n\n # Number of mapped chains (inferred)\n \"\"\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 1);\"\"\",\n\n # Number of unique mapped chains (inferred)\n \"\"\"SELECT count(*) FROM (SELECT DISTINCT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 1);\"\"\",\n\n # Number of mapped chains inferred once\n \"\"\"SELECT count(*) FROM (\n SELECT structure_id, chain_name, COUNT(DISTINCT rfam_acc) as c \n FROM chain where rfam_acc!='unmappd' and inferred=1 \n GROUP BY structure_id, chain_name\n ) WHERE c=1;\"\"\",\n\n # Number of mapped chains inferred twice\n \"\"\"select count(*) from (\n select structure_id, chain_name, count(distinct rfam_acc) as c \n from chain where rfam_acc!='unmappd' and inferred=1 \n group by structure_id, chain_name\n ) where c=2;\"\"\",\n\n # Number of mapped chains inferred 3 times or more\n \"\"\"select count(*) from (\n select structure_id, chain_name, count(distinct rfam_acc) as c \n from chain where rfam_acc!='unmappd' and inferred=1 \n group by structure_id, chain_name\n ) where c>2;\"\"\",\n\n # Number of chains both mapped with and without inferrence\n \"\"\" SELECT COUNT(*) FROM (\n SELECT structure_id, chain_name, sum(inferred) AS s, COUNT(rfam_acc) AS c \n FROM chain \n WHERE rfam_acc!='unmappd' \n GROUP BY structure_id, chain_name\n ) \n WHERE s < c AND s > 0;\"\"\",\n \n # Number of mapped chains (total)\n \"\"\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd');\"\"\",\n\n # Number of unique mapped chains\n \"\"\"SELECT count(*) FROM (SELECT DISTINCT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd');\"\"\",\n\n # Number of unmapped chains\n \"\"\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc = 'unmappd');\"\"\",\n \n # Number of mapped chains without issues (not inferred)\n \"\"\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 0 AND issue = 0);\"\"\",\n\n # Number of unique mapped chains without issues (not inferred)\n \"\"\"SELECT count(*) FROM (SELECT DISTINCT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 0 AND issue = 0);\"\"\",\n\n # Number of mapped chains without issues (inferred)\n \"\"\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 1 AND issue=0);\"\"\",\n\n # Number of unique mapped chains without issues (inferred)\n \"\"\"SELECT count(*) FROM (SELECT DISTINCT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 1 AND issue=0);\"\"\",\n\n # Number of mapped chains without issues (total)\n \"\"\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND issue=0);\"\"\",\n\n # Number of unique mapped chains without issues\n \"\"\"SELECT count(*) FROM (SELECT DISTINCT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND issue=0);\"\"\",\n\n # Number of unmapped chains without issues\n \"\"\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc = 'unmappd' AND issue=0);\"\"\"\n ]\n\n answers = []\n with sqlite3.connect(runDir + \"/results/RNANet.db\") as conn:\n conn.execute('pragma journal_mode=wal')\n for r in reqs:\n answers.append(pd.read_sql(r, conn))\n df_unique = answers[0]\n df_mapped_unique = answers[1]\n df_mapped_copies = answers[2]\n df_inferred_only_unique = answers[3]\n print()\n print(\"> found\", answers[4].iloc[0][0], f\"chains ({answers[5].iloc[0][0]} unique chains) that are mapped thanks to Rfam. Removing chains with issues, only {answers[15].iloc[0][0]} ({answers[16].iloc[0][0]} unique)\")\n if answers[4].iloc[0][0] != answers[5].iloc[0][0]:\n print(\"\\t> This happens because different parts of the same chain can be mapped to different families.\")\n print(\"> found\", answers[6].iloc[0][0], f\"chains ({answers[7].iloc[0][0]} unique chains) that are mapped by inferrence. Removing chains with issues, only {answers[17].iloc[0][0]} ({answers[18].iloc[0][0]} unique).\")\n print(\"\\t> \", answers[8].iloc[0][0], \"chains are mapped only once,\")\n print(\"\\t> \", answers[9].iloc[0][0], \"are mapped to 2 families,\")\n print(\"\\t> \", answers[10].iloc[0][0], \"are mapped to 3 or more.\")\n print(\"> Among them,\", answers[11].iloc[0][0], \"chains are mapped both with families found on Rfam and by inferrence.\")\n if answers[11].iloc[0][0]:\n print(\"\\t> this is normal if you used option -f (--full-inference). Otherwise, there might be a problem.\")\n print(\"> TOTAL:\", answers[12].iloc[0][0], f\"chains ({answers[13].iloc[0][0]} unique chains) mapped to a family. Removing chains with issues, only {answers[19].iloc[0][0]} ({answers[20].iloc[0][0]} unique).\")\n print(\"> TOTAL:\", answers[14].iloc[0][0], f\"unmapped chains. Removing chains with issues, {answers[21].iloc[0][0]}.\")\n if answers[14].iloc[0][0]:\n print(\"\\t> this is normal if you used option --no-homology. Otherwise, there might be a problem.\")\n print()\n\n ##########################################\n # plot N = f(resolution, exp_method)\n ##########################################\n\n methods = df_unique.exp_method.unique()\n\n fig, axs = plt.subplots(1+len(methods), 3, figsize=(15,5*(1+len(methods))), sharex=True)\n df_unique.sort_values('resolution', inplace=True, ignore_index=True)\n df_mapped_unique.sort_values('resolution', inplace=True, ignore_index=True)\n df_inferred_only_unique.sort_values('resolution', inplace=True, ignore_index=True)\n df_mapped_copies.sort_values('resolution', inplace=True, ignore_index=True)\n max_res = max(df_unique.resolution)\n max_structs = max(len(df_mapped_copies.index), len(df_unique.index))\n colors = np.linspace(0,1,1+len(methods))\n plt.xticks( np.arange(0, max_res+2, 2.0).tolist(), np.arange(0, max_res+2, 2.0).tolist() )\n\n axs[0][0].grid(axis='y', ls='dotted', lw=1)\n axs[0][0].hist(df_unique.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 1, colors[0], 1), label='distribution')\n axs[0][0].hist(df_unique.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 0, colors[0], 0.5), cumulative=True, label='cumulative')\n axs[0][0].text(0.95*max_res, 0.95*len(df_unique.resolution), \"%d \" % len(df_unique.resolution), \n horizontalalignment='right', verticalalignment='top', fontsize=14)\n axs[0][0].set_ylabel(\"ALL\", fontsize=14)\n axs[0][0].set_title(\"Number of unique RNA chains\", fontsize=14)\n axs[0][0].set_ylim((0, max_structs * 1.05))\n axs[0][0].legend(loc=\"lower right\", fontsize=14)\n\n axs[0][1].grid(axis='y', ls='dotted', lw=1)\n axs[0][1].set_yticklabels([])\n axs[0][1].hist(df_mapped_unique.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 1, colors[0], 1), label='distribution')\n axs[0][1].hist(df_mapped_unique.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 0, colors[0], 0.5), cumulative=True, label='cumulative')\n axs[0][1].hist(df_inferred_only_unique.resolution, bins=np.arange(0, max_res, 0.5), fc=(0.2, 0, colors[0], 0.5), cumulative=True, label='only by inference')\n axs[0][1].text(0.95*max_res, 0.95*len(df_mapped_unique.resolution), \"%d \" % len(df_mapped_unique.resolution), \n horizontalalignment='right', verticalalignment='top', fontsize=14)\n axs[0][1].set_title(r\"Number of unique RNA chains\\nmapped to $\\geq 1$ family\", fontsize=14)\n axs[0][1].set_ylim((0, max_structs * 1.05))\n axs[0][1].legend(loc=\"upper left\", fontsize=14)\n\n axs[0][2].grid(axis='y', ls='dotted', lw=1)\n axs[0][2].set_yticklabels([])\n axs[0][2].hist(df_mapped_copies.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 1, colors[0], 1), label='distribution')\n axs[0][2].hist(df_mapped_copies.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 0, colors[0], 0.5), cumulative=True, label='cumulative')\n axs[0][2].hist(df_mapped_copies[df_mapped_copies.inferred == 1].resolution, bins=np.arange(0, max_res, 0.5), fc=(0.2, 0, colors[0], 0.5), cumulative=True, label='inferred')\n axs[0][2].text(0.95*max_res, 0.95*len(df_mapped_copies.resolution), \"%d \" % len(df_mapped_copies.resolution), \n horizontalalignment='right', verticalalignment='top', fontsize=14)\n axs[0][2].set_title(\"Number of RNA chains mapped to a\\nfamily (with copies)\", fontsize=14)\n axs[0][2].legend(loc=\"upper left\", fontsize=14)\n axs[0][2].set_ylim((0, max_structs * 1.05))\n\n for i,m in enumerate(methods):\n df_unique_m = df_unique[df_unique.exp_method == m]\n df_mapped_unique_m = df_mapped_unique[df_mapped_unique.exp_method == m]\n df_inferred_only_unique_m = df_inferred_only_unique[df_inferred_only_unique.exp_method == m]\n df_mapped_copies_m = df_mapped_copies[ df_mapped_copies.exp_method == m]\n max_structs = max(len(df_mapped_copies_m.index), len(df_unique_m.index))\n print(\"> found\", max_structs, \"structures with method\", m, flush=True)\n\n axs[1+i][0].grid(axis='y', ls='dotted', lw=1)\n axs[1+i][0].hist(df_unique_m.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 1, colors[1+i], 1), label='distribution')\n axs[1+i][0].hist(df_unique_m.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 0, colors[1+i], 0.5), cumulative=True, label='cumulative')\n axs[1+i][0].text(0.95*max_res, 0.95*len(df_unique_m.resolution), \"%d \" % len(df_unique_m.resolution), \n horizontalalignment='right', verticalalignment='top', fontsize=14)\n axs[1+i][0].set_ylim((0, max_structs * 1.05))\n axs[1+i][0].set_ylabel(m, fontsize=14)\n axs[1+i][0].legend(loc=\"lower right\", fontsize=14)\n\n axs[1+i][1].grid(axis='y', ls='dotted', lw=1)\n axs[1+i][1].set_yticklabels([])\n axs[1+i][1].hist(df_mapped_unique_m.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 1, colors[1+i], 1), label='distribution')\n axs[1+i][1].hist(df_mapped_unique_m.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 0, colors[1+i], 0.5), cumulative=True, label='cumulative')\n axs[1+i][1].hist(df_inferred_only_unique_m.resolution, bins=np.arange(0, max_res, 0.5), fc=(0.2, 0, colors[1+i], 0.5), cumulative=True, label='only by inference')\n axs[1+i][1].text(0.95*max_res, 0.95*len(df_mapped_unique_m.resolution), \"%d \" % len(df_mapped_unique_m.resolution), \n horizontalalignment='right', verticalalignment='top', fontsize=14)\n axs[1+i][1].set_ylim((0, max_structs * 1.05))\n axs[1+i][1].legend(loc=\"upper left\", fontsize=14)\n \n axs[1+i][2].grid(axis='y', ls='dotted', lw=1)\n axs[1+i][2].set_yticklabels([])\n axs[1+i][2].hist(df_mapped_copies_m.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 1, colors[1+i], 1), label='distribution')\n axs[1+i][2].hist(df_mapped_copies_m.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 0, colors[1+i], 0.5), cumulative=True, label='cumulative')\n axs[1+i][2].hist(df_mapped_copies_m[df_mapped_copies_m.inferred == 1].resolution, bins=np.arange(0, max_res, 0.5), fc=(0.2, 0, colors[1+i], 0.5), cumulative=True, label='inferred')\n axs[1+i][2].text(0.95*max_res, 0.95*len(df_mapped_copies_m.resolution), \"%d \" % len(df_mapped_copies_m.resolution), \n horizontalalignment='right', verticalalignment='top', fontsize=14)\n axs[1+i][2].set_ylim((0, max_structs * 1.05))\n axs[1+i][2].legend(loc=\"upper left\", fontsize=14)\n \n axs[-1][0].set_xlabel(\"Structure resolution\\n(Angströms, lower is better)\", fontsize=14)\n axs[-1][1].set_xlabel(\"Structure resolution\\n(Angströms, lower is better)\", fontsize=14)\n axs[-1][2].set_xlabel(\"Structure resolution\\n(Angströms, lower is better)\", fontsize=14)\n\n fig.suptitle(\"Number of RNA chains by experimental method and resolution\", fontsize=16)\n fig.subplots_adjust(left=0.07, right=0.98, wspace=0.05, \n hspace=0.05, bottom=0.05, top=0.92)\n fig.savefig(runDir + \"/results/figures/resolutions.png\")\n plt.close()\n\n ##########################################\n # plot Nfam = f(resolution, exp_method)\n ##########################################\n\n df_mapped_copies['n_fam'] = [ len(df_mapped_copies.rfam_acc[:i+1].unique()) for i in range(len(df_mapped_copies.index)) ]\n\n fig, axs = plt.subplots(1, 1+len(methods), figsize=(5*(1+len(methods)), 5))\n max_res = max(df_mapped_copies.resolution)\n max_fams = max(df_mapped_copies.n_fam)\n colors = np.linspace(0,1,1+len(methods))\n plt.xticks( np.arange(0, max_res+2, 2.0).tolist(), np.arange(0, max_res+2, 2.0).tolist() )\n\n axs[0].grid(axis='y', ls='dotted', lw=1)\n axs[0].plot(df_mapped_copies.resolution, df_mapped_copies.n_fam)\n axs[0].text(0.95*max_res, 0.95*df_mapped_copies.n_fam.iloc[-1], \"%d \" % df_mapped_copies.n_fam.iloc[-1], \n horizontalalignment='right', verticalalignment='top', fontsize=14)\n axs[0].set_title(\"ALL\", fontsize=14)\n axs[0].set_xlabel(\"Structure resolution (Angströms)\", fontsize=14)\n axs[0].set_ylabel(\"Number of Rfam families\", fontsize=14)\n axs[0].set_ylim((0, max_res * 1.05))\n axs[0].set_ylim((0, max_fams * 1.05))\n \n for i,m in enumerate(methods):\n df_mapped_copies_m = df_mapped_copies[ df_mapped_copies.exp_method == m].drop(\"n_fam\", axis=1).copy()\n df_mapped_copies_m['n_fam'] = [ len(df_mapped_copies_m.rfam_acc[:i+1].unique()) for i in range(len(df_mapped_copies_m.index)) ]\n print(\">\", df_mapped_copies_m.n_fam.iloc[-1], \"different RNA families have a 3D structure solved by\", m)\n\n axs[1+i].grid(axis='y', ls='dotted', lw=1)\n axs[1+i].plot(df_mapped_copies_m.resolution, df_mapped_copies_m.n_fam, )\n axs[1+i].text(0.95*max(df_mapped_copies_m.resolution), 0.95*df_mapped_copies_m.n_fam.iloc[-1], \"%d \" % df_mapped_copies_m.n_fam.iloc[-1], \n horizontalalignment='right', verticalalignment='top', fontsize=14)\n axs[1+i].set_xlim((0, max_res * 1.05))\n axs[1+i].set_ylim((0, max_fams * 1.05))\n axs[1+i].set_xlabel(\"Structure resolution (Angströms)\", fontsize=14)\n axs[1+i].set_title(m, fontsize=14)\n axs[1+i].set_yticklabels([])\n \n fig.suptitle(\"Number of RNA families used by experimental method and resolution\", fontsize=16)\n fig.subplots_adjust(left=0.05, right=0.98, wspace=0.05, \n hspace=0.05, bottom=0.12, top=0.84)\n fig.savefig(runDir + \"/results/figures/Nfamilies.png\")\n plt.close()","def score(self, input_batch, input_ref):\n x_standardized = self.model._batch_to_list(input_batch)\n ref_standaradized = None\n if input_ref is not None:\n ref_standaradized = self.model._batch_to_list(input_ref)\n\n scores = self.deeplift_contribs_func(task_idx=self.task_idx,\n input_data_list=x_standardized,\n input_references_list=ref_standaradized,\n batch_size=self.batch_size,\n progress_update=1000)\n\n # TODO DeepLIFT error when using batched execution:\n \"\"\"\n # run_function_in_batches fails for \n scores = run_function_in_batches(\n func=self.deeplift_contribs_func,\n input_data_list=x_standardized,\n batch_size=self.batch_size,\n progress_update=1000,\n task_idx=self.task_idx)\n \"\"\"\n\n # DeepLIFT returns all samples as a list of individual samples\n scores = [numpy_collate(el) for el in scores]\n\n # re-format the list-type input back to how the input_batch was:\n scores = self.model._match_to_input(scores, input_batch)\n return scores","def compute_rouge_l(output, reference, mode='f'):\n assert mode in list('fpr') # F-1, precision, recall\n lcs = _lcs_len(output, reference)\n if lcs == 0:\n score = 0.0\n else:\n precision = lcs / len(output)\n recall = lcs / len(reference)\n f_score = 2 * (precision * recall) / (precision + recall)\n if mode == 'p':\n score = precision\n if mode == 'r':\n score = recall\n else:\n score = f_score\n return score","def get_score(submissions, problem, due_date, options):\r\n best_score = None\r\n best_percent = 0\r\n best_ts = None\r\n bonus = None\r\n partners = set()\r\n for i, s in enumerate(submissions):\r\n timestamp = s['date']\r\n submission_num = s['submission_num']\r\n detail = s['detail']\r\n if 'correct_map' in detail and not options.is_clicker:\r\n try:\r\n autograder_out = detail['correct_map']['i4x-BerkeleyX-CS188x-17-problem-' + problem + '_2_1']['msg']\r\n except Exception, e:\r\n logging.error(\"Error getting output: %s. Submission:\\n%s\" % (e, s))\r\n continue\r\n\r\n autograder_out = unescape(autograder_out)\r\n if options.output:\r\n print(\"Autograder output for submission %s on %s:\\n%s\" % (submission_num, timestamp, autograder_out))\r\n\r\n get_bonus(autograder_out)\r\n extra = bonus_pattern.findall(autograder_out)\r\n if extra:\r\n bonus = extra[0]\r\n num, denom = s['score'].split(' / ')\r\n percent = float(num) / float(denom) if 'None' not in num else 0\r\n if percent > best_percent:\r\n best_score = s['score']\r\n best_percent = percent\r\n best_ts = timestamp\r\n if 'student_answers' in detail and not options.is_clicker:\r\n partner = detail['student_answers'].get('i4x-BerkeleyX-CS188x-17-problem-' + problem + '_3_1', '')\r\n if partner:\r\n partners.add(partner)\r\n logging.info(\"Partners: %s\" % (partners))\r\n\r\n if best_ts is not None and due_date is not None:\r\n submitted = dt.datetime.strptime(best_ts.split('+')[0], '%Y-%m-%d %H:%M:%S')\r\n slip_days_used = str((submitted - due_date).days + 1)\r\n else:\r\n slip_days_used = 'N/A'\r\n return best_score, bonus, partners, slip_days_used","def scoring(self):\n pass","def rank_skill_support():\n import collections\n score_dict = collections.defaultdict(int)\n for item in classes.Crusader.items:\n for name in classes.Crusader.skill_names:\n if name in inspect.getsource(item):\n score_dict[name] += 1\n\n for name, freq in sorted(score_dict.items(), key=lambda x: -x[1]):\n print(name, freq)","def main():\n\trelations = [json.loads(x) for x in open('tutorial/pdtb_trial_data.json')]\n\toutput_relations = [convert_to_output(x) for x in relations]\n\toutput_relations[1]['Connective']['TokenList'] = [0]\n\toutput_relations[3]['Arg1']['TokenList'].pop(4)\n\toutput_relations[4]['Arg2']['TokenList'].pop(4)\n\toutput_relations[5]['Arg2']['TokenList'].pop(4)\n\toutput_relations[6]['Sense'] = [u'Contingency.Condition'] # This will hurt sense recall\n\toutput_relations.pop(0) # This will hurt all precision\n\tscorer.evaluate(relations, output_relations)\n\treturn output_relations","def corpus_gleu(list_of_references, hypotheses, min_len=1, max_len=4):\n # sanity check\n assert len(list_of_references) == len(\n hypotheses\n ), \"The number of hypotheses and their reference(s) should be the same\"\n\n # sum matches and max-token-lengths over all sentences\n corpus_n_match = 0\n corpus_n_all = 0\n\n for references, hypothesis in zip(list_of_references, hypotheses):\n hyp_ngrams = Counter(everygrams(hypothesis, min_len, max_len))\n tpfp = sum(hyp_ngrams.values()) # True positives + False positives.\n\n hyp_counts = []\n for reference in references:\n ref_ngrams = Counter(everygrams(reference, min_len, max_len))\n tpfn = sum(ref_ngrams.values()) # True positives + False negatives.\n\n overlap_ngrams = ref_ngrams & hyp_ngrams\n tp = sum(overlap_ngrams.values()) # True positives.\n\n # While GLEU is defined as the minimum of precision and\n # recall, we can reduce the number of division operations by one by\n # instead finding the maximum of the denominators for the precision\n # and recall formulae, since the numerators are the same:\n # precision = tp / tpfp\n # recall = tp / tpfn\n # gleu_score = min(precision, recall) == tp / max(tpfp, tpfn)\n n_all = max(tpfp, tpfn)\n\n if n_all > 0:\n hyp_counts.append((tp, n_all))\n\n # use the reference yielding the highest score\n if hyp_counts:\n n_match, n_all = max(hyp_counts, key=lambda hc: hc[0] / hc[1])\n corpus_n_match += n_match\n corpus_n_all += n_all\n\n # corner case: empty corpus or empty references---don't divide by zero!\n if corpus_n_all == 0:\n gleu_score = 0.0\n else:\n gleu_score = corpus_n_match / corpus_n_all\n\n return gleu_score","def rouge(hypotheses, references):\n\n # Filter out hyps that are of 0 length\n # hyps_and_refs = zip(hypotheses, references)\n # hyps_and_refs = [_ for _ in hyps_and_refs if len(_[0]) > 0]\n # hypotheses, references = zip(*hyps_and_refs)\n\n # Calculate ROUGE-1 F1, precision, recall scores\n rouge_1 = [\n rouge_n([hyp], [ref], 1) for hyp, ref in zip(hypotheses, references)\n ]\n rouge_1_f, rouge_1_p, rouge_1_r = map(np.mean, zip(*rouge_1))\n\n # Calculate ROUGE-2 F1, precision, recall scores\n rouge_2 = [\n rouge_n([hyp], [ref], 2) for hyp, ref in zip(hypotheses, references)\n ]\n rouge_2_f, rouge_2_p, rouge_2_r = map(np.mean, zip(*rouge_2))\n\n # Calculate ROUGE-L F1, precision, recall scores\n rouge_l = [\n rouge_l_sentence_level([hyp], [ref])\n for hyp, ref in zip(hypotheses, references)\n ]\n rouge_l_f, rouge_l_p, rouge_l_r = map(np.mean, zip(*rouge_l))\n\n return {\n \"rouge_1/f_score\": rouge_1_f,\n \"rouge_1/r_score\": rouge_1_r,\n \"rouge_1/p_score\": rouge_1_p,\n \"rouge_2/f_score\": rouge_2_f,\n \"rouge_2/r_score\": rouge_2_r,\n \"rouge_2/p_score\": rouge_2_p,\n \"rouge_l/f_score\": rouge_l_f,\n \"rouge_l/r_score\": rouge_l_r,\n \"rouge_l/p_score\": rouge_l_p,\n }","def assign_similarity_importance( self, similarity_matrix_sources, tools_list, optimal_weights ):\n similarity_matrix_learned = list()\n all_tools = len( tools_list )\n for tool_index, tool in enumerate( tools_list ):\n sim_mat_tool_learned = np.zeros( all_tools )\n for source in similarity_matrix_sources:\n optimal_weight_source = optimal_weights[ tools_list[ tool_index ] ][ source ]\n # add up the similarity scores from each source weighted by importance factors learned by machine leanring algorithm\n sim_mat_tool_learned += optimal_weight_source * similarity_matrix_sources[ source ][ tool_index ]\n similarity_matrix_learned.append( sim_mat_tool_learned )\n return similarity_matrix_sources, similarity_matrix_learned","def compute_score(predictions, references, vocab=None, beam_size=4):\n assert np.rank(predictions) == 3\n assert predictions.shape[0] == references.shape[0]\n batch_size = predictions.shape[0]\n predictions = tf.make_ndarray(tf.make_tensor_proto(predictions)).tolist()\n references = tf.make_ndarray(tf.make_tensor_proto(references)).tolist()\n hypotheses_list = []\n references_list = []\n\n for index in range(batch_size):\n # All predictions in beam search are used for validation scores.\n for b_index in range(beam_size):\n h = predictions[index][b_index]\n try:\n eos_index = h.index(input_utils.EOS)\n except ValueError:\n eos_index = len(h)\n hypotheses_list.append(h[:eos_index])\n\n ref = references[index][0].decode().split('|')\n ref_list = [r.strip().split(' ') for r in ref if r.strip()]\n references_list.append(ref_list)\n\n all_scores = collections.defaultdict(list)\n for hypothesis, references in zip(hypotheses_list, references_list):\n if vocab is not None and len(vocab):\n # Skip PADDING, UNK, EOS, START (0-3).\n hypothesis = [\n vocab[word_id].numpy().decode()\n for word_id in hypothesis\n if word_id > 3\n ]\n\n h_str = ' '.join(str(e) for e in hypothesis)\n r_str = [' '.join(str(e) for e in ref) for ref in references]\n\n print('hypothesis: ', str(h_str))\n print('references: ', str(r_str))\n print('\\n')\n scores = screen2words_eval.coco_evaluate(r_str, h_str)\n for key, score in scores.items():\n all_scores[key].append(score)\n score_names = [\n 'BLEU-1', 'BLEU-2', 'BLEU-3', 'BLEU-4', 'ROUGE-1-f1-mean',\n 'ROUGE-1-f1-min', 'ROUGE-1-f1-max', 'ROUGE-2-f1-mean', 'ROUGE-2-f1-min',\n 'ROUGE-2-f1-max', 'ROUGE-L-f1-mean', 'ROUGE-L-f1-min', 'ROUGE-L-f1-max'\n ]\n\n return [np.array(all_scores[name], dtype=np.float32) for name in score_names]","def global_distribution(references_list):\n total_reference = ''\n for reference in references_list:\n with reference.open() as f:\n total_reference = total_reference + f.read()\n words, probs, pairs = calculate_vocab_distribution(total_reference)\n total_distribution = dit.ScalarDistribution(words, probs)\n return total_distribution, words","def score_points(train, target, sample_points):\n rf = rf_factory()\n rf.fit(train, target)\n mu, sigma = random_forest_evaluate(rf, sample_points)\n scores = expected_improvement(target.min(), mu, sigma)\n return scores, rf.feature_importances_","def getreferences(self, pmcid, source):\n import requests\n r = requests.get(\n (self.referencesurl).format(source=source, pmcid=pmcid))\n return r.content","def __score_by_iceberg_level(self, source_iceberg, iceberg_to_score, iceberg_owner_after_all_groups_arrived):\n if utils.is_me(self.__game, iceberg_owner_after_all_groups_arrived):\n if source_iceberg.level <= iceberg_to_score.level:\n return SOURCE_LEVEL_SMALL_THAN_DESTINATION_SCORE\n if iceberg_to_score.level < iceberg_to_score.upgrade_level_limit:\n return LEVEL_FACTOR_SCORE ** iceberg_to_score.penguins_per_turn\n elif utils.is_neutral(self.__game, iceberg_owner_after_all_groups_arrived):\n if MapChecker.get().is_tricky_map() or MapChecker.get().is_extra_far_treasure() or MapChecker.get().is_extra_far():\n return LEVEL_FACTOR_SCORE * iceberg_to_score.penguins_per_turn\n else:\n return LEVEL_FACTOR_SCORE ** iceberg_to_score.penguins_per_turn\n return iceberg_to_score.penguins_per_turn","def main(args):\n dm = DistanceMatrix()\n for filename in args.samFile:\n dm.addFile(filename, scoreTag=args.scoreTag)\n\n if args.minMatchingReads is None:\n wantedReferenceIds = sorted(set(dm.scores))\n else:\n wantedReferenceIds = sorted(\n set(\n referenceId\n for (referenceId, reads) in dm.scores.items()\n if len(reads) >= args.minMatchingReads\n )\n )\n if args.verbose:\n print(\n f\"Found {len(wantedReferenceIds)} references with at least \"\n f\"{args.minMatchingReads} matching reads.\",\n file=sys.stderr,\n )\n\n if args.verbose:\n for referenceId in wantedReferenceIds:\n nReads = len(dm.scores[referenceId])\n print(f\"Reference {referenceId!r} matched {nReads} reads.\")\n\n dump(\n dict((id_, dm.scores[id_]) for id_ in wantedReferenceIds),\n sys.stdout,\n sort_keys=True,\n indent=4,\n )\n print()","def rouge(hypotheses, references):\n\n # Filter out hyps that are of 0 length\n # hyps_and_refs = zip(hypotheses, references)\n # hyps_and_refs = [_ for _ in hyps_and_refs if len(_[0]) > 0]\n # hypotheses, references = zip(*hyps_and_refs)\n\n # Calculate ROUGE-1 F1, precision, recall scores\n rouge_1 = [\n rouge_n([hyp], [ref], 1) for hyp, ref in zip(hypotheses, references)\n ]\n rouge_1_f, rouge_1_p, rouge_1_r = map(np.mean, zip(*rouge_1))\n\n # Calculate ROUGE-2 F1, precision, recall scores\n rouge_2 = [\n rouge_n([hyp], [ref], 2) for hyp, ref in zip(hypotheses, references)\n ]\n rouge_2_f, rouge_2_p, rouge_2_r = map(np.mean, zip(*rouge_2))\n\n # Calculate ROUGE-L F1, precision, recall scores\n rouge_l = [\n rouge_l_sentence_level([hyp], [ref])\n for hyp, ref in zip(hypotheses, references)\n ]\n rouge_l_f, rouge_l_p, rouge_l_r = map(np.mean, zip(*rouge_l))\n\n return {\n \"rouge_1/f_score\": rouge_1_f,\n \"rouge_1/r_score\": rouge_1_r,\n \"rouge_1/p_score\": rouge_1_p,\n \"rouge_2/f_score\": rouge_2_f,\n \"rouge_2/r_score\": rouge_2_r,\n \"rouge_2/p_score\": rouge_2_p,\n \"rouge_l/f_score\": rouge_l_f,\n \"rouge_l/r_score\": rouge_l_r,\n \"rouge_l/p_score\": rouge_l_p,\n }","def __score_by_penguins_gaining(self, source_iceberg, destination_iceberg_to_score,\n iceberg_owner_after_all_groups_arrived):\n if iceberg_owner_after_all_groups_arrived.equals(self.__game.get_myself()):\n return 0\n turns_to_check = self.__max_distance - \\\n source_iceberg.get_turns_till_arrival(destination_iceberg_to_score)\n return turns_to_check * destination_iceberg_to_score.penguins_per_turn * PENGUINS_GAINING_SCORE_FACTOR","def update(self, phase, targets, outputs):\n iou, dice, dice_neg, dice_pos, _, _ = self.metric(outputs, targets)\n self.base_dice_scores[phase].append(dice)\n self.dice_pos_scores[phase].append(dice_pos)\n self.dice_neg_scores[phase].append(dice_neg)\n self.iou_scores[phase].append(iou)","def run(self, args):\n self.pen.score_for_matched_lexical = args[0]\n self.pen.score_for_matched_synonym = args[1]\n self.factor_word_offset_penalty = args[2]\n self.factor_sentence_length_mismatch = args[3]\n self.factor_name_mismatch = args[4]\n self.factor_fe_offset_penalty = args[5]\n self.weight_target_frame_element = args[6]\n self.weight_frame_elements = args[7]\n self.factor_frame_offset_penalty = args[8]\n misses = []\n for row in range(self.data.get_number_of_rows()):\n ref_sentence = self.data.get_row(row)[self.data.get_gold()]\n results = {}\n for team, team_sentence in self.data.get_row_for_teams(self.evaluator.get_teams(row), row).iteritems():\n results[team] = self.get_sentence_score(ref_sentence, team_sentence)\n misses.append(self.evaluator.compare_all(results, row))\n return np.mean(misses) / 5.0","def postprocess_cga(lines, outfile):\n pattern = re.compile(\"^\\s*([0-9,]+)\\s+\\([ 0-9.]+%\\)\\s+Source/(\\S+):(\\S+)\\(.*\\).*$\")\n\n totalCost = 0.0\n functionTable = []\n functionMap = {}\n\n for line in lines:\n line = line.strip()\n match = pattern.match(line)\n if not match:\n continue\n\n cost = float(match.group(1).replace(\",\", \"\"))\n sourceFile = match.group(2)\n function = match.group(3)\n\n # Filter out library code we don't want to change\n if function.startswith(\"stbi__\"):\n continue\n\n totalCost += cost\n\n # Accumulate the scores from functions in multiple call chains\n if function in functionMap:\n index = functionMap[function]\n functionTable[index][1] += cost\n functionTable[index][2] += cost\n # Else add new functions to the end of the table\n else:\n functionMap[function] = len(functionTable)\n functionTable.append([function, cost, cost])\n\n # Sort the table by accumulated cost\n functionTable.sort(key=lambda x: 101.0 - x[2])\n\n for function in functionTable:\n function[2] /= totalCost\n function[2] *= 100.0\n\n with open(outfile, \"w\") as fileHandle:\n\n totals = 0.0\n for function in functionTable:\n # Omit entries less than 1% load\n if function[2] < 1:\n break\n\n totals += function[2]\n fileHandle.write(\"%5.2f%% %s\\n\" % (function[2], function[0]))\n\n fileHandle.write(\"======\\n\")\n fileHandle.write(f\"{totals:5.2f}%\\n\")","def get_distance_metrics(source_embeddings, target_embeddings):\n cosine_avg, euclidean_avg = 0.0, 0.0\n for i in range(len(source_embeddings)):\n cosine_avg += cosine(source_embeddings[i], target_embeddings[i])\n euclidean_avg += euclidean(source_embeddings[i], target_embeddings[i])\n return (cosine_avg / len(source_embeddings)), (euclidean_avg / len(source_embeddings))","def gather(ref_gatherer, reference_node, constraints_as_spans, concept_graph):\n my_span = Span('my', 'my', 2, 3, 0, 0, 1)\n very_span = Span('very', 'very', 3, 4, 0, 0, 1)\n red_span = Span('red', 'red', 4, 5, 0, 0, 1)\n car_span = Span('car', 'car', 5, 6, 0, 0, 1)\n graph = ConceptGraph(predicates=[\n ('user', 'possess', 'c1', 'upc'),\n ('c1', 'type', 'car', 'ctc'),\n ('user', 'like', 'c1', 'ulc'),\n ('c1', 'property', 'red', 'cpr'),\n ('cpr', 'property', 'very', 'rpv'),\n ('u1', 'type', 'extra', 'extra1'),\n ('c1', 'focus', None, 'prim1'),\n (my_span.to_string(), 'ref', 'upc'),\n (very_span.to_string(), 'ref', 'rpv'),\n (red_span.to_string(), 'ref', 'cpr'),\n (car_span.to_string(), 'ref', 'c1')\n ])\n graph.features['upc']['comps'] = set()\n graph.features['rpv']['comps'] = set()\n graph.features['cpr']['comps'] = {'prim1'}\n graph.features['c1']['comps'] = {'ctc', 'extra1'}\n constraints_as_spans = {my_span.to_string(), very_span.to_string(),\n red_span.to_string()}\n\n assert ref_gatherer.gather('c1', constraints_as_spans, graph) == \\\n {'upc', 'rpv', 'cpr', 'ctc'}","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 get_target_per_score(self):\n pass","def calc_source_blend_distance(source,blend,RC,log):\n\n\n log.info('\\n')\n\n source.calc_distance(log)\n\n try:\n log.info('Inferred source distance: '+str(source.D)+' +/- '+str(source.sig_D)+' pc')\n\n log.info('Inferred source distance if its a small red giant: '+\\\n str(source.D_small_giant)+' +/- '+str(source.sig_D_small_giant)+' pc')\n\n log.info('Inferred source distance if its a large red giant: '+\\\n str(source.D_large_giant)+' +/- '+str(source.sig_D_large_giant)+' pc')\n\n except AttributeError:\n pass\n\n blend.calc_distance(log)\n\n try:\n log.info('Inferred blend distance: '+str(blend.D)+' +/- '+str(blend.sig_D)+' pc')\n\n except AttributeError:\n pass\n\n (Rstar, sig_Rstar) = stellar_radius_relations.scale_source_distance(source.ang_radius, source.sig_ang_radius, RC.D*1000.0 ,log)\n\n source.radius = Rstar\n source.sig_radius = sig_Rstar\n\n return source, blend","def get_usage_stats(usages):\n\n # TODO: add the dates at which each of the highest & lowest were admined\n\n # average & total calculation\n administration_stats = {'total': 0,\n 'highest': 0,\n 'lowest': None,\n 'average': None,\n 'count': len(usages)}\n\n for use in usages:\n administration_stats['total'] += use.dosage\n\n # rounding things to 3 decimal places for a nicer display experience\n if use.dosage > administration_stats['highest']:\n administration_stats['highest'] = round(use.dosage, 3)\n\n if administration_stats['lowest'] is None or use.dosage < administration_stats['lowest']:\n administration_stats['lowest'] = round(use.dosage, 3)\n\n administration_stats['average'] = round((administration_stats['total'] / administration_stats['count']), 3)\n\n return administration_stats","def sources(obj, reftype):","def get_score(self, a, b):\n ### FILL IN ###","def do_analyse(args):\n\n pd.set_option('display.max_columns', None)\n pd.set_option('display.width', None)\n\n score = 'score'\n\n # Read in the results, and add a boolean target column.\n df = pd.read_csv(args.results, index_col=0)\n df['target'] = df['verify_speaker'] == df['enrol_speaker']\n\n # Calculate ideal 0.01% threshold over the multi-session data.\n nontarget_df = df.loc[df['target'] == False].sort_values(score, ascending=False)\n nontarget_count = nontarget_df[score].count()\n th_calc = nontarget_df.iloc[int(nontarget_count * (1 / 10000))][score]\n\n # Now filter the data so that we only consider mono-session enrolment and verification.\n df = df.loc[df['verify_room'] == df['enrol_room']]\n target_df = df.loc[df['target'] == True].sort_values(score, ascending=False)\n nontarget_df = df.loc[df['target'] == False].sort_values(score, ascending=False)\n target_count = target_df[score].count()\n nontarget_count = nontarget_df[score].count()\n\n # Calculate FA/FR for the user-defined threshold.\n th_user = args.th_user\n fr_user = target_df.loc[target_df[score] < th_user][score].count()\n fa_user = nontarget_df.loc[nontarget_df[score] > th_user][score].count()\n frr_user = fr_user / target_count\n far_user = fa_user / nontarget_count\n label_user = 'User Threshold: th {:.4f}, FR {} ({:.3f}%), FA {} ({:.3f}%)'.format(th_user, fr_user, frr_user * 100,\n fa_user, far_user * 100)\n\n # Calculate the FA/FR for the ideal threshold calculated from the multi-session data.\n fr_calc = target_df.loc[target_df[score] < th_calc][score].count()\n fa_calc = nontarget_df.loc[nontarget_df[score] > th_calc][score].count()\n frr_calc = fr_calc / target_count\n far_calc = fa_calc / nontarget_count\n label_calc = 'Calc Threshold: th {:.4f}, FR {} ({:.3f}%), FA {} ({:.3f}%)'.format(th_calc, fr_calc, frr_calc * 100,\n fa_calc, far_calc * 100)\n\n # Print the stats.\n print('\\nTarget Stats:')\n print(target_df[score].describe())\n print('\\nNon-Target Stats:')\n print(nontarget_df[score].describe())\n print('\\nThresholds:')\n print(label_user)\n print(label_calc)\n\n # Paint the graphs.\n paint_graph(score, 'verify_room', df, th_user, label_user, th_calc, label_calc)\n paint_graph(score, 'enrol_room', df, th_user, label_user, th_calc, label_calc)\n paint_graph(score, 'verify_speaker', df, th_user, label_user, th_calc, label_calc)\n paint_graph(score, 'enrol_speaker', df, th_user, label_user, th_calc, label_calc)","def display(self,source,matched_network=False):\n \n if len(self._members) == 0: # matchch\n raise NameError(\"Network is empty, no such source exists!\")\n \n handled_members = 0\n \n for k in range(len(self._members)):\n try:\n depth_k = self.collect(source,k)\n counter = len(depth_k)\n for member in depth_k:\n curr_node = self._get(member)\n\n curr_node.displayed = True # Marks node as displayed\n handled_members += 1\n\n if matched_network is True:\n if curr_node.weight is not None:\n weight_perc = str(round((curr_node.weight*100),2))+\"%\"+\" match!\"\n else:\n weight_perc = \" No weight\"\n else:\n weight_perc = curr_node.weight\n\n if counter != 1:\n print(\"-\" * (len(curr_node.alias + str(weight_perc)) + 5))\n print(\"|\", \" \" * (len(curr_node.alias + str(weight_perc))), \" |\")\n print(\"|\", curr_node.alias, str(weight_perc), \"|\")\n print(\"|\", \" \" * (len(curr_node.alias + str(weight_perc))), \" |\")\n print(\"-\" * (len(curr_node.alias + str(weight_perc)) + 5))\n\n print(\" \"*(len(\"SHARED DISTANCE FROM SOURCE\")//2),\"^\",\" \"*(len(\"SHARED DISTANCE FROM SOURCE\")//2))\n print(\" \"*(len(\"SHARED DISTANCE FROM SOURCE\")//2),\"|\",\" \"*(len(\"SHARED DISTANCE FROM SOURCE\")//2))\n print(\"SHARED DISTANCE FROM SOURCE\")\n print(\" \"*(len(\"SHARED DISTANCE FROM SOURCE\")//2),\"|\",\" \"*(len(\"SHARED DISTANCE FROM SOURCE\")//2))\n print(\" \"*(len(\"SHARED DISTANCE FROM SOURCE\")//2),\"v\",\" \"*(len(\"SHARED DISTANCE FROM SOURCE\")//2))\n\n counter -= 1\n elif counter == 1:\n print(\"-\" * (len(curr_node.alias + str(weight_perc)) + 5))\n print(\"|\", \" \" * (len(curr_node.alias + str(weight_perc))), \" |\")\n print(\"|\", curr_node.alias, str(weight_perc), \"|\")\n print(\"|\", \" \" * (len(curr_node.alias + str(weight_perc))), \" |\")\n print(\"-\" * (len(curr_node.alias + str(weight_perc)) + 5))\n\n except ValueError:\n pass\n \n # Handles disconnected graphs\n for member in self._members:\n if member.displayed == False:\n print(\"!!DISCONNECTED NETWORK!!\")\n if matched_network is True:\n self.display(source=member.alias,matched_network=True)\n else:\n self.display(source=member.alias)\n if handled_members == len(self._members):\n member.displayed = False","def _rouge_l_score(pred: Sequence[str], target: Sequence[str]) ->Dict[str, Tensor]:\n pred_len, target_len = len(pred), len(target)\n if 0 in (pred_len, target_len):\n return dict(precision=tensor(0.0), recall=tensor(0.0), fmeasure=tensor(0.0))\n lcs: int = _lcs(pred, target)\n return _compute_metrics(lcs, pred_len, target_len)","def _rouge_lsum_score(pred: Sequence[Sequence[str]], target: Sequence[Sequence[str]]) ->Dict[str, Tensor]:\n pred_len = sum(map(len, pred))\n target_len = sum(map(len, target))\n if 0 in (pred_len, target_len):\n return dict(precision=tensor(0.0), recall=tensor(0.0), fmeasure=tensor(0.0))\n\n def _get_token_counts(sentences: Sequence[Sequence[str]]) ->Counter:\n ngrams: Counter = Counter()\n for sentence in sentences:\n ngrams.update(sentence)\n return ngrams\n pred_tokens_count = _get_token_counts(pred)\n target_tokens_count = _get_token_counts(target)\n hits = 0\n for tgt in target:\n lcs = _union_lcs(pred, tgt)\n for token in lcs:\n if pred_tokens_count[token] > 0 and target_tokens_count[token] > 0:\n hits += 1\n pred_tokens_count[token] -= 1\n target_tokens_count[token] -= 1\n return _compute_metrics(hits, pred_len, target_len)","def __calculate_statistics(self, candidates):\n pdf = {}\n for candidate in candidates:\n neighbors = list(self.G.neighbors(candidate))\n capacity = sum([self.G.get_edge_data(candidate, n)[\"satoshis\"] for n in neighbors])\n average = capacity / len(neighbors)\n pdf[candidate] = average\n cumsum = sum(pdf.values())\n pdf = {k:v/cumsum for k,v in pdf.items()}\n w = 0.7\n print(\"percentage smoothed percentage capacity numchannels alias\")\n print(\"----------------------------------------------------------------------\")\n res_pdf = {}\n for k,v in pdf.items():\n neighbors = list(self.G.neighbors(k))\n capacity = sum([self.G.get_edge_data(k, n)[\"satoshis\"] for n in neighbors])\n name = k\n if \"alias\" in self.G.node[k]:\n name = self.G.node[k][\"alias\"]\n print(\"{:12.2f} \".format(100*v), \"{:12.2f} \".format(100*(w * v + (1-w)/len(candidates))) ,\"{:10} {:10} \".format( capacity, len(neighbors)), name)\n res_pdf[k] = (w * v + (1-w)/len(candidates))\n return res_pdf"],"string":"[\n \"def bleu_score(references, generated, n_gram=4, smooth=False):\\r\\n formatted_ref = [[ref] for ref in references]\\r\\n bleu_s, _, _, _, _, _ = compute_bleu(formatted_ref, generated, n_gram, smooth)\\r\\n return bleu_s * 100\",\n \"def bleu_stats(hypothesis, reference):\\n stats = []\\n stats.append(len(hypothesis))\\n stats.append(len(reference))\\n for n in range(1, 5):\\n s_ngrams = Counter(\\n [tuple(hypothesis[i:i + n]) for i in range(len(hypothesis) + 1 - n)]\\n )\\n r_ngrams = Counter(\\n [tuple(reference[i:i + n]) for i in range(len(reference) + 1 - n)]\\n )\\n stats.append(max([sum((s_ngrams & r_ngrams).values()), 0]))\\n stats.append(max([len(hypothesis) + 1 - n, 0]))\\n return stats\",\n \"def bleu_stats(hypothesis, reference):\\n stats = []\\n stats.append(len(hypothesis))\\n stats.append(len(reference))\\n for n in range(1, 5):\\n s_ngrams = Counter(\\n [tuple(hypothesis[i:i + n]) for i in range(len(hypothesis) + 1 - n)]\\n )\\n r_ngrams = Counter(\\n [tuple(reference[i:i + n]) for i in range(len(reference) + 1 - n)]\\n )\\n stats.append(max([sum((s_ngrams & r_ngrams).values()), 0]))\\n stats.append(max([len(hypothesis) + 1 - n, 0]))\\n return stats\",\n \"def reference_stats(refs, output_len):\\n\\n ngrams = Counter()\\n closest_diff = None\\n closest_len = None\\n\\n for ref in refs:\\n tokens = ref.split()\\n reflen = len(tokens)\\n diff = abs(output_len - reflen)\\n if closest_diff is None or diff < closest_diff:\\n closest_diff = diff\\n closest_len = reflen\\n elif diff == closest_diff:\\n if reflen < closest_len:\\n closest_len = reflen\\n\\n ngrams_ref = CachedBLEU.extract_ngrams(ref)\\n for ngram in ngrams_ref.keys():\\n ngrams[ngram] = max(ngrams[ngram], ngrams_ref[ngram])\\n\\n return ngrams, closest_diff, closest_len\",\n \"def bleu_stats(hypo, ref, bleu_len=5):\\n stats = list()\\n stats.append(len(hypo))\\n stats.append(len(ref))\\n for n in range(1, bleu_len):\\n s_ngrams = Counter([tuple(hypo[i:i+n]) for i in range(len(hypo)+1-n)])\\n r_ngrams = Counter([tuple(ref[i:i+n]) for i in range(len(ref)+1-n)])\\n stats.append(max([sum((s_ngrams & r_ngrams).values()), 0]))\\n stats.append(max([len(hypo) + 1-n, 0]))\\n return stats\",\n \"def classify(self, source1, source2):\\n scores1 = self.similarity_scores(source1)\\n scores2 = self.similarity_scores(source2)\\n\\n print(\\\"scores for\\\", source1.name, \\\":\\\", [round(number, 2) for number in scores1])\\n print(\\\"scores for\\\", source2.name, \\\":\\\", [round(number, 2) for number in scores2])\\n\\n s1 = 0\\n s2 = 0\\n for x in range(len(scores1)):\\n if scores1[x] >= scores2[x]:\\n s1 += 1\\n else:\\n s2 += 1\\n \\n if s1 > s2:\\n print(self.name, \\\"is more likely to have come from \\\", source1.name)\\n print()\\n else:\\n print(self.name, \\\"is more likely to have come from \\\", source2.name)\\n print()\",\n \"def classify(self, source1, source2):\\n scores1 = self.similarity_scores(source1)\\n scores2 = self.similarity_scores(source2)\\n for i in range(len(scores1)):\\n scores1[i] = round(scores1[i], 2)\\n scores2[i] = round(scores2[i], 2)\\n \\n print('scores for source1: ', scores1, '\\\\n', \\\\\\n 'scores for source2: ', scores2)\\n num_larger1 = 0\\n num_larger2 = 0\\n for i in range(len(scores1)):\\n if scores1[i] > scores2[i]:\\n num_larger1 += 1\\n else:\\n num_larger2 += 1\\n if num_larger1 > num_larger2:\\n print(self.name, 'is more likely to have come from source1')\\n else:\\n print(self.name, 'is more likely to have come from source2')\",\n \"def bleu_score(ref_file, hyp_file):\\n command = 'perl scripts/multi-bleu.pl ' + ref_file + ' < ' + hyp_file\\n c = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)\\n details, error = c.communicate()\\n details, error = details.decode('utf-8'), error.decode('utf-8')\\n if not details.startswith('BLEU ='):\\n raise ValueError('Error in BLEU score computation:\\\\n%s' % error)\\n else:\\n BLEU_str = details.split(' ')[2][:-1]\\n BLEU = float(BLEU_str)\\n return BLEU, details\",\n \"def metric_halstats(hal_filename, reference_id=\\\"ref\\\"):\\n \\n # Get the list of dicts of per-genome stats.\\n status_list = get_halstats_stats(hal_filename)\\n \\n # Throw out non-leaves\\n status_list = [entry for entry in status_list if entry[\\\"NumChildren\\\"] == 0]\\n \\n # Grab all the genome names\\n genome_names = [entry[\\\"GenomeName\\\"] for entry in status_list]\\n \\n # Get the dict from genome name to total bases from that genome aligned to\\n # the reference at all, and the dict of N compositions, in parallel.\\n coverage_dict, basecomp_dict = in_parallel(\\n lambda: get_halstats_coverage(hal_filename, genome_names, reference_id),\\n lambda: get_halstats_basecomps(hal_filename, genome_names))\\n \\n for entry in status_list:\\n # For each genome, we want the coverage against the reference.\\n \\n # Grab the genome name\\n genome_name = entry[\\\"GenomeName\\\"]\\n \\n if not coverage_dict.has_key(genome_name):\\n # This is probably the root sequence and didn't get a coverage for\\n # some reason. At any rate, the root sequence would be all Ns\\n continue\\n \\n # Figure out how much of it is not Ns\\n non_n = basecomp_dict[genome_name]\\n \\n # How many bases are eligible?\\n eligible = float(entry[\\\"Length\\\"] * non_n)\\n \\n if eligible == 0:\\n # No coverage is defined\\n entry[\\\"Coverage\\\"] = float(\\\"NaN\\\")\\n continue\\n \\n # Compute and save the coverage for each entry, by dividing bases\\n # aligned by bases eligible.\\n entry[\\\"Coverage\\\"] = coverage_dict[genome_name] / eligible\\n \\n # Return the results\\n return status_list\",\n \"def eval_accuracies(hypotheses, references, sources=None, filename=None, mode='dev'):\\n assert (sorted(references.keys()) == sorted(hypotheses.keys()))\\n\\n # Compute BLEU scores\\n _, bleu, ind_bleu = corpus_bleu(hypotheses, references)\\n\\n # Compute ROUGE scores\\n rouge_calculator = Rouge()\\n rouge_l, ind_rouge = rouge_calculator.compute_score(references, hypotheses)\\n\\n # Compute METEOR scores\\n if mode == 'test':\\n meteor_calculator = Meteor()\\n meteor, _ = meteor_calculator.compute_score(references, hypotheses)\\n else:\\n meteor = 0\\n\\n fw = open(filename, 'w') if filename else None\\n for key in references.keys():\\n if fw:\\n pred_i = hypotheses[key]\\n\\n logobj = OrderedDict()\\n logobj['id'] = key\\n if sources is not None:\\n logobj['code'] = sources[key]\\n logobj['predictions'] = pred_i\\n logobj['references'] = references[key]\\n logobj['bleu'] = ind_bleu[key]\\n logobj['rouge_l'] = ind_rouge[key]\\n print(json.dumps(logobj), file=fw)\\n\\n if fw: fw.close()\\n return bleu * 100, rouge_l * 100, meteor * 100\",\n \"def summary_source(classes_fold_score_list, classes_periods, classes): \\n scores = []\\n for idx in range(len(classes_periods)):\\n temp = pd.concat([classes_fold_score_list[idx], classes_periods[idx].source], axis=1)\\n temp = temp.groupby(['source', 'catalog']).size().unstack(fill_value=0).T\\n scores.append(temp)\\n score_df = pd.concat(scores, keys=classes)\\n score_df.index.set_levels([\\\"Wrong\\\", \\\"Right\\\", \\\"Multiply\\\"], \\n level=1,\\n inplace=True)\\n score_df = (score_df.T.fillna(0))\\n dividend = score_df.iloc[:, score_df.columns.get_level_values(1)==\\\"Right\\\"].T.droplevel(-1).T\\n divisor = score_df.T.groupby(level=0).sum().T.loc[:,[\\\"RRL\\\",\\\"Ceph\\\",\\\"LPV\\\",\\\"DSCT\\\",\\\"EB\\\"]]\\n return dividend.divide(divisor).round(2).mean(axis=1)\",\n \"def bleu(hypotheses, references):\\n return sacrebleu.raw_corpus_bleu(sys_stream=hypotheses,\\n ref_streams=[references]).score\",\n \"def get_user_referrals(self, username, metric='source', start_date=None, end_date=None):\\n\\tif not start_date and not end_date:\\n\\t if metric == 'source':\\n\\t\\tunique_sources = db.session.query(GoogleAnalyticsReferralsModel.source.distinct().label('source')).all()\\n\\t\\tsources = [GoogleAnalyticsReferralsModel.query.filter_by(username=username, source=source).all() for source in unique_sources]\\n\\t\\tsource_counts = []\\n\\t\\tfor source in sources:\\n\\t\\t counts = [s.sessions for s in source]\\n\\t\\t count = sum(counts)\\n\\t\\t source_counts.append(count)\\n\\t\\tsource_names = [source[0].source for source in sources]\\n\\t\\tprint source_counts\\n\\t\\tprint source_names\\n\\t\\tsource_count_list = []\\n\\t\\tfor i in range(len(source_counts)):\\n\\t\\t source_count_dict = {}\\n\\t\\t source = source_names[i]\\n\\t\\t source_count = source_counts[i]\\n\\t\\t source_count_dict['key'] = source\\n\\t\\t source_count_dict['y'] = source_count\\n\\t\\t source_count_list.append(source_count_dict)\\n\\t\\treturn make_response(dumps(source_count_list))\\n\\n\\t elif metric == \\\"mediums\\\":\\n\\t\\tunique_mediums = db.session.query(GoogleAnalyticsReferralsModel.medium.distinct().label('medium')).all()\\n\\t\\tmediums = [GoogleAnalyticsReferralsModel.query.filter_by(username=username, medium=medium).all() for medium in unique_mediums]\\n\\t\\tmedium_counts = []\\n\\t\\tfor medium in mediums:\\n\\t\\t counts = [m.sessions for m in medium]\\n\\t\\t count = sum(counts)\\n\\t\\t medium_counts.append(count)\\n\\t\\tmedium_names = [medium[0].medium for medium in mediums]\\n\\t\\tprint medium_counts\\n\\t\\tprint medium_names\\n\\t\\treturn ''\",\n \"def calculate_bleu(output_lns, refs_lns, **kwargs) -> dict:\\n return {\\\"bleu\\\": round(corpus_bleu(output_lns, [refs_lns], **kwargs).score, 4)}\",\n \"def calculate_bleu(output_lns, refs_lns, **kwargs) -> dict:\\n return {\\\"bleu\\\": round(corpus_bleu(output_lns, [refs_lns], **kwargs).score, 4)}\",\n \"def get_bleu(hypotheses, reference):\\n stats = np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])\\n for hyp, ref in zip(hypotheses, reference):\\n stats += np.array(bleu_stats(hyp, ref))\\n return 100 * bleu(stats)\",\n \"def classify(self, source1, source2):\\n\\n scores1 = self.similarity_scores(source1)\\n scores2 = self.similarity_scores(source2)\\n \\n print('scores for ' + source1.name +':' + str(self.similarity_scores(source1)))\\n print('scores for ' + source2.name +':' + str(self.similarity_scores(source2)))\\n \\n source1_score=0\\n source2_score=0\\n\\n for i in range(len(scores1)):\\n if scores1[i]> scores2[i]:\\n source1_score+=1\\n elif scores2[i]>scores1[i]:\\n source2_score+=1\\n \\n if source1_score > source2_score:\\n win=source1.name\\n else:\\n win=source2.name\\n\\n print(self.name + ' is more likely to have come from ' + win)\",\n \"def get_stats(inp_fn):\\n ent_pred_cnts = []\\n ent_gold_cnts = []\\n ent_intr_cnts = []\\n ccs = ConllCorefScores()\\n jsons = [json.loads(line) for line in open(inp_fn, encoding = \\\"utf8\\\")]\\n for doc_dict in jsons:\\n cur_doc = nlp(\\\" \\\".join(doc_dict[\\\"document\\\"]))\\n gold_clusts = doc_dict[\\\"gold_clusters\\\"]\\n pred_clusts = doc_dict[\\\"clusters\\\"]\\n\\n gold_ent_clusts = get_entities(cur_doc, gold_clusts)\\n pred_ent_clusts = get_entities(cur_doc, pred_clusts)\\n\\n gold_clusts_pronouns = [gold_clust\\n for gold_clust, gold_ent_clust\\n in zip(gold_clusts, gold_ent_clusts)\\n if contains_pronoun(gold_ent_clust)]\\n\\n pred_clusts_pronouns = [pred_clust\\n for pred_clust, pred_ent_clust\\n in zip(pred_clusts, pred_ent_clusts)\\n if contains_pronoun(pred_ent_clust)]\\n\\n update_avg_f1(ccs, gold_clusts_pronouns, pred_clusts_pronouns)\\n\\n pred_ents = set(map(str, flatten(pred_ent_clusts)))\\n gold_ents = set(map(str, flatten(gold_ent_clusts)))\\n if (not pred_ents) and (not gold_ents):\\n #TODO: what's going on in these instances?\\n continue\\n\\n ent_pred_cnts.append(len(pred_ents))\\n ent_gold_cnts.append(len(gold_ents))\\n ent_intr_cnts.append(len(pred_ents & gold_ents))\\n\\n ent_micro = micro_f1(ent_pred_cnts, ent_gold_cnts, ent_intr_cnts)\\n ent_macro = macro_f1(ent_pred_cnts, ent_gold_cnts, ent_intr_cnts)\\n ret_dict = {\\\"ent_micro\\\": ent_micro,\\n \\\"ent_macro\\\": ent_macro,\\n \\\"pronoun_avg_f1\\\": get_avg_f1(ccs)}\\n\\n logging.debug(f\\\"micro = {ent_micro['f1']:.2f}, macro = {ent_macro['f1']:.2f}\\\")\\n\\n return ret_dict\",\n \"def rouge_score(references, generated):\\r\\n score = rouge(generated, references)\\r\\n rouge_s = {k: (v * 100) for (k, v) in score.items()}\\r\\n '''\\r\\n \\\"rouge_1/f_score\\\": rouge_1_f,\\r\\n \\\"rouge_1/r_score\\\": rouge_1_r,\\r\\n \\\"rouge_1/p_score\\\": rouge_1_p,\\r\\n \\\"rouge_2/f_score\\\": rouge_2_f,\\r\\n \\\"rouge_2/r_score\\\": rouge_2_r,\\r\\n \\\"rouge_2/p_score\\\": rouge_2_p,\\r\\n \\\"rouge_l/f_score\\\": rouge_l_f,\\r\\n \\\"rouge_l/r_score\\\": rouge_l_r,\\r\\n \\\"rouge_l/p_score\\\": rouge_l_p,\\r\\n '''\\r\\n return rouge_s\",\n \"def make_ungrounded_stats():\\n def get_ungrounded_stats(stmts):\\n # What fraction of statements grounded?\\n all_ungrounded = 0\\n any_ungrounded = 0\\n for stmt in stmts:\\n agents_ungrounded = []\\n for ag in stmt.agent_list():\\n if ag is not None and list(ag.db_refs.keys()) == ['TEXT']:\\n agents_ungrounded.append(True)\\n else:\\n agents_ungrounded.append(False)\\n if all(agents_ungrounded):\\n all_ungrounded += 1\\n if any(agents_ungrounded):\\n any_ungrounded += 1\\n all_ungrounded_ratio = 100 * (all_ungrounded / float(len(stmts)))\\n any_ungrounded_ratio = 100 * (any_ungrounded / float(len(stmts)))\\n return all_ungrounded_ratio, any_ungrounded_ratio\\n\\n def get_agent_counts(stmts):\\n agents = gm.ungrounded_texts(stmts)\\n agent_counts = [t[1] for t in agents]\\n return agent_counts\\n\\n fname = '../step3_sample_training_test/famplex_test_stmts_mapped.pkl'\\n stmts = ac.load_statements(fname)\\n allu_test, anyu_test = get_ungrounded_stats(stmts)\\n counts_test = get_agent_counts(stmts)\\n\\n fname = '../step3_sample_training_test/training_pmid_stmts.pkl'\\n stmts = ac.load_statements(fname)\\n allu_train, anyu_train = get_ungrounded_stats(stmts)\\n counts_train = get_agent_counts(stmts)\\n\\n return (allu_test, anyu_test, allu_train, anyu_train,\\n counts_train, counts_test)\",\n \"def calculate_bleu(output_lns, refs_lns):\\n return round(corpus_bleu(output_lns, [refs_lns]).score, 4)\",\n \"def bleu_score(output, reference):\\n num_sentences = min(len(output), len(reference))\\n for i in range(num_sentences):\\n if i == 5:\\n print(\\\"Do you want to calculate all sentences? (y/n)\\\")\\n answer = input()\\n if answer.lower() == 'n':\\n break\\n out_sentence, ref_sentence = output[i], reference[i]\\n bleu_score = calculate_bleu(out_sentence, ref_sentence)\\n print(\\n f\\\"Sentence {i + 1}, Score: {bleu_score}\\\")\",\n \"def _compute_score(self):\\n\\n sgml_path = str(self.sgml_file.name)\\n text_path = sgml_path.replace('.sgm', '.txt')\\n ref_path = 'testsets/wmt18.ende.ref.txt'\\n\\n from sacrebleu import process_to_text, corpus_bleu\\n from pathlib import Path\\n\\n if not Path(text_path).exists():\\n process_to_text(sgml_path, text_path)\\n\\n hyp_stream = [x for x in open(text_path, encoding='utf-8')]\\n ref_stream = [r for r in open(ref_path, encoding='utf-8')]\\n\\n bleu = corpus_bleu(hyp_stream, [ref_stream])\\n\\n self.score = bleu.score\\n self.save()\",\n \"def get_usage(self, source):\\n return sum(i.quantity for i in self.items.all() if i.source == source)\",\n \"def get_bleu(hypo, ref, seq_len=10, bleu_len=5):\\n stats = np.array([0.]*seq_len)\\n for h, r in zip(hypo, ref):\\n h = np.trim_zeros(h)\\n r = np.trim_zeros(r)\\n stats += np.array(bleu_stats(h, r, bleu_len))\\n return 100 * bleu(stats)\",\n \"def references(df, sort='rank', ascending=True, output='list', limit=-1):\\n \\n ref_counts = list(df['references'].value_counts().items())\\\\\\n\\n if output == 'string':\\n ref_string = \\\"\\\"\\n if sort == 'rank':\\n if ascending:\\n ref_number = 1\\n else:\\n ref_number = len(ref_counts) + 1\\n for ref_pair in ref_counts:\\n if (ascending == True) and (limit != -1) and (ref_number > limit):\\n break\\n elif (ascending == False) and (limit != -1) and (ref_number < (len(ref_counts) + 1 - limit)):\\n break\\n ref_string += '--------\\\\n'\\n ref_string += f\\\"Most common reference {ref_number}\\\\n\\\"\\n ref_string += '\\\\n'\\n source_number = 1\\n for ref in ref_pair[0]:\\n ref_string += f\\\"Source number: {source_number}\\\\n\\\"\\n ref_string += f\\\"Title: {ref['title']}\\\\n\\\"\\n ref_string += f\\\"Author: {ref['author']}\\\\n\\\"\\n ref_string += f\\\"Publisher: {ref['publisher']}\\\\n\\\"\\n ref_string += f\\\"Publisher Location: {ref['publisherLocation']}\\\\n\\\"\\n ref_string += f\\\"Year: {ref['year']}\\\\n\\\"\\n ref_string += f\\\"Reference Type: {ref['refType']}\\\\n\\\"\\n ref_string += f\\\"Reference Key: {ref['key']}\\\\n\\\"\\n ref_string += '\\\\n'\\n source_number += 1\\n ref_string += f\\\"Total Occurrences: {ref_pair[1]}\\\\n\\\"\\n ref_string += '--------\\\\n'\\n ref_string += '\\\\n'\\n if ascending: \\n ref_number += 1\\n else:\\n ref_number -= 1\\n elif sort == 'alphabet':\\n # TODO: alphabetical sorting\\n pass\\n else:\\n raise ValueError(f\\\"Invalid parameter for sort '{sort}' - Accepted values are 'rank' or 'alphabet'\\\")\\n return ref_string\\n elif output == 'list':\\n return ref_counts\\n else:\\n raise ValueError(f\\\"Invalid parameter for output '{output}' - Accepted values are 'list' or 'string'\\\")\",\n \"def get_score(src_ref, src_est, eps=1e-8):\\n\\n # Expected inputs of size (nsrc x nsamples)\\n if src_ref.shape[0] > src_ref.shape[1]:\\n src_ref = src_ref.T\\n src_est = src_est.T\\n\\n # Get the SDR only for the first (=speech) source\\n sdr = 10 * np.log10(np.sum(src_ref[0, :] ** 2) / (np.sum((src_ref[0, :] - src_est[0, :]) ** 2) + eps))\\n\\n return sdr\",\n \"def compute_statistics(self):\",\n \"def compute_statistic(path_user, path_refs, tp_consensus='mean', path_dataset=None,\\n path_visu=None):\\n assert path_user and path_refs, 'missing user or reference annotation'\\n lnds_user, _ = create_consensus_landmarks([path_user])\\n lnds_refs, _ = create_consensus_landmarks(path_refs, method=tp_consensus)\\n\\n list_stats = []\\n name_set, name_user_scale = path_user.split(os.sep)[-2:]\\n user, scale = parse_path_user_scale(name_user_scale)\\n for csv_name in lnds_user:\\n if csv_name not in lnds_refs:\\n continue\\n im_size = find_image_full_size(path_dataset, name_set,\\n os.path.splitext(csv_name)[0])\\n d_stat = compute_landmarks_statistic(lnds_refs[csv_name],\\n lnds_user[csv_name],\\n use_affine=False, im_size=im_size)\\n d_stat.update({'image_set': name_set,\\n 'user': user,\\n 'scale': scale,\\n 'landmarks': csv_name})\\n list_stats.append(d_stat)\\n if path_visu is not None and os.path.isdir(path_visu):\\n img_name = os.path.splitext(csv_name)[0]\\n visual_coannotation(lnds_user[csv_name], lnds_refs[csv_name], path_dataset,\\n path_user, img_name, path_visu)\\n return list_stats\",\n \"def get_bleu(hypotheses, reference):\\n stats = np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])\\n for hyp, ref in zip(hypotheses, reference):\\n stats += np.array(bleu_stats(hyp, ref))\\n return bleu(stats)\",\n \"def compute_metrics_from_files(p_path_to_reference_file,\\r\\n p_path_to_candidate_file,\\r\\n p_max_bleu_order):\\r\\n\\r\\n reference_dictionary, reference_no_answer_query_ids = \\\\\\r\\n load_file(p_path_to_reference_file)\\r\\n candidate_dictionary, candidate_no_answer_query_ids = load_file(p_path_to_candidate_file)\\r\\n query_id_answerable = set(reference_dictionary.keys())-reference_no_answer_query_ids\\r\\n query_id_answerable_candidate = set(candidate_dictionary.keys())-candidate_no_answer_query_ids\\r\\n \\r\\n true_positives = len(query_id_answerable_candidate.intersection(query_id_answerable))\\r\\n false_negatives = len(query_id_answerable)-true_positives\\r\\n true_negatives = len(candidate_no_answer_query_ids.intersection(reference_no_answer_query_ids))\\r\\n false_positives = len(reference_no_answer_query_ids)-true_negatives\\r\\n precision = float(true_positives)/(true_positives+false_positives) if (true_positives+false_positives)>0 else 1.\\r\\n recall = float(true_positives)/(true_positives+false_negatives) if (true_positives+false_negatives)>0 else 1.\\r\\n F1 = 2 *((precision*recall)/(precision+recall))\\r\\n filtered_reference_dictionary = \\\\\\r\\n {key: value for key, value in reference_dictionary.items() \\\\\\r\\n if key not in reference_no_answer_query_ids}\\r\\n\\r\\n filtered_candidate_dictionary = \\\\\\r\\n {key: value for key, value in candidate_dictionary.items() \\\\\\r\\n if key not in reference_no_answer_query_ids}\\r\\n\\r\\n for query_id, answers in filtered_candidate_dictionary.items():\\r\\n assert \\\\\\r\\n len(answers) <= 1, \\\\\\r\\n 'query_id %d contains more than 1 answer \\\\\\\"%s\\\\\\\" in candidate file' % \\\\\\r\\n (query_id, str(answers))\\r\\n\\r\\n reference_query_ids = set(filtered_reference_dictionary.keys())\\r\\n candidate_query_ids = set(filtered_candidate_dictionary.keys())\\r\\n common_query_ids = reference_query_ids.intersection(candidate_query_ids)\\r\\n assert (len(common_query_ids) == len(reference_query_ids)) and \\\\\\r\\n (len(common_query_ids) == len(candidate_query_ids)), \\\\\\r\\n 'Reference and candidate files must share same query ids'\\r\\n\\r\\n all_scores = {}\\r\\n bleu_scores, _ = \\\\\\r\\n Bleu(p_max_bleu_order).compute_score(filtered_reference_dictionary, \\\\\\r\\n filtered_candidate_dictionary)\\r\\n for i, bleu_score in enumerate(bleu_scores):\\r\\n all_scores['bleu_%d' % (i+1)] = bleu_score\\r\\n\\r\\n rouge_score, _ = Rouge().compute_score(filtered_reference_dictionary, \\\\\\r\\n filtered_candidate_dictionary)\\r\\n all_scores['rouge_l'] = rouge_score\\r\\n all_scores['F1'] = F1\\r\\n similarity = 0\\r\\n for key in filtered_reference_dictionary:\\r\\n candidate_answer = nlp(filtered_candidate_dictionary[key][0])\\r\\n reference_answer = filtered_reference_dictionary[key]\\r\\n answersimilarity = 0\\r\\n for answer in reference_answer:\\r\\n answersimilarity += candidate_answer.similarity(nlp(answer))\\r\\n similarity += answersimilarity/len(reference_answer)\\r\\n semantic_similarity = similarity/len(filtered_reference_dictionary)\\r\\n all_scores['Semantic_Similarity'] = semantic_similarity\\r\\n return all_scores\",\n \"def get_reliability_table_for_source(source):\\n dq_file = 'DQ_Reliability_Scores_Table3-3fromERGreport.csv'\\n df = (pd.read_csv(DATA_PATH.joinpath(dq_file),\\n usecols=['Source', 'Code', 'DQI Reliability Score'])\\n .query('Source == @source')\\n .reset_index(drop=True)\\n .drop(columns='Source'))\\n return df\",\n \"def _cmd_reference(args):\\n usage_err_msg = \\\"Give .cnn samples OR targets and (optionally) antitargets.\\\"\\n if args.targets:\\n # Flat reference\\n assert not args.references, usage_err_msg\\n ref_probes = reference.do_reference_flat(\\n args.targets, args.antitargets, args.fasta, args.male_reference\\n )\\n elif args.references:\\n # Pooled reference\\n assert not args.targets and not args.antitargets, usage_err_msg\\n filenames = []\\n for path in args.references:\\n if os.path.isdir(path):\\n filenames.extend(\\n os.path.join(path, f)\\n for f in os.listdir(path)\\n if f.endswith(\\\"targetcoverage.cnn\\\")\\n )\\n else:\\n filenames.append(path)\\n targets = [f for f in filenames if \\\"antitarget\\\" not in f]\\n antitargets = [f for f in filenames if \\\"antitarget\\\" in f]\\n logging.info(\\n \\\"Number of target and antitarget files: %d, %d\\\",\\n len(targets),\\n len(antitargets),\\n )\\n female_samples = (\\n (args.sample_sex.lower() not in [\\\"y\\\", \\\"m\\\", \\\"male\\\"])\\n if args.sample_sex\\n else None\\n )\\n ref_probes = reference.do_reference(\\n targets,\\n antitargets,\\n args.fasta,\\n args.male_reference,\\n args.diploid_parx_genome,\\n female_samples,\\n args.do_gc,\\n args.do_edge,\\n args.do_rmask,\\n args.cluster,\\n args.min_cluster_size,\\n )\\n else:\\n raise ValueError(usage_err_msg)\\n\\n ref_fname = args.output or \\\"cnv_reference.cnn\\\"\\n core.ensure_path(ref_fname)\\n tabio.write(ref_probes, ref_fname)\",\n \"def compute_bleu_rouge(pred_dict, ref_dict, bleu_order=4):\\n assert set(pred_dict.keys()) == set(ref_dict.keys()), \\\\\\n \\\"missing keys: {}\\\".format(set(ref_dict.keys()) - set(pred_dict.keys()))\\n scores = {}\\n bleu_scores, _ = Bleu(bleu_order).compute_score(ref_dict, pred_dict)\\n for i, bleu_score in enumerate(bleu_scores):\\n scores['Bleu-%d' % (i + 1)] = bleu_score\\n rouge_score, _ = Rouge().compute_score(ref_dict, pred_dict)\\n scores['Rouge-L'] = rouge_score\\n return scores\",\n \"def __score_by_support(self, source_iceberg, iceberg_to_score, iceberg_to_score_owner, simulation_data):\\n game = self.__game\\n is_belong_to_me = iceberg_to_score_owner.equals(game.get_myself())\\n score = 0\\n is_closest_to_enemy, avr_distance_from_enemy = self.__is_destination_closest_to_enemy(source_iceberg,\\n iceberg_to_score,\\n simulation_data)\\n if is_belong_to_me and is_closest_to_enemy:\\n if not iceberg_to_score is game.get_bonus_iceberg():\\n score += (self.__max_distance - avr_distance_from_enemy) * SUPPORT_SCORE_FACTOR\\n else:\\n score += CANT_DO_ACTION_SCORE\\n elif is_belong_to_me:\\n score += OUR_DESTINATION_ICEBERG_FAR_FROM_ENEMY_SCORE\\n return score\",\n \"def parse_halstats_coverage(stream, reference_id):\\n \\n # Get a reader and skip the first line\\n reader = csv.reader(stream)\\n for i in xrange(1):\\n next(reader)\\n \\n for data in reader:\\n if len(data) == 0:\\n # We finished the table\\n break\\n \\n \\n # Drop all the whitespace\\n data = [x.strip() for x in data]\\n \\n if data[0] == reference_id:\\n if len(data) > 1:\\n # We have some bases aligned\\n return float(data[1])\\n else:\\n # We had no bases aligned\\n return 0.0\\n \\n raise RuntimeError(\\\"Could not find coverage against {}\\\".format(\\n reference_id))\",\n \"def get_halstats_coverage(hal_filename, other_genomes, reference_id):\\n \\n print(\\\"Getting mapping counts\\\")\\n \\n def get_coverage_for_genome(other_genome):\\n # Set up the arguments\\n args = [\\\"halStats\\\", hal_filename, \\\"--coverage\\\", other_genome]\\n\\n # Open the process\\n process = subprocess.Popen(args, stdout=subprocess.PIPE)\\n \\n # Get the number of bases of the other genome that are aligned to\\n # anywhere (or any set of more than one place) in the reference genome.\\n coverage = parse_halstats_coverage(process.stdout, reference_id)\\n \\n if process.wait() != 0:\\n raise RuntimeError(\\\"halStats --coverage failed\\\")\\n \\n # Give back the coverage (in columns)\\n return coverage\\n \\n # Get all the coverages in order, and in parallel.\\n coverages = ThreadPool(len(other_genomes)).map(get_coverage_for_genome, \\n other_genomes) \\n \\n return dict(itertools.izip(other_genomes, coverages))\",\n \"def enable_source(self, source, geometries):\\n if source in self._counts.keys():\\n for geometry_key in self._counts[source].keys():\\n if geometries[geometry_key].is_checked:\\n self._total_count += self._counts[source][geometry_key]\\n self.change_text()\",\n \"def calculate_single_cycle_gan_metrics(source, target):\\n metric_results = MetricsContainer(len(source))\\n for i, x in enumerate(source):\\n scores = torch.mean(torch.abs(x.view(1, -1) - target), dim=1)\\n _, indices = torch.sort(scores, descending=False)\\n indices = indices.cpu().numpy()\\n rank = np.nonzero(indices == i)[0][0] + 1\\n metric_results.update(rank)\\n return metric_results.get_results()\",\n \"async def fetch_referrals(self):\\n data = await self.http.get_referral_statistics()\",\n \"def assemble_stats(lma_sum, mma_sum, hma_sum, peer_lma_sum, peer_mma_sum, peer_hma_sum):\\n lma_pct = 0.0\\n mma_pct = 0.0\\n hma_pct = 0.0\\n\\n peer_lma_pct = 0.0\\n peer_mma_pct = 0.0\\n peer_hma_pct = 0.0\\n\\n stats = {}\\n\\n target_lar_total = lma_sum + mma_sum + hma_sum\\n if target_lar_total:\\n lma_pct = round(1.0 * lma_sum / target_lar_total, 3)\\n mma_pct = round(1.0 * mma_sum / target_lar_total, 3)\\n hma_pct = round(1.0 * hma_sum / target_lar_total, 3)\\n maj_pct = round(mma_pct + hma_pct, 3)\\n stats.update({\\n 'lma': lma_sum, \\n 'lma_pct': lma_pct, \\n 'mma': mma_sum,\\n 'mma_pct': mma_pct,\\n 'hma': hma_sum,\\n 'hma_pct': hma_pct,\\n 'maj_pct': maj_pct,\\n 'lar_total': target_lar_total\\n })\\n else:\\n stats.update({\\n 'lar_total': 0,\\n 'lma': 0, \\n 'lma_pct': 0, \\n 'mma': 0,\\n 'mma_pct': 0,\\n 'hma': 0,\\n 'hma_pct': 0\\n })\\n #assemble peer data\\n peer_lar_total = peer_lma_sum + peer_mma_sum + peer_hma_sum\\n if peer_lar_total:\\n peer_lma_pct = round(1.0 * peer_lma_sum / peer_lar_total, 3)\\n peer_mma_pct = round(1.0 * peer_mma_sum / peer_lar_total, 3)\\n peer_hma_pct = round(1.0 * peer_hma_sum / peer_lar_total, 3)\\n peer_maj_pct = round(peer_mma_pct + peer_hma_pct, 3)\\n stats.update({\\n 'peer_lma': peer_lma_sum, \\n 'peer_lma_pct': peer_lma_pct, \\n 'peer_mma': peer_mma_sum,\\n 'peer_mma_pct': peer_mma_pct,\\n 'peer_hma': peer_hma_sum,\\n 'peer_hma_pct': peer_hma_pct,\\n 'peer_maj_pct': peer_maj_pct,\\n 'peer_lar_total': peer_lar_total\\n })\\n else:\\n stats.update({\\n 'peer_lma': 0,\\n 'peer_lma_pct': 0, \\n 'peer_mma': 0, \\n 'peer_mma_pct': 0,\\n 'peer_hma': 0,\\n 'peer_hma_pct': 0,\\n 'peer_lar_total': 0\\n })\\n odds_lma = odds_ratio(lma_pct, peer_lma_pct)\\n odds_mma = odds_ratio(mma_pct, peer_mma_pct)\\n odds_hma = odds_ratio(hma_pct, peer_hma_pct)\\n odds_maj = odds_ratio(mma_pct+hma_pct, peer_mma_pct+peer_hma_pct)\\n stats.update({\\n 'odds_lma':odds_lma,\\n 'odds_mma':odds_mma,\\n 'odds_hma':odds_hma,\\n 'odds_maj':odds_maj\\n })\\n return stats\",\n \"def _rouge(ref_file, summarization_file, subword_option=None):\\n\\n references = []\\n with codecs.getreader(\\\"utf-8\\\")(tf.gfile.GFile(ref_file, \\\"rb\\\")) as fh:\\n for line in fh:\\n references.append(_clean(line, subword_option))\\n\\n hypotheses = []\\n with codecs.getreader(\\\"utf-8\\\")(\\n tf.gfile.GFile(summarization_file, \\\"rb\\\")) as fh:\\n for line in fh:\\n hypotheses.append(_clean(line, subword_option=subword_option))\\n\\n rouge_score_map = rouge.rouge(hypotheses, references)\\n return 100 * rouge_score_map[\\\"rouge_l/f_score\\\"]\",\n \"def compute_bleu(self, ref_ids_list: Iterable[Iterable[int]], hyp_ids_list: Iterable[Iterable[int]],\\n ref_is_tensor: bool = False, hyp_is_tensor: bool = False,\\n reader_level: ReaderLevel=ReaderLevel.WORD) -> Tuple[float, str, str]:\\n assert len(ref_ids_list) == len(hyp_ids_list)\\n refs = self.target_sentensify_all(ref_ids_list, input_is_tensor=ref_is_tensor, reader_level=reader_level)\\n hyps = self.target_sentensify_all(hyp_ids_list, input_is_tensor=hyp_is_tensor, reader_level=reader_level)\\n scores = [sentence_bleu(hyps[sid], refs[sid]) for sid in range(len(ref_ids_list))]\\n random_index = choice(range(len(refs)))\\n return sum(scores) / len(scores), refs[random_index], hyps[random_index]\",\n \"def advancedStats():\",\n \"def optimize_reference(self, num_targets):\\n \\n target_weights = np.ones(num_targets)\\n target_weights = target_weights/sum(target_weights)\\n \\n #target_weights = [0.8,0.2]\\n\\n x0 = np.asarray(np.insert(np.zeros(self._refs.shape[0]-len(target_weights)),0,target_weights))\\n print(x0)\\n \\n # num_weights = self._refs.shape[0]\\n # x0 = np.ones(num_weights)/sum(np.ones(num_weights))\\n\\n #x0 = np.asarray([0.8,0.2,0,0,0,0,0,0])\\n\\n assert num_targets >= 1, 'num_targets >= 1'\\n assert num_targets <= len(x0), 'num_targets < len(x0)'\\n\\n\\n lsq = sciopt.least_squares(self.residual, \\n x0, \\n #args=(np.reshape(self._true, (1,36)), num_targets), \\n args=(self._true, num_targets), \\n bounds=(0,1), \\n method='trf', \\n tr_solver='lsmr', \\n diff_step=0.1, \\n loss='soft_l1',\\n tr_options={'damp':1.0},\\n ftol=1e-6,\\n verbose=2) #diff_step=0.2, verbose=2)#, loss='linear')\\n\\n return (lsq.x/sum(lsq.x), lsq)\",\n \"def get_score(self):\\n files_flare = self.generate_flare_set()\\n files_non_flare = self.generate_non_flare_set()\\n timeseries = []\\n y = []\\n scores = {}\\n column_mapping = self.__get_column_mapping()\\n for col in tqdm(range(1, 25)):\\n for file in tqdm(files_flare):\\n s = Sample(\\\"FL\\\", file).get_data().iloc[:, col].values\\n y.append(self.mapping[file[0]])\\n timeseries.append(s)\\n\\n for file in tqdm(files_non_flare):\\n s = Sample(\\\"NF\\\", file).get_data().iloc[:, col].values\\n y.append(self.mapping[file[0]])\\n timeseries.append(s)\\n embed = self.get_embed_vector(timeseries)\\n\\n embed_y = KMeans(n_clusters=5).fit_predict(embed)\\n y = np.array(y).flatten()\\n scores[column_mapping[col]] = self.relevance_score(embed_y, y)\\n timeseries = []\\n y = []\\n scores_data = pd.DataFrame.from_dict(scores, orient='index', columns=['Relevance Score']).sort_values(\\n by='Relevance Score', ascending=False)\\n return scores_data\",\n \"def gw_heritability(\\n input_snp_filename: \\\"Data Input, use the SNPs file from dataParse\\\",\\n output_summary_filename: 'output file for the genomewide results summary, use .csv',\\n logger_filename: 'file for the logger, use a txt',\\n sweeps: \\\"number of samples for each chain\\\" = 1000,\\n burnin: \\\"number of burnin samples\\\" = 1000,\\n n_chains: \\\"number of chains of the sampler\\\" = 4,\\n n_cores: \\\"number of parallel cores to use\\\" = 4,\\n N_1kG: \\\"number of SNPs onwhich the LD-score is calculates\\\" = 1290028,\\n chromosome: \\\"chromosome on which the analysis is run\\\" = \\\"all\\\",\\n sep: \\\"separator for the input files, use t for tab separated (not \\\\t)\\\" = \\\",\\\",\\n model: 'regression model'='normal',\\n fix_intercept = False,\\n ):\\n\\n # Initialisation of the logger\\n output_logger = log.setup_logger(\\\"output_logger\\\", logger_filename)\\n log.initialise_log(output_logger,\\n 'genome-wide regression, model: %s' %model,\\n [input_snp_filename],\\n [output_summary_filename],\\n sweeps,\\n burnin,\\n chromosome = str(chromosome),\\n other_params_diz = {'chains': n_chains, 'cores': n_cores})\\n\\n # Initialisation function, it reads the summary stats file, filters the SNPs,\\n # creates the output files\\n\\n logging.info(\\\"Start Analysis\\\")\\n\\n snps = s.Snps()\\n # read table\\n snps.read_table(input_snp_filename, separator=sep)\\n # generate chi squared stats\\n snps.generate_stats()\\n # update the summary stats\\n snps.update_summary()\\n output_logger.info(\\\" Sample size \\\" + str(snps.n_patients) + \\\"\\\\n\\\")\\n\\n\\n snps.apply_filter_table(s.baghera_filter)\\n snps.update_summary()\\n output_logger.info(\\\"After baghera init filter.\\\\nNumber of SNPs: %s\\\\nNumber of genes: %s\\\\n\\\" \\\\\\n %(str(snps.n_snps), str(snps.n_genes)) )\\n\\n # Non coding SNPs are assigned to a dummy gene, such that the regression is done on the entire SNPs' set\\n snps.rename_non_annotated(name='NonCoding')\\n\\n if chromosome != \\\"all\\\":\\n snps.apply_filter_table(snps.cut_single_chrom, **{'chromosome': chromosome})\\n output_logger.info(\\n \\\"Analysis restricted to chr %s\\\" %str(chromosome) )\\n\\n snps.update_summary()\\n output_logger.info(\\\"Analysis. Number of SNPs: %s\\\\n, Number of genes: %s\\\\n\\\" \\\\\\n %(str(snps.n_snps), str(snps.n_genes)) )\\n\\n\\n if model =='normal':\\n [intercept, slope] = heritability.gw_normal(snps, output_summary_filename, output_logger,\\n sweeps, burnin, n_chains, n_cores, N_1kG, fix_intercept)\\n elif model=='gamma':\\n [intercept, slope] = heritability.gw_normal(snps, output_summary_filename, output_logger,\\n sweeps, burnin, n_chains, n_cores, N_1kG, fix_intercept)\\n else:\\n logging.info('Normal model by default')\\n [intercept, slope] = heritability.gw_normal(snps, output_summary_filename, output_logger,\\n sweeps, burnin, n_chains, n_cores, N_1kG, fix_intercept)\\n logging.info(\\\"Analysis complete\\\")\",\n \"def _run():\\n matching_terms = {'a', 'b'}\\n source_counts = {'a': 10, 'b': 50, 'c': 25}\\n target_counts = {'a': 4, 'b': 73, 'c': 15}\\n source_chunk = ['a', 'b']\\n target_chunk = ['a', 'c', 'b']\\n source_distance = score.find_distance(\\n matching_terms, source_chunk, source_counts)\\n target_distance = score.find_distance(\\n matching_terms, target_chunk, target_counts)\\n match_score = score.vanilla(\\n matching_terms, source_distance, target_distance, source_counts,\\n target_counts)\\n print('Calculated score:', match_score)\",\n \"def read_result(result_file, source2target):\\n result_index = defaultdict(lambda: [])\\n \\n with open(result_file) as tsvfile:\\n tsvreader = csv.reader(tsvfile, delimiter='\\\\t')\\n for row in tsvreader: \\n source = row[0]\\n target = row[1]\\n score = float(row[2])\\n\\n if source in source2target:\\n result_index[source].append((target, score))\\n else:\\n logging.warning('Source term \\\"%s\\\" not found in the gold standard' % source)\\n\\n return result_index\",\n \"def all_raw_stats(r1_stats, r2_stats, name):\\n raw_output= name + \\\"_raw_read_counts.txt\\\"\\n raw_R1_reads, raw_R1_bases, Q20_R1_bp, Q20_R1_percent, Q30_R1_bp, Q30_R1_percent = get_raw_stats(r1_stats)\\n raw_R2_reads, raw_R2_bases, Q20_R2_bp, Q20_R2_percent, Q30_R2_bp, Q30_R2_percent = get_raw_stats(r2_stats)\\n write_raw_stats(raw_R1_reads, raw_R1_bases, Q20_R1_bp, Q20_R1_percent, Q30_R1_bp, Q30_R1_percent, raw_R2_reads, raw_R2_bases, Q20_R2_bp, Q20_R2_percent, Q30_R2_bp, Q30_R2_percent, raw_output, name)\",\n \"def calculate_stats(team_id, current_matches, prev_matches, stats, targets):\\n\\n # Features\\n current_formation = None\\n opp_formation = None\\n win = 0\\n loss = 0\\n recent_wins = 0\\n recent_losses = 0\\n prev_opp = []\\n current_opp = 0\\n total_goals = 0\\n goals_for = 0\\n goals_against = 0\\n goal_diff = 0\\n total_points = 0\\n count = 1\\n played = float(0)\\n goal_efficiency = 0\\n\\n # Game Features\\n game_features = {'possession': [], 'attacks': [], 'dangerous_attacks': [], 'yellow_cards': [],\\n 'corner_kicks': [], 'shots_on_target': [], 'shots_total': [], 'ball_safe': [],\\n 'goal_attempts': [], 'goal_attempts_allowed': [], 'saves': [], 'first_half_goals': [], 'sec_half_goals': [], 'goal_kicks': []}\\n\\n # Targets\\n points = 0\\n goals = 0\\n opp_goals = 0\\n\\n goals_home = 0\\n goals_away = 0\\n opp_goals_at_home = 0 # Opponent goals when CURRENT team is AT Home\\n opp_goals_at_away = 0 # Opponent goals when CURRENT team is Away\\n\\n total_games = len(prev_matches)\\n # Pulling Data for PREVIOUS Matches\\n for index, game in prev_matches.iterrows():\\n\\n # Home Wins and Road Losses are .8 while Road Wins and Home Losses are 1.2 / Draws remain the same\\n if team_id == game['home_id']:\\n\\n if game['home_points'] == 3:\\n win += .8\\n\\n elif game['home_points'] == 1:\\n win += .5\\n loss += .5\\n\\n else:\\n loss += 1.2\\n\\n total_goals += game['home_score']\\n goals_for += game['home_score']\\n goals_against += game['away_score']\\n goal_diff += game['home_score'] - game['away_score']\\n total_points += game['home_points']\\n\\n goals_home += game['home_points']\\n opp_goals_at_away += game['away_points']\\n\\n current_formation = game['home_formation']\\n opp_formation = game['away_formation']\\n\\n prev_opp.append(game['away_id'])\\n\\n game_features['possession'].append(game['home_possession'])\\n game_features['attacks'].append(game['home_attacks'])\\n game_features['dangerous_attacks'].append(game['home_dangerous_attacks'])\\n game_features['yellow_cards'].append(game['home_yellow_card'])\\n game_features['corner_kicks'].append(game['home_corner_kicks'])\\n game_features['shots_on_target'].append(game['home_shots_on_target'])\\n game_features['shots_total'].append(game['home_shots_total'])\\n game_features['ball_safe'].append(game['home_ball_safe'])\\n game_features['goal_attempts'].append(game['home_goal_attempts'])\\n game_features['goal_attempts_allowed'].append(game['away_goal_attempts'])\\n game_features['saves'].append(game['home_saves'])\\n game_features['first_half_goals'].append(game['home_first_half_score'])\\n game_features['sec_half_goals'].append(game['home_second_half_score'])\\n game_features['goal_kicks'].append(game['home_goal_kicks'])\\n\\n else:\\n team_name = game[\\\"away_team\\\"]\\n\\n if game['away_points'] == 3:\\n win += 1.2\\n\\n elif game['away_points'] == 1:\\n win += .5\\n loss += .5\\n\\n else:\\n loss += .8\\n\\n total_goals += game['away_score']\\n goals_for += game['away_score']\\n goals_against += game['home_score']\\n goal_diff += game['away_score'] - game['home_score']\\n total_points += game['away_points']\\n\\n goals_away += game['away_points']\\n opp_goals_at_home += game['home_points']\\n\\n current_formation = game['away_formation']\\n opp_formation = game['home_formation']\\n\\n prev_opp.append(game['home_id'])\\n\\n game_features['possession'].append(game['away_possession'])\\n game_features['attacks'].append(game['away_attacks'])\\n game_features['dangerous_attacks'].append(game['away_dangerous_attacks'])\\n game_features['yellow_cards'].append(game['away_yellow_card'])\\n game_features['corner_kicks'].append(game['away_corner_kicks'])\\n game_features['shots_on_target'].append(game['away_shots_on_target'])\\n game_features['shots_total'].append(game['away_shots_total'])\\n game_features['ball_safe'].append(game['away_ball_safe'])\\n game_features['goal_attempts'].append(game['away_goal_attempts'])\\n game_features['goal_attempts_allowed'].append(game['home_goal_attempts'])\\n game_features['saves'].append(game['away_saves'])\\n game_features['first_half_goals'].append(game['away_first_half_score'])\\n game_features['sec_half_goals'].append(game['away_second_half_score'])\\n game_features['goal_kicks'].append(game['away_goal_kicks'])\\n\\n played += 1\\n count += 1\\n\\n # Pulling the data for the CURRENT MATCH\\n for index, cur_game in current_matches.iterrows():\\n\\n match_id = cur_game[\\\"match_id\\\"]\\n scheduled = cur_game[\\\"scheduled\\\"]\\n if team_id == cur_game['home_id']:\\n is_home = True\\n team_name = cur_game[\\\"home_team\\\"]\\n current_opp = cur_game['away_id']\\n\\n if targets:\\n # Targets\\n points = cur_game['home_points']\\n goals = cur_game['home_score']\\n opp_goals = cur_game['away_score']\\n\\n else:\\n\\n is_home = False\\n team_name = cur_game[\\\"away_team\\\"]\\n current_opp = cur_game['home_id']\\n\\n if targets:\\n # Targets\\n points = cur_game['away_points']\\n goals = cur_game['away_score']\\n opp_goals = cur_game['home_score']\\n\\n for k, v in game_features.items():\\n game_features[k] = np.sum(np.array(v))\\n \\\"\\\"\\\"if len(v) != 0:\\n game_features[k] = np.nanmean(np.array(v))\\n else:\\n game_features[k] = np.nan\\\"\\\"\\\"\\n\\n\\n if stats:\\n print(\\\" ========================== \\\")\\n print(\\\"Team Id : {} - Name : {}\\\".format(team_id, team_name))\\n print(\\\"Prev Opponent Ids : {}\\\".format(prev_opp))\\n print(\\\"FEATURES (Stats from * 3 Previous Matches)\\\")\\n print(\\\"Total Goals : {}\\\".format(total_goals))\\n print(\\\"Total Points : {}\\\".format(total_points))\\n # print(\\\"Win Points : {}\\\".format(win))\\n # print(\\\"Loss Points : {}\\\".format(loss))\\n print(\\\"Played : {}\\\".format(played))\\n print(\\\"Goal Diff : {}\\\".format(goal_diff))\\n print(\\\"Margin : {}\\\".format(np.divide(goal_diff, played)))\\n print(\\\"\\\")\\n\\n if targets:\\n # Still can weight games more on most recent games\\n print(\\\"\\\\nTARGETS (RESULTS OF CURRENT MATCH)\\\")\\n print(\\\"Points : {}\\\".format(points))\\n print(\\\"Goals : {}\\\".format(goals))\\n print(\\\"Opp_Goals : {}\\\".format(opp_goals))\\n\\n return match_id, team_id, team_name, scheduled, int(is_home == True), total_points, \\\\\\n goals_for, goals_against, goal_diff, goal_efficiency, played, win, loss, recent_wins, recent_losses, prev_opp, \\\\\\n current_opp, points, goals, opp_goals, current_formation, opp_formation, game_features\",\n \"def score_summary(self, summary, references, summary_id='A'):\\n try:\\n self._write_config(references, Doc(summary_id, summary))\\n output = self._run_rouge()\\n output = output.decode(\\\"utf-8\\\")\\n return self._parse_output(output)\\n except CalledProcessError as e:\\n print(\\\"Rouge returned a non-zero error code. Output was: \\\", file=sys.stderr)\\n print(\\\"BEGIN OUTPUT \\\", file=sys.stderr)\\n print(e.output, file=sys.stderr)\\n print(\\\"END OUTPUT\\\", file=sys.stderr)\\n raise e\\n finally:\\n self._cleanup()\",\n \"def stats(self):\",\n \"def get_bleu(ref, hyp, tokenization=\\\"intl\\\"):\\n BLEU = corpus_bleu(hyp, [ref], tokenize=tokenization)\\n return BLEU.score\",\n \"def _calc_refs(counts):\\n refs = 0\\n for allele in counts.keys():\\n refs += counts[allele]\\n return refs\",\n \"def summarize(self, field=None):\\n\\n # Check extra-dependency for computing the bleu score\\n try:\\n import sacrebleu\\n except ImportError:\\n print(\\n \\\"Please install sacrebleu (https://pypi.org/project/sacrebleu/) in order to use the BLEU metric\\\"\\n )\\n\\n scores = sacrebleu.corpus_bleu(self.predicts, self.targets)\\n details = {}\\n details[\\\"BLEU\\\"] = scores.score\\n details[\\\"BP\\\"] = scores.bp\\n details[\\\"ratio\\\"] = scores.sys_len / scores.ref_len\\n details[\\\"hyp_len\\\"] = scores.sys_len\\n details[\\\"ref_len\\\"] = scores.ref_len\\n details[\\\"precisions\\\"] = scores.precisions\\n\\n self.scores = scores\\n self.summary = details\\n\\n # Add additional, more generic key\\n self.summary[\\\"bleu_score\\\"] = self.summary[\\\"BLEU\\\"]\\n\\n if field is not None:\\n return self.summary[field]\\n else:\\n return self.summary\",\n \"def _estimate_stats_with_rel_info(self):\\r\\n nonrel_list = []\\r\\n rel_list = []\\r\\n for ele in self._ranking_list:\\r\\n score = ele[0]\\r\\n rel = ele[1]\\r\\n if rel:\\r\\n rel_list.append(score)\\r\\n else:\\r\\n nonrel_list.append(score)\\r\\n m1,v1 = self._compute_stat_from_list(rel_list) \\r\\n m0,v0 = self._compute_stat_from_list(nonrel_list)\\r\\n estimated_lambda = len(rel_list)*1.0/len(self._ranking_list)\\r\\n\\r\\n self._m1 = m1\\r\\n self._v1 = v1\\r\\n self._m0 = m0\\r\\n self._v0 = v0\\r\\n self._lambda = estimated_lambda\\r\\n\\r\\n if self._debug :\\r\\n print \\\"m1: %f, v1: %f, m0: %f, v0: %f\\\" %(self._m1,self._v1,self._m0,self._v0)\\r\\n print \\\"lambda: %f\\\" %(estimated_lambda)\",\n \"def get_scores(self):\\n\\n\\t\\tscores = np.dot(self.rankings, self.weights)\\n\\t\\tranked_indices = np.argsort(scores)\\n\\t\\tranked_sources = self.source_names[ranked_indices]\\n\\t\\tranked_scores = sorted(scores)\\n\\t\\tself.scores = {source:score for source, score in zip(ranked_sources, ranked_scores)}\\n\\n\\t\\treturn self.scores\",\n \"def score(self):\\n\\n self.link()\\n roc, _ = self.aggregate()\\n\\n return roc\",\n \"def rouge_l_summary_level(evaluated_sentences, reference_sentences):\\n if len(evaluated_sentences) <= 0 or len(reference_sentences) <= 0:\\n raise ValueError(\\\"Collections must contain at least 1 sentence.\\\")\\n\\n # total number of words in reference sentences\\n m = len(_split_into_words(reference_sentences))\\n\\n # total number of words in evaluated sentences\\n n = len(_split_into_words(evaluated_sentences))\\n\\n union_lcs_sum_across_all_references = 0\\n for ref_s in reference_sentences:\\n union_lcs_sum_across_all_references += _union_lcs(evaluated_sentences,\\n ref_s)\\n return _f_p_r_lcs(union_lcs_sum_across_all_references, m, n)\",\n \"def calc_difference_from_reference(inputs, outputs, verbose=True):\\n\\n # Get a list of reference input/output files\\n filename_ref_inputs = glob.glob(lal_cuda.full_path_datafile(\\\"inputs.dat*\\\"))\\n filename_ref_outputs = [\\n filename_ref_input_i.replace(\\n \\\"inputs.dat\\\",\\n \\\"outputs.dat\\\") for filename_ref_input_i in filename_ref_inputs]\\n\\n # Look to see if the given inputs are in the stored reference inputs\\n filename_ref_output = None\\n for filename_ref_input_i, filename_ref_output_i in zip(filename_ref_inputs, filename_ref_outputs):\\n inputs_i = inputs.read(filename_ref_input_i)\\n\\n # Check to see if this set of inputs matches the set that has been passed\\n if(inputs_i == inputs):\\n inputs_ref = inputs_i\\n filename_ref_output = filename_ref_output_i\\n break\\n\\n # Perform check if a match has been found\\n if(not filename_ref_output):\\n lal_cuda.log.warning(\\n \\\"Checking could not be performed: reference data set with given inputs (%s) not found.\\\" %\\n (inputs))\\n else:\\n if(verbose):\\n lal_cuda.log.open('Performing test...')\\n\\n # Read reference dataset's outputs\\n outputs_ref = outputs.read(filename_ref_output)\\n\\n # Compute statistics of difference from test reference\\n hpval_real_diff_avg = 0.\\n hpval_imag_diff_avg = 0.\\n hcval_real_diff_avg = 0.\\n hcval_imag_diff_avg = 0.\\n hpval_real_diff_max = 0.\\n hpval_imag_diff_max = 0.\\n hcval_real_diff_max = 0.\\n hcval_imag_diff_max = 0.\\n for (hp_i, hc_i, hp_ref_i, hc_ref_i) in zip(outputs.hp, outputs.hc, outputs_ref.hp, outputs_ref.hc):\\n hpval_real_diff_i = calc_frac_diff(hp_i.real, hp_ref_i.real)\\n hpval_imag_diff_i = calc_frac_diff(hp_i.imag, hp_ref_i.imag)\\n hcval_real_diff_i = calc_frac_diff(hc_i.real, hc_ref_i.real)\\n hcval_imag_diff_i = calc_frac_diff(hc_i.imag, hc_ref_i.imag)\\n hpval_real_diff_avg += hpval_real_diff_i\\n hpval_imag_diff_avg += hpval_imag_diff_i\\n hcval_real_diff_avg += hcval_real_diff_i\\n hcval_imag_diff_avg += hcval_imag_diff_i\\n hpval_real_diff_max = max([hpval_real_diff_max, hpval_real_diff_i])\\n hpval_imag_diff_max = max([hpval_imag_diff_max, hpval_imag_diff_i])\\n hcval_real_diff_max = max([hcval_real_diff_max, hcval_real_diff_i])\\n hcval_imag_diff_max = max([hcval_imag_diff_max, hcval_imag_diff_i])\\n hpval_real_diff_avg /= float(len(outputs.hp))\\n hpval_imag_diff_avg /= float(len(outputs.hp))\\n hcval_real_diff_avg /= float(len(outputs.hc))\\n hcval_imag_diff_avg /= float(len(outputs.hc))\\n\\n # Report results\\n if(verbose):\\n lal_cuda.log.comment(' Average/maximum real(hp) fractional difference: %.2e/%.2e' %\\n (hpval_real_diff_avg, hpval_real_diff_max))\\n lal_cuda.log.comment(' Average/maximum imag(hp) fractional difference: %.2e/%.2e' %\\n (hpval_imag_diff_avg, hpval_imag_diff_max))\\n lal_cuda.log.comment(' Average/maximum real(hc) fractional difference: %.2e/%.2e' %\\n (hcval_real_diff_avg, hcval_real_diff_max))\\n lal_cuda.log.comment(' Average/maximum imag(hc) fractional difference: %.2e/%.2e' %\\n (hcval_imag_diff_avg, hcval_imag_diff_max))\\n lal_cuda.log.close(\\\"Done.\\\")\\n\\n return {\\n 'hpval_real_diff_avg': hpval_real_diff_avg,\\n 'hpval_real_diff_max': hpval_real_diff_max,\\n 'hpval_imag_diff_avg': hpval_imag_diff_avg,\\n 'hpval_imag_diff_max': hpval_imag_diff_max,\\n 'hcval_real_diff_avg': hcval_real_diff_avg,\\n 'hcval_real_diff_max': hcval_real_diff_max,\\n 'hcval_imag_diff_avg': hcval_imag_diff_avg,\\n 'hcval_imag_diff_max': hcval_imag_diff_max}\",\n \"def table_stats(self, db, dest, kvargs, lines):\\n if 'table' in kvargs:\\n tables = [db.get_table(kvargs['table'])]\\n else:\\n tables = db.tables()\\n options = kvargs.get('options','')\\n done = False\\n for table in db.tables():\\n print(\\\"======================= {} =======================\\\".format(table.name))\\n if 'dump' in options:\\n print(\\\"schema dump:\\\")\\n table.dump()\\n print(\\\"\\\")\\n if 'head' in options:\\n print(\\\"First 5 records:\\\")\\n for source_record in db.read_records_as_dicts(tablename=table.name, limit=5):\\n print(source_record)\\n print(\\\"\\\")\\n # Compute single-variable stats on each of the variables\\n sw = stopwatch().start()\\n print(\\\"Computing statistics...\\\")\\n stats = {}\\n census_checksum = 0\\n \\n if self.spark_context:\\n print(\\\"Using spark to read {} ... assuming first line has headings\\\".format(table.filename))\\n sc = self.spark_context\\n data = sc.textFile(table.filename)\\n header = data.first() # extract the header\\n stats = data.filter(lambda row:row!=header).map(table.parse_line_to_dict).reduce(stats_reducer)\\n else:\\n try:\\n for source_record in db.read_records_as_dicts(tablename=table.name,limit=self.limit):\\n if source_record['RECTYPE']=='P':\\n census_checksum += census_person_polynominal(source_record)\\n stats = stats_reducer(source_record, stats)\\n except KeyboardInterrupt as e:\\n print(\\\"*** KeyboardInterrupt at count: {}\\\".format(stats[':count']))\\n done = True\\n if stats:\\n print(\\\"total records: {} speed: {:8.0f} records/sec\\\".format( stats[':count'], stats[':count']/sw.elapsed()))\\n tt = tytable.ttable()\\n tt.add_head(['variable','min','avg','max'])\\n tt.set_col_alignment(1,tytable.ttable.RIGHT)\\n tt.set_col_alignment(2,tytable.ttable.RIGHT)\\n tt.set_col_alignment(3,tytable.ttable.RIGHT)\\n for key in stats_variable_names(stats):\\n try:\\n tt.add_data([key, stats[key+\\\":min\\\"], stats[key+\\\":sum\\\"] / stats[':count'], stats[key+\\\":max\\\"]])\\n except TypeError:\\n tt.add_data([key, stats[key+\\\":min\\\"], \\\"\\\", stats[key+\\\":max\\\"]])\\n print(tt.typeset(mode=tytable.TEXT))\\n if census_checksum:\\n print(\\\"Census checksum: {}\\\".format(census_checksum))\\n print(\\\"\\\")\\n if done:\\n return True # had the keyboard abort\\n return True\",\n \"def rouge_l_summary_level(evaluated_sentences, reference_sentences):\\n if len(evaluated_sentences) <= 0 or len(reference_sentences) <= 0:\\n raise ValueError(\\\"Collections must contain at least 1 sentence.\\\")\\n\\n # total number of words in reference sentences\\n m = len(_split_into_words(reference_sentences))\\n\\n # total number of words in evaluated sentences\\n n = len(_split_into_words(evaluated_sentences))\\n\\n union_lcs_sum_across_all_references = 0\\n for ref_s in reference_sentences:\\n union_lcs_sum_across_all_references += _union_lcs(evaluated_sentences,\\n ref_s)\\n return _f_p_r_lcs(union_lcs_sum_across_all_references, m, n)\",\n \"def evaluate_rouge_match(ref_data, pred_data, align=\\\"rouge\\\"):\\n\\n scorer = RougeScorer([\\\"rougeL\\\"])\\n agg = scoring.BootstrapAggregator(confidence_interval=0.95)\\n sample_evaluated = 0\\n\\n for tid in tqdm(pred_data):\\n cur_sys = pred_data[tid][\\\"pred\\\"]\\n if not tid in ref_data: continue\\n cur_ref_lst = [x[\\\"tgt_words\\\"] for x in ref_data[tid]]\\n if len(cur_ref_lst) > 0:\\n if align == \\\"rouge\\\":\\n best_rouge_scrs = __rouge_pairs(cur_sys, cur_ref_lst, scorer)\\n agg.add_scores(best_rouge_scrs)\\n else:\\n best_paired_ref, _ = utils.pair_ref_sys_by_coverage(cur_sys, cur_ref_lst)\\n agg.add_scores(scorer.score(best_paired_ref, cur_sys))\\n sample_evaluated += 1\\n\\n print(sample_evaluated)\\n result = agg.aggregate()\\n for rouge_type in result:\\n print(rouge_type)\\n print(result[rouge_type].mid)\\n\\n print(agg.aggregate())\\n return\",\n \"def get_rouge(ref_path, pred_path):\\n print(\\\"###########cal rouge###############\\\")\\n source_lines = [line.strip() for line in codecs.open(ref_path, \\\"r\\\", \\\"utf-8\\\").readlines()]\\n pred_lines = [ pred.strip() for pred in codecs.open(pred_path, \\\"r\\\", \\\"utf-8\\\").readlines() ]\\n assert len(source_lines) == len(pred_lines)\\n rou = rouge.Rouge()\\n scores = rou.get_scores(pred_lines, source_lines)\\n ave_scores = rou.get_scores(pred_lines, source_lines, avg=True)\\n result = OrderedDict()\\n result[\\\"ave_scores\\\"] = ave_scores\\n result[\\\"detail_scores\\\"] = scores\\n print(ave_scores)\\n print(\\\"############end rouge#############\\\\n\\\")\\n return result\",\n \"def test_add_two_sources(self):\\n metric = self.metric()\\n measurement = self.measurement(\\n metric,\\n sources=[self.source(metric, value=\\\"10\\\"), self.source(metric, value=\\\"20\\\")],\\n )\\n self.assertEqual(\\\"30\\\", measurement[\\\"count\\\"][\\\"value\\\"])\",\n \"def general_stats():\\n\\n setproctitle(f\\\"RNANet statistics.py general_stats()\\\")\\n\\n reqs = [\\n # unique unmapped chains with no issues\\n \\\"\\\"\\\" SELECT distinct pdb_id, chain_name, exp_method, resolution\\n FROM chain JOIN structure ON chain.structure_id = structure.pdb_id\\n WHERE rfam_acc = 'unmappd' AND ISSUE=0;\\\"\\\"\\\",\\n\\n # unique mapped chains with no issues\\n \\\"\\\"\\\" SELECT distinct pdb_id, chain_name, exp_method, resolution\\n FROM chain JOIN structure ON chain.structure_id = structure.pdb_id\\n WHERE rfam_acc != 'unmappd' AND ISSUE=0;\\\"\\\"\\\",\\n\\n # mapped chains with no issues\\n \\\"\\\"\\\" SELECT pdb_id, chain_name, inferred, rfam_acc, pdb_start, pdb_end, exp_method, resolution\\n FROM chain JOIN structure ON chain.structure_id = structure.pdb_id\\n WHERE rfam_acc != 'unmappd' AND ISSUE=0;\\\"\\\"\\\",\\n\\n # mapped chains with no issues that are all inferred\\n \\\"\\\"\\\" SELECT DISTINCT pdb_id, c.chain_name, exp_method, resolution\\n FROM (\\n SELECT inferred, rfam_acc, pdb_start, pdb_end, chain.structure_id, chain.chain_name, r.redundancy, r.inf_redundancy\\n FROM chain \\n JOIN (SELECT structure_id, chain_name, COUNT(distinct rfam_acc) AS redundancy, SUM(inferred) AS inf_redundancy \\n FROM chain \\n WHERE rfam_acc != 'unmappd' AND issue=0 \\n GROUP BY structure_id, chain_name\\n ) AS r ON chain.structure_id=r.structure_id AND chain.chain_name = r.chain_name \\n WHERE r.redundancy=r.inf_redundancy AND rfam_acc != 'unmappd' and issue=0\\n ) AS c\\n JOIN structure ON c.structure_id=structure.pdb_id;\\\"\\\"\\\",\\n\\n # Number of mapped chains (not inferred)\\n \\\"\\\"\\\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 0);\\\"\\\"\\\",\\n\\n # Number of unique mapped chains (not inferred)\\n \\\"\\\"\\\"SELECT count(*) FROM (SELECT DISTINCT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 0);\\\"\\\"\\\",\\n\\n # Number of mapped chains (inferred)\\n \\\"\\\"\\\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 1);\\\"\\\"\\\",\\n\\n # Number of unique mapped chains (inferred)\\n \\\"\\\"\\\"SELECT count(*) FROM (SELECT DISTINCT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 1);\\\"\\\"\\\",\\n\\n # Number of mapped chains inferred once\\n \\\"\\\"\\\"SELECT count(*) FROM (\\n SELECT structure_id, chain_name, COUNT(DISTINCT rfam_acc) as c \\n FROM chain where rfam_acc!='unmappd' and inferred=1 \\n GROUP BY structure_id, chain_name\\n ) WHERE c=1;\\\"\\\"\\\",\\n\\n # Number of mapped chains inferred twice\\n \\\"\\\"\\\"select count(*) from (\\n select structure_id, chain_name, count(distinct rfam_acc) as c \\n from chain where rfam_acc!='unmappd' and inferred=1 \\n group by structure_id, chain_name\\n ) where c=2;\\\"\\\"\\\",\\n\\n # Number of mapped chains inferred 3 times or more\\n \\\"\\\"\\\"select count(*) from (\\n select structure_id, chain_name, count(distinct rfam_acc) as c \\n from chain where rfam_acc!='unmappd' and inferred=1 \\n group by structure_id, chain_name\\n ) where c>2;\\\"\\\"\\\",\\n\\n # Number of chains both mapped with and without inferrence\\n \\\"\\\"\\\" SELECT COUNT(*) FROM (\\n SELECT structure_id, chain_name, sum(inferred) AS s, COUNT(rfam_acc) AS c \\n FROM chain \\n WHERE rfam_acc!='unmappd' \\n GROUP BY structure_id, chain_name\\n ) \\n WHERE s < c AND s > 0;\\\"\\\"\\\",\\n \\n # Number of mapped chains (total)\\n \\\"\\\"\\\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd');\\\"\\\"\\\",\\n\\n # Number of unique mapped chains\\n \\\"\\\"\\\"SELECT count(*) FROM (SELECT DISTINCT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd');\\\"\\\"\\\",\\n\\n # Number of unmapped chains\\n \\\"\\\"\\\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc = 'unmappd');\\\"\\\"\\\",\\n \\n # Number of mapped chains without issues (not inferred)\\n \\\"\\\"\\\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 0 AND issue = 0);\\\"\\\"\\\",\\n\\n # Number of unique mapped chains without issues (not inferred)\\n \\\"\\\"\\\"SELECT count(*) FROM (SELECT DISTINCT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 0 AND issue = 0);\\\"\\\"\\\",\\n\\n # Number of mapped chains without issues (inferred)\\n \\\"\\\"\\\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 1 AND issue=0);\\\"\\\"\\\",\\n\\n # Number of unique mapped chains without issues (inferred)\\n \\\"\\\"\\\"SELECT count(*) FROM (SELECT DISTINCT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 1 AND issue=0);\\\"\\\"\\\",\\n\\n # Number of mapped chains without issues (total)\\n \\\"\\\"\\\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND issue=0);\\\"\\\"\\\",\\n\\n # Number of unique mapped chains without issues\\n \\\"\\\"\\\"SELECT count(*) FROM (SELECT DISTINCT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND issue=0);\\\"\\\"\\\",\\n\\n # Number of unmapped chains without issues\\n \\\"\\\"\\\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc = 'unmappd' AND issue=0);\\\"\\\"\\\"\\n ]\\n\\n answers = []\\n with sqlite3.connect(runDir + \\\"/results/RNANet.db\\\") as conn:\\n conn.execute('pragma journal_mode=wal')\\n for r in reqs:\\n answers.append(pd.read_sql(r, conn))\\n df_unique = answers[0]\\n df_mapped_unique = answers[1]\\n df_mapped_copies = answers[2]\\n df_inferred_only_unique = answers[3]\\n print()\\n print(\\\"> found\\\", answers[4].iloc[0][0], f\\\"chains ({answers[5].iloc[0][0]} unique chains) that are mapped thanks to Rfam. Removing chains with issues, only {answers[15].iloc[0][0]} ({answers[16].iloc[0][0]} unique)\\\")\\n if answers[4].iloc[0][0] != answers[5].iloc[0][0]:\\n print(\\\"\\\\t> This happens because different parts of the same chain can be mapped to different families.\\\")\\n print(\\\"> found\\\", answers[6].iloc[0][0], f\\\"chains ({answers[7].iloc[0][0]} unique chains) that are mapped by inferrence. Removing chains with issues, only {answers[17].iloc[0][0]} ({answers[18].iloc[0][0]} unique).\\\")\\n print(\\\"\\\\t> \\\", answers[8].iloc[0][0], \\\"chains are mapped only once,\\\")\\n print(\\\"\\\\t> \\\", answers[9].iloc[0][0], \\\"are mapped to 2 families,\\\")\\n print(\\\"\\\\t> \\\", answers[10].iloc[0][0], \\\"are mapped to 3 or more.\\\")\\n print(\\\"> Among them,\\\", answers[11].iloc[0][0], \\\"chains are mapped both with families found on Rfam and by inferrence.\\\")\\n if answers[11].iloc[0][0]:\\n print(\\\"\\\\t> this is normal if you used option -f (--full-inference). Otherwise, there might be a problem.\\\")\\n print(\\\"> TOTAL:\\\", answers[12].iloc[0][0], f\\\"chains ({answers[13].iloc[0][0]} unique chains) mapped to a family. Removing chains with issues, only {answers[19].iloc[0][0]} ({answers[20].iloc[0][0]} unique).\\\")\\n print(\\\"> TOTAL:\\\", answers[14].iloc[0][0], f\\\"unmapped chains. Removing chains with issues, {answers[21].iloc[0][0]}.\\\")\\n if answers[14].iloc[0][0]:\\n print(\\\"\\\\t> this is normal if you used option --no-homology. Otherwise, there might be a problem.\\\")\\n print()\\n\\n ##########################################\\n # plot N = f(resolution, exp_method)\\n ##########################################\\n\\n methods = df_unique.exp_method.unique()\\n\\n fig, axs = plt.subplots(1+len(methods), 3, figsize=(15,5*(1+len(methods))), sharex=True)\\n df_unique.sort_values('resolution', inplace=True, ignore_index=True)\\n df_mapped_unique.sort_values('resolution', inplace=True, ignore_index=True)\\n df_inferred_only_unique.sort_values('resolution', inplace=True, ignore_index=True)\\n df_mapped_copies.sort_values('resolution', inplace=True, ignore_index=True)\\n max_res = max(df_unique.resolution)\\n max_structs = max(len(df_mapped_copies.index), len(df_unique.index))\\n colors = np.linspace(0,1,1+len(methods))\\n plt.xticks( np.arange(0, max_res+2, 2.0).tolist(), np.arange(0, max_res+2, 2.0).tolist() )\\n\\n axs[0][0].grid(axis='y', ls='dotted', lw=1)\\n axs[0][0].hist(df_unique.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 1, colors[0], 1), label='distribution')\\n axs[0][0].hist(df_unique.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 0, colors[0], 0.5), cumulative=True, label='cumulative')\\n axs[0][0].text(0.95*max_res, 0.95*len(df_unique.resolution), \\\"%d \\\" % len(df_unique.resolution), \\n horizontalalignment='right', verticalalignment='top', fontsize=14)\\n axs[0][0].set_ylabel(\\\"ALL\\\", fontsize=14)\\n axs[0][0].set_title(\\\"Number of unique RNA chains\\\", fontsize=14)\\n axs[0][0].set_ylim((0, max_structs * 1.05))\\n axs[0][0].legend(loc=\\\"lower right\\\", fontsize=14)\\n\\n axs[0][1].grid(axis='y', ls='dotted', lw=1)\\n axs[0][1].set_yticklabels([])\\n axs[0][1].hist(df_mapped_unique.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 1, colors[0], 1), label='distribution')\\n axs[0][1].hist(df_mapped_unique.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 0, colors[0], 0.5), cumulative=True, label='cumulative')\\n axs[0][1].hist(df_inferred_only_unique.resolution, bins=np.arange(0, max_res, 0.5), fc=(0.2, 0, colors[0], 0.5), cumulative=True, label='only by inference')\\n axs[0][1].text(0.95*max_res, 0.95*len(df_mapped_unique.resolution), \\\"%d \\\" % len(df_mapped_unique.resolution), \\n horizontalalignment='right', verticalalignment='top', fontsize=14)\\n axs[0][1].set_title(r\\\"Number of unique RNA chains\\\\nmapped to $\\\\geq 1$ family\\\", fontsize=14)\\n axs[0][1].set_ylim((0, max_structs * 1.05))\\n axs[0][1].legend(loc=\\\"upper left\\\", fontsize=14)\\n\\n axs[0][2].grid(axis='y', ls='dotted', lw=1)\\n axs[0][2].set_yticklabels([])\\n axs[0][2].hist(df_mapped_copies.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 1, colors[0], 1), label='distribution')\\n axs[0][2].hist(df_mapped_copies.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 0, colors[0], 0.5), cumulative=True, label='cumulative')\\n axs[0][2].hist(df_mapped_copies[df_mapped_copies.inferred == 1].resolution, bins=np.arange(0, max_res, 0.5), fc=(0.2, 0, colors[0], 0.5), cumulative=True, label='inferred')\\n axs[0][2].text(0.95*max_res, 0.95*len(df_mapped_copies.resolution), \\\"%d \\\" % len(df_mapped_copies.resolution), \\n horizontalalignment='right', verticalalignment='top', fontsize=14)\\n axs[0][2].set_title(\\\"Number of RNA chains mapped to a\\\\nfamily (with copies)\\\", fontsize=14)\\n axs[0][2].legend(loc=\\\"upper left\\\", fontsize=14)\\n axs[0][2].set_ylim((0, max_structs * 1.05))\\n\\n for i,m in enumerate(methods):\\n df_unique_m = df_unique[df_unique.exp_method == m]\\n df_mapped_unique_m = df_mapped_unique[df_mapped_unique.exp_method == m]\\n df_inferred_only_unique_m = df_inferred_only_unique[df_inferred_only_unique.exp_method == m]\\n df_mapped_copies_m = df_mapped_copies[ df_mapped_copies.exp_method == m]\\n max_structs = max(len(df_mapped_copies_m.index), len(df_unique_m.index))\\n print(\\\"> found\\\", max_structs, \\\"structures with method\\\", m, flush=True)\\n\\n axs[1+i][0].grid(axis='y', ls='dotted', lw=1)\\n axs[1+i][0].hist(df_unique_m.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 1, colors[1+i], 1), label='distribution')\\n axs[1+i][0].hist(df_unique_m.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 0, colors[1+i], 0.5), cumulative=True, label='cumulative')\\n axs[1+i][0].text(0.95*max_res, 0.95*len(df_unique_m.resolution), \\\"%d \\\" % len(df_unique_m.resolution), \\n horizontalalignment='right', verticalalignment='top', fontsize=14)\\n axs[1+i][0].set_ylim((0, max_structs * 1.05))\\n axs[1+i][0].set_ylabel(m, fontsize=14)\\n axs[1+i][0].legend(loc=\\\"lower right\\\", fontsize=14)\\n\\n axs[1+i][1].grid(axis='y', ls='dotted', lw=1)\\n axs[1+i][1].set_yticklabels([])\\n axs[1+i][1].hist(df_mapped_unique_m.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 1, colors[1+i], 1), label='distribution')\\n axs[1+i][1].hist(df_mapped_unique_m.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 0, colors[1+i], 0.5), cumulative=True, label='cumulative')\\n axs[1+i][1].hist(df_inferred_only_unique_m.resolution, bins=np.arange(0, max_res, 0.5), fc=(0.2, 0, colors[1+i], 0.5), cumulative=True, label='only by inference')\\n axs[1+i][1].text(0.95*max_res, 0.95*len(df_mapped_unique_m.resolution), \\\"%d \\\" % len(df_mapped_unique_m.resolution), \\n horizontalalignment='right', verticalalignment='top', fontsize=14)\\n axs[1+i][1].set_ylim((0, max_structs * 1.05))\\n axs[1+i][1].legend(loc=\\\"upper left\\\", fontsize=14)\\n \\n axs[1+i][2].grid(axis='y', ls='dotted', lw=1)\\n axs[1+i][2].set_yticklabels([])\\n axs[1+i][2].hist(df_mapped_copies_m.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 1, colors[1+i], 1), label='distribution')\\n axs[1+i][2].hist(df_mapped_copies_m.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 0, colors[1+i], 0.5), cumulative=True, label='cumulative')\\n axs[1+i][2].hist(df_mapped_copies_m[df_mapped_copies_m.inferred == 1].resolution, bins=np.arange(0, max_res, 0.5), fc=(0.2, 0, colors[1+i], 0.5), cumulative=True, label='inferred')\\n axs[1+i][2].text(0.95*max_res, 0.95*len(df_mapped_copies_m.resolution), \\\"%d \\\" % len(df_mapped_copies_m.resolution), \\n horizontalalignment='right', verticalalignment='top', fontsize=14)\\n axs[1+i][2].set_ylim((0, max_structs * 1.05))\\n axs[1+i][2].legend(loc=\\\"upper left\\\", fontsize=14)\\n \\n axs[-1][0].set_xlabel(\\\"Structure resolution\\\\n(Angströms, lower is better)\\\", fontsize=14)\\n axs[-1][1].set_xlabel(\\\"Structure resolution\\\\n(Angströms, lower is better)\\\", fontsize=14)\\n axs[-1][2].set_xlabel(\\\"Structure resolution\\\\n(Angströms, lower is better)\\\", fontsize=14)\\n\\n fig.suptitle(\\\"Number of RNA chains by experimental method and resolution\\\", fontsize=16)\\n fig.subplots_adjust(left=0.07, right=0.98, wspace=0.05, \\n hspace=0.05, bottom=0.05, top=0.92)\\n fig.savefig(runDir + \\\"/results/figures/resolutions.png\\\")\\n plt.close()\\n\\n ##########################################\\n # plot Nfam = f(resolution, exp_method)\\n ##########################################\\n\\n df_mapped_copies['n_fam'] = [ len(df_mapped_copies.rfam_acc[:i+1].unique()) for i in range(len(df_mapped_copies.index)) ]\\n\\n fig, axs = plt.subplots(1, 1+len(methods), figsize=(5*(1+len(methods)), 5))\\n max_res = max(df_mapped_copies.resolution)\\n max_fams = max(df_mapped_copies.n_fam)\\n colors = np.linspace(0,1,1+len(methods))\\n plt.xticks( np.arange(0, max_res+2, 2.0).tolist(), np.arange(0, max_res+2, 2.0).tolist() )\\n\\n axs[0].grid(axis='y', ls='dotted', lw=1)\\n axs[0].plot(df_mapped_copies.resolution, df_mapped_copies.n_fam)\\n axs[0].text(0.95*max_res, 0.95*df_mapped_copies.n_fam.iloc[-1], \\\"%d \\\" % df_mapped_copies.n_fam.iloc[-1], \\n horizontalalignment='right', verticalalignment='top', fontsize=14)\\n axs[0].set_title(\\\"ALL\\\", fontsize=14)\\n axs[0].set_xlabel(\\\"Structure resolution (Angströms)\\\", fontsize=14)\\n axs[0].set_ylabel(\\\"Number of Rfam families\\\", fontsize=14)\\n axs[0].set_ylim((0, max_res * 1.05))\\n axs[0].set_ylim((0, max_fams * 1.05))\\n \\n for i,m in enumerate(methods):\\n df_mapped_copies_m = df_mapped_copies[ df_mapped_copies.exp_method == m].drop(\\\"n_fam\\\", axis=1).copy()\\n df_mapped_copies_m['n_fam'] = [ len(df_mapped_copies_m.rfam_acc[:i+1].unique()) for i in range(len(df_mapped_copies_m.index)) ]\\n print(\\\">\\\", df_mapped_copies_m.n_fam.iloc[-1], \\\"different RNA families have a 3D structure solved by\\\", m)\\n\\n axs[1+i].grid(axis='y', ls='dotted', lw=1)\\n axs[1+i].plot(df_mapped_copies_m.resolution, df_mapped_copies_m.n_fam, )\\n axs[1+i].text(0.95*max(df_mapped_copies_m.resolution), 0.95*df_mapped_copies_m.n_fam.iloc[-1], \\\"%d \\\" % df_mapped_copies_m.n_fam.iloc[-1], \\n horizontalalignment='right', verticalalignment='top', fontsize=14)\\n axs[1+i].set_xlim((0, max_res * 1.05))\\n axs[1+i].set_ylim((0, max_fams * 1.05))\\n axs[1+i].set_xlabel(\\\"Structure resolution (Angströms)\\\", fontsize=14)\\n axs[1+i].set_title(m, fontsize=14)\\n axs[1+i].set_yticklabels([])\\n \\n fig.suptitle(\\\"Number of RNA families used by experimental method and resolution\\\", fontsize=16)\\n fig.subplots_adjust(left=0.05, right=0.98, wspace=0.05, \\n hspace=0.05, bottom=0.12, top=0.84)\\n fig.savefig(runDir + \\\"/results/figures/Nfamilies.png\\\")\\n plt.close()\",\n \"def score(self, input_batch, input_ref):\\n x_standardized = self.model._batch_to_list(input_batch)\\n ref_standaradized = None\\n if input_ref is not None:\\n ref_standaradized = self.model._batch_to_list(input_ref)\\n\\n scores = self.deeplift_contribs_func(task_idx=self.task_idx,\\n input_data_list=x_standardized,\\n input_references_list=ref_standaradized,\\n batch_size=self.batch_size,\\n progress_update=1000)\\n\\n # TODO DeepLIFT error when using batched execution:\\n \\\"\\\"\\\"\\n # run_function_in_batches fails for \\n scores = run_function_in_batches(\\n func=self.deeplift_contribs_func,\\n input_data_list=x_standardized,\\n batch_size=self.batch_size,\\n progress_update=1000,\\n task_idx=self.task_idx)\\n \\\"\\\"\\\"\\n\\n # DeepLIFT returns all samples as a list of individual samples\\n scores = [numpy_collate(el) for el in scores]\\n\\n # re-format the list-type input back to how the input_batch was:\\n scores = self.model._match_to_input(scores, input_batch)\\n return scores\",\n \"def compute_rouge_l(output, reference, mode='f'):\\n assert mode in list('fpr') # F-1, precision, recall\\n lcs = _lcs_len(output, reference)\\n if lcs == 0:\\n score = 0.0\\n else:\\n precision = lcs / len(output)\\n recall = lcs / len(reference)\\n f_score = 2 * (precision * recall) / (precision + recall)\\n if mode == 'p':\\n score = precision\\n if mode == 'r':\\n score = recall\\n else:\\n score = f_score\\n return score\",\n \"def get_score(submissions, problem, due_date, options):\\r\\n best_score = None\\r\\n best_percent = 0\\r\\n best_ts = None\\r\\n bonus = None\\r\\n partners = set()\\r\\n for i, s in enumerate(submissions):\\r\\n timestamp = s['date']\\r\\n submission_num = s['submission_num']\\r\\n detail = s['detail']\\r\\n if 'correct_map' in detail and not options.is_clicker:\\r\\n try:\\r\\n autograder_out = detail['correct_map']['i4x-BerkeleyX-CS188x-17-problem-' + problem + '_2_1']['msg']\\r\\n except Exception, e:\\r\\n logging.error(\\\"Error getting output: %s. Submission:\\\\n%s\\\" % (e, s))\\r\\n continue\\r\\n\\r\\n autograder_out = unescape(autograder_out)\\r\\n if options.output:\\r\\n print(\\\"Autograder output for submission %s on %s:\\\\n%s\\\" % (submission_num, timestamp, autograder_out))\\r\\n\\r\\n get_bonus(autograder_out)\\r\\n extra = bonus_pattern.findall(autograder_out)\\r\\n if extra:\\r\\n bonus = extra[0]\\r\\n num, denom = s['score'].split(' / ')\\r\\n percent = float(num) / float(denom) if 'None' not in num else 0\\r\\n if percent > best_percent:\\r\\n best_score = s['score']\\r\\n best_percent = percent\\r\\n best_ts = timestamp\\r\\n if 'student_answers' in detail and not options.is_clicker:\\r\\n partner = detail['student_answers'].get('i4x-BerkeleyX-CS188x-17-problem-' + problem + '_3_1', '')\\r\\n if partner:\\r\\n partners.add(partner)\\r\\n logging.info(\\\"Partners: %s\\\" % (partners))\\r\\n\\r\\n if best_ts is not None and due_date is not None:\\r\\n submitted = dt.datetime.strptime(best_ts.split('+')[0], '%Y-%m-%d %H:%M:%S')\\r\\n slip_days_used = str((submitted - due_date).days + 1)\\r\\n else:\\r\\n slip_days_used = 'N/A'\\r\\n return best_score, bonus, partners, slip_days_used\",\n \"def scoring(self):\\n pass\",\n \"def rank_skill_support():\\n import collections\\n score_dict = collections.defaultdict(int)\\n for item in classes.Crusader.items:\\n for name in classes.Crusader.skill_names:\\n if name in inspect.getsource(item):\\n score_dict[name] += 1\\n\\n for name, freq in sorted(score_dict.items(), key=lambda x: -x[1]):\\n print(name, freq)\",\n \"def main():\\n\\trelations = [json.loads(x) for x in open('tutorial/pdtb_trial_data.json')]\\n\\toutput_relations = [convert_to_output(x) for x in relations]\\n\\toutput_relations[1]['Connective']['TokenList'] = [0]\\n\\toutput_relations[3]['Arg1']['TokenList'].pop(4)\\n\\toutput_relations[4]['Arg2']['TokenList'].pop(4)\\n\\toutput_relations[5]['Arg2']['TokenList'].pop(4)\\n\\toutput_relations[6]['Sense'] = [u'Contingency.Condition'] # This will hurt sense recall\\n\\toutput_relations.pop(0) # This will hurt all precision\\n\\tscorer.evaluate(relations, output_relations)\\n\\treturn output_relations\",\n \"def corpus_gleu(list_of_references, hypotheses, min_len=1, max_len=4):\\n # sanity check\\n assert len(list_of_references) == len(\\n hypotheses\\n ), \\\"The number of hypotheses and their reference(s) should be the same\\\"\\n\\n # sum matches and max-token-lengths over all sentences\\n corpus_n_match = 0\\n corpus_n_all = 0\\n\\n for references, hypothesis in zip(list_of_references, hypotheses):\\n hyp_ngrams = Counter(everygrams(hypothesis, min_len, max_len))\\n tpfp = sum(hyp_ngrams.values()) # True positives + False positives.\\n\\n hyp_counts = []\\n for reference in references:\\n ref_ngrams = Counter(everygrams(reference, min_len, max_len))\\n tpfn = sum(ref_ngrams.values()) # True positives + False negatives.\\n\\n overlap_ngrams = ref_ngrams & hyp_ngrams\\n tp = sum(overlap_ngrams.values()) # True positives.\\n\\n # While GLEU is defined as the minimum of precision and\\n # recall, we can reduce the number of division operations by one by\\n # instead finding the maximum of the denominators for the precision\\n # and recall formulae, since the numerators are the same:\\n # precision = tp / tpfp\\n # recall = tp / tpfn\\n # gleu_score = min(precision, recall) == tp / max(tpfp, tpfn)\\n n_all = max(tpfp, tpfn)\\n\\n if n_all > 0:\\n hyp_counts.append((tp, n_all))\\n\\n # use the reference yielding the highest score\\n if hyp_counts:\\n n_match, n_all = max(hyp_counts, key=lambda hc: hc[0] / hc[1])\\n corpus_n_match += n_match\\n corpus_n_all += n_all\\n\\n # corner case: empty corpus or empty references---don't divide by zero!\\n if corpus_n_all == 0:\\n gleu_score = 0.0\\n else:\\n gleu_score = corpus_n_match / corpus_n_all\\n\\n return gleu_score\",\n \"def rouge(hypotheses, references):\\n\\n # Filter out hyps that are of 0 length\\n # hyps_and_refs = zip(hypotheses, references)\\n # hyps_and_refs = [_ for _ in hyps_and_refs if len(_[0]) > 0]\\n # hypotheses, references = zip(*hyps_and_refs)\\n\\n # Calculate ROUGE-1 F1, precision, recall scores\\n rouge_1 = [\\n rouge_n([hyp], [ref], 1) for hyp, ref in zip(hypotheses, references)\\n ]\\n rouge_1_f, rouge_1_p, rouge_1_r = map(np.mean, zip(*rouge_1))\\n\\n # Calculate ROUGE-2 F1, precision, recall scores\\n rouge_2 = [\\n rouge_n([hyp], [ref], 2) for hyp, ref in zip(hypotheses, references)\\n ]\\n rouge_2_f, rouge_2_p, rouge_2_r = map(np.mean, zip(*rouge_2))\\n\\n # Calculate ROUGE-L F1, precision, recall scores\\n rouge_l = [\\n rouge_l_sentence_level([hyp], [ref])\\n for hyp, ref in zip(hypotheses, references)\\n ]\\n rouge_l_f, rouge_l_p, rouge_l_r = map(np.mean, zip(*rouge_l))\\n\\n return {\\n \\\"rouge_1/f_score\\\": rouge_1_f,\\n \\\"rouge_1/r_score\\\": rouge_1_r,\\n \\\"rouge_1/p_score\\\": rouge_1_p,\\n \\\"rouge_2/f_score\\\": rouge_2_f,\\n \\\"rouge_2/r_score\\\": rouge_2_r,\\n \\\"rouge_2/p_score\\\": rouge_2_p,\\n \\\"rouge_l/f_score\\\": rouge_l_f,\\n \\\"rouge_l/r_score\\\": rouge_l_r,\\n \\\"rouge_l/p_score\\\": rouge_l_p,\\n }\",\n \"def assign_similarity_importance( self, similarity_matrix_sources, tools_list, optimal_weights ):\\n similarity_matrix_learned = list()\\n all_tools = len( tools_list )\\n for tool_index, tool in enumerate( tools_list ):\\n sim_mat_tool_learned = np.zeros( all_tools )\\n for source in similarity_matrix_sources:\\n optimal_weight_source = optimal_weights[ tools_list[ tool_index ] ][ source ]\\n # add up the similarity scores from each source weighted by importance factors learned by machine leanring algorithm\\n sim_mat_tool_learned += optimal_weight_source * similarity_matrix_sources[ source ][ tool_index ]\\n similarity_matrix_learned.append( sim_mat_tool_learned )\\n return similarity_matrix_sources, similarity_matrix_learned\",\n \"def compute_score(predictions, references, vocab=None, beam_size=4):\\n assert np.rank(predictions) == 3\\n assert predictions.shape[0] == references.shape[0]\\n batch_size = predictions.shape[0]\\n predictions = tf.make_ndarray(tf.make_tensor_proto(predictions)).tolist()\\n references = tf.make_ndarray(tf.make_tensor_proto(references)).tolist()\\n hypotheses_list = []\\n references_list = []\\n\\n for index in range(batch_size):\\n # All predictions in beam search are used for validation scores.\\n for b_index in range(beam_size):\\n h = predictions[index][b_index]\\n try:\\n eos_index = h.index(input_utils.EOS)\\n except ValueError:\\n eos_index = len(h)\\n hypotheses_list.append(h[:eos_index])\\n\\n ref = references[index][0].decode().split('|')\\n ref_list = [r.strip().split(' ') for r in ref if r.strip()]\\n references_list.append(ref_list)\\n\\n all_scores = collections.defaultdict(list)\\n for hypothesis, references in zip(hypotheses_list, references_list):\\n if vocab is not None and len(vocab):\\n # Skip PADDING, UNK, EOS, START (0-3).\\n hypothesis = [\\n vocab[word_id].numpy().decode()\\n for word_id in hypothesis\\n if word_id > 3\\n ]\\n\\n h_str = ' '.join(str(e) for e in hypothesis)\\n r_str = [' '.join(str(e) for e in ref) for ref in references]\\n\\n print('hypothesis: ', str(h_str))\\n print('references: ', str(r_str))\\n print('\\\\n')\\n scores = screen2words_eval.coco_evaluate(r_str, h_str)\\n for key, score in scores.items():\\n all_scores[key].append(score)\\n score_names = [\\n 'BLEU-1', 'BLEU-2', 'BLEU-3', 'BLEU-4', 'ROUGE-1-f1-mean',\\n 'ROUGE-1-f1-min', 'ROUGE-1-f1-max', 'ROUGE-2-f1-mean', 'ROUGE-2-f1-min',\\n 'ROUGE-2-f1-max', 'ROUGE-L-f1-mean', 'ROUGE-L-f1-min', 'ROUGE-L-f1-max'\\n ]\\n\\n return [np.array(all_scores[name], dtype=np.float32) for name in score_names]\",\n \"def global_distribution(references_list):\\n total_reference = ''\\n for reference in references_list:\\n with reference.open() as f:\\n total_reference = total_reference + f.read()\\n words, probs, pairs = calculate_vocab_distribution(total_reference)\\n total_distribution = dit.ScalarDistribution(words, probs)\\n return total_distribution, words\",\n \"def score_points(train, target, sample_points):\\n rf = rf_factory()\\n rf.fit(train, target)\\n mu, sigma = random_forest_evaluate(rf, sample_points)\\n scores = expected_improvement(target.min(), mu, sigma)\\n return scores, rf.feature_importances_\",\n \"def getreferences(self, pmcid, source):\\n import requests\\n r = requests.get(\\n (self.referencesurl).format(source=source, pmcid=pmcid))\\n return r.content\",\n \"def __score_by_iceberg_level(self, source_iceberg, iceberg_to_score, iceberg_owner_after_all_groups_arrived):\\n if utils.is_me(self.__game, iceberg_owner_after_all_groups_arrived):\\n if source_iceberg.level <= iceberg_to_score.level:\\n return SOURCE_LEVEL_SMALL_THAN_DESTINATION_SCORE\\n if iceberg_to_score.level < iceberg_to_score.upgrade_level_limit:\\n return LEVEL_FACTOR_SCORE ** iceberg_to_score.penguins_per_turn\\n elif utils.is_neutral(self.__game, iceberg_owner_after_all_groups_arrived):\\n if MapChecker.get().is_tricky_map() or MapChecker.get().is_extra_far_treasure() or MapChecker.get().is_extra_far():\\n return LEVEL_FACTOR_SCORE * iceberg_to_score.penguins_per_turn\\n else:\\n return LEVEL_FACTOR_SCORE ** iceberg_to_score.penguins_per_turn\\n return iceberg_to_score.penguins_per_turn\",\n \"def main(args):\\n dm = DistanceMatrix()\\n for filename in args.samFile:\\n dm.addFile(filename, scoreTag=args.scoreTag)\\n\\n if args.minMatchingReads is None:\\n wantedReferenceIds = sorted(set(dm.scores))\\n else:\\n wantedReferenceIds = sorted(\\n set(\\n referenceId\\n for (referenceId, reads) in dm.scores.items()\\n if len(reads) >= args.minMatchingReads\\n )\\n )\\n if args.verbose:\\n print(\\n f\\\"Found {len(wantedReferenceIds)} references with at least \\\"\\n f\\\"{args.minMatchingReads} matching reads.\\\",\\n file=sys.stderr,\\n )\\n\\n if args.verbose:\\n for referenceId in wantedReferenceIds:\\n nReads = len(dm.scores[referenceId])\\n print(f\\\"Reference {referenceId!r} matched {nReads} reads.\\\")\\n\\n dump(\\n dict((id_, dm.scores[id_]) for id_ in wantedReferenceIds),\\n sys.stdout,\\n sort_keys=True,\\n indent=4,\\n )\\n print()\",\n \"def rouge(hypotheses, references):\\n\\n # Filter out hyps that are of 0 length\\n # hyps_and_refs = zip(hypotheses, references)\\n # hyps_and_refs = [_ for _ in hyps_and_refs if len(_[0]) > 0]\\n # hypotheses, references = zip(*hyps_and_refs)\\n\\n # Calculate ROUGE-1 F1, precision, recall scores\\n rouge_1 = [\\n rouge_n([hyp], [ref], 1) for hyp, ref in zip(hypotheses, references)\\n ]\\n rouge_1_f, rouge_1_p, rouge_1_r = map(np.mean, zip(*rouge_1))\\n\\n # Calculate ROUGE-2 F1, precision, recall scores\\n rouge_2 = [\\n rouge_n([hyp], [ref], 2) for hyp, ref in zip(hypotheses, references)\\n ]\\n rouge_2_f, rouge_2_p, rouge_2_r = map(np.mean, zip(*rouge_2))\\n\\n # Calculate ROUGE-L F1, precision, recall scores\\n rouge_l = [\\n rouge_l_sentence_level([hyp], [ref])\\n for hyp, ref in zip(hypotheses, references)\\n ]\\n rouge_l_f, rouge_l_p, rouge_l_r = map(np.mean, zip(*rouge_l))\\n\\n return {\\n \\\"rouge_1/f_score\\\": rouge_1_f,\\n \\\"rouge_1/r_score\\\": rouge_1_r,\\n \\\"rouge_1/p_score\\\": rouge_1_p,\\n \\\"rouge_2/f_score\\\": rouge_2_f,\\n \\\"rouge_2/r_score\\\": rouge_2_r,\\n \\\"rouge_2/p_score\\\": rouge_2_p,\\n \\\"rouge_l/f_score\\\": rouge_l_f,\\n \\\"rouge_l/r_score\\\": rouge_l_r,\\n \\\"rouge_l/p_score\\\": rouge_l_p,\\n }\",\n \"def __score_by_penguins_gaining(self, source_iceberg, destination_iceberg_to_score,\\n iceberg_owner_after_all_groups_arrived):\\n if iceberg_owner_after_all_groups_arrived.equals(self.__game.get_myself()):\\n return 0\\n turns_to_check = self.__max_distance - \\\\\\n source_iceberg.get_turns_till_arrival(destination_iceberg_to_score)\\n return turns_to_check * destination_iceberg_to_score.penguins_per_turn * PENGUINS_GAINING_SCORE_FACTOR\",\n \"def update(self, phase, targets, outputs):\\n iou, dice, dice_neg, dice_pos, _, _ = self.metric(outputs, targets)\\n self.base_dice_scores[phase].append(dice)\\n self.dice_pos_scores[phase].append(dice_pos)\\n self.dice_neg_scores[phase].append(dice_neg)\\n self.iou_scores[phase].append(iou)\",\n \"def run(self, args):\\n self.pen.score_for_matched_lexical = args[0]\\n self.pen.score_for_matched_synonym = args[1]\\n self.factor_word_offset_penalty = args[2]\\n self.factor_sentence_length_mismatch = args[3]\\n self.factor_name_mismatch = args[4]\\n self.factor_fe_offset_penalty = args[5]\\n self.weight_target_frame_element = args[6]\\n self.weight_frame_elements = args[7]\\n self.factor_frame_offset_penalty = args[8]\\n misses = []\\n for row in range(self.data.get_number_of_rows()):\\n ref_sentence = self.data.get_row(row)[self.data.get_gold()]\\n results = {}\\n for team, team_sentence in self.data.get_row_for_teams(self.evaluator.get_teams(row), row).iteritems():\\n results[team] = self.get_sentence_score(ref_sentence, team_sentence)\\n misses.append(self.evaluator.compare_all(results, row))\\n return np.mean(misses) / 5.0\",\n \"def postprocess_cga(lines, outfile):\\n pattern = re.compile(\\\"^\\\\s*([0-9,]+)\\\\s+\\\\([ 0-9.]+%\\\\)\\\\s+Source/(\\\\S+):(\\\\S+)\\\\(.*\\\\).*$\\\")\\n\\n totalCost = 0.0\\n functionTable = []\\n functionMap = {}\\n\\n for line in lines:\\n line = line.strip()\\n match = pattern.match(line)\\n if not match:\\n continue\\n\\n cost = float(match.group(1).replace(\\\",\\\", \\\"\\\"))\\n sourceFile = match.group(2)\\n function = match.group(3)\\n\\n # Filter out library code we don't want to change\\n if function.startswith(\\\"stbi__\\\"):\\n continue\\n\\n totalCost += cost\\n\\n # Accumulate the scores from functions in multiple call chains\\n if function in functionMap:\\n index = functionMap[function]\\n functionTable[index][1] += cost\\n functionTable[index][2] += cost\\n # Else add new functions to the end of the table\\n else:\\n functionMap[function] = len(functionTable)\\n functionTable.append([function, cost, cost])\\n\\n # Sort the table by accumulated cost\\n functionTable.sort(key=lambda x: 101.0 - x[2])\\n\\n for function in functionTable:\\n function[2] /= totalCost\\n function[2] *= 100.0\\n\\n with open(outfile, \\\"w\\\") as fileHandle:\\n\\n totals = 0.0\\n for function in functionTable:\\n # Omit entries less than 1% load\\n if function[2] < 1:\\n break\\n\\n totals += function[2]\\n fileHandle.write(\\\"%5.2f%% %s\\\\n\\\" % (function[2], function[0]))\\n\\n fileHandle.write(\\\"======\\\\n\\\")\\n fileHandle.write(f\\\"{totals:5.2f}%\\\\n\\\")\",\n \"def get_distance_metrics(source_embeddings, target_embeddings):\\n cosine_avg, euclidean_avg = 0.0, 0.0\\n for i in range(len(source_embeddings)):\\n cosine_avg += cosine(source_embeddings[i], target_embeddings[i])\\n euclidean_avg += euclidean(source_embeddings[i], target_embeddings[i])\\n return (cosine_avg / len(source_embeddings)), (euclidean_avg / len(source_embeddings))\",\n \"def gather(ref_gatherer, reference_node, constraints_as_spans, concept_graph):\\n my_span = Span('my', 'my', 2, 3, 0, 0, 1)\\n very_span = Span('very', 'very', 3, 4, 0, 0, 1)\\n red_span = Span('red', 'red', 4, 5, 0, 0, 1)\\n car_span = Span('car', 'car', 5, 6, 0, 0, 1)\\n graph = ConceptGraph(predicates=[\\n ('user', 'possess', 'c1', 'upc'),\\n ('c1', 'type', 'car', 'ctc'),\\n ('user', 'like', 'c1', 'ulc'),\\n ('c1', 'property', 'red', 'cpr'),\\n ('cpr', 'property', 'very', 'rpv'),\\n ('u1', 'type', 'extra', 'extra1'),\\n ('c1', 'focus', None, 'prim1'),\\n (my_span.to_string(), 'ref', 'upc'),\\n (very_span.to_string(), 'ref', 'rpv'),\\n (red_span.to_string(), 'ref', 'cpr'),\\n (car_span.to_string(), 'ref', 'c1')\\n ])\\n graph.features['upc']['comps'] = set()\\n graph.features['rpv']['comps'] = set()\\n graph.features['cpr']['comps'] = {'prim1'}\\n graph.features['c1']['comps'] = {'ctc', 'extra1'}\\n constraints_as_spans = {my_span.to_string(), very_span.to_string(),\\n red_span.to_string()}\\n\\n assert ref_gatherer.gather('c1', constraints_as_spans, graph) == \\\\\\n {'upc', 'rpv', 'cpr', 'ctc'}\",\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 get_target_per_score(self):\\n pass\",\n \"def calc_source_blend_distance(source,blend,RC,log):\\n\\n\\n log.info('\\\\n')\\n\\n source.calc_distance(log)\\n\\n try:\\n log.info('Inferred source distance: '+str(source.D)+' +/- '+str(source.sig_D)+' pc')\\n\\n log.info('Inferred source distance if its a small red giant: '+\\\\\\n str(source.D_small_giant)+' +/- '+str(source.sig_D_small_giant)+' pc')\\n\\n log.info('Inferred source distance if its a large red giant: '+\\\\\\n str(source.D_large_giant)+' +/- '+str(source.sig_D_large_giant)+' pc')\\n\\n except AttributeError:\\n pass\\n\\n blend.calc_distance(log)\\n\\n try:\\n log.info('Inferred blend distance: '+str(blend.D)+' +/- '+str(blend.sig_D)+' pc')\\n\\n except AttributeError:\\n pass\\n\\n (Rstar, sig_Rstar) = stellar_radius_relations.scale_source_distance(source.ang_radius, source.sig_ang_radius, RC.D*1000.0 ,log)\\n\\n source.radius = Rstar\\n source.sig_radius = sig_Rstar\\n\\n return source, blend\",\n \"def get_usage_stats(usages):\\n\\n # TODO: add the dates at which each of the highest & lowest were admined\\n\\n # average & total calculation\\n administration_stats = {'total': 0,\\n 'highest': 0,\\n 'lowest': None,\\n 'average': None,\\n 'count': len(usages)}\\n\\n for use in usages:\\n administration_stats['total'] += use.dosage\\n\\n # rounding things to 3 decimal places for a nicer display experience\\n if use.dosage > administration_stats['highest']:\\n administration_stats['highest'] = round(use.dosage, 3)\\n\\n if administration_stats['lowest'] is None or use.dosage < administration_stats['lowest']:\\n administration_stats['lowest'] = round(use.dosage, 3)\\n\\n administration_stats['average'] = round((administration_stats['total'] / administration_stats['count']), 3)\\n\\n return administration_stats\",\n \"def sources(obj, reftype):\",\n \"def get_score(self, a, b):\\n ### FILL IN ###\",\n \"def do_analyse(args):\\n\\n pd.set_option('display.max_columns', None)\\n pd.set_option('display.width', None)\\n\\n score = 'score'\\n\\n # Read in the results, and add a boolean target column.\\n df = pd.read_csv(args.results, index_col=0)\\n df['target'] = df['verify_speaker'] == df['enrol_speaker']\\n\\n # Calculate ideal 0.01% threshold over the multi-session data.\\n nontarget_df = df.loc[df['target'] == False].sort_values(score, ascending=False)\\n nontarget_count = nontarget_df[score].count()\\n th_calc = nontarget_df.iloc[int(nontarget_count * (1 / 10000))][score]\\n\\n # Now filter the data so that we only consider mono-session enrolment and verification.\\n df = df.loc[df['verify_room'] == df['enrol_room']]\\n target_df = df.loc[df['target'] == True].sort_values(score, ascending=False)\\n nontarget_df = df.loc[df['target'] == False].sort_values(score, ascending=False)\\n target_count = target_df[score].count()\\n nontarget_count = nontarget_df[score].count()\\n\\n # Calculate FA/FR for the user-defined threshold.\\n th_user = args.th_user\\n fr_user = target_df.loc[target_df[score] < th_user][score].count()\\n fa_user = nontarget_df.loc[nontarget_df[score] > th_user][score].count()\\n frr_user = fr_user / target_count\\n far_user = fa_user / nontarget_count\\n label_user = 'User Threshold: th {:.4f}, FR {} ({:.3f}%), FA {} ({:.3f}%)'.format(th_user, fr_user, frr_user * 100,\\n fa_user, far_user * 100)\\n\\n # Calculate the FA/FR for the ideal threshold calculated from the multi-session data.\\n fr_calc = target_df.loc[target_df[score] < th_calc][score].count()\\n fa_calc = nontarget_df.loc[nontarget_df[score] > th_calc][score].count()\\n frr_calc = fr_calc / target_count\\n far_calc = fa_calc / nontarget_count\\n label_calc = 'Calc Threshold: th {:.4f}, FR {} ({:.3f}%), FA {} ({:.3f}%)'.format(th_calc, fr_calc, frr_calc * 100,\\n fa_calc, far_calc * 100)\\n\\n # Print the stats.\\n print('\\\\nTarget Stats:')\\n print(target_df[score].describe())\\n print('\\\\nNon-Target Stats:')\\n print(nontarget_df[score].describe())\\n print('\\\\nThresholds:')\\n print(label_user)\\n print(label_calc)\\n\\n # Paint the graphs.\\n paint_graph(score, 'verify_room', df, th_user, label_user, th_calc, label_calc)\\n paint_graph(score, 'enrol_room', df, th_user, label_user, th_calc, label_calc)\\n paint_graph(score, 'verify_speaker', df, th_user, label_user, th_calc, label_calc)\\n paint_graph(score, 'enrol_speaker', df, th_user, label_user, th_calc, label_calc)\",\n \"def display(self,source,matched_network=False):\\n \\n if len(self._members) == 0: # matchch\\n raise NameError(\\\"Network is empty, no such source exists!\\\")\\n \\n handled_members = 0\\n \\n for k in range(len(self._members)):\\n try:\\n depth_k = self.collect(source,k)\\n counter = len(depth_k)\\n for member in depth_k:\\n curr_node = self._get(member)\\n\\n curr_node.displayed = True # Marks node as displayed\\n handled_members += 1\\n\\n if matched_network is True:\\n if curr_node.weight is not None:\\n weight_perc = str(round((curr_node.weight*100),2))+\\\"%\\\"+\\\" match!\\\"\\n else:\\n weight_perc = \\\" No weight\\\"\\n else:\\n weight_perc = curr_node.weight\\n\\n if counter != 1:\\n print(\\\"-\\\" * (len(curr_node.alias + str(weight_perc)) + 5))\\n print(\\\"|\\\", \\\" \\\" * (len(curr_node.alias + str(weight_perc))), \\\" |\\\")\\n print(\\\"|\\\", curr_node.alias, str(weight_perc), \\\"|\\\")\\n print(\\\"|\\\", \\\" \\\" * (len(curr_node.alias + str(weight_perc))), \\\" |\\\")\\n print(\\\"-\\\" * (len(curr_node.alias + str(weight_perc)) + 5))\\n\\n print(\\\" \\\"*(len(\\\"SHARED DISTANCE FROM SOURCE\\\")//2),\\\"^\\\",\\\" \\\"*(len(\\\"SHARED DISTANCE FROM SOURCE\\\")//2))\\n print(\\\" \\\"*(len(\\\"SHARED DISTANCE FROM SOURCE\\\")//2),\\\"|\\\",\\\" \\\"*(len(\\\"SHARED DISTANCE FROM SOURCE\\\")//2))\\n print(\\\"SHARED DISTANCE FROM SOURCE\\\")\\n print(\\\" \\\"*(len(\\\"SHARED DISTANCE FROM SOURCE\\\")//2),\\\"|\\\",\\\" \\\"*(len(\\\"SHARED DISTANCE FROM SOURCE\\\")//2))\\n print(\\\" \\\"*(len(\\\"SHARED DISTANCE FROM SOURCE\\\")//2),\\\"v\\\",\\\" \\\"*(len(\\\"SHARED DISTANCE FROM SOURCE\\\")//2))\\n\\n counter -= 1\\n elif counter == 1:\\n print(\\\"-\\\" * (len(curr_node.alias + str(weight_perc)) + 5))\\n print(\\\"|\\\", \\\" \\\" * (len(curr_node.alias + str(weight_perc))), \\\" |\\\")\\n print(\\\"|\\\", curr_node.alias, str(weight_perc), \\\"|\\\")\\n print(\\\"|\\\", \\\" \\\" * (len(curr_node.alias + str(weight_perc))), \\\" |\\\")\\n print(\\\"-\\\" * (len(curr_node.alias + str(weight_perc)) + 5))\\n\\n except ValueError:\\n pass\\n \\n # Handles disconnected graphs\\n for member in self._members:\\n if member.displayed == False:\\n print(\\\"!!DISCONNECTED NETWORK!!\\\")\\n if matched_network is True:\\n self.display(source=member.alias,matched_network=True)\\n else:\\n self.display(source=member.alias)\\n if handled_members == len(self._members):\\n member.displayed = False\",\n \"def _rouge_l_score(pred: Sequence[str], target: Sequence[str]) ->Dict[str, Tensor]:\\n pred_len, target_len = len(pred), len(target)\\n if 0 in (pred_len, target_len):\\n return dict(precision=tensor(0.0), recall=tensor(0.0), fmeasure=tensor(0.0))\\n lcs: int = _lcs(pred, target)\\n return _compute_metrics(lcs, pred_len, target_len)\",\n \"def _rouge_lsum_score(pred: Sequence[Sequence[str]], target: Sequence[Sequence[str]]) ->Dict[str, Tensor]:\\n pred_len = sum(map(len, pred))\\n target_len = sum(map(len, target))\\n if 0 in (pred_len, target_len):\\n return dict(precision=tensor(0.0), recall=tensor(0.0), fmeasure=tensor(0.0))\\n\\n def _get_token_counts(sentences: Sequence[Sequence[str]]) ->Counter:\\n ngrams: Counter = Counter()\\n for sentence in sentences:\\n ngrams.update(sentence)\\n return ngrams\\n pred_tokens_count = _get_token_counts(pred)\\n target_tokens_count = _get_token_counts(target)\\n hits = 0\\n for tgt in target:\\n lcs = _union_lcs(pred, tgt)\\n for token in lcs:\\n if pred_tokens_count[token] > 0 and target_tokens_count[token] > 0:\\n hits += 1\\n pred_tokens_count[token] -= 1\\n target_tokens_count[token] -= 1\\n return _compute_metrics(hits, pred_len, target_len)\",\n \"def __calculate_statistics(self, candidates):\\n pdf = {}\\n for candidate in candidates:\\n neighbors = list(self.G.neighbors(candidate))\\n capacity = sum([self.G.get_edge_data(candidate, n)[\\\"satoshis\\\"] for n in neighbors])\\n average = capacity / len(neighbors)\\n pdf[candidate] = average\\n cumsum = sum(pdf.values())\\n pdf = {k:v/cumsum for k,v in pdf.items()}\\n w = 0.7\\n print(\\\"percentage smoothed percentage capacity numchannels alias\\\")\\n print(\\\"----------------------------------------------------------------------\\\")\\n res_pdf = {}\\n for k,v in pdf.items():\\n neighbors = list(self.G.neighbors(k))\\n capacity = sum([self.G.get_edge_data(k, n)[\\\"satoshis\\\"] for n in neighbors])\\n name = k\\n if \\\"alias\\\" in self.G.node[k]:\\n name = self.G.node[k][\\\"alias\\\"]\\n print(\\\"{:12.2f} \\\".format(100*v), \\\"{:12.2f} \\\".format(100*(w * v + (1-w)/len(candidates))) ,\\\"{:10} {:10} \\\".format( capacity, len(neighbors)), name)\\n res_pdf[k] = (w * v + (1-w)/len(candidates))\\n return res_pdf\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6538913","0.611638","0.611638","0.5920825","0.58097124","0.57767993","0.56798124","0.56685686","0.56611174","0.5635664","0.5564803","0.5557683","0.5550513","0.552961","0.552961","0.5481987","0.5463703","0.54276645","0.5392559","0.5389487","0.5355115","0.5329073","0.53235346","0.5315337","0.5304004","0.52987087","0.5223209","0.5206235","0.5163009","0.5134437","0.5132998","0.5117025","0.51166016","0.51020294","0.5084353","0.5082221","0.50622374","0.5052436","0.50376105","0.5024006","0.50203514","0.5011134","0.50072587","0.49893945","0.49851945","0.4964813","0.49520174","0.49502432","0.49279827","0.49171242","0.4914386","0.4909587","0.490265","0.4891044","0.4885685","0.4885507","0.4879841","0.48797262","0.48763388","0.48741004","0.4871241","0.4865042","0.48592043","0.48568654","0.48315683","0.48289192","0.4824394","0.48207223","0.48166466","0.48152095","0.48101753","0.4803558","0.48017725","0.47717455","0.47705236","0.4766051","0.47656336","0.47646284","0.47611392","0.47524762","0.47499967","0.47441143","0.47439033","0.4742927","0.47428524","0.47396678","0.47392008","0.47379068","0.47362995","0.4734134","0.47185838","0.471136","0.46993926","0.46988612","0.46943256","0.46891493","0.46862233","0.4686144","0.46554333","0.46497667"],"string":"[\n \"0.6538913\",\n \"0.611638\",\n \"0.611638\",\n \"0.5920825\",\n \"0.58097124\",\n \"0.57767993\",\n \"0.56798124\",\n \"0.56685686\",\n \"0.56611174\",\n \"0.5635664\",\n \"0.5564803\",\n \"0.5557683\",\n \"0.5550513\",\n \"0.552961\",\n \"0.552961\",\n \"0.5481987\",\n \"0.5463703\",\n \"0.54276645\",\n \"0.5392559\",\n \"0.5389487\",\n \"0.5355115\",\n \"0.5329073\",\n \"0.53235346\",\n \"0.5315337\",\n \"0.5304004\",\n \"0.52987087\",\n \"0.5223209\",\n \"0.5206235\",\n \"0.5163009\",\n \"0.5134437\",\n \"0.5132998\",\n \"0.5117025\",\n \"0.51166016\",\n \"0.51020294\",\n \"0.5084353\",\n \"0.5082221\",\n \"0.50622374\",\n \"0.5052436\",\n \"0.50376105\",\n \"0.5024006\",\n \"0.50203514\",\n \"0.5011134\",\n \"0.50072587\",\n \"0.49893945\",\n \"0.49851945\",\n \"0.4964813\",\n \"0.49520174\",\n \"0.49502432\",\n \"0.49279827\",\n \"0.49171242\",\n \"0.4914386\",\n \"0.4909587\",\n \"0.490265\",\n \"0.4891044\",\n \"0.4885685\",\n \"0.4885507\",\n \"0.4879841\",\n \"0.48797262\",\n \"0.48763388\",\n \"0.48741004\",\n \"0.4871241\",\n \"0.4865042\",\n \"0.48592043\",\n \"0.48568654\",\n \"0.48315683\",\n \"0.48289192\",\n \"0.4824394\",\n \"0.48207223\",\n \"0.48166466\",\n \"0.48152095\",\n \"0.48101753\",\n \"0.4803558\",\n \"0.48017725\",\n \"0.47717455\",\n \"0.47705236\",\n \"0.4766051\",\n \"0.47656336\",\n \"0.47646284\",\n \"0.47611392\",\n \"0.47524762\",\n \"0.47499967\",\n \"0.47441143\",\n \"0.47439033\",\n \"0.4742927\",\n \"0.47428524\",\n \"0.47396678\",\n \"0.47392008\",\n \"0.47379068\",\n \"0.47362995\",\n \"0.4734134\",\n \"0.47185838\",\n \"0.471136\",\n \"0.46993926\",\n \"0.46988612\",\n \"0.46943256\",\n \"0.46891493\",\n \"0.46862233\",\n \"0.4686144\",\n \"0.46554333\",\n \"0.46497667\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.49421677"},"document_rank":{"kind":"string","value":"48"}}},{"rowIdx":22892,"cells":{"query":{"kind":"string","value":"Perform ZCA whitening on an image."},"document":{"kind":"string","value":"def whiten(x, e):\n x = x - x.mean(0).repeat(x.size()[1], 1)\n sigma = x * x.t / x.shape[1]\n u, s, _ = torch.svd(sigma, some=False)\n return u * torch.diag(1 / torch.sqrt(S.diag() + e)) * u.t * 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 ZCA_whitening(imageVector):\n\n sigma = np.dot(inputs, inputs.T)/inputs.shape[1] #Correlation matrix\n U,S,V = np.linalg.svd(sigma) #Singular Value Decomposition\n epsilon = 0.1 #Whitening constant, it prevents division by zero\n ZCAMatrix = np.dot(np.dot(U, np.diag(1.0/np.sqrt(np.diag(S) + epsilon))), U.T) #ZCA Whitening matrix\n return np.dot(ZCAMatrix, inputs) #Data whitening","def _whiten_embeddings_zca(self, lambd = 1e-8):\n print('ZCA-Whitening')\n Cov_s = np.cov(self.xs.T)\n Cov_t = np.cov(self.xt.T)\n d = Cov_s.shape[0]\n\n W_s = scipy.linalg.sqrtm(Cov_s + lambd*np.eye(d))\n W_t = scipy.linalg.sqrtm(Cov_t + lambd*np.eye(d))\n\n self.xs = self.xs@W_s#.T\n self.xt = self.xt@W_t#.T","def zca_whiten(self, data):\n # input tensor is [batch_size, num_samples, dim_x]\n num = compat.get_dim_int(data, 1)\n\n data = tf.cast(data, tf.float64)\n\n # center the samples\n mean = tf.reduce_mean(data, axis=1, keepdims=True)\n centered = data - tf.tile(mean, [1, num, 1])\n\n # whiten\n # compute the current covariance\n diff_square = tf.matmul(centered[:, :, :, None],\n centered[:, :, None, :])\n # sigma: [batch_size, dim_x, dim_x]\n sigma = tf.reduce_mean(diff_square, axis=1)\n # get the whitening matrix\n # s: [batch_size, dim_x], u: [batch_size, dim_x, dim_x]\n s, u, _ = tf.linalg.svd(sigma, full_matrices=True)\n s_inv = 1. / tf.sqrt(s + 1e-5)\n s_inv = tf.linalg.diag(s_inv)\n # w: [batch_size, dim_x, dim_x]\n w = tf.matmul(u, tf.matmul(s_inv, u, transpose_b=True))\n\n whitened = tf.matmul(centered, w)\n\n return whitened","def _whiten_embeddings_zca(self, xs, lambd = 1e-8):\n print('ZCA-Whitening')\n Cov_s = np.cov(xs.T)\n d = Cov_s.shape[0]\n\n W_s = scipy.linalg.sqrtm(Cov_s + lambd*np.eye(d))\n xs = xs@W_s#.T\n return xs","def zca_whiten(X):\n cov = np.cov(X.T)\n U, Sigma, V = np.linalg.svd(cov)\n D = np.diag(np.sqrt(1/Sigma)) # square root inverse of singular value matrix\n W = U @ D @ V # rotation matrix\n centered = X - X.mean(axis=0)\n X_white = np.einsum(\"ij, ...j -> ...i\", W, centered)\n return X_white","def PCA_ZCA_whiten_transform(X, symmetric = True):\n X = np.asarray(X, dtype='float32')\n #center\n X = X - np.mean(X, axis=1).reshape((-1,1))\n C = np.dot(X.T, X) / X.shape[0]\n EigVal, EigVec = np.linalg.eigh(C)\n mval = np.max(np.real(EigVal))\n max_ratio = 1e4\n tol = mval / max_ratio\n #ngd = np.nonzero(np.real(EigVal) > mval/max_ratio)\n if symmetric:\n ngd = np.nonzero(np.real(EigVal) > tol)[0]\n P = (np.real(EigVal[ngd])**(-0.5)).reshape((-1,1)) * EigVec[:, ngd].T # [reduced dim]*[dim]\n P = np.dot(EigVec[:, ngd], P)\n else:\n EigVal[EigVal <= tol] = 1.\n P = EigVal.reshape((-1,1)) * (EigVec.T)\n X = np.dot(X, P.T)\n return X, P.T","def whiten(self, blocks=20000, eps=0.0001):\r\n cov = np.zeros([self.datasize, self.datasize])\r\n nblocks = int(np.ceil(self.nstims / blocks))\r\n for ind in range(nblocks):\r\n X = self.data[blocks*ind:blocks*(ind+1)]\r\n cov += X.T.dot(X)\r\n eigvals, eigvecs = np.linalg.eigh(cov)\r\n if np.any(np.isnan(eigvals)):\r\n print('Warning: some nan eigenvalues found, replacing with small numbers.')\r\n eigvals[np.isnan(eigvals)] = 0.9 * eps**2\r\n if np.any(eigvals < 0):\r\n print('Warning: some negative eigenvalues of covariance matrix found. Replacing with small numbers.')\r\n eigvals[eigvals < 0] = 0.9 * eps**2\r\n\r\n idx = np.argsort(eigvals)\r\n svals = np.sqrt(eigvals[idx][::-1])\r\n eigvecs = eigvecs[idx][::-1]\r\n\r\n # do ZCA whitening\r\n wm = np.diag(1./np.maximum(svals, eps))\r\n self.zca_matrix = eigvecs.T.dot(wm).dot(eigvecs)\r\n self.data = self.data.dot(self.zca_matrix)","def pca_whiten(X):\n cov = np.cov(X.T)\n Sigma, U = np.linalv.eig(cov)\n D = np.diag(np.sqrt(1/Sigma)) # square root inverse of singular value matrix\n W = D @ U.T # rotation matrix\n centered = X - X.mean(axis=0)\n X_white = np.einsum(\"ij, ...j -> ...i\", W, centered)\n return X_white","def make_acwe(patch: Patch, params: dict):\r\n edge_map = 1.0 - patch.image_layers[\"Main\"]\r\n edge_map -= np.min(edge_map)\r\n edge_map = edge_map / np.max(edge_map)\r\n logger.debug(\"Calculating ACWE\")\r\n\r\n seg1 = ms.morphological_geodesic_active_contour(\r\n edge_map,\r\n iterations=params[\"iterations\"],\r\n init_level_set=patch.image_layers[\"total_mask\"],\r\n smoothing=params[\"smoothing\"],\r\n threshold=params[\"threshold\"],\r\n balloon=params[\"balloon\"],\r\n )\r\n outer_mask = ((seg1 * 1.0) > 0) * 2.0\r\n patch.image_layers[\"acwe\"] = outer_mask\r\n\r\n return patch","def test_identity(self, input_shape, eps, device, dtype):\n data = torch.randn(*input_shape, device=device, dtype=dtype)\n\n zca = kornia.enhance.ZCAWhitening(compute_inv=True, eps=eps).fit(data)\n\n data_w = zca(data)\n\n data_hat = zca.inverse_transform(data_w)\n\n self.assert_close(data, data_hat, low_tolerance=True)","def zca_whitening_matrix(X):\n # Covariance matrix [column-wise variables]: Sigma = (X-mu)' * (X-mu) / N\n sigma = np.cov(X, rowvar=True) # [M x M]\n # Singular Value Decomposition. X = U * np.diag(S) * V\n U,S,V = np.linalg.svd(sigma)\n # U: [M x M] eigenvectors of sigma.\n # S: [M x 1] eigenvalues of sigma.\n # V: [M x M] transpose of U\n # Whitening constant: prevents division by zero\n epsilon = 1e-5\n # ZCA Whitening matrix: U * Lambda * U'\n ZCAMatrix = np.dot(U, np.dot(np.diag(1.0/np.sqrt(S + epsilon)), U.T)) # [M x M]\n return ZCAMatrix","def whiten(X):\n X = asmatrix(X - mean(asmatrix(X),axis=1))\n C = X * X.T / X.shape[1]\n d, V = eigh(C)\n d[d<0] = 0 # In case d returns very small negative eigenvalues\n return (V / sqrt(d+spacing(1))) * V.T * X","def bayes_matting(img, trimap, sigma_d=10, it=1):\n assert img.shape[:-1] == trimap.shape\n\n img = img / 255.0\n nrows, ncols = img.shape[:-1]\n\n # initial alpha guess\n alpha = np.zeros(trimap.shape)\n alpha[trimap == 255] = 1\n alpha[trimap == 128] = 0.5\n\n B = img[alpha == 0] # background pixel mask\n F = img[alpha == 1] # foreground pixel mask\n\n mean_B = np.mean(B, axis=0)\n cov_B = np.cov(B.T)\n mean_F = np.mean(F, axis=0)\n cov_F = np.cov(F.T)\n\n try:\n inv_cov_B = np.linalg.inv(cov_B)\n inv_cov_F = np.linalg.inv(cov_F)\n except LinAlgError:\n print(\"LinAlgError\")\n\n for i in range(it):\n print(\"Iteration {}\".format(i))\n for row in range(nrows):\n for col in range(ncols):\n if trimap[row, col] == 128:\n f, g = calculate_fg(img[row, col], alpha[row, col], mean_F, inv_cov_F, mean_B, inv_cov_B, sigma_d)\n alpha[row, col] = calculate_alpha(img[row, col], f, g)\n\n alpha = np.clip(alpha, 0, 1)\n\n return alpha","def apply_filter(image: np.ndarray) -> np.ndarray:\n # choose filters to apply\n return clahe(image)","def apply_filter(self, image):\n pass","def whiten(data):\n\n from numpy.linalg import eig\n\n eps = 0.01\n \n # covariance matrix\n Sigma = np.cov(data)\n\n # eigenvalue decomposition\n V,U = eig(Sigma)\n \n W = U.dot(np.diag((V+eps)**(-0.5)).dot(U.transpose()))\n\n return W","def clahe(image: np.ndarray) -> np.ndarray:\n clahe_filter = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))\n return clahe_filter.apply(image)","def computeB(linsys_setup):\n datamaps, ninvs, beams, freqs, power_2d, precond_2d, clumaps, g_nu, \\\n map_prop = linsys_setup\n nx, ny, pixScaleX, pixScaleY = map_prop\n nFreq = len(g_nu); nCluster = len(clumaps[0])\n ksz = False\n if len(clumaps)==2: ksz = True\n \n def computeCMBY(d0):\n \"\"\"\n For CMB, y = S^1/2 A N^-1 d, where S is CMB signal covariance matrix (Cl's)\n \"\"\"\n # N.B. Reshaping operations required to go between 2D pixel arrays and \n # 1D vector (for linear system)\n d2 = 0\n for freq in range(nFreq):\n d1 = d0[freq].data.copy().reshape((ny,nx))\n d1 *= ninvs[freq]\n a_l = fft.fft(d1,axes=[-2,-1])\n a_l *= beams[freq]*precond_2d\n d1 = numpy.real(fft.ifft(a_l,axes=[-2,-1],normalize=True))\n d1 = numpy.reshape(d1,(nx*ny))\n d2 += d1\n return d2\n \n def computeClusterY(d0):\n \"\"\"\n For cluster, y = F^T A^T N^-1 d, where F is TSZ spatial template for cluster.\n \"\"\"\n d2 = numpy.zeros(nCluster)\n for ic in range(nCluster):\n for freq in range(nFreq):\n d1 = d0[freq].data.copy().reshape((ny, nx))\n d2[ic] += numpy.sum(d1 * ninvs[freq] * clumaps[0][ic][freq] * g_nu[freq])\n return d2\n \n def computeClusterKSZY(d0):\n \"\"\"\n For cluster, y = K^T A^T N^-1 d, where K is KSZ spatial template for cluster.\n \"\"\"\n d2 = numpy.zeros(nCluster)\n for ic in range(nCluster):\n for freq in range(nFreq):\n d1 = d0[freq].data.copy().reshape((ny, nx))\n d2[ic] += numpy.sum(d1 * ninvs[freq] * clumaps[1][ic][freq])\n return d2\n \n def computeMonopoleY(d0):\n \"\"\"\n Overall monopole amplitude.\n \"\"\"\n d2 = 0\n for freq in range(nFreq):\n d1 = d0[freq].data.copy().reshape((ny, nx))\n d2 += numpy.sum(d1 * ninvs[freq])\n return(d2)\n \n \n # CMB realisation; convolve white noise map with beam and multiply by \n # signal covmat S^1/2 in harmonic space\n b0 = numpy.random.randn(ny,nx)\n a_l = numpy.fft.fft2(b0, b0.shape)\n a_l *= precond_2d * power_2d**(-0.5)\n b0 = numpy.fft.irfft2(a_l, b0.shape)\n \n # Calculate per-band noise realisation.\n # Multiply by pixel-space N^1/2, convolve with beam, and sum over \n # cluster pixels to get RHS\n b1 = 0; b4 = 0\n b2 = numpy.zeros(nCluster)\n if ksz: b3 = numpy.zeros(nCluster)\n \n for freq in range(nFreq):\n _b = numpy.random.randn(ny,nx) * ninvs[freq]**0.5\n a_l = numpy.fft.fft2(_b) * beams[freq] * precond_2d\n b1 += numpy.fft.irfft2(a_l, _b.shape)\n b4 += numpy.sum(_b)\n for ic in range(nCluster):\n b2[ic] += numpy.sum( _b * g_nu[freq] * clumaps[0][ic][freq] )\n if ksz: b3[ic] += numpy.sum( _b * clumaps[1][ic][freq] )\n\n b0 = numpy.reshape(b0,(nx*ny))\n b1 = numpy.reshape(b1,(nx*ny))\n \n\n # Compute CMB and cluster data parts of b\n b_CMB = computeCMBY(datamaps) + b0 + b1\n b_mono = computeMonopoleY(datamaps) + b4\n b_tsz = computeClusterY(datamaps) + b2\n if ksz: b_ksz = computeClusterKSZY(datamaps) + b3\n \n # Return total b vector (Ncmbpix + 1 + (1|2)*Ncluster elements in vector)\n b = numpy.append(b_CMB, b_mono)\n b = numpy.append(b, b_tsz)\n if ksz: b = numpy.append(b, b_ksz)\n return b","def filterClusters(inputFile, maskImage, outputFile):\n os.system('3drefit -space MNI ' + maskImage)\n os.system('3dcalc -a ' + maskImage \\\n + ' -b ' + inputFile \\\n + \" -expr 'step(a) * b'\" \\\n + ' -prefix ' + outputFile)","def filterClusters(inputFile, maskImage, outputFile):\n os.system('3drefit -space MNI ' + maskImage)\n os.system('3dcalc -a ' + maskImage \\\n + ' -b ' + inputFile \\\n + \" -expr 'step(a) * b'\" \\\n + ' -prefix ' + outputFile)","def _augment(img):\r\n return flip(img, axis=2)","def ICA_Denoise(Y, ica_model, noise_std):\n\n # TODO: YOUR CODE HERE","def do_transform(self):\n # TODO: after unit tests are added switch to astropy fftconvolve here.\n from scipy.signal import fftconvolve\n total_background = self.model + self.background + self.approx\n excess = self.image - total_background\n for key, kern in self.kernbase.items():\n self.transform[key] = fftconvolve(excess, kern, mode='same')\n self.error[key] = np.sqrt(fftconvolve(total_background, kern ** 2, mode='same'))\n\n self.approx = fftconvolve(self.image - self.model - self.bkg,\n self.kern_approx, mode='same')\n self.approx_bkg = fftconvolve(self.bkg, self.kern_approx, mode='same')","def _augment(img):\n return flip(img, axis=2)","def zca(x, xtest, bias=0.1):\n covariance = np.dot(x.T, x) / x.shape[0]\n covariance += bias * np.eye(x.shape[1])\n U, S, _ = np.linalg.svd(covariance)\n pc = U @ np.diag(1. / np.sqrt(S)) @ U.T\n X = x @ pc\n Xtest = xtest @ pc\n return X, Xtest","def edges(image):\n #store image width and height and initialize new image\n image_width = image['width']\n image_height = image['height']\n new_image = {'height': image['height'], 'width': image['width'], 'pixels': len(image['pixels'])*[0]}\n \n #sobel operator kernels\n kernel_x = {'height': 3, 'width': 3, 'pixels': [-1,0,1,-2,0,2,-1,0,1]}\n kernel_y = {'height': 3, 'width': 3, 'pixels': [-1,-2,-1,0,0,0,1,2,1]}\n \n #creating the filters\n o_x = correlate(image, kernel_x)\n o_y = correlate(image, kernel_y)\n\n #perform relvant calculation for each pixel \n for x in range(image_width):\n for y in range(image_height):\n a = ((get_pixel(o_x, x, y))**2+(get_pixel(o_y, x, y))**2)**0.5\n set_pixel(new_image, x, y, a)\n return round_and_clip_image(new_image)","def coherenceFilter(img, sigma=11, str_sigma=11, blend=0.5, iter_n=4):\n h, w = img.shape[:2]\n tmp = img.copy()\n for i in xrange(iter_n):\n gray = cv2.cvtColor(tmp, cv2.COLOR_BGR2GRAY)\n eigen = cv2.cornerEigenValsAndVecs(gray, str_sigma, 3)\n eigen = eigen.reshape(h, w, 3, 2) # [[e1, e2], v1, v2]\n x, y = eigen[:,:,1,0], eigen[:,:,1,1]\n gxx = cv2.Sobel(gray, cv2.CV_32F, 2, 0, ksize=sigma)\n gxy = cv2.Sobel(gray, cv2.CV_32F, 1, 1, ksize=sigma)\n gyy = cv2.Sobel(gray, cv2.CV_32F, 0, 2, ksize=sigma)\n gvv = x*x*gxx + 2*x*y*gxy + y*y*gyy\n m = gvv < 0\n ero = cv2.erode(tmp, None)\n dil = cv2.dilate(tmp, None)\n img1 = ero\n img1[m] = dil[m]\n tmp = np.uint8(tmp*(1.0 - blend) + img1*blend)\n return tmp","def apply(self, mode='lateral'):\n num_lat_slices = self.img3d.shape[0]\n num_cor_slices = self.img3d.shape[2]\n bin_mask = np.zeros(self.mask3d.shape)\n x,y,z = np.where(self.mask3d==self.vertebra_id)\n bin_mask[np.min(x):np.max(x), np.min(y):np.max(y), np.min(z):np.max(z)] = 1\n if mode=='lateral' or mode=='fuse':\n mask_lat = np.zeros((6, self.mask3d.shape[0], self.mask3d.shape[1], self.mask3d.shape[2]))\n img_lat = np.zeros(self.img3d.shape)\n binary_lat = np.zeros(self.mask3d.shape)\n # for each lateral slice\n for idx in range(num_lat_slices):\n img_slice, mask_slice = np.copy(self.img3d[idx, :, :]), np.copy(self.mask3d[idx, :, :])\n xloc, yloc = np.where(mask_slice==self.vertebra_id)\n # check if vertebra is present in image\n if xloc.shape[0]==0:\n # if not keep mask as it is\n mask_lat[:,idx, :, :] = self.get_one_hot(mask_slice)\n img_lat[idx, :, :] = img_slice\n else:\n min_x, max_x = np.min(xloc), np.max(xloc)\n min_y, max_y = np.min(yloc), np.max(yloc)\n inpainted_img, inpainted_mask, binary_mask = self.inpaint(img_slice, mask_slice, min_x, max_x, min_y, max_y)\n mask_lat[:,idx, :, :] = inpainted_mask\n img_lat[idx,:, :] = inpainted_img\n binary_lat[idx,:,:] = binary_mask\n\n\n if mode=='coronal' or mode=='fuse':\n mask_cor = np.zeros((6, self.mask3d.shape[0], self.mask3d.shape[1], self.mask3d.shape[2]))\n img_cor = np.zeros(self.img3d.shape)\n binary_cor = np.zeros(self.mask3d.shape)\n # for each coronal slice\n for idx in range(num_cor_slices):\n img_slice, mask_slice = np.copy(self.img3d[:, :, idx]), np.copy(self.mask3d[:, :, idx])\n xloc, yloc = np.where(mask_slice==self.vertebra_id)\n # check if vertebra is present in image\n if xloc.shape[0]==0:\n # if not keep mask as it is\n mask_cor[:, :, :, idx] = self.get_one_hot(mask_slice)\n img_cor[:, :, idx] = img_slice\n else:\n min_x, max_x = np.min(xloc), np.max(xloc)\n min_y, max_y = np.min(yloc), np.max(yloc)\n # else remove fractured vertebra and inpaint\n inpainted_img, inpainted_mask, binary_mask = self.inpaint(img_slice, mask_slice, min_x, max_x, min_y, max_y, 'coronal')\n mask_cor[:, :, :, idx] = inpainted_mask\n img_cor[:, :, idx] = inpainted_img\n binary_cor[:,:,idx] = binary_mask\n \n # return to a one channel mask and convert labels back\n if mode=='lateral':\n mask_lat = np.argmax(mask_lat, axis=0)\n mask_lat = self.map_class_to_vert(mask_lat)\n self.mask3d = mask_lat\n self.img3d = img_lat\n elif mode=='coronal':\n mask_cor = np.argmax(mask_cor, axis=0)\n mask_cor = self.map_class_to_vert(mask_cor)\n self.mask3d = mask_cor\n self.img3d = img_cor\n elif mode=='fuse':\n mask_fuse = mask_cor*0.5+mask_lat*0.5\n mask_fuse = np.argmax(mask_fuse, axis=0)\n mask_fuse = self.map_class_to_vert(mask_fuse)\n self.mask3d = mask_fuse\n self.img3d = (img_lat+img_cor)/2\n \n # save result\n self.mask3d = self.mask3d.astype(np.uint8)\n self.img3d = self.img3d.astype(np.float32)\n \n # put back if we padded and cropped\n if self.padz and self.padx:\n self.orig_img3d[:,self.ymin:self.ymax, :] = self.img3d[self.xcrop1:-self.xcrop2,:,self.zcrop1:-self.zcrop2]\n self.orig_mask3d[:,self.ymin:self.ymax, :] = self.mask3d[self.xcrop1:-self.xcrop2,:,self.zcrop1:-self.zcrop2]\n elif self.padz and not self.padx:\n self.orig_img3d[self.xcrop1:self.xcrop2,self.ymin:self.ymax, :] = self.img3d[:,:,self.zcrop1:-self.zcrop2]\n self.orig_mask3d[self.xcrop1:self.xcrop2,self.ymin:self.ymax, :] = self.mask3d[:,:,self.zcrop1:-self.zcrop2]\n elif not self.padz and self.padx:\n self.orig_img3d[:,self.ymin:self.ymax, self.zcrop1:self.zcrop2] = self.img3d[self.xcrop1:-self.xcrop2,:,:]\n self.orig_mask3d[:,self.ymin:self.ymax, self.zcrop1:self.zcrop2] = self.mask3d[self.xcrop1:-self.xcrop2,:,:]\n else:\n self.orig_img3d[self.xcrop1:self.xcrop2,self.ymin:self.ymax, self.zcrop1:self.zcrop2] = self.img3d\n self.orig_mask3d[self.xcrop1:self.xcrop2,self.ymin:self.ymax, self.zcrop1:self.zcrop2] = self.mask3d\n \n img = return_scan_to_orig(self.orig_img3d, self.mask_affine, self.mask_header, self.zooms)\n nib.save(img, self.inpainted_img_path)\n\n mask_fuse = return_scan_to_orig(self.orig_mask3d, self.mask_affine, self.mask_header, self.zooms, np.uint8)\n nib.save(mask_fuse, self.inpainted_mask_path)\n print('Inpaint mask and image saved at: ', self.inpainted_mask_path, self.inpainted_img_path)","def process(data,patch_dim,W=None):\n\n # pull patches from image\n patches = extract_patches(data,patch_dim)\n\n # remove dc component and contrast normalize\n patches = normalize(patches)\n\n if W is None:\n # build whitening matrix\n W = whiten(patches)\n\n # apply whitening\n patches = W.dot(patches)\n\n return patches,W","def run(self):\n #calculate platescale of first input image\n try:\n det = np.linalg.det(wcs.WCS(self.datain[0].header).wcs.cd)\n pscale = np.sqrt(np.abs(det))*3600.\n except:\n try:\n det = np.linalg.det(wcs.WCS(self.datain[0].header).wcs.pc)\n pscale = np.sqrt(np.abs(det))*3600.\n except:\n pscale = self.datain[0].header['PIXSCAL']\n #filtering out images which are too far away from the others\n #passing images added to a list of (image, WCS) tuples\n '''\n image_centers = []\n for f in self.datain:\n image_centers.append((f.header['CRVAL1'], f.header['CRVAL2']))\n filtered_datain = []\n dist_list = [[[0]*(len(image_centers)-1)]*len(image_centers)]\n for i in range(len(image_centers)):\n for j in range(len(image_centers)-1):\n dist_list[i][j+1] = np.sqrt((image_)**2+()**2)\n '''\n #calculations necessary for updating wcs information\n px = []\n py = []\n \n #in order to avoid NaN interactions, creating weight map\n weights=[]\n for f in self.datain:\n weights.append((np.where(np.isnan(f.image) == True, 0, 1)))\n \n for f in self.datain:\n px.extend(wcs.WCS(f.header).calc_footprint()[:,0])\n py.extend(wcs.WCS(f.header).calc_footprint()[:,1])\n x0 = (max(px)+min(px))/2.\n y0 = (max(py)+min(py))/2.\n sx = (max(px)-min(px))*np.cos(y0/180*np.pi) # arcsec\n sy = (max(py)-min(py)) # arcsec\n size = (sx*3600+self.getarg('pad')*2, sy*3600+self.getarg('pad')*2)\n xpix = size[0]//pscale\n ypix = size[1]//pscale\n cdelt = [pscale/3600.]*2\n \n #create self.dataout and give it a copy of an input's header\n self.dataout = DataFits(config = self.config)\n self.dataout.header = self.datain[0].header.copy()\n \n #update header wcs information\n self.log.info('Creating new WCS header')\n \n self.dataout.header['CRPIX1'] = xpix/2\n self.dataout.header['CRPIX2'] = ypix/2\n self.dataout.header['CRVAL1'] = x0\n self.dataout.header['CRVAL2'] = y0\n self.dataout.header['CD1_1'] = -cdelt[0]\n self.dataout.header['CD1_2'] = self.dataout.header['CD2_1'] = 0.\n self.dataout.header['CD2_2'] = cdelt[1]\n self.dataout.header['NAXIS1'] = int(xpix)\n self.dataout.header['NAXIS2'] = int(ypix)\n self.dataout.header['CTYPE1'] = 'RA---TAN-SIP'\n self.dataout.header['CTYPE2'] = 'DEC--TAN-SIP'\n self.dataout.header['RADESYS'] = 'ICRS'\n self.dataout.header['EQUINOX'] = 2000\n self.dataout.header['LATPOLE'] = self.datain[0].header['CRVAL2']\n self.dataout.header['LONPOLE'] = 180\n self.dataout.header['PIXASEC'] = pscale\n \n theta_rad = np.deg2rad(self.getarg('outangle'))\n rot_matrix = np.array([[np.cos(theta_rad), -np.sin(theta_rad)], \n [np.sin(theta_rad), np.cos(theta_rad)]])\n rot_cd = np.dot(rot_matrix, np.array([[self.dataout.header['CD1_1'], 0.],[0., self.dataout.header['CD2_2']]]))\n for i in [0,1]:\n for j in [0,1]:\n self.dataout.header['CD{0:d}_{1:d}'.format(i+1, j+1)] = rot_cd[i,j]\n \n #check drizzle arguments\n if self.getarg('kernel') == 'smoothing':\n kernel = 'lanczos3'\n elif self.getarg('kernel') in ['square', 'point', 'gaussian', 'tophat']:\n kernel = self.getarg('kernel')\n else:\n self.log.error('Kernel name not recognized, using default')\n kernel = 'square'\n if self.getarg('drizzleweights') == 'uniform':\n driz_wt = ''\n elif self.getarg('drizzleweights') in ['exptime', 'expsq']:\n driz_wt = self.getarg('drizzleweights')\n else:\n self.log.error('Drizzle weighting not recognized, using default')\n driz_wt = ''\n \n #create drizzle object and add input images\n fullwcs = wcs.WCS(self.dataout.header)\n self.log.info('Starting drizzle')\n driz = drz.Drizzle(outwcs = fullwcs, pixfrac=self.getarg('pixfrac'), \\\n kernel=kernel, fillval='10000', wt_scl=driz_wt)\n for i,f in enumerate(self.datain):\n self.log.info('Adding %s to drizzle stack' % f.filename)\n driz.add_image(f.imgdata[0], wcs.WCS(f.header), inwht=weights[i])\n \n try:\n fillval=float(self.getarg('fillval'))\n except:\n fillval=np.nan\n self.log.error('Fillvalue not recognized or missing, using default')\n \n #creates output fits file from drizzle output\n self.dataout.imageset(np.where(driz.outsci == 10000, fillval, driz.outsci))\n self.dataout.imageset(driz.outwht,'OutWeight', self.dataout.header)\n self.dataout.filename = self.datain[0].filename\n\n #add history\n self.dataout.setheadval('HISTORY','Coadd: %d files combined with %s kernel, pixfrac %f at %f times resolution' \\\n % (len(self.datain), kernel, self.getarg('pixfrac'), self.getarg('resolution')))","def custom_filter(image: Image) -> Image:\n image = image.filter(ImageFilter.Kernel(\n size=(3, 3), kernel=(1, 0, 1, 0, 0, 0, 1, 0, 1)))\n return image","def elastic_transform(image, alpha_param, sigma_param, alpha_affine_param, random_state=None):\n image = np.asarray(image)\n #im_np = im_np.transpose(1,0,2) # when we go from pil to numpy array the W and L dimensions are swaped\n\n if len(image.shape) < 3: # if there is less than 3 channels (black&white) we triplicate the image\n image = np.concatenate((image[:,:, np.newaxis], image[:,:, np.newaxis], image[:,:, np.newaxis]), axis = 2)\n\n alpha = image.shape[1] * alpha_param\n sigma = image.shape[1] * sigma_param\n alpha_affine = image.shape[1] * alpha_affine_param\n\n if random_state is None:\n random_state = np.random.RandomState(None)\n\n shape = image.shape\n shape_size = shape[:2]\n\n # Random affine\n center_square = np.float32(shape_size) // 2\n square_size = min(shape_size) // 3\n pts1 = np.float32([center_square + square_size, [center_square[0]+square_size, center_square[1]-square_size], center_square - square_size])\n pts2 = pts1 + random_state.uniform(-alpha_affine, alpha_affine, size=pts1.shape).astype(np.float32)\n M = cv2.getAffineTransform(pts1, pts2)\n image = cv2.warpAffine(image, M, shape_size[::-1], borderMode=cv2.BORDER_REFLECT_101)\n\n dx = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma) * alpha\n dy = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma) * alpha\n dz = np.zeros_like(dx)\n\n x, y, z = np.meshgrid(np.arange(shape[1]), np.arange(shape[0]), np.arange(shape[2]))\n indices = np.reshape(y+dy, (-1, 1)), np.reshape(x+dx, (-1, 1)), np.reshape(z, (-1, 1))\n\n im_elastic = map_coordinates(image, indices, order=1, mode='reflect').reshape(shape)\n\n return Image.fromarray(np.uint8(im_elastic))","def _pca(self):\n mean_beam = np.mean(self.beam_images, axis=1, keepdims=False)\n mask = self.mask\n beam_images = self.beam_images[:, :self.n_beam_images]\n\n # Subtract mean_beam from images and apply the mask. Element-wise\n # multiplication and subtraction using numpy broadcasting (as commented\n # out below) requires 3 large matrices in memory at an intermediate\n # point in the computation, namely right after (beam_images -\n # mean_beam_2d) is evaluated and memory for centered_masked_images is\n # allocated.\n # mask_2d = mask[:,np.newaxis]\n # mean_beam_2d = mean_beam[:,np.newaxis]\n # centered_masked_images = mask_2d * (beam_images - mean_beam_2d)\n\n # Instead of that direct approach, use self._center_and_mask_numba() or\n # self._center_and_mask_in_place(). As of this writing the _in_place\n # version is faster, but this may change in the future since the numba\n # version supports parallelization.\n centered_masked_images = self._center_and_mask_in_place(\n beam_images,\n mask,\n mean_beam,\n )\n # centered_masked_images should be C-contiguous already but it's good to\n # make sure.\n centered_masked_images = np.ascontiguousarray(centered_masked_images)\n\n # Compute the masked principal components\n # -1 since last eigenvector isn't necessarily orthogonal to the others.\n n_eigs = min(self.n_beam_images - 1, self.max_principal_components)\n n_eigs = max(n_eigs, 1) # Need at least one.\n # .T means transpose, @ means matrix multiplication.\n cov_mat = centered_masked_images.T @ centered_masked_images\n del centered_masked_images # Free up memory.\n if self.use_sparse_routines:\n variances, principal_components = eigsh(\n cov_mat, k=n_eigs, which='LM')\n else:\n eigvals_param = (\n self.n_beam_images - n_eigs,\n self.n_beam_images - 1)\n # overwrite_a might reduce memory usage\n variances, principal_components = eigh(\n cov_mat, eigvals=eigvals_param, overwrite_a=True)\n del cov_mat # Free up memory.\n\n # Reverse ordering to put largest eigenvectors/eigenvalues first\n principal_components = np.fliplr(principal_components)\n variances = np.flip(variances)\n\n # principal_components isn't always C-contiguous, and when it's not the\n # matrix multiplication below becomes extremely slow. It's much faster\n # to make it C-contiguous first so that numpy can use faster matrix\n # multiplication routines behind the scenes.\n principal_components = np.ascontiguousarray(principal_components)\n\n # Construct the un-masked basis vectors.\n centered_images = beam_images - mean_beam[:, np.newaxis]\n # centered_images should be C-contiguous already but it's good to make\n # sure.\n centered_images = np.ascontiguousarray(centered_images)\n principal_components = centered_images @ principal_components\n del centered_images # Free up memory.\n\n # As of this writing, self._normalize_vectorized() is faster than using\n # self._normalize_numba() despite the fact that the latter is uses numba\n # and allows for parallelization. That may change in the future though.\n principal_components = self._normalize_vectorized(\n principal_components,\n mask,\n )\n\n return mean_beam, principal_components, variances","def __call__(self, image: torch.Tensor) -> torch.Tensor:\n # Convert torch tensor to numpy array for scipy\n image = image.numpy()\n # Save basic shape\n shape = image.shape[1:]\n # Sample offsets\n dx = gaussian_filter((np.random.rand(*shape) * 2 - 1), self.sigma, mode=\"constant\", cval=0) * self.alpha\n dy = gaussian_filter((np.random.rand(*shape) * 2 - 1), self.sigma, mode=\"constant\", cval=0) * self.alpha\n x, y = np.meshgrid(np.arange(shape[0]), np.arange(shape[1]), indexing='ij')\n indices = np.reshape(x + dx, (-1, 1)), np.reshape(y + dy, (-1, 1))\n # Perform deformation\n for index in range(image.shape[0]):\n image[index] = map_coordinates(image[index], indices, order=1).reshape(shape)\n return torch.from_numpy(image)","def augment_image(im):\n # First crop out the face to save reduce computation load\n bb = im.landmarks['bb'].lms\n bb_vec = bb.as_vector()\n bb_ul = (np.array([bb_vec[0], bb_vec[1]]) - bb.centre()) * 2\n bb_lr = (np.array([bb_vec[4], bb_vec[5]]) - bb.centre()) * 2\n ul = bb_ul + bb.centre()\n lr = bb_lr + bb.centre()\n im = im.crop(ul, lr, constrain_to_boundary=True)\n if im.pixels.shape[0] == 1:\n pix = np.zeros((3, im.pixels.shape[1], im.pixels.shape[2]))\n pix[:,] = im.pixels\n im.pixels = pix\n\n beta = 0.3\n cx = np.random.uniform(-beta, beta)\n cy = np.random.uniform(-beta, beta)\n fx = 1.0\n fy = np.random.uniform(0.6, 1.4)\n max_rotation = 30\n theta = np.random.uniform(-max_rotation, max_rotation)\n\n rotation = menpo.transform.Rotation.init_from_2d_ccw_angle(theta)\n shear = menpo.transform.Affine(np.array([[1, cx, 0],[cy, 1, 0], [0,0,1]]))\n scale = menpo.transform.Affine(np.array([[fx, 0, 0],[0, fy, 0], [0,0,1]]))\n T = scale.compose_after(shear).compose_after(rotation)\n\n t_im = im.transform_about_centre(T)\n\n t_im = add_color_jetting(t_im)\n t_im = add_occlusion(t_im)\n\n\n new_bb = t_im.landmarks['PTS'].lms.bounding_box()\n\n #new_bb contains the gt bounding box\n augmented_bb = add_bb_noise(new_bb)\n augmented_bb = augmented_bb.reshape((4,2))\n augmented_bb = menpo.shape.PointCloud(augmented_bb)\n t_im.landmarks['bb'] = menpo.landmark.LandmarkGroup.init_with_all_label(augmented_bb)\n\n return t_im","def warp_channel(image, homography):\n\n\n boundings = compute_bounding_box(homography,image.shape[1],image.shape[0])\n x_vals = np.arange(boundings[0][0], boundings[1][0])\n y_vals = np.arange(boundings[0][1], boundings[1][1])\n x_vals,y_vals = np.meshgrid(x_vals,y_vals)\n\n x_vals_f, y_vals_f = x_vals.flatten(),y_vals.flatten()\n coor_lst = np.array([x_vals_f.tolist(),y_vals_f.tolist()])\n inv_hom = np.linalg.inv(homography)\n new_coor = apply_homography(coor_lst.transpose(),inv_hom).reshape(x_vals.shape[0],x_vals.shape[1],2)\n warped_im = map_coordinates(image,[new_coor[:, :, 1], new_coor[:, :, 0]],order=1,prefilter=False)\n return warped_im","def GenerateMapAffinity(img,nb_vertex,pointsInterest,objects_centroid,scale):\n\n # Apply the downscale right now, so the vectors are correct. \n img_affinity = Image.new(img.mode, (int(img.size[0]/scale),int(img.size[1]/scale)), \"black\")\n # Create the empty tensors\n totensor = transforms.Compose([transforms.ToTensor()])\n\n affinities = []\n for i_points in range(nb_vertex):\n affinities.append(torch.zeros(2,int(img.size[1]/scale),int(img.size[0]/scale)))\n \n for i_pointsImage in range(len(pointsInterest)): \n pointsImage = pointsInterest[i_pointsImage]\n center = objects_centroid[i_pointsImage]\n for i_points in range(nb_vertex):\n point = pointsImage[i_points]\n affinity_pair, img_affinity = getAfinityCenter(int(img.size[0]/scale),\n int(img.size[1]/scale),\n tuple((np.array(pointsImage[i_points])/scale).tolist()),\n tuple((np.array(center)/scale).tolist()), \n img_affinity = img_affinity, radius=1)\n\n affinities[i_points] = (affinities[i_points] + affinity_pair)/2\n\n\n # Normalizing\n v = affinities[i_points].numpy() \n \n xvec = v[0]\n yvec = v[1]\n\n norms = np.sqrt(xvec * xvec + yvec * yvec)\n nonzero = norms > 0\n\n xvec[nonzero]/=norms[nonzero]\n yvec[nonzero]/=norms[nonzero]\n\n affinities[i_points] = torch.from_numpy(np.concatenate([[xvec],[yvec]]))\n affinities = torch.cat(affinities,0)\n\n return affinities","def setUp(self):\n test_file_1 = path.join(\n path.dirname(datasets.__file__), \"twod_image_1.npy\"\n )\n\n original_image = np.load(test_file_1)\n\n # get a single tile from the image to test\n # note this image is currently unpadded.\n # how many boundary elements are needed to pad?\n extracted_image = original_image[0:32, 0:32]\n\n self.img = np.expand_dims(extracted_image, axis=-1)\n\n # Don't make this too huge for brevity.\n self.J = 3\n # 0 = no overlap etc.\n self.overlap_log_2 = 0\n # apply to all available orders\n self.order = 3\n # Should be one or more to avoid aliasing, if you want overlapping\n # tiles this can increase too.\n self.oversampling = 1\n\n self.num_angles = 3\n self.angles = tuple(\n [\n 90.0\n - np.rad2deg(\n (int(self.num_angles - self.num_angles / 2 - 1) - theta)\n * np.pi\n / self.num_angles\n )\n for theta in range(self.num_angles)\n ]\n )\n\n # details of the input data\n self.sample_rate = 0.004 * 3\n\n # vanilla filter bank\n wavelets = [\n vanilla_morlet_2d(self.sample_rate, j=i) for i in range(0, self.J)\n ]\n father_wavelet = vanilla_gabor_2d(self.sample_rate, j=self.J)\n\n # extract the kernels of each of the wavelets for manual convolution\n # we'll test using three different angles that we used to create the\n # transform above.\n wav1 = wavelets[0]\n wav2 = wavelets[1]\n wav3 = wavelets[2]\n\n # extract the kernels of each of the wavelets for manual convolution\n # we'll test using three different angles that we used to create the\n # transform above.\n wav1_k = wav1.kernel(self.angles[0])\n wav2_k = wav2.kernel(self.angles[1])\n wav3_k = wav3.kernel(self.angles[2])\n\n phi = father_wavelet.kernel(0.0)\n\n npad = 31\n img_pad = np.pad(\n self.img, ((npad, npad), (npad, npad), (0, 0)), mode=\"reflect\"\n )\n # get numpy array of the test input image\n x = img_pad[:, :, 0]\n\n # manual convolution, |x * psi_1|\n conv = np.abs(convolve2d(x, wav1_k, mode=\"same\"))\n conv2 = np.abs(convolve2d(conv, wav2_k, mode=\"same\"))\n conv3 = np.abs(convolve2d(conv2, wav3_k, mode=\"same\"))\n\n # unpad the original image, and convolve with the phi\n # note that the dimensions for phi are one less than the\n # conv result, so we get a 4x4 result. Take the first one\n self.manual_result1 = convolve2d(\n conv[npad:-npad, npad:-npad], phi.real, mode=\"valid\"\n )[0, 0]\n self.manual_result2 = convolve2d(\n conv2[npad:-npad, npad:-npad], phi.real, mode=\"valid\"\n )[0, 0]\n self.manual_result3 = convolve2d(\n conv3[npad:-npad, npad:-npad], phi.real, mode=\"valid\"\n )[0, 0]","def GenerateMapAffinity(img, nb_vertex, pointsInterest, objects_centroid, scale):\n\n # Apply the downscale right now, so the vectors are correct.\n img_affinity = Image.new(img.mode, (int(img.size[0] / scale), int(img.size[1] / scale)), \"black\")\n # Create the empty tensors\n totensor = transforms.Compose([transforms.ToTensor()])\n\n affinities = []\n for i_points in range(nb_vertex):\n affinities.append(torch.zeros(2, int(img.size[1] / scale), int(img.size[0] / scale)))\n\n for i_pointsImage in range(len(pointsInterest)):\n pointsImage = pointsInterest[i_pointsImage]\n center = objects_centroid[i_pointsImage]\n for i_points in range(nb_vertex):\n point = pointsImage[i_points]\n affinity_pair, img_affinity = getAfinityCenter(int(img.size[0] / scale),\n int(img.size[1] / scale),\n tuple((np.array(pointsImage[i_points]) / scale).tolist()),\n tuple((np.array(center) / scale).tolist()),\n img_affinity=img_affinity, radius=1)\n\n affinities[i_points] = (affinities[i_points] + affinity_pair) / 2\n\n # Normalizing\n v = affinities[i_points].numpy()\n\n xvec = v[0]\n yvec = v[1]\n\n norms = np.sqrt(xvec * xvec + yvec * yvec)\n nonzero = norms > 0\n\n xvec[nonzero] /= norms[nonzero]\n yvec[nonzero] /= norms[nonzero]\n\n affinities[i_points] = torch.from_numpy(np.concatenate([[xvec], [yvec]]))\n affinities = torch.cat(affinities, 0)\n\n return affinities","def convolve_im(im: np.array,\n kernel: np.array,\n verbose=True):\n ### START YOUR CODE HERE ### (You can change anything inside this block)\n \"\"\"\n\tcompared to the 4a solution this just adds padding to the filter if its smaller than the image\n\tthis is done by using the second parameter in fft.fft2 \n\t\n\tfirst it applies fourier transforms on the kernel and the image\n\tthen it sets the image to be the pointwise multiplication of the transforms\n\n the image is inverse fourier transformed and filtered for real values\n the domain image is shifted and taken the absolute value of\n the fourier transform of the image and kernel are also shifted and set to be the absolute value\n\tlastly everything is displayed in the subplots\n \"\"\"\n conv_result = im \n \n if verbose:\n fftKernel=np.fft.fft2(kernel,im.shape)\n fftImage=np.fft.fft2(conv_result)\n\t\t\n\t\t\n\t\t\n conv_result=np.multiply(fftImage,fftKernel)\n fftImageTransformed=conv_result\n\t\t\n \n conv_result=np.fft.ifft2(conv_result)\n \n conv_result=np.real(conv_result)\n\n fftImageTransformed=np.fft.fftshift(fftImageTransformed)\n fftImage=np.fft.fftshift(fftImage)\n fftKernel=np.fft.fftshift(fftKernel)\n\n fftImageTransformed=np.absolute(fftImageTransformed)\n fftImage=np.absolute(fftImage)\n fftKernel=np.absolute(fftKernel)\n\t\t\n\t\t\n # Use plt.subplot to place two or more images beside eachother\n plt.figure(figsize=(20, 4))\n # plt.subplot(num_rows, num_cols, position (1-indexed))\n plt.subplot(1, 5, 1)\n plt.imshow(im, cmap=\"gray\")\n plt.subplot(1, 5, 2)\n plt.imshow(fftImage, cmap=\"gray\")\n plt.subplot(1, 5, 3)\n plt.imshow(fftKernel, cmap=\"gray\")\n plt.subplot(1, 5, 4)\n plt.imshow(fftImageTransformed, cmap=\"gray\")\n plt.subplot(1, 5, 5)\n plt.imshow(conv_result, cmap=\"gray\")\n ### END YOUR CODE HERE ###\n return conv_result","def PA_SB_Zx_func(data, weit_data, pix_size, cx, cy, z0, R_bins):\n\tDa0 = Test_model.angular_diameter_distance(z0).value ## in unit 'Mpc'\n\tNx = data.shape[1]\n\tNy = data.shape[0]\n\tx0 = np.linspace(0, Nx-1, Nx)\n\ty0 = np.linspace(0, Ny-1, Ny)\n\tpix_id = np.array(np.meshgrid(x0,y0))\n\n\t#..center pixel point\n\tdev_05_x = cx - np.int( cx )\n\tdev_05_y = cy - np.int( cy )\n\n\tif dev_05_x > 0.5:\n\t\txn = np.int( cx ) + 1\n\telse:\n\t\txn = np.int( cx )\n\n\tif dev_05_y > 0.5:\n\t\tyn = np.int( cy ) + 1\n\telse:\n\t\tyn = np.int( cy )\n\n\ttheta = np.arctan2((pix_id[1,:] - yn), (pix_id[0,:] - xn))\n\tchi = theta * 180 / np.pi\n\n\trbin = R_bins # have been divided bins, in unit of pixels\n\tset_r = rbin * pix_size * Da0 * 1e3 / rad2arcsec # in unit of kpc\n\n\n\t#. surface brightness along the row direction\n\tintens_r_h = np.zeros(len(rbin), dtype = np.float)\n\tintens_h = np.zeros(len(rbin), dtype = np.float)\n\tintens_h_err = np.zeros(len(rbin), dtype = np.float)\n\n\tN_pix_h = np.zeros(len(rbin), dtype = np.float)\n\tnsum_ratio_h = np.zeros(len(rbin), dtype = np.float)\n\n\n\t#. surface brightness along the column direction\n\tintens_r_v = np.zeros(len(rbin), dtype = np.float)\n\tintens_v = np.zeros(len(rbin), dtype = np.float)\n\tintens_v_err = np.zeros(len(rbin), dtype = np.float)\n\n\tN_pix_v = np.zeros(len(rbin), dtype = np.float)\n\tnsum_ratio_v = np.zeros(len(rbin), dtype = np.float)\n\n\n\t#. surface brightness along the diagonal direction\n\tintens_r_d = np.zeros(len(rbin), dtype = np.float)\n\tintens_d = np.zeros(len(rbin), dtype = np.float)\n\tintens_d_err = np.zeros(len(rbin), dtype = np.float)\t\n\n\tN_pix_d = np.zeros(len(rbin), dtype = np.float)\n\tnsum_ratio_d = np.zeros(len(rbin), dtype = np.float)\n\n\n\tdr = np.sqrt( ( (2*pix_id[0] + 1) / 2 - (2*xn + 1) / 2)**2 + ( (2*pix_id[1] + 1) / 2 - (2*yn + 1) / 2)**2)\n\tdiff_x = (2 * pix_id[0] + 1) / 2 - (2 * xn + 1) / 2\n\tdiff_y = (2 * pix_id[1] + 1) / 2 - (2 * yn + 1) / 2\n\n\n\tfor k in range(len(rbin) - 1):\n\n\t\tcdr = rbin[k + 1] - rbin[k]\n\t\td_phi = (cdr / ( 0.5 * (rbin[k] + rbin[k + 1]) ) ) * 180 / np.pi\n\t\tN_phi = np.int(360 / d_phi) + 1\n\t\tphi = np.linspace(0, 360, N_phi)\n\t\tphi = phi - 180\n\n\t\tr_iner = set_r[k] ## useing radius in unit of kpc\n\t\tr_out = set_r[k + 1]\n\n\t\tir = (dr >= rbin[k]) & (dr < rbin[k + 1])\n\t\tbool_sum = np.sum(ir)\n\n\t\tif bool_sum == 0:\n\t\t\tintens_r_h[k] = 0.5 * (r_iner + r_out) # in unit of kpc\n\t\t\tintens_r_v[k] = 0.5 * (r_iner + r_out) # in unit of kpc\n\t\t\tintens_r_d[k] = 0.5 * (r_iner + r_out) # in unit of kpc\n\n\t\t\tcontinue\n\n\t\telse:\n\t\t\t#. points located in radius bin\n\t\t\tid_vx = (dr >= rbin[k]) & (dr < rbin[k + 1])\n\n\n\t\t\t##. points along the row direction\n\t\t\tid_ux_0 = np.abs( diff_x ) < rbin[ k ]\n\t\t\tid_uy_0 = ( np.abs( diff_y ) >= rbin[ k ] ) & ( np.abs( diff_y ) < rbin[ k+1 ] )\n\t\t\tid_lim_0 = ( id_ux_0 & id_uy_0 ) & id_vx\n\n\t\t\tweit_arr_0 = weit_data[ id_lim_0 ]\n\n\t\t\tsamp_flux = data[ id_lim_0 ]\n\t\t\tsamp_chi = chi[ id_lim_0 ]\n\t\t\ttot_flux = np.nansum( samp_flux * weit_arr_0 ) / np.nansum( weit_arr_0 )\n\n\t\t\tidnn = np.isnan( samp_flux )\n\t\t\tN_pix_v[ k ] = np.sum( idnn == False )\n\t\t\tnsum_ratio_v[ k ] = np.nansum( weit_arr_0 ) / np.sum( idnn == False )\t\t\t\n\n\t\t\tintens_v[ k ] = tot_flux\n\t\t\tcen_r = np.nansum( dr[ id_lim_0 ] * weit_arr_0 ) / np.nansum( weit_arr_0 ) * pix_size\n\t\t\tintens_r_v[ k ] = cen_r * Da0 * 1e3 / rad2arcsec\n\n\t\t\ttmpf = []\n\t\t\tfor tt in range(len(phi) - 1):\n\n\t\t\t\tiv = (samp_chi >= phi[tt]) & (samp_chi <= phi[tt+1])\n\n\t\t\t\tif np.sum( iv ) == 0:\n\t\t\t\t\tcontinue\n\n\t\t\t\telse:\n\t\t\t\t\tset_samp = samp_flux[ iv ]\n\t\t\t\t\tset_weit = weit_arr_0[ iv ]\n\n\t\t\t\t\tttf = np.nansum( set_samp * set_weit ) / np.nansum( set_weit )\n\t\t\t\t\ttmpf.append( ttf )\n\n\t\t\t# rms of flux\n\t\t\ttmpf = np.array( tmpf )\n\t\t\tid_inf = np.isnan( tmpf )\n\t\t\ttmpf[ id_inf ] = np.nan\n\t\t\tid_zero = tmpf == 0\n\t\t\ttmpf[id_zero] = np.nan\n\n\t\t\tid_nan = np.isnan( tmpf )\n\t\t\tid_fals = id_nan == False\n\t\t\tTmpf = tmpf[ id_fals ]\n\n\t\t\tRMS = np.std(Tmpf)\n\n\t\t\tif len(Tmpf) > 1:\n\t\t\t\tintens_v_err[k] = RMS / np.sqrt(len(Tmpf) - 1)\n\t\t\telse:\n\t\t\t\tintens_v_err[k] = RMS\n\n\n\t\t\t##. points along the columns direction\n\t\t\tid_ux_1 = np.abs( diff_y ) < rbin[ k ]\n\t\t\tid_uy_1 = ( np.abs( diff_x ) >= rbin[ k ] ) & ( np.abs( diff_x ) < rbin[ k+1 ] )\n\t\t\tid_lim_1 = ( id_ux_1 & id_uy_1 ) & id_vx\n\n\t\t\tweit_arr_1 = weit_data[ id_lim_1 ]\n\n\t\t\tsamp_flux = data[ id_lim_1 ]\n\t\t\tsamp_chi = chi[ id_lim_1 ]\n\t\t\ttot_flux = np.nansum( samp_flux * weit_arr_1 ) / np.nansum( weit_arr_1 )\n\n\t\t\tidnn = np.isnan( samp_flux )\n\t\t\tN_pix_h[ k ] = np.sum( idnn == False )\n\t\t\tnsum_ratio_h[ k ] = np.nansum( weit_arr_1 ) / np.sum( idnn == False )\t\t\t\n\n\t\t\tintens_h[ k ] = tot_flux\n\t\t\tcen_r = np.nansum( dr[ id_lim_1 ] * weit_arr_1 ) / np.nansum( weit_arr_1 ) * pix_size\n\t\t\tintens_r_h[ k ] = cen_r * Da0 * 1e3 / rad2arcsec\n\n\t\t\ttmpf = []\n\t\t\tfor tt in range(len(phi) - 1):\n\n\t\t\t\tiv = (samp_chi >= phi[tt]) & (samp_chi <= phi[tt+1])\n\n\t\t\t\tif np.sum( iv ) == 0:\n\t\t\t\t\tcontinue\n\n\t\t\t\telse:\n\t\t\t\t\tset_samp = samp_flux[ iv ]\n\t\t\t\t\tset_weit = weit_arr_1[ iv ]\n\n\t\t\t\t\tttf = np.nansum( set_samp * set_weit ) / np.nansum( set_weit )\n\t\t\t\t\ttmpf.append( ttf )\n\n\t\t\t# rms of flux\n\t\t\ttmpf = np.array( tmpf )\n\t\t\tid_inf = np.isnan( tmpf )\n\t\t\ttmpf[ id_inf ] = np.nan\n\t\t\tid_zero = tmpf == 0\n\t\t\ttmpf[id_zero] = np.nan\n\n\t\t\tid_nan = np.isnan( tmpf )\n\t\t\tid_fals = id_nan == False\n\t\t\tTmpf = tmpf[ id_fals ]\n\n\t\t\tRMS = np.std(Tmpf)\n\n\t\t\tif len(Tmpf) > 1:\n\t\t\t\tintens_h_err[k] = RMS / np.sqrt(len(Tmpf) - 1)\n\t\t\telse:\n\t\t\t\tintens_h_err[k] = RMS\n\n\n\t\t\t##. points along the diagonal direction\n\t\t\tid_qx = ( np.abs( diff_x ) <= rbin[ k ] ) & ( np.abs( diff_y ) <= rbin[ k ] )\n\t\t\tid_lim_2 = id_qx & id_vx\n\n\t\t\tweit_arr_2 = weit_data[ id_lim_2 ]\n\n\t\t\tsamp_flux = data[ id_lim_2 ]\n\t\t\tsamp_chi = chi[ id_lim_2 ]\n\t\t\ttot_flux = np.nansum( samp_flux * weit_arr_2 ) / np.nansum( weit_arr_2 )\n\n\t\t\tidnn = np.isnan( samp_flux )\n\t\t\tN_pix_d[ k ] = np.sum( idnn == False )\n\t\t\tnsum_ratio_d[ k ] = np.nansum( weit_arr_2 ) / np.sum( idnn == False )\t\t\t\n\n\t\t\tintens_d[ k ] = tot_flux\n\t\t\tcen_r = np.nansum( dr[ id_lim_2 ] * weit_arr_2 ) / np.nansum( weit_arr_2 ) * pix_size\n\t\t\tintens_r_d[ k ] = cen_r * Da0 * 1e3 / rad2arcsec\n\n\t\t\ttmpf = []\n\t\t\tfor tt in range(len(phi) - 1):\n\n\t\t\t\tiv = (samp_chi >= phi[tt]) & (samp_chi <= phi[tt+1])\n\n\t\t\t\tif np.sum( iv ) == 0:\n\t\t\t\t\tcontinue\n\n\t\t\t\telse:\n\t\t\t\t\tset_samp = samp_flux[ iv ]\n\t\t\t\t\tset_weit = weit_arr_2[ iv ]\n\n\t\t\t\t\tttf = np.nansum( set_samp * set_weit ) / np.nansum( set_weit )\n\t\t\t\t\ttmpf.append( ttf )\n\n\t\t\t# rms of flux\n\t\t\ttmpf = np.array( tmpf )\n\t\t\tid_inf = np.isnan( tmpf )\n\t\t\ttmpf[ id_inf ] = np.nan\n\t\t\tid_zero = tmpf == 0\n\t\t\ttmpf[id_zero] = np.nan\n\n\t\t\tid_nan = np.isnan( tmpf )\n\t\t\tid_fals = id_nan == False\n\t\t\tTmpf = tmpf[ id_fals ]\n\n\t\t\tRMS = np.std(Tmpf)\n\n\t\t\tif len(Tmpf) > 1:\n\t\t\t\tintens_d_err[k] = RMS / np.sqrt(len(Tmpf) - 1)\n\t\t\telse:\n\t\t\t\tintens_d_err[k] = RMS\n\n\t#..\n\tidzo = N_pix_h < 1\n\n\tSB_h = intens_h.copy()\n\tSB_h[idzo] = 0.\n\tSB_h_err = intens_h_err.copy()\n\tSB_h_err[idzo] = 0.\n\n\tSB_h_R = intens_r_h.copy()\n\tnsum_ratio_h[idzo] = 0.\n\tSB_h, SB_h_err = SB_h / pix_size**2, SB_h_err / pix_size**2\n\n\n\tidzo = N_pix_v < 1\n\n\tSB_v = intens_v.copy()\n\tSB_v[idzo] = 0.\n\tSB_v_err = intens_v_err.copy()\n\tSB_v_err[idzo] = 0.\n\n\tSB_v_R = intens_r_v.copy()\n\tnsum_ratio_v[idzo] = 0.\n\tSB_v, SB_v_err = SB_v / pix_size**2, SB_v_err / pix_size**2\n\n\n\tidzo = N_pix_d < 1\n\n\tSB_d = intens_d.copy()\n\tSB_d[idzo] = 0.\n\tSB_d_err = intens_d_err.copy()\n\tSB_d_err[idzo] = 0.\n\n\tSB_d_R = intens_r_d.copy()\n\tnsum_ratio_d[idzo] = 0.\n\tSB_d, SB_d_err = SB_d / pix_size**2, SB_d_err / pix_size**2\n\n\n\th_array = [ SB_h_R, SB_h, SB_h_err, N_pix_h, nsum_ratio_h ]\n\tv_array = [ SB_v_R, SB_v, SB_v_err, N_pix_v, nsum_ratio_v ]\n\td_array = [ SB_d_R, SB_d, SB_d_err, N_pix_d, nsum_ratio_d ]\n\n\treturn h_array, v_array, d_array","def elasticTransform_legacy(image, mask, sigma, alpha_affine, random_seed=None):\n\t\n\trandom_state = np.random.RandomState(random_seed)\n\t\n\tif len(image.shape)<3:\n\t\timage = np.expand_dims(image,-1)\n\tif len(mask.shape)<3:\n\t\tmask = np.expand_dims(mask,-1)\n\t\n\tshape = image.shape\n\tshape_size = shape[:2]\n\n\t# Random affine\n\tcenter_square = np.float32(shape_size) // 2\n\tsquare_size = min(shape_size) // 3\n\tpts1 = np.float32([center_square + square_size, [center_square[0] + square_size,center_square[1] - square_size], center_square - square_size])\n\tpts2 = pts1 + random_state.uniform(-alpha_affine,alpha_affine, size=pts1.shape).astype(np.float32)\n\t\n\tM = cv2.getAffineTransform(pts1, pts2)\n\t\n\timage_w = np.zeros_like(image)\n\tfor i in range(image.shape[-1]):\n\t\timage_w[...,i] = cv2.warpAffine(image[...,i], M, shape_size[::-1], borderMode=cv2.BORDER_CONSTANT, borderValue=int(np.min(image[...,i])))\n\t\n\tmask_w = np.zeros_like(mask)\n\tfor i in range(mask.shape[-1]):\n\t\tmask_w[...,i] = cv2.warpAffine(mask[...,i] , M, shape_size[::-1], borderMode=cv2.BORDER_REPLICATE)\n\n\tblur_size = int(2*sigma) | 1\n\tdx = cv2.GaussianBlur((random_state.rand(*shape) * 2 - 1), ksize=(blur_size, blur_size), sigmaX=sigma)\n\tdy = cv2.GaussianBlur((random_state.rand(*shape) * 2 - 1), ksize=(blur_size, blur_size), sigmaX=sigma)\n\t\n\tif len(dx.shape) < 3:\n\t\tdx = np.expand_dims(dx,-1)\n\t\tdy = np.expand_dims(dy,-1)\n\n\tgx, gy = np.meshgrid(np.arange(shape_size[1]), np.arange(shape_size[0]))\n\tgx = np.expand_dims(gx,-1)\n\tgy = np.expand_dims(gy,-1)\n\n\tgx = np.repeat(gx,dx.shape[-1], -1)\n\tgy = np.repeat(gy,dy.shape[-1], -1)\n\n\tgx = (gx + dx).astype(np.float32)\n\tgy = (gy + dy).astype(np.float32)\n\n\timage_d = np.zeros_like(image_w)\n\tmask_d = np.zeros_like(mask_w)\n\n\tfor i in range(image.shape[-1]):\n\t\timage_d[...,i] = cv2.remap(image_w[...,i], gx[...,i], gy[...,i], interpolation=cv2.INTER_LINEAR)\n\t\n\tradix = gx.shape[-1]\n\tfor i in range(mask.shape[-1]):\n\t\tmask_d[...,i] = cv2.remap(mask_w[...,i], gx[...,i%radix], gy[...,i%radix], interpolation=cv2.INTER_LINEAR)\n\t\n\treturn image_d, mask_d","def applyIncidenceFilter(image, bandNames, classDictionary, numChangesCutoff = 8, connectedPixelCutoff=6):\n #Calculate the number of times a pixel changes throughout the time series and determine if it is over the numChangesCutoff\n num_changes = calculateNumberOfChanges(image, bandNames)\n too_many_changes = num_changes.gt(numChangesCutoff)\n \n #Get binary images of the land cover classifications for the current year\n binary_class_images = npv.convertClassificationsToBinaryImages(image, classDictionary)\n \n #Calculate the number of connected pixels for each land cover class and year, reduce to a single band image representing the number\n #of connected pixels of the same land cover class as the central pixel, and determine if it is over the connectedPixelCutoff\n connected_pixel_count = ee.ImageCollection(binary_class_images.map(lambda x: x.mask(x).connectedPixelCount(100,False).reduce(ee.Reducer.sum()).lt(connectedPixelCutoff)))\n \n #Get a bitwiseAnd determination if the number of connected pixels <= connectedPixelCutoff and the number of changes > numChangesCutoff \n incidence_filter = ee.ImageCollection(connected_pixel_count.map(lambda x: x.bitwiseAnd(too_many_changes))).toBands().rename(bandNames)\n \n #Get an image that represents the mode of the land cover classes in each pixel\n mode_image = image.reduce(ee.Reducer.mode())\n \n #Replace pixels of image where incidence_filter is True with mode_image\n incidence_filtered = image.where(incidence_filter, mode_image)\n \n return incidence_filtered","def preprocess(self, img):\n undistorted = undistort(img, self.mtx, self.dist)\n warped = warp(self.transform_matrix, undistorted)\n binary_img = binarize(warped, s_thres=(100, 255), l_thres=(50, 255))\n return binary_img","def normalise(image):","def azizen(self):\n # x0,y0 array pixel coordinates relative to cx,cy\n# ndy0,ndx0=img.shape\n ndy0=self.ndy0\n ndx0=self.ndx0\n x0,y0=np.meshgrid(np.linspace(0,ndx0-1,ndx0)-self.cx,np.linspace(0,ndy0-1,ndy0)-self.cy)\n r0=np.sqrt(x0**2+y0**2)/self.pr0 # fractional radial distance from 0,0\n# self.roi=np.s_[ystart:ystart+self.ny0,xstart:xstart+self.nx0]\n # why not model the zenith angle dependence with polynomial directly\n # rather than linear interpolation between roots.\n roots=np.zeros(51)\n rr=np.arange(51)/100.0\n for i,ref in enumerate(rr):\n roots[i]=np.real(np.roots([self.c3,0,self.c2,0,self.c1,-ref])[-1])\n theta0 = np.interp(r0/2,rr,roots)\n \n phi0 = np.arctan2(x0,y0) - self.rot ####phi (i.e., azimuth) is reckoned with -pi corresponding to north, increasing clockwise, NOTE: pysolar use sub-standard definition\n phi0 = phi0%(2*np.pi)\n\n #####correction for the tilt of the camera\n k=np.array((np.sin(self.azm),np.cos(self.azm),0))\n a=np.array([np.sin(theta0)*np.cos(phi0),np.sin(theta0)*np.sin(phi0),np.cos(theta0)]); \n a = np.transpose(a,[1,2,0])\n b=np.cos(self.beta)*a + np.sin(self.beta)*np.cross(k,a,axisb=2) \\\n + np.reshape(np.outer(np.dot(a,k),k),(self.ndy0,self.ndx0,3))*(1-np.cos(self.beta))\n theta0=np.arctan(np.sqrt(b[:,:,0]**2+b[:,:,1]**2)/b[:,:,2])\n phi0=np.arctan2(b[:,:,1],b[:,:,0])%(2*np.pi)\n# max_theta *= deg2rad \n# valid0 = (theta0<max_theta) & (theta0>0); \n# theta0[valid0]=np.nan;\n self.theta0,self.phi0=theta0,phi0","def filtering(self):\r\n # 1 ###########################################################################################################\r\n fft_image = np.fft.fft2(self.image)\r\n # 2 ###########################################################################################################\r\n fft_shift_image = np.fft.fftshift(fft_image)\r\n\r\n ###\r\n mag_dft = np.log(np.abs(fft_shift_image))\r\n mag_dft = (255 * (mag_dft / np.max(mag_dft))).astype(dtype='uint8')\r\n ###\r\n\r\n # 3 ###########################################################################################################\r\n if self.filter_name == 'butterworth_l' or self.filter_name == 'butterworth_h':\r\n mask = self.filter(fft_shift_image.shape, self.cutoff, self.order)\r\n else:\r\n mask = self.filter(fft_shift_image.shape, self.cutoff)\r\n # 4 ###########################################################################################################\r\n # multiply the dft (fft shift image) by the mask\r\n filtered_image = fft_shift_image * mask\r\n\r\n ###\r\n mag_filtered_image = mag_dft * mask\r\n ###\r\n\r\n # 5 ###########################################################################################################\r\n inverse_fft_shift_image = np.fft.ifftshift(filtered_image)\r\n # 6 ###########################################################################################################\r\n inverse_fft_image = np.fft.ifft2(inverse_fft_shift_image)\r\n # 7 ###########################################################################################################\r\n mag_image = np.zeros(inverse_fft_image.shape, dtype=complex)\r\n for i in range(inverse_fft_image.shape[0]):\r\n for j in range(inverse_fft_image.shape[1]):\r\n if inverse_fft_image[i][j] < 0:\r\n mag_image[i][j] = -1 * inverse_fft_image[i][j]\r\n else:\r\n mag_image[i][j] = inverse_fft_image[i][j]\r\n # magnitude of inverse fft is complete\r\n # 8 ###########################################################################################################\r\n full_contrast_image = self.post_process_image(mag_image)\r\n\r\n return [mag_dft, mag_filtered_image, full_contrast_image]","def _apply_cz(self, state, axes, **kwargs):\n ndim = self._ndim(state)\n sl_0 = _get_slice(0, axes[0], ndim)\n sl_1 = _get_slice(1, axes[0], ndim)\n\n if axes[1] > axes[0]:\n target_axes = [axes[1] - 1]\n else:\n target_axes = [axes[1]]\n\n state_z = self._apply_z(state[sl_1], axes=target_axes)\n return self._stack([state[sl_0], state_z], axis=axes[0])","def zncc(template, image):\n std_template = np.std(template)\n if std_template == 0:\n return 0\n\n std_image = np.std(image)\n if std_image == 0:\n return 0\n\n template_t = template - np.mean(template)\n image_t = image - np.mean(image)\n\n cross_correlation = np.mean(np.multiply(template_t, image_t)) / (std_template * std_image)\n return cross_correlation","def testComputeImage(self):\n for fiberId in self.detMap.fiberId:\n for fraction in (0.1, 0.5, 0.9):\n yy = self.synthConfig.height*fraction\n if yy == int(yy):\n # Ensure we have a non-integer pixel position,\n # so computeImage and computeKernelImage differ\n yy += 0.5\n wavelength = self.detMap.findWavelength(fiberId, yy)\n image = self.psf.computeImage(fiberId, wavelength)\n kernel = self.psf.computeKernelImage(fiberId, wavelength)\n\n # Image should have xy0 set somewhere in the middle of the larger image\n self.assertNotEqual(image.getX0(), 0)\n self.assertNotEqual(image.getY0(), 0)\n\n # Kernel should have xy0 set to the half-size\n halfSize = (self.size - 1)//2\n self.assertEqual(kernel.getX0(), -halfSize)\n self.assertEqual(kernel.getY0(), -halfSize)\n\n # Centroid on image should be at the point of interest\n xx, yy = self.detMap.findPoint(fiberId, wavelength)\n centroid = calculateCentroid(image)\n self.assertFloatsAlmostEqual(xx, centroid.x, atol=2.0e-2)\n self.assertFloatsAlmostEqual(yy, centroid.y, atol=2.0e-2)\n\n # Centroid on kernel should be zero\n centroid = calculateCentroid(kernel)\n self.assertFloatsAlmostEqual(centroid.x, 0.0, atol=1.0e-7)\n self.assertFloatsAlmostEqual(centroid.y, 0.0, atol=1.0e-7)","def kalman_filter(x, x_cov, u, u_cov, Z, z_cov):\n for i in range(len(Z)):\n x, x_cov = predict_new_belief(x, x_cov, u, u_cov)\n x, x_cov = incorporate_measurement(x, x_cov, Z[i], z_cov)\n\n return x, x_cov","def ACS_zeropoint(image):\n logging.debug('Calculating zeropoint for {}'.format(image))\n\n PHOTFLAM = fits.getheader(image,1)['PHOTFLAM']\n PHOTPLAM = fits.getheader(image,1)['PHOTPLAM']\n\n ABMAG_ZEROPOINT=-2.5*np.log10(PHOTFLAM)-5*np.log10(PHOTPLAM)-2.408\n\n return ABMAG_ZEROPOINT","def stfbss(X,nsources=5,ng=2**5-1,nh=2**9-1,tstep=2**6-1,df=1.0,nfbins=2**10,\r\n tftol=1.E-8,normalize=True):\r\n \r\n \r\n #get shape of timeseries matrix, \r\n #m=number of channels\r\n #tlen=length of timeseries\r\n m,maxn=X.shape\r\n \r\n n=nsources\r\n #get number of time bins\r\n ntbins=int(float(maxn)/tstep)\r\n \r\n tfkwargs={'ng':ng,'nh':nh,'df':df,'nfbins':nfbins,'tstep':tstep}\r\n \r\n \r\n #remove dc component from time series and normalize\r\n if normalize==True:\r\n for ii in range(m):\r\n X[ii,:]=X[ii,:]-np.mean(X[ii,:])\r\n X[ii,:]=X[ii,:]/X[ii,:].std() \r\n \r\n #===============================================================================\r\n # Whiten data and Compute Whitening matrix\r\n #===============================================================================\r\n #whiten data to get a unitary matrix with unit variance and zero mean\r\n #compute covariance matrix\r\n Rxx=(np.dot(X,X.T))/float(maxn)\r\n \r\n #calculate eigen decomposition\r\n [l,u]=np.linalg.eig(Rxx)\r\n \r\n #sort eigenvalues from smallest to largest assuming largest are sources and \r\n #smallest are noise\r\n lspot=l.argsort()\r\n eigval=l[lspot]\r\n eigvec=u[:,lspot]\r\n \r\n #calculate the noise variance as mean of non-principal components\r\n sigman=np.mean(eigval[0:m-n])\r\n \r\n #compute scaling factor for whitening matrix\r\n wscale=1/np.sqrt(eigval[m-n:m]-sigman)\r\n \r\n #compute whitening matrix\r\n W=np.zeros((m,n))\r\n for kk in range(n):\r\n W[:,kk]=wscale[kk]*eigvec[:,m-n+kk].T\r\n W=W.T\r\n #compute whitened signal vector. Note the dimensionality is reduced from [mxn] \r\n #to [nxn] making the computation simpler.\r\n Z=np.dot(W,X)\r\n \r\n #===============================================================================\r\n # Compute Spatial Time Frequency Distribution\r\n #===============================================================================\r\n \r\n stfd=np.zeros((n,n,nfbins,ntbins+1),dtype='complex128')\r\n Za=np.array(Z.copy())\r\n #compute auto terms\r\n for ii in range(n):\r\n pswvd,tswvd,fswvd=spwvd(Za[ii].reshape(maxn),**tfkwargs)\r\n stfd[ii,ii,:,:]=pswvd\r\n \r\n #compute cross terms\r\n for jj in range(n):\r\n for kk in range(jj,n):\r\n pswvd,tswvd,fswvd=spwvd([Za[jj].reshape(maxn),Za[kk].reshape(maxn)],\r\n **tfkwargs)\r\n stfd[jj,kk,:,:]=pswvd\r\n stfd[kk,jj,:,:]=pswvd.conj()\r\n \r\n #===============================================================================\r\n # Compute criteria for cross terms \r\n #===============================================================================\r\n \r\n stfdTr=np.zeros((nfbins,ntbins))\r\n C=np.zeros((nfbins,ntbins))\r\n \r\n for ff in range(nfbins):\r\n for tt in range(ntbins):\r\n #compensate for noise\r\n stfd[:,:,ff,tt]=stfd[:,:,ff,tt]-sigman*np.matrix(W)*np.matrix(W.T)\r\n #compute the trace\r\n stfdTr[ff,tt]=abs(np.trace(stfd[:,:,ff,tt]))\r\n #compute mean over entire t-f plane\r\n trmean=stfdTr.mean()\r\n \r\n #find t-f points that meet the criteria\r\n fspot,tspot=np.nonzero(stfdTr>trmean)\r\n \r\n for ll in range(len(fspot)):\r\n treig=abs(np.linalg.eig(stfd[:,:,fspot[ll],tspot[ll]])[0])\r\n if sum(treig)!=0 and sum(treig)>tftol:\r\n C[fspot[ll],tspot[ll]]=max(treig)/sum(treig)\r\n else:\r\n C[fspot[ll],tspot[ll]]=0\r\n \r\n #compute gradients and jacobi matrices\r\n negjacobi=np.zeros((nfbins,ntbins))\r\n smallgrad=np.zeros((nfbins,ntbins))\r\n maxpoints=np.zeros((nfbins,ntbins))\r\n \r\n gradt,gradf=np.gradient(C)\r\n Jtt,Jtf=np.gradient(gradt)\r\n Jft,Jff=np.gradient(gradf)\r\n \r\n #get points when L2 of gradient is smaller than tolerance level\r\n smallgrad=np.where(np.sqrt(gradt**2+gradf**2)<tftol,1,0)\r\n \r\n #get points where the Jacobi is negative definite\r\n detjacobi=Jtt*Jff-Jtf*Jft\r\n negjacobi=np.where(detjacobi>0,1,0)*np.where(Jtt<0,1,0)\\\r\n *np.where((Jtt+Jff)<0,1,0)\r\n \r\n maxpoints=smallgrad*negjacobi\r\n \r\n gfspot,gtspot=np.nonzero(maxpoints)\r\n ntfpoints=len(gfspot)\r\n \r\n if ntfpoints==0:\r\n raise ValueError('Found no tf points, relax tolerance')\r\n else:\r\n print 'Found '+str(ntfpoints)+' t-f points'\r\n \r\n for rr in range(ntfpoints):\r\n if rr==0:\r\n Rjd=stfd[:,:,gfspot[rr],gtspot[rr]]\r\n else:\r\n Rjd=np.concatenate((Rjd,stfd[:,:,gfspot[rr],gtspot[rr]]),axis=1)\r\n Rjd=np.array(Rjd)\r\n \r\n #===============================================================================\r\n # Calculate Joint Diagonalization\r\n #===============================================================================\r\n #get size of array of matrices to be diagonalized\r\n mtf,nm=Rjd.shape #mtf is number of t-f points, nm is number of matrices\r\n #set up some initial parameters\r\n V=np.eye(mtf)\r\n \r\n #update boolean\r\n encore=True \r\n #Total number of rotations\r\n updates=0\r\n sweep=0\r\n #print 'Computing Joint Diagonalization'\r\n # Joint diagonalization proper\r\n # ============================\r\n while encore:\r\n #reset some parameters\r\n encore=False\r\n sweep+=1 \r\n upds=0\r\n Vkeep=V\r\n for p in range(mtf):\r\n \r\n for q in range(p+1,mtf):\r\n #set up indices\r\n qi=np.arange(start=q,stop=nm,step=mtf)\r\n pi=np.arange(start=p,stop=nm,step=mtf)\r\n # computation of Givens angle\r\n g=np.array([Rjd[p,pi]-Rjd[q,qi],Rjd[p,qi],Rjd[q,pi]])\r\n gg=np.real(np.dot(g,g.T))\r\n ton=gg[0,0]-gg[1,1] \r\n toff=gg[0,1]+gg[1,0]\r\n theta=0.5*np.arctan2(toff,ton+np.sqrt(ton**2+toff**2))\r\n # Givens update\r\n if abs(theta) > tftol:\r\n encore=True\r\n upds+=1\r\n c=np.cos(theta) \r\n s=np.sin(theta)\r\n G=np.matrix([[c,-s],[s,c]])\r\n pair =np.array([p,q])\r\n V[:,pair]=V[:,pair]*G\r\n Rjd[pair,:]=G.T*Rjd[pair,:]\r\n Rjd[:,np.concatenate([pi,qi])]=np.append(\r\n c*Rjd[:,pi]+s*Rjd[:,qi],\r\n -s*Rjd[:,pi]+c*Rjd[:,qi],axis=1)\r\n updates+=upds\r\n print 'Updated '+str(updates)+' times.'\r\n \r\n #compute estimated signal matrix\r\n Se=np.dot(V.T,Z)\r\n #compute estimated mixing matrix\r\n Ae=np.dot(np.linalg.pinv(W),V)\r\n \r\n return Se,Ae","def data_augmenter(image, label, shift, rotate, scale, intensity, flip):\n image2 = np.zeros(image.shape, dtype=np.float32)\n label2 = np.zeros(label.shape, dtype=np.int32)\n for i in range(image.shape[0]):\n # For each image slice, generate random affine transformation parameters\n # using the Gaussian distribution\n shift_val = [np.clip(np.random.normal(), -3, 3) * shift,\n np.clip(np.random.normal(), -3, 3) * shift]\n rotate_val = np.clip(np.random.normal(), -3, 3) * rotate\n scale_val = 1 + np.clip(np.random.normal(), -3, 3) * scale\n intensity_val = 1 + np.clip(np.random.normal(), -3, 3) * intensity\n\n # Apply the affine transformation (rotation + scale + shift) to the image\n row, col = image.shape[1:3]\n M = cv2.getRotationMatrix2D((row / 2, col / 2), rotate_val, 1.0 / scale_val)\n M[:, 2] += shift_val\n for c in range(image.shape[3]):\n image2[i, :, :, c] = ndimage.interpolation.affine_transform(image[i, :, :, c],\n M[:, :2], M[:, 2], order=1)\n\n # Apply the affine transformation (rotation + scale + shift) to the label map\n label2[i, :, :] = ndimage.interpolation.affine_transform(label[i, :, :],\n M[:, :2], M[:, 2], order=0)\n\n # Apply intensity variation\n image2[i] *= intensity_val\n\n # Apply random horizontal or vertical flipping\n if flip:\n if np.random.uniform() >= 0.5:\n image2[i] = image2[i, ::-1, :, :]\n label2[i] = label2[i, ::-1, :]\n else:\n image2[i] = image2[i, :, ::-1, :]\n label2[i] = label2[i, :, ::-1]\n return image2, label2","def fit(self, x,\n augment=False,\n rounds=1,\n seed=None):\n x = np.asarray(x, dtype=self.dtype)\n if x.ndim != 4:\n raise ValueError('Input to `.fit()` should have rank 4. '\n 'Got array with shape: ' + str(x.shape))\n if seed is not None:\n np.random.seed(seed)\n\n x = np.copy(x)\n if augment:\n ax = np.zeros(\n tuple([rounds * x.shape[0]] + list(x.shape)[1:]),\n dtype=self.dtype)\n for r in range(rounds):\n for i in range(x.shape[0]):\n ax[i + r * x.shape[0]] = self.random_transform(x[i])\n x = ax\n\n if self.featurewise_center:\n self.mean = np.mean(x, axis=(0, self.row_axis, self.col_axis))\n broadcast_shape = [1, 1, 1]\n broadcast_shape[self.channel_axis - 1] = x.shape[self.channel_axis]\n self.mean = np.reshape(self.mean, broadcast_shape)\n x -= self.mean\n\n if self.featurewise_std_normalization:\n self.std = np.std(x, axis=(0, self.row_axis, self.col_axis))\n broadcast_shape = [1, 1, 1]\n broadcast_shape[self.channel_axis - 1] = x.shape[self.channel_axis]\n self.std = np.reshape(self.std, broadcast_shape)\n x /= (self.std + 1e-6)\n\n if self.zca_whitening:\n if scipy is None:\n raise ImportError('Using zca_whitening requires SciPy. '\n 'Install SciPy.')\n flat_x = np.reshape(\n x, (x.shape[0], x.shape[1] * x.shape[2] * x.shape[3]))\n sigma = np.dot(flat_x.T, flat_x) / flat_x.shape[0]\n u, s, _ = linalg.svd(sigma)\n s_inv = 1. / np.sqrt(s[np.newaxis] + self.zca_epsilon)\n self.principal_components = (u * s_inv).dot(u.T)\n return x","def addseeingImgFFTmoffat(img = None,fwhm=None):\n beta = 3.5\n alpha = fwhm/scale/(2.*np.sqrt(2**(1/beta)-1))\n kern = moffat_seeing(npix,alpha=alpha,beta=beta)\n img = img.astype('f') # required for the fftconvolve\n covimg = convolveH(img,kern)\n covimg = covimg/covimg.sum()\n return covimg","def backgroundEstimator(self, image):\n return self.bg_filter.convolve(image)","def aveEz2CC(self):\n if self.dim < 3:\n return None\n if getattr(self, '_aveEz2CC', None) is None:\n # The number of cell centers in each direction\n n = self.vnC\n if(self.dim == 3):\n self._aveEz2CC = kron3(speye(n[2]), av(n[1]), av(n[0]))\n return self._aveEz2CC","def add_zca_whitening(self, pc=None):\n self.global_pc.is_required = True\n self.global_pc.value = pc\n self.methods.append(self._zca_whitening)\n self.args.append(None)","def ledaps(image):\n cmask = image.select('QA')\n\n valid_data_mask = tools.compute_bits(cmask, 1, 1, 'valid_data')\n cloud_mask = tools.compute_bits(cmask, 2, 2, 'cloud')\n snow_mask = tools.compute_bits(cmask, 4, 4, 'snow')\n\n good_pix = cloud_mask.eq(0).And(valid_data_mask.eq(0)).And(snow_mask.eq(0))\n result = image.updateMask(good_pix)\n\n return result","def perform_coszen_flipback(cz_kern_cdf, flipback_mask, keep):\n flipback = np.where(flipback_mask)[0]\n\n flipup = flipback[:int(len(flipback)/2)]\n flipdown = flipback[int(len(flipback)/2):]\n no_flipback = np.where(np.logical_not(flipback_mask))[0]\n\n cz_kern_cdf = (cz_kern_cdf[flipup][::-1] + cz_kern_cdf[flipdown][::-1] +\n cz_kern_cdf[no_flipback])[keep-int(len(flipback)/2)]\n\n return cz_kern_cdf","def image_conv(image, kernel):\n \n # Filter2D used for performance\n return cv2.filter2D(image, -1, kernel)","def denoise_image(image,dest):\n beta = 1e-3\n eta = 2e-4\n argh = 0.0\n kmax = 10\n data = sign(image.getdata(), {0: -1, 255: 1}) # convert to {-1, 1}\n E, localized_E = E_generator(beta, eta, argh)\n temp_dir = os.path.dirname(os.path.realpath(os.path.join('submits', 'img', dest)))\n y = data.reshape(image.size[::-1]) # convert 1-d array to matrix\n result = simulated_annealing(\n y, kmax, E, localized_E, temp_dir)\n result = sign(result, {-1: 0, 1: 255})\n output_image = Image.fromarray(result).convert('1', dither=Image.NONE)\n return output_image","def __init__(self, n_x, n_z, qz_hid, px_hid, filters, seq_length=50, nonlinearity=rectify,\r\n px_nonlinearity=None, x_dist='linear', batchnorm=False, seed=1234):\r\n super(CVAE, self).__init__(n_x, qz_hid + px_hid, n_z, nonlinearity)\r\n self.x_dist = x_dist\r\n self.n_x = n_x\r\n self.seq_length = seq_length\r\n self.n_z = n_z\r\n self.batchnorm = batchnorm\r\n self._srng = RandomStreams(seed)\r\n\r\n # Pool layer cache\r\n pool_layers = []\r\n\r\n # Decide Glorot initializaiton of weights.\r\n init_w = 1e-3\r\n hid_w = \"\"\r\n if nonlinearity == rectify or nonlinearity == softplus:\r\n hid_w = \"relu\"\r\n\r\n # Define symbolic variables for theano functions.\r\n self.sym_x = T.tensor3('x') # inputs\r\n self.sym_z = T.matrix('z')\r\n self.sym_samples = T.iscalar('samples') # MC samples\r\n\r\n # Assist methods for collecting the layers\r\n def dense_layer(layer_in, n, dist_w=init.GlorotNormal, dist_b=init.Normal):\r\n dense = DenseLayer(layer_in, n, dist_w(hid_w), dist_b(init_w), None)\r\n if batchnorm:\r\n dense = bn(dense)\r\n return NonlinearityLayer(dense, self.transf)\r\n\r\n def stochastic_layer(layer_in, n, samples, nonlin=None):\r\n mu = DenseLayer(layer_in, n, init.Normal(init_w), init.Normal(init_w), nonlin)\r\n logvar = DenseLayer(layer_in, n, init.Normal(init_w), init.Normal(init_w), nonlin)\r\n return SampleLayer(mu, logvar, eq_samples=samples, iw_samples=1), mu, logvar\r\n\r\n def conv_layer(layer_in, filter, stride=(1, 1), pool=1, name='conv'):\r\n l_conv = Conv2DLayer(layer_in, num_filters=filter, filter_size=(3, 1), stride=stride, pad='full', name=name)\r\n if pool > 1:\r\n l_conv = MaxPool2DLayer(l_conv, pool_size=(pool, 1))\r\n pool_layers.append(l_conv)\r\n return l_conv\r\n\r\n # Reshape input\r\n l_x_in = InputLayer((None, seq_length, n_x), name='Input')\r\n l_x_in_reshp = ReshapeLayer(l_x_in, (-1, 1, seq_length, n_x))\r\n print(\"l_x_in_reshp\", l_x_in_reshp.output_shape)\r\n\r\n # CNN encoder implementation\r\n l_conv_enc = l_x_in_reshp\r\n for filter, stride, pool in filters:\r\n l_conv_enc = conv_layer(l_conv_enc, filter, stride, pool)\r\n print(\"l_conv_enc\", l_conv_enc.output_shape)\r\n\r\n # Pool along last 2 axes\r\n l_global_pool_enc = GlobalPoolLayer(l_conv_enc)\r\n l_enc = dense_layer(l_global_pool_enc, n_z)\r\n print(\"l_enc\", l_enc.output_shape)\r\n\r\n # Recognition q(z|x)\r\n l_qz = l_enc\r\n for hid in qz_hid:\r\n l_qz = dense_layer(l_qz, hid)\r\n l_qz, l_qz_mu, l_qz_logvar = stochastic_layer(l_qz, n_z, self.sym_samples)\r\n print(\"l_qz\", l_qz.output_shape)\r\n\r\n # Inverse pooling\r\n l_global_depool = InverseLayer(l_qz, l_global_pool_enc)\r\n print(\"l_global_depool\", l_global_depool.output_shape)\r\n\r\n # Reverse pool layer order\r\n pool_layers = pool_layers[::-1]\r\n\r\n # Decode\r\n l_deconv = l_global_depool\r\n for idx, filter in enumerate(filters[::-1]):\r\n filter, stride, pool = filter\r\n if pool > 1:\r\n l_deconv = InverseLayer(l_deconv, pool_layers[idx])\r\n l_deconv = Conv2DLayer(l_deconv, num_filters=filter, filter_size=(3, 1), stride=(stride, 1), W=init.GlorotNormal('relu'))\r\n print(\"l_deconv\", l_deconv.output_shape)\r\n\r\n # The last l_conv layer should give us the input shape\r\n l_dec = Conv2DLayer(l_deconv, num_filters=1, filter_size=(3, 1), pad='same', nonlinearity=None)\r\n print(\"l_dec\", l_dec.output_shape)\r\n\r\n # Flatten first two dimensions\r\n l_dec = ReshapeLayer(l_dec, (-1, n_x))\r\n\r\n l_px = l_dec\r\n if x_dist == 'bernoulli':\r\n l_px = DenseLayer(l_px, n_x, init.GlorotNormal(), init.Normal(init_w), sigmoid)\r\n elif x_dist == 'multinomial':\r\n l_px = DenseLayer(l_px, n_x, init.GlorotNormal(), init.Normal(init_w), softmax)\r\n elif x_dist == 'gaussian':\r\n l_px, l_px_mu, l_px_logvar = stochastic_layer(l_px, n_x, self.sym_samples, px_nonlinearity)\r\n elif x_dist == 'linear':\r\n l_px = DenseLayer(l_px, n_x, nonlinearity=None)\r\n\r\n # Reshape all the model layers to have the same size\r\n self.l_x_in = l_x_in\r\n\r\n self.l_qz = ReshapeLayer(l_qz, (-1, self.sym_samples, 1, n_z))\r\n self.l_qz_mu = DimshuffleLayer(l_qz_mu, (0, 'x', 'x', 1))\r\n self.l_qz_logvar = DimshuffleLayer(l_qz_logvar, (0, 'x', 'x', 1))\r\n\r\n self.l_px = DimshuffleLayer(ReshapeLayer(l_px, (-1, seq_length, self.sym_samples, 1, n_x)), (0, 2, 3, 1, 4))\r\n self.l_px_mu = DimshuffleLayer(ReshapeLayer(l_px_mu, (-1, seq_length, self.sym_samples, 1, n_x)), (0, 2, 3, 1, 4)) \\\r\n if x_dist == \"gaussian\" else None\r\n self.l_px_logvar = DimshuffleLayer(ReshapeLayer(l_px_logvar, (-1, seq_length, self.sym_samples, 1, n_x)), (0, 2, 3, 1, 4)) \\\r\n if x_dist == \"gaussian\" else None\r\n\r\n # Predefined functions\r\n inputs = {self.l_x_in: self.sym_x}\r\n outputs = get_output(l_qz, inputs, deterministic=True)\r\n self.f_qz = theano.function([self.sym_x, self.sym_samples], outputs)\r\n\r\n inputs = {l_qz: self.sym_z}\r\n outputs = get_output(self.l_px, inputs, deterministic=True).mean(axis=(1, 2))\r\n self.f_px = theano.function([self.sym_z, self.sym_samples], outputs)\r\n\r\n outputs = get_output(self.l_px_mu, inputs, deterministic=True).mean(axis=(1, 2))\r\n self.f_mu = theano.function([self.sym_z, self.sym_samples], outputs)\r\n\r\n outputs = get_output(self.l_px_logvar, inputs, deterministic=True).mean(axis=(1, 2))\r\n self.f_var = theano.function([self.sym_z, self.sym_samples], outputs)\r\n\r\n # Define model parameters\r\n self.model_params = get_all_params([self.l_px])\r\n self.trainable_model_params = get_all_params([self.l_px], trainable=True)","def computeInverse2DDCT(self, imge):\n \n # Assuming a square image\n N = imge.shape[0]\n finalInverse2DDCT = np.zeros([N, N], dtype=float)\n for x in xrange(N):\n for y in xrange(N):\n #Compute the DCT value for each cells/points in the resulting transformed image.\n finalInverse2DDCT[x, y] = DCT.__computeSinglePointInverse2DCT(imge, x, y, N)\n return finalInverse2DDCT","def pca(image):\n # Reshape image.\n reshaped_image = np.reshape(image, (224 * 224, 3))\n # Find the covariance.\n cov = np.cov(reshaped_image, rowvar=0)\n # Eigenvalues and vectors.\n eigvals, eigvecs = np.linalg.eigh(cov)\n\n # Pick random gaussian values.\n a = np.random.normal(0, 0.1, size=(3,))\n\n scaled = eigvals * a\n delta = np.dot(eigvecs, scaled.T)\n return np.add(delta, scaled)","def applyMat(my_map, linsys_setup):\n \n datamaps, ninvs, beams, freqs, power_2d, precond_2d, clumaps, g_nu, \\\n map_prop = linsys_setup\n \n \n\n nx, ny, pixScaleX, pixScaleY = map_prop\n nFreq = len(g_nu); nCluster = len(clumaps[0])\n\n #Always apply beam * precond\n beam_prec=[]\n\n for f in range(nFreq):\n beam_prec+=[beams[f][:,:ny/2+1]*precond_2d[:,:ny/2+1]]\n precond_2d=precond_2d[:,:ny/2+1]\n power_2d=power_2d[:,:ny/2+1]\n \n ksz = False\n if len(clumaps) == 2: ksz = True\n \n # Routines to perform block matrix multiplication defined in Eriksen Eq. 19\n \n def apply_cmb_cmb(d0):\n \"\"\"\n Apply (S^-1 + A N^-1 A) x\n \"\"\"\n d1 = d0.copy()\n d1 = numpy.reshape(d1,(nx,ny))\n a_l = fft.rfft(d1,axes=[-2,-1])\n \n c_l = 0\n for f in range(nFreq):\n\n b_l = a_l * beam_prec[f]\n d2 = fft.irfft(b_l,axes=[-2,-1],normalize=True)\n d2 *= ninvs[f]\n b_l = fft.rfft(d2,axes=[-2,-1])\n c_l += b_l * beam_prec[f]\n \n d2 = fft.irfft(c_l,axes=[-2,-1],normalize=True)\n d1 = fft.irfft(precond_2d**2 * a_l/power_2d,axes=[-2,-1],normalize=True)\n \n d2 += d1\n \n return d2.reshape((nx*ny,))\n \n \"\"\"\n def apply_tsz_tsz(d0): # DONE\n \\\"\"\"\n Apply (F^T A^T N^-1 A F) x\n \\\"\"\"\n d1 = numpy.zeros(nCluster)\n mat = numpy.zeros((nCluster, nCluster))\n # TODO: This could probably be more efficient (e.g. using np.outer)\n for freq in range(nFreq):\n for ic in range(nCluster):\n for jc in range(0, ic+1):\n mat[ic,jc] = numpy.sum( ninvs[freq] * g_nu[freq]**2. \\\n * clumaps[0][ic][freq] * clumaps[0][jc][freq] )\n if ic != jc: mat[jc,ic] = mat[ic,jc]\n d1 += numpy.dot(mat, d0)\n return d1\n \n def apply_ksz_ksz(d0): # DONE\n \\\"\"\"\n Apply (K^T A^T N^-1 A K) x\n \\\"\"\"\n # FIXME: Missing factor of ivcov\n d1 = numpy.zeros(nCluster)\n mat = numpy.zeros((nCluster, nCluster))\n # TODO: This could probably be more efficient (e.g. using np.outer)\n for freq in range(nFreq):\n for ic in range(nCluster):\n for jc in range(0, ic+1):\n mat[ic,jc] = numpy.sum( ninvs[freq] \\\n * clumaps[1][ic][freq] * clumaps[1][jc][freq] )\n if ic != jc: mat[jc,ic] = mat[ic,jc]\n d1 += numpy.dot(mat, d0)\n d1 += numpy.dot(ivcov, d0) # Add prior term\n return d1\n \"\"\"\n \n def apply_cmb_foreground_block(dc, dm, dt, dk=None):\n \"\"\"\n Apply the CMB x (Monopole + TSZ + KSZ) terms in one block:\n (A^T N^-1 A T) x_mono\n (A^T N^-1 A F) x_tsz\n (A^T N^-1 A K) x_ksz\n \n (T^T A^T N^-1 A) x_cmb\n (F^T A^T N^-1 A) x_cmb\n (K^T A^T N^-1 A) x_cmb\n \"\"\"\n ksz = False\n if dk is not None: ksz = True\n \n # (A^T N^-1 A T) x_mono; (A^T N^-1 A F) x_tsz; (A^T N^-1 A K) x_ksz\n b_lt = 0; b_lk = 0; b_lm = 0\n for f in range(nFreq):\n mct = 0; mck = 0\n for ic in range(nCluster):\n mct += dt[ic] * ninvs[f] * clumaps[0][ic][f] * g_nu[f]\n if ksz: mck += dk[ic] * ninvs[f] * clumaps[1][ic][f]\n \n b_lm += fft.rfft(dm * ninvs[f],axes=[-2,-1]) * beam_prec[f]\n b_lt += fft.rfft(mct,axes=[-2,-1]) * beam_prec[f]\n if ksz: b_lk += fft.rfft(mck,axes=[-2,-1]) * beam_prec[f]\n\n mcm = fft.irfft(b_lm,axes=[-2,-1],normalize=True).reshape((nx*ny,))\n mct = fft.irfft(b_lt,axes=[-2,-1],normalize=True).reshape((nx*ny,))\n if ksz: mck = fft.irfft(b_lk,axes=[-2,-1],normalize=True).reshape((nx*ny,))\n \n # (T^T A^T N^-1 A) x_cmb; (F^T A^T N^-1 A) x_cmb; (K^T A^T N^-1 A) x_cmb\n mc = dc.copy().reshape((nx,ny))\n a_l = fft.rfft(mc,axes=[-2,-1])\n mtc = numpy.zeros(nCluster)\n mkc = numpy.zeros(nCluster)\n mmc = 0\n for f in range(nFreq):\n b_l = a_l * beam_prec[f]\n mc = fft.irfft(b_l,axes=[-2,-1],normalize=True)\n mmc += numpy.sum(mc * ninvs[f])\n for ic in range(nCluster):\n mtc[ic] += numpy.sum(mc * ninvs[f] * clumaps[0][ic][f] * g_nu[f])\n if ksz: mkc[ic] += numpy.sum(mc * ninvs[f] * clumaps[1][ic][f])\n \n if ksz: return mct, mcm, mck, mtc, mmc, mkc\n return mct, mcm, mtc, mmc\n \n \n def apply_foreground_block(m0, t0, k0=None):\n \"\"\"\n Apply the TSZ + KSZ + Monopole terms in one block:\n [ (T^T A^T N^-1 A F) (T^T A^T N^-1 A K) (T^T A^T N^-1 A T) ] (x_mono)\n [ (F^T A^T N^-1 A F) (F^T A^T N^-1 A K) (F^T A^T N^-1 A T) ] (x_tsz)\n [ (K^T A^T N^-1 A F) (K^T A^T N^-1 A K) (K^T A^T N^-1 A T) ] (x_ksz)\n \"\"\"\n ksz = True if k0 is not None else False\n \n dtt, dkk, dtk, dkt = [numpy.zeros(nCluster) for i in range(4)]\n mtt, mkk, mtk, mkt = [numpy.zeros((nCluster, nCluster)) for i in range(4)]\n dmm, dmk, dmt = [0 for i in range(3)]\n dkm, dtm = [numpy.zeros(nCluster) for i in range(2)]\n \n # TODO: This could probably be more efficient (e.g. using np.outer)\n for f in range(nFreq):\n dmm += numpy.sum(ninvs[f]) * m0\n \n # Loop through clusters\n for ic in range(nCluster):\n dmt += numpy.sum( ninvs[f] * g_nu[f] * clumaps[0][ic][f] * t0[ic] )\n dtm[ic] += numpy.sum( ninvs[f] * g_nu[f] * clumaps[0][ic][f] * m0 )\n if ksz:\n dmk += numpy.sum( ninvs[f] * clumaps[1][ic][f] * k0[ic] )\n dkm[ic] += numpy.sum( ninvs[f] * clumaps[1][ic][f] * m0 )\n \n for jc in range(0, ic+1):\n mtt[ic,jc] = numpy.sum( ninvs[f] * g_nu[f]**2. \\\n * clumaps[0][ic][f] * clumaps[0][jc][f] )\n if ksz:\n mkk[ic,jc] = numpy.sum( ninvs[f] \\\n * clumaps[1][ic][f] * clumaps[1][jc][f] )\n mtk[ic,jc] = numpy.sum( ninvs[f] * g_nu[f] \\\n * clumaps[0][ic][f] * clumaps[1][jc][f] )\n mkt[ic,jc] = numpy.sum( ninvs[f] * g_nu[f] \\\n * clumaps[1][ic][f] * clumaps[0][jc][f] )\n # Mirror indices\n mtt[jc,ic] = mtt[ic,jc]\n if ksz:\n mkk[jc,ic] = mkk[ic,jc]\n mtk[jc,ic] = mtk[ic,jc]\n mkt[jc,ic] = mkt[ic,jc]\n \n # Add total contribs. for this band\n dtt += numpy.dot(mtt, t0)\n if ksz:\n dkk += numpy.dot(mkk, k0)\n dtk += numpy.dot(mtk, k0)\n dkt += numpy.dot(mkt, t0)\n \n if ksz: return dtt, dkk, dmm, dtk, dkt, dmk, dkm, dtm, dmt\n return dtt, dmm, dtm, dmt\n \n # Apply block matrix multiplications and return\n # FIXME: What if KSZ not used?\n x0 = my_map[:nx*ny]\n x1 = my_map[nx*ny:nx*ny+1]\n x2 = my_map[nx*ny+1:nx*ny+nCluster+1]\n if ksz: x3 = my_map[nx*ny+nCluster+1:nx*ny+2*nCluster+1]\n \n # Multiply input vector in blocks\n #t=time.time()\n dcc = apply_cmb_cmb(x0)\n #print 'CMB', time.time()-t\n if ksz:\n dct, dcm, dck, dtc, dmc, dkc = apply_cmb_foreground_block(x0, x1, x2, x3)\n dtt, dkk, dmm, dtk, dkt, dmk, dkm, dtm, dmt = apply_foreground_block(x1, x2, x3)\n x_new_0 = dcc + dct + dck + dcm\n x_new_1= dmc + dmt + dmk + dmm\n x_new_2 = dtc + dtt + dtk + dtm\n x_new_3 = dkc + dkt + dkk + dkm\n x_new = numpy.concatenate((x_new_0, x_new_1, x_new_2, x_new_3))\n else:\n #t=time.time()\n dct, dcm, dtc, dmc = apply_cmb_foreground_block(x0, x1, x2)\n #print 'CMB-F', time.time()-t\n \n #t=time.time()\n dtt, dmm, dtm, dmt = apply_foreground_block(x1, x2)\n #print 'F', time.time()-t\n \n x_new_0 = dcc + dct + dcm\n x_new_1 = dmc + dmt + dmm\n x_new_2 = dtc + dtt + dtm\n x_new = numpy.concatenate((x_new_0, x_new_1, x_new_2))\n\n\n#sys.exit()\n return x_new","def post_process_image(self, image):\r\n A = np.min(image)\r\n B = np.max(image)\r\n k = 255\r\n R, C = image.shape\r\n for i in range(R):\r\n for j in range(C):\r\n image[i][j] = (k / (B-A)) * (image[i][j] - A)\r\n average_image = np.average(image)\r\n if average_image > 50:\r\n return image.astype(dtype='uint8')\r\n else:\r\n return (255-image).astype(dtype='uint8')","def apply_clahe(img, clip_limit=2.0, tile_grid_size=(8, 8)):\r\n shape = img.shape\r\n if len(shape) > 2 and shape[2] == 1:\r\n img = img.reshape(shape[:2])\r\n\r\n assert img.dtype == np.uint8, '0 to 255 uint8 for pixel values are expected'\r\n assert len(img.shape) == 2, 'only on one channel'\r\n\r\n clahe = cv2.createCLAHE(clipLimit=clip_limit, tileGridSize=tile_grid_size)\r\n return clahe.apply(np.array(img, dtype=np.uint8)).reshape(shape)","def transform(self, previousimage):","def process_image_for_heuristic_af(self, tile_key):\n\n # image provided as numpy array from dictionary,\n # already cropped to 512x512\n img = self.img[tile_key]\n mean = int(np.mean(img))\n # recast as int16 before mean subtraction\n img = img.astype(np.int16)\n img -= mean\n # Autocorrelation:\n norm = np.sum(img ** 2)\n autocorr = fftconvolve(img, img[::-1, ::-1])/norm\n height, width = autocorr.shape[0], autocorr.shape[1]\n # Crop to 64-pixel central region:\n autocorr = autocorr[int(height/2 - 32):int(height/2 + 32),\n int(width/2 - 32):int(width/2 + 32)]\n # Calculate coefficients:\n fi = self.muliply_with_mask(autocorr, self.fi_mask)\n fo = self.muliply_with_mask(autocorr, self.fo_mask)\n apx = self.muliply_with_mask(autocorr, self.apx_mask)\n amx = self.muliply_with_mask(autocorr, self.amx_mask)\n apy = self.muliply_with_mask(autocorr, self.apy_mask)\n amy = self.muliply_with_mask(autocorr, self.amy_mask)\n # Check if tile_key already in dictionary:\n if not (tile_key in self.foc_est):\n self.foc_est[tile_key] = []\n if not (tile_key in self.astgx_est):\n self.astgx_est[tile_key] = []\n if not (tile_key in self.astgy_est):\n self.astgy_est[tile_key] = []\n # Calculate single-image estimators for current tile key:\n if len(self.foc_est[tile_key]) > 1:\n self.foc_est[tile_key].pop(0)\n self.foc_est[tile_key].append(\n (fi - fo) / (fi + fo))\n if len(self.astgx_est[tile_key]) > 1:\n self.astgx_est[tile_key].pop(0)\n self.astgx_est[tile_key].append(\n (apx - amx) / (apx + amx))\n if len(self.astgy_est[tile_key]) > 1:\n self.astgy_est[tile_key].pop(0)\n self.astgy_est[tile_key].append(\n (apy - amy) / (apy + amy))","def askapsoft_decimate_n_extract(af, over_sampling, kernel_support):\n\n # why is this normalization required..?\n rescale = over_sampling*over_sampling\n #rescale = 1\n\n cSize = 2 * kernel_support + 1\n itsConvFunc=np.zeros((over_sampling, over_sampling, cSize, cSize), dtype=complex)\n\n for fracu in range(0,over_sampling):\n for fracv in range(0,over_sampling):\n\n # Now cut out the inner part of the convolution function and\n # insert it into the convolution function\n for iy in range(-kernel_support,kernel_support+1):\n for ix in range(-kernel_support,kernel_support+1):\n\n nx = af.shape[0]\n ny = af.shape[1]\n\n # assumes support is the same for all w-planes:\n xval = (ix) * over_sampling + fracu + nx / 2\n yval = (iy) * over_sampling + fracv + ny / 2\n\n itsConvFunc[fracu, fracv, ix+cSize/2, iy+cSize/2] \\\n = rescale * af[xval, yval]\n\n return itsConvFunc[::-1,::-1]","def image_local_enhance_contrast(image: np.ndarray):\n \n # Resize image to a shape of (48, 48)\n image = image_as_square(image)\n\n image = filters.rank.enhance_contrast(image, morphology.disk(2))\n\n # Resize the iamge back to a shape of (2304, )\n return image_as_array(image)","def execute(self, image):\n undist = self.undistort(image)\n result = self.threshold_image(undist, self.thresholds['ksize'],\n self.thresholds['sobel'],\n self.thresholds['magnitude'],\n self.thresholds['direction'],\n self.thresholds['saturation'],\n self.thresholds['lightness'],\n self.thresholds['blue-yellow'])\n warped = self.warp(result)\n if self.args.is_test:\n self.image_logger.save_image(warped, 'warped_image.png')\n ploty, left_fit, right_fit, left_fitx, right_fitx = self.get_line_fit(warped)\n left_rad, right_rad = measure_curvature(warped, left_fitx, right_fitx, self.args.is_test)\n self.left_line.update(left_fit, left_rad)\n self.right_line.update(right_fit, right_rad)\n result = self.draw_final_image(image, warped, undist, ploty, left_fitx, right_fitx, self.Minv,\n self.left_line.best_curvature,\n self.right_line.best_curvature)\n return result","def convolve(kerns, kshp, nkern, images, imgshp, step=(1, 1), bias=None,\r\n mode='valid', flatten=True):\r\n N = numpy\r\n # start by computing output dimensions, size, etc\r\n kern_size = N.int64(N.prod(kshp))\r\n\r\n # inshp contains either 2 entries (height,width) or 3 (nfeatures,h,w)\r\n # in the first case, default nfeatures to 1\r\n if N.size(imgshp) == 2:\r\n imgshp = (1,) + imgshp\r\n\r\n # construct indices and index pointers for sparse matrix, which,\r\n # when multiplied with input images will generate a stack of image\r\n # patches\r\n indices, indptr, spmat_shape, sptype, outshp = \\\r\n convolution_indices.conv_eval(imgshp, kshp, step, mode)\r\n\r\n # build sparse matrix, then generate stack of image patches\r\n csc = theano.sparse.CSM(sptype)(N.ones(indices.size), indices,\r\n indptr, spmat_shape)\r\n patches = (sparse.structured_dot(csc, images.T)).T\r\n\r\n # compute output of linear classifier\r\n pshape = tensor.stack(images.shape[0] * tensor.as_tensor(N.prod(outshp)),\\\r\n tensor.as_tensor(imgshp[0] * kern_size))\r\n patch_stack = tensor.reshape(patches, pshape, ndim=2)\r\n\r\n # kern is of shape: nkern x ksize*number_of_input_features\r\n # output is thus of shape: bsize*outshp x nkern\r\n output = tensor.dot(patch_stack, kerns.T)\r\n\r\n # add bias across each feature map (more efficient to do it now)\r\n if bias is not None:\r\n output += bias\r\n\r\n # now to have feature maps in raster order ...\r\n # go from bsize*outshp x nkern to bsize x nkern*outshp\r\n newshp = tensor.stack(images.shape[0],\\\r\n tensor.as_tensor(N.prod(outshp)),\\\r\n tensor.as_tensor(nkern))\r\n tensout = tensor.reshape(output, newshp, ndim=3)\r\n output = tensor.DimShuffle((False,) * tensout.ndim, (0, 2, 1))(tensout)\r\n if flatten:\r\n output = tensor.flatten(output, 2)\r\n\r\n return output, N.hstack((nkern, outshp))","def nitidez(img):\n kernel = np.array([\n [0, -1, 0],\n [-1, 5, -1],\n [0, -1, 0]\n ])\n if img.modo == \"L\":\n return convoluir(img, kernel)\n canais = [\n filtrar_canal(img, \"R\"), filtrar_canal(img, \"G\"), filtrar_canal(img, \"B\") \n ]\n canais = [convoluir(i, kernel) for i in canais]\n return reunir_canais(*canais)","def warp_channel(image, homography):\n\n ## calc canvas\n top, bottom = compute_bounding_box(homography, image.shape[1],\n image.shape[0])\n\n canvas_shape = tuple(np.diff([top,bottom], axis=0).flatten()[::-1])\n\n ## create index map\n x,y = np.meshgrid(np.arange(top[0], bottom[0]),\n np.arange(top[1], bottom[1]))\n\n ## calc inv indecies\n orig_pts = np.vstack((x.flatten(), y.flatten())).T\n inv_index_map = apply_homography(orig_pts,\n np.linalg.inv(homography) )\n\n ## calc back images\n warped = map_coordinates(image, [inv_index_map[:,1],\n inv_index_map[:,0]], order=1,\n prefilter=False)\n\n warped = warped.reshape(canvas_shape)\n return warped","def affine(self, image, random_state):\n shape = image.shape\n shape_size = shape[:2]\n transform_std = self.alpha_affine*image.shape[1]\n\n center_square = np.float32(shape[:2]) // 2\n square_size = min(shape[:2]) // 3\n\n source = np.float32([center_square + square_size, [center_square[0]+square_size, center_square[1]-square_size], center_square - square_size])\n destination = source + random_state.uniform(-transform_std, transform_std, size=source.shape).astype(np.float32)\n M = cv2.getAffineTransform(source, destination)\n\n return cv2.warpAffine(image, M, shape_size[::-1], borderMode=cv2.BORDER_REPLICATE)","def snic(image, seeds, compactness, nd_computation=None, image_distance=None, update_func=None):\n image_size = [len(image), len(image[0])]\n label_map = [[-1] * image_size[1] for _ in range(image_size[0])]\n distance_map = [[sys.float_info.max] * image_size[1] for _ in range(image_size[0])]\n\n if nd_computation is None:\n nd_computation = nd_computations[\"3\"]\n nd_lerp = nd_computation.lerp\n\n if type(seeds) is int:\n # generate equidistant grid and flatten into list\n grid = [seed for row in compute_grid(image_size, seeds) for seed in row]\n\n real_number_of_pixels = len(grid)\n else:\n # assume seeds is an iterable\n grid = seeds\n real_number_of_pixels = len(seeds)\n\n if image_distance is None:\n image_distance = create_augmented_snic_distance(image_size, real_number_of_pixels, compactness)\n\n # store centroids\n centroids_pos = grid # flatten grid\n centroids = [[pos, image[pos[0]][pos[1]], 0] for pos in centroids_pos] # [position, color at position, #pixels]\n\n # create priority queue\n queue = Queue(image_size[0] * image_size[1] * 4) # [position, color, centroid_idx]\n q_add = queue.add # cache some functions\n q_pop = queue.pop\n # we create a priority queue and fill with the centroids itself. Since the python priority queue can not\n # handle multiple entries with the same key, we start inserting the super pixel seeds with negative values. This\n # makes sure they get processed before any other pixels. Since distances can not be negative, all new\n # pixels will have a positive value, and therefore will be handles only after all seeds have been processed.\n for k in range(real_number_of_pixels):\n init_centroid = centroids[k]\n\n q_len = -queue.length()\n q_add(q_len, [init_centroid[0], init_centroid[1], k])\n distance_map[init_centroid[0][0]][init_centroid[0][1]] = q_len\n\n # classification\n classified_pixels = 0\n # while not q_empty(): -> replaced with \"try: while True:\" to speed-up code (~1sec with 50k iterations)\n try:\n while True:\n # get pixel that has the currently smallest distance to a centroid\n item = q_pop()\n candidate_distance = item._key\n candidate = item.value\n candidate_pos = candidate[0]\n\n # test if pixel is not already labeled\n # if label_map[candidate_pos[1] * im_width + candidate_pos[0]] == -1:\n if label_map[candidate_pos[0]][candidate_pos[1]] == -1:\n centroid_idx = candidate[2]\n\n # label new pixel\n label_map[candidate_pos[0]][candidate_pos[1]] = centroid_idx\n #\n distance_map[candidate_pos[0]][candidate_pos[1]] = candidate_distance\n # label_map[candidate_pos[1] * im_width + candidate_pos[0]] = centroid_idx\n classified_pixels += 1\n\n # online update of centroid\n centroid = centroids[centroid_idx]\n num_pixels = centroid[2] + 1\n lerp_ratio = 1 / num_pixels\n\n # adjust centroid position\n centroid[0] = lerp2(centroid[0], candidate_pos, lerp_ratio)\n # update centroid color\n centroid[1] = nd_lerp(centroid[1], candidate[1], lerp_ratio)\n # adjust number of pixels counted towards this super pixel\n centroid[2] = num_pixels\n\n # add new candidates to queue\n neighbours, neighbour_num = get_4_neighbourhood_1(candidate_pos, image_size)\n for i in range(neighbour_num):\n neighbour_pos = neighbours[i]\n # Check if neighbour is already labeled, as these pixels would get discarded later on.\n # We filter them here as queue insertions are expensive\n # if label_map[neighbour_pos[1] * im_width + neighbour_pos[0]] == -1:\n if label_map[neighbour_pos[0]][neighbour_pos[1]] == -1:\n neighbour_color = image[neighbour_pos[0]][neighbour_pos[1]]\n neighbour = [neighbour_pos, neighbour_color, centroid_idx]\n\n distance = image_distance(neighbour_pos, centroid[0], neighbour_color, centroid[1])\n\n # test if another candidate with a lower distance, is not already\n # registered to this pixel\n if distance_map[neighbour_pos[0]][neighbour_pos[1]] >= distance:\n distance_map[neighbour_pos[0]][neighbour_pos[1]] = distance\n q_add(distance, neighbour)\n\n # status update\n if (update_func is not None) and (classified_pixels % 10000 == 0):\n update_func(classified_pixels)\n except IndexError:\n pass\n\n return label_map, distance_map, real_number_of_pixels, centroids","def cml_encrypt(im, key, iterations, cycles):\n pixels = np.array(im)\n p, s = key\n seed(s)\n\n for i in range(3):\n cml_encrypt_channel(pixels[:, :, i], p, iterations, cycles)\n\n return Image.fromarray(pixels)","def clConvolution(self, size, mask):","def main():\n test_image = load_image()\n\n pixelate_image(\n normalize_image(test_image)\n )\n pass","def find_img2d_candidates(image, **kwargs):\n\n # filter_kernel = np.array([[-1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225],\n # [-1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225],\n # [-1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225],\n # [-1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225],\n # [-1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225],\n # [-1/225, -1/225, -1/225, -1/225, -1/225, 8/225, 8/225, 8/225, 8/225, 8/225, -1/225, -1/225, -1/225, -1/225, -1/225],\n # [-1/225, -1/225, -1/225, -1/225, -1/225, 8/225, 8/225, 8/225, 8/225, 8/225, -1/225, -1/225, -1/225, -1/225, -1/225],\n # [-1/225, -1/225, -1/225, -1/225, -1/225, 8/225, 8/225, 8/225, 8/225, 8/225, -1/225, -1/225, -1/225, -1/225, -1/225],\n # [-1/225, -1/225, -1/225, -1/225, -1/225, 8/225, 8/225, 8/225, 8/225, 8/225, -1/225, -1/225, -1/225, -1/225, -1/225],\n # [-1/225, -1/225, -1/225, -1/225, -1/225, 8/225, 8/225, 8/225, 8/225, 8/225, -1/225, -1/225, -1/225, -1/225, -1/225],\n # [-1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225],\n # [-1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225],\n # [-1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225],\n # [-1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225],\n # [-1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225]])\n\n filter_kernel = np.array([[-2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2/324, -2/324, -2/324],\n [-2 / 324, -2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1/324, -2/324, -2/324],\n [-2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1/324, -1/324, -2/324],\n [-2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1/324, -1/324, -2/324],\n [-2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -2 / 324, -2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -2 / 324, -1 / 324, -1 / 324, -1/324, -1/324, -2/324],\n [-2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -1 / 324, -1 / 324, -1/324, -1/324, -2/324],\n [-2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -2 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, -2 / 324, -1 / 324, -1 / 324, -1/324, -1/324, -2/324],\n [-2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -2 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, -2 / 324, -1 / 324, -1 / 324, -1/324, -1/324, -2/324],\n [-2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -2 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, -2 / 324, -1 / 324, -1 / 324, -1/324, -1/324, -2/324],\n [-2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -2 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, -2 / 324, -1 / 324, -1 / 324, -1/324, -1/324, -2/324],\n [-2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -2 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, -2 / 324, -1 / 324, -1 / 324, -1/324, -1/324, -2/324],\n [-2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -2 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, -2 / 324, -1 / 324, -1 / 324, -1/324, -1/324, -2/324],\n [-2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -1 / 324, -1 / 324, -1/324, -1/324, -2/324],\n [-2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -2 / 324, -2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -2 / 324, -2 / 324, -1 / 324, -1 / 324, -1/324, -1/324, -2/324],\n [-2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1/324, -1/324, -2/324],\n [-2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1/324, -1/324, -2/324],\n [-2 / 324, -2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1/324, -2/324, -2/324],\n [-2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2/324, -2/324, -2/324]])\n\n res = sg.convolve2d(image, filter_kernel, mode='same', boundary='fill', fillvalue=0)\n coord_x, coord_y = find_max_coords(np.absolute(res))\n\n return coord_x, coord_y","def image_augmentation(img):\n return np.fliplr(img)","def compute(\n self,\n image,\n exclude_center_feature: bool = False,\n exclude_center_value: bool = False,\n features: ndarray = None,\n feature_last_dim: bool = True,\n passthrough_channels: Optional[Tuple[bool]] = None,\n num_reserved_features: int = 0,\n excluded_voxels: Optional[List[Tuple[int]]] = None,\n spatial_feature_offset: Optional[Tuple[float, ...]] = None,\n spatial_feature_scale: Optional[Tuple[float, ...]] = None,\n ):\n raise NotImplementedError()","def pipeline(image, plot = False):\n # undistort image\n undistorted_image = undistort_image(image)\n \n # R&S|sobel-x thresholding\n _, _, _, _, threshold_image = thresholding(undistorted_image)\n \n # yellow mask\n _, mask_yellow = filter_color(undistorted_image, np.array([20,100,100]), np.array([50,255,255]))\n \n # white mask\n _, mask_white = filter_color(undistorted_image, np.array([0,0,220]), np.array([255,35,255]))\n \n # combine yellow and white mask\n mask = cv2.bitwise_or(mask_yellow, mask_white)\n comb_image = np.zeros_like(threshold_image)\n \n # combine mask and thresholded image\n comb_image[(mask > 0)&(threshold_image == 1)] = 1\n \n # warp the binary image\n warped_image, Minv = warp(comb_image, src, dst)\n if plot:\n plt.figure(2)\n plt.imshow(warped_image, cmap = \"gray\")\n plt.title(\"Binary warped image\")\n \n # calculate polynomial fit\n left_fitx, right_fitx, ploty, left_curverad, right_curverad, offset = fit_polynomial(warped_image, plot)\n \n # superimpose lines on top of the polynomial\n superimposed_image = mark_lane_lines(undistorted_image, warped_image, ploty, left_fitx, right_fitx, Minv)\n cv2.putText(superimposed_image, \"Left curvature = \" + str(np.round(left_curverad, 2)) + \" m\",(40,40), \\\n cv2.FONT_HERSHEY_PLAIN, 2, (255,0,0), 2)\n cv2.putText(superimposed_image,\"Right curvature = \" + str(np.round(right_curverad, 2)) + \" m\",(40,80), \\\n cv2.FONT_HERSHEY_PLAIN, 2, (255,0,0), 2)\n cv2.putText(superimposed_image,\"Offset = \" + str(np.round(offset*100, 2)) + \" cm\",(40,120), \\\n cv2.FONT_HERSHEY_PLAIN, 2, (255,0,0), 2)\n \n return superimposed_image","def apply_filter(self, image):\n return cv2.fastNlMeansDenoising(image.astype('uint8'), h=self._strength)","def cs4243_filter(image, kernel):\n Hi, Wi = image.shape\n Hk, Wk = kernel.shape\n filtered_image = np.zeros((Hi, Wi))\n\n ###Your code here####\n # pad image to handle border pixels\n pad_height = (int)((Hk - 1)/2)\n pad_width = (int)((Wk - 1)/2)\n image_pad = pad_zeros(image, pad_height, pad_width)\n\n # Flip the kernel horizontal and vertical\n kernel = cs4243_rotate180(kernel)\n \n # compute effective output size, assume stride=1\n out_height = 1 + Hi - Hk + 2*pad_height\n out_width = 1 + Wi - Wk + 2*pad_width\n \n # get initial nodes of receptive fields\n recep_fields_h = [i for i in range(out_height)]\n recep_fields_w = [i for i in range(out_width)]\n \n for i in recep_fields_h:\n for j in recep_fields_w: \n # get receptive area\n recep_area = image_pad[i:i+Hk, j:j+Wk] \n\n # multiply recep_area with kernel\n conv_sum = 0.0\n for y in range(Hk):\n for x in range(Wk): \n conv_sum += kernel[y][x] * recep_area[y][x]\n filtered_image[i, j] = conv_sum\n ###\n\n return filtered_image","def apply_CLAHE(input_file, output_file):\n img = cv2.imread(input_file, 0)\n\n # Convert image to gray channgel\n img_eq = None\n\n cv2.imwrite(output_file, img_eq)","def fit(self, X, seed=None):\n X = np.copy(X)\n\n if self.featurewise_center:\n self.mean = np.mean(X, axis=0)\n X -= self.mean\n\n if self.featurewise_std_normalization:\n self.std = np.std(X, axis=0)\n X /= self.std\n\n if self.zca_whitening:\n flatX = np.reshape(X, (X.shape[0], X.shape[1]*X.shape[2]*X.shape[3]))\n fudge = 10e-6\n sigma = np.dot(flatX.T, flatX) / flatX.shape[1]\n U, S, V = linalg.svd(sigma)\n self.principal_components = np.dot(np.dot(U, np.diag(1. / np.sqrt(S + fudge))), U.T)","def filtering(self):\n from numpy import fft\n import numpy as np\n\n _image_dft = fft.fft2(self.image)\n _image_dft = fft.fftshift(_image_dft)\n # dft = DFT.DFT()\n # plt.figure(1) \n # plt.imshow(self.image)\n # plt.figure(2)\n # plt.imshow(20*np.log10(abs(_image_dft))) \n # print(_image_dft)\n # print(abs(_image_dft))\n # plt.show()\n filter = self.filter(self.image.shape, self.cutoff, self.order) \\\n if self.filter_name.startswith('butterworth') \\\n else self.filter(self.image.shape, self.cutoff)\n \n _image_dft_filtered = _image_dft * filter\n _image_filtered = abs(fft.ifft2(_image_dft_filtered))\n \n return [ self.post_process_image(_image_filtered), \\\n self.post_process_image(20*np.log10(abs(_image_dft)+.00001)), \\\n self.post_process_image(20*np.log10(abs(_image_dft_filtered)+.00001)) ]","def inverse_cayley_transform(z: torch.Tensor) -> torch.Tensor:\n identity = identity_like(z)\n i_identity = multiply_by_i(identity)\n\n z_minus_id = z - i_identity\n inv_z_plus_id = inverse(z + i_identity)\n return z_minus_id @ inv_z_plus_id","def test_cupy_conv(array, func):\n weights = cupy.ones(array.ndim * (3,), dtype=cupy.float32)\n result = func(array, weights)\n result.compute()","def img2heliovec(bxImg,byImg,bzImg,lon,lat,lonc,latc,pAng):\n a11 = -np.sin(latc)*np.sin(pAng)*np.sin(lon - lonc) + np.cos(pAng)*np.cos(lon - lonc)\n a12 = np.sin(latc)*np.cos(pAng)*np.sin(lon - lonc) + np.sin(pAng)*np.cos(lon - lonc)\n a13 = -np.cos(latc)*np.sin(lon - lonc)\n a21 = -np.sin(lat)*(np.sin(latc)*np.sin(pAng)*np.cos(lon - lonc) + np.cos(pAng)*np.sin(lon - lonc)) - np.cos(lat)*np.cos(latc)*np.sin(pAng)\n a22 = np.sin(lat)*(np.sin(latc)*np.cos(pAng)*np.cos(lon - lonc) - np.sin(pAng)*np.sin(lon - lonc)) + np.cos(lat)*np.cos(latc)*np.cos(pAng)\n a23 = -np.cos(latc)*np.sin(lat)*np.cos(lon - lonc) + np.sin(latc)*np.cos(lat)\n a31 = np.cos(lat)*(np.sin(latc)*np.sin(pAng)*np.cos(lon - lonc) + np.cos(pAng)*np.sin(lon - lonc)) - np.sin(lat)*np.cos(latc)*np.sin(pAng)\n a32 = -np.cos(lat)*(np.sin(latc)*np.cos(pAng)*np.cos(lon - lonc) - np.sin(pAng)*np.sin(lon - lonc)) + np.sin(lat)*np.cos(latc)*np.cos(pAng)\n a33 = np.cos(lat)*np.cos(latc)*np.cos(lon - lonc) + np.sin(lat)*np.sin(latc)\n\n bxHelio = a11 * bxImg + a12 * byImg + a13 * bzImg\n byHelio = a21 * bxImg + a22 * byImg + a23 * bzImg\n bzHelio = a31 * bxImg + a32 * byImg + a33 * bzImg\n\n return bxHelio,byHelio,bzHelio","def perform(self, node, inp, out):\r\n img2d, filtersflipped = inp\r\n z, = out\r\n if not imported_scipy_signal:\r\n raise theano.gof.utils.MethodNotDefined(\r\n \"c_headers\", type(self), self.__class__.__name__,\r\n \"Need the python package for scipy.signal to be installed \"\r\n \"for the python implementation. You can use the C\"\r\n \" implementation instead.\")\r\n\r\n # TODO: move these back out to global scope when they no longer\r\n # cause an atexit error\r\n imshp = self.imshp\r\n if imshp is None or any([x is None for x in imshp]):\r\n imshp = tuple(img2d.shape[1:])\r\n kshp = self.kshp\r\n if kshp is None or any([x is None for x in kshp]):\r\n kshp = tuple(filtersflipped.shape[2:])\r\n bsize = self.bsize\r\n if bsize is None:\r\n bsize = img2d.shape[0]\r\n nkern = self.nkern\r\n if nkern is None:\r\n nkern = filtersflipped.shape[0]\r\n\r\n imshp_logical = self.imshp_logical\r\n if imshp_logical is None:\r\n imshp_logical = imshp\r\n if numpy.any([x is None for x in imshp_logical]):\r\n imshp_logical = tuple(img2d.shape[1:])\r\n\r\n kshp_logical = self.kshp_logical\r\n if kshp_logical is None:\r\n kshp_logical = kshp\r\n if numpy.any([x is None for x in kshp_logical]):\r\n kshp = tuple(filtersflipped.shape[2:])\r\n\r\n if self.fulloutshp is not None:\r\n fulloutshp = tuple(self.fulloutshp)\r\n else:\r\n fulloutshp = tuple(ConvOp.getOutputShape(imshp_logical[\r\n 1:], kshp_logical, (1, 1), self.out_mode))\r\n\r\n if z[0] is None or z[0].shape != (bsize, nkern,) + fulloutshp:\r\n z[0] = numpy.zeros((bsize, nkern,) + fulloutshp,\r\n dtype=img2d.dtype)\r\n zz = z[0]\r\n\r\n stacklen = imshp[0]\r\n\r\n img2d = img2d.reshape((bsize,) + imshp)\r\n filtersflipped = filtersflipped.reshape((nkern, stacklen) + kshp)\r\n\r\n if self.imshp != self.imshp_logical:\r\n # assuming that to get from imshp to imshp logical we insert zeros in missing spots\r\n rstride = int(numpy.ceil(imshp_logical[1] / float(imshp[1])))\r\n cstride = int(numpy.ceil(imshp_logical[2] / float(imshp[2])))\r\n buf = numpy.zeros((bsize,) + imshp_logical, dtype=img2d.dtype)\r\n buf[:, :, ::rstride, ::cstride] = img2d\r\n img2d = buf\r\n del buf, rstride, cstride\r\n\r\n if kshp != kshp_logical:\r\n rstride = int(numpy.ceil(kshp_logical[0] / float(kshp[0])))\r\n cstride = int(numpy.ceil(kshp_logical[1] / float(kshp[1])))\r\n buf = numpy.zeros((nkern, stacklen) +\r\n self.kshp_logical, dtype=filtersflipped.dtype)\r\n if self.kshp_logical_top_aligned:\r\n roffset = coffset = 0\r\n else:\r\n roffset = (kshp_logical[0] - (kshp[0] *\r\n rstride) - 1 + rstride) % rstride\r\n coffset = (kshp_logical[1] - (kshp[1] *\r\n cstride) - 1 + cstride) % cstride\r\n assert roffset >= 0\r\n assert coffset >= 0\r\n buf[:, :, roffset::rstride, coffset::cstride] = filtersflipped\r\n filtersflipped = buf\r\n del buf, rstride, cstride\r\n\r\n val = _valfrommode(self.out_mode)\r\n bval = _bvalfromboundary('fill')\r\n\r\n for b in xrange(bsize):\r\n for n in xrange(nkern):\r\n zz[b, n, ...].fill(0)\r\n for im0 in xrange(stacklen):\r\n zz[b, n, ...] += _convolve2d(img2d[b, im0, ...],\r\n filtersflipped[n, im0, ...],\r\n 1, val, bval, 0)\r\n\r\n if False:\r\n if False and self.out_mode == \"full\":\r\n img2d2 = numpy.zeros((bsize, stacklen,\r\n imshp[1] + 2 * kshp[0] - 2,\r\n imshp[2] + 2 * kshp[1] - 2))\r\n img2d2[:, :, kshp[0] - 1:kshp[0] - 1 + imshp[1],\r\n kshp[1] - 1:kshp[1] - 1 + imshp[2]] = img2d\r\n img2d = img2d2\r\n #N_image_shape = image_data.shape\r\n\r\n for b in xrange(bsize):\r\n for n in xrange(nkern):\r\n zz[b, n, ...].fill(0)\r\n for im0 in xrange(stacklen):\r\n for row in xrange(0, zz.shape[2], self.dx):\r\n for col in xrange(0, zz.shape[3], self.dy):\r\n zz[b, n, row, col] += (img2d[b, im0, row:row + kshp[0], col:col + kshp[1]] *\r\n filtersflipped[n, im0, ::-1, ::-1]).sum()\r\n\r\n #We copy it to remove the Stride mismatch warning from DEBUG_MODE.\r\n #The copy make that we return an object with the same stride as the c version.\r\n #The copy don't affect the performence during our experience as in that case we\r\n #execute the c version which is much faster.\r\n if self.dx > 1 or self.dy > 1:\r\n zz = zz[:, :, 0::self.dx, 0::self.dy].copy()\r\n\r\n z[0] = zz","def __call__(self, img: Image):\n if self.K <= 1:\n return self.transform(img)\n else:\n return [self.transform(img) for _ in range(self.K)]","def anoise(this, *args, **kargs):\n\t\t\n\t\t# Arguments\n\t\tif not args: args = [50]\n\t\t\n\t\t# Kernel's retrieval\n\t\tanoisek = this._ANOISEK\n\t\tif anoisek is None: return None\n\t\t\n\t\t# More magic\n\t\tbin = this._BINARY\n\t\tfor thresh in args:\n\t\t\tbin[:,:] = (cv2.filter2D(bin, -1, anoisek) / 2.55 > thresh) * 255\n\t\treturn True","def WFC3_zeropoint(image):\n logging.debug('Calculating zeropoint for {}'.format(image))\n\n PHOTFLAM = fits.getheader(image)['PHOTFLAM']\n try:\n PHOTPLAM = fits.getheader(image)['PHOTPLAM']\n except:\n PHOTPLAM = fits.getheader(image, 1)['PHOTPLAM']\n\n ABMAG_ZEROPOINT=-2.5*np.log10(PHOTFLAM)-5*np.log10(PHOTPLAM)-2.408\n\n return ABMAG_ZEROPOINT","def aortic_data_augmenter(image, label, shift, rotate, scale, intensity, flip):\n image2 = np.zeros(image.shape, dtype=np.float32)\n label2 = np.zeros(label.shape, dtype=np.int32)\n\n # For N image. which come come from the same subject in the LSTM model,\n # generate the same random affine transformation parameters.\n shift_val = [np.clip(np.random.normal(), -3, 3) * shift,\n np.clip(np.random.normal(), -3, 3) * shift]\n rotate_val = np.clip(np.random.normal(), -3, 3) * rotate\n scale_val = 1 + np.clip(np.random.normal(), -3, 3) * scale\n intensity_val = 1 + np.clip(np.random.normal(), -3, 3) * intensity\n\n # The affine transformation (rotation + scale + shift)\n row, col = image.shape[1:3]\n M = cv2.getRotationMatrix2D(\n (row / 2, col / 2), rotate_val, 1.0 / scale_val)\n M[:, 2] += shift_val\n\n # Apply the transformation to the image\n for i in range(image.shape[0]):\n for c in range(image.shape[3]):\n image2[i, :, :, c] = ndimage.interpolation.affine_transform(\n image[i, :, :, c], M[:, :2], M[:, 2], order=1)\n\n label2[i, :, :] = ndimage.interpolation.affine_transform(\n label[i, :, :], M[:, :2], M[:, 2], order=0)\n\n # Apply intensity variation\n image2[i] *= intensity_val\n\n # Apply random horizontal or vertical flipping\n if flip:\n if np.random.uniform() >= 0.5:\n image2[i] = image2[i, ::-1, :, :]\n label2[i] = label2[i, ::-1, :]\n else:\n image2[i] = image2[i, :, ::-1, :]\n label2[i] = label2[i, :, ::-1]\n return image2, label2","def elastic_transform(\n img: np.ndarray,\n alpha: float,\n sigma: float,\n alpha_affine: float,\n interpolation: int = cv2.INTER_LINEAR,\n border_mode: int = cv2.BORDER_REFLECT_101,\n value: Optional[ImageColorType] = None,\n random_state: Optional[np.random.RandomState] = None,\n approximate: bool = False,\n same_dxdy: bool = False,\n):\n height, width = img.shape[:2]\n\n # Random affine\n center_square = np.array((height, width), dtype=np.float32) // 2\n square_size = min((height, width)) // 3\n alpha = float(alpha)\n sigma = float(sigma)\n alpha_affine = float(alpha_affine)\n\n pts1 = np.array(\n [\n center_square + square_size,\n [center_square[0] + square_size, center_square[1] - square_size],\n center_square - square_size,\n ],\n dtype=np.float32,\n )\n pts2 = pts1 + random_utils.uniform(-alpha_affine, alpha_affine, size=pts1.shape, random_state=random_state).astype(\n np.float32\n )\n matrix = cv2.getAffineTransform(pts1, pts2)\n\n warp_fn = _maybe_process_in_chunks(\n cv2.warpAffine, M=matrix, dsize=(width, height), flags=interpolation, borderMode=border_mode, borderValue=value\n )\n img = warp_fn(img)\n\n if approximate:\n # Approximate computation smooth displacement map with a large enough kernel.\n # On large images (512+) this is approximately 2X times faster\n dx = random_utils.rand(height, width, random_state=random_state).astype(np.float32) * 2 - 1\n cv2.GaussianBlur(dx, (17, 17), sigma, dst=dx)\n dx *= alpha\n if same_dxdy:\n # Speed up even more\n dy = dx\n else:\n dy = random_utils.rand(height, width, random_state=random_state).astype(np.float32) * 2 - 1\n cv2.GaussianBlur(dy, (17, 17), sigma, dst=dy)\n dy *= alpha\n else:\n dx = np.float32(\n gaussian_filter((random_utils.rand(height, width, random_state=random_state) * 2 - 1), sigma) * alpha\n )\n if same_dxdy:\n # Speed up\n dy = dx\n else:\n dy = np.float32(\n gaussian_filter((random_utils.rand(height, width, random_state=random_state) * 2 - 1), sigma) * alpha\n )\n\n x, y = np.meshgrid(np.arange(width), np.arange(height))\n\n map_x = np.float32(x + dx)\n map_y = np.float32(y + dy)\n\n remap_fn = _maybe_process_in_chunks(\n cv2.remap, map1=map_x, map2=map_y, interpolation=interpolation, borderMode=border_mode, borderValue=value\n )\n return remap_fn(img)"],"string":"[\n \"def ZCA_whitening(imageVector):\\n\\n sigma = np.dot(inputs, inputs.T)/inputs.shape[1] #Correlation matrix\\n U,S,V = np.linalg.svd(sigma) #Singular Value Decomposition\\n epsilon = 0.1 #Whitening constant, it prevents division by zero\\n ZCAMatrix = np.dot(np.dot(U, np.diag(1.0/np.sqrt(np.diag(S) + epsilon))), U.T) #ZCA Whitening matrix\\n return np.dot(ZCAMatrix, inputs) #Data whitening\",\n \"def _whiten_embeddings_zca(self, lambd = 1e-8):\\n print('ZCA-Whitening')\\n Cov_s = np.cov(self.xs.T)\\n Cov_t = np.cov(self.xt.T)\\n d = Cov_s.shape[0]\\n\\n W_s = scipy.linalg.sqrtm(Cov_s + lambd*np.eye(d))\\n W_t = scipy.linalg.sqrtm(Cov_t + lambd*np.eye(d))\\n\\n self.xs = self.xs@W_s#.T\\n self.xt = self.xt@W_t#.T\",\n \"def zca_whiten(self, data):\\n # input tensor is [batch_size, num_samples, dim_x]\\n num = compat.get_dim_int(data, 1)\\n\\n data = tf.cast(data, tf.float64)\\n\\n # center the samples\\n mean = tf.reduce_mean(data, axis=1, keepdims=True)\\n centered = data - tf.tile(mean, [1, num, 1])\\n\\n # whiten\\n # compute the current covariance\\n diff_square = tf.matmul(centered[:, :, :, None],\\n centered[:, :, None, :])\\n # sigma: [batch_size, dim_x, dim_x]\\n sigma = tf.reduce_mean(diff_square, axis=1)\\n # get the whitening matrix\\n # s: [batch_size, dim_x], u: [batch_size, dim_x, dim_x]\\n s, u, _ = tf.linalg.svd(sigma, full_matrices=True)\\n s_inv = 1. / tf.sqrt(s + 1e-5)\\n s_inv = tf.linalg.diag(s_inv)\\n # w: [batch_size, dim_x, dim_x]\\n w = tf.matmul(u, tf.matmul(s_inv, u, transpose_b=True))\\n\\n whitened = tf.matmul(centered, w)\\n\\n return whitened\",\n \"def _whiten_embeddings_zca(self, xs, lambd = 1e-8):\\n print('ZCA-Whitening')\\n Cov_s = np.cov(xs.T)\\n d = Cov_s.shape[0]\\n\\n W_s = scipy.linalg.sqrtm(Cov_s + lambd*np.eye(d))\\n xs = xs@W_s#.T\\n return xs\",\n \"def zca_whiten(X):\\n cov = np.cov(X.T)\\n U, Sigma, V = np.linalg.svd(cov)\\n D = np.diag(np.sqrt(1/Sigma)) # square root inverse of singular value matrix\\n W = U @ D @ V # rotation matrix\\n centered = X - X.mean(axis=0)\\n X_white = np.einsum(\\\"ij, ...j -> ...i\\\", W, centered)\\n return X_white\",\n \"def PCA_ZCA_whiten_transform(X, symmetric = True):\\n X = np.asarray(X, dtype='float32')\\n #center\\n X = X - np.mean(X, axis=1).reshape((-1,1))\\n C = np.dot(X.T, X) / X.shape[0]\\n EigVal, EigVec = np.linalg.eigh(C)\\n mval = np.max(np.real(EigVal))\\n max_ratio = 1e4\\n tol = mval / max_ratio\\n #ngd = np.nonzero(np.real(EigVal) > mval/max_ratio)\\n if symmetric:\\n ngd = np.nonzero(np.real(EigVal) > tol)[0]\\n P = (np.real(EigVal[ngd])**(-0.5)).reshape((-1,1)) * EigVec[:, ngd].T # [reduced dim]*[dim]\\n P = np.dot(EigVec[:, ngd], P)\\n else:\\n EigVal[EigVal <= tol] = 1.\\n P = EigVal.reshape((-1,1)) * (EigVec.T)\\n X = np.dot(X, P.T)\\n return X, P.T\",\n \"def whiten(self, blocks=20000, eps=0.0001):\\r\\n cov = np.zeros([self.datasize, self.datasize])\\r\\n nblocks = int(np.ceil(self.nstims / blocks))\\r\\n for ind in range(nblocks):\\r\\n X = self.data[blocks*ind:blocks*(ind+1)]\\r\\n cov += X.T.dot(X)\\r\\n eigvals, eigvecs = np.linalg.eigh(cov)\\r\\n if np.any(np.isnan(eigvals)):\\r\\n print('Warning: some nan eigenvalues found, replacing with small numbers.')\\r\\n eigvals[np.isnan(eigvals)] = 0.9 * eps**2\\r\\n if np.any(eigvals < 0):\\r\\n print('Warning: some negative eigenvalues of covariance matrix found. Replacing with small numbers.')\\r\\n eigvals[eigvals < 0] = 0.9 * eps**2\\r\\n\\r\\n idx = np.argsort(eigvals)\\r\\n svals = np.sqrt(eigvals[idx][::-1])\\r\\n eigvecs = eigvecs[idx][::-1]\\r\\n\\r\\n # do ZCA whitening\\r\\n wm = np.diag(1./np.maximum(svals, eps))\\r\\n self.zca_matrix = eigvecs.T.dot(wm).dot(eigvecs)\\r\\n self.data = self.data.dot(self.zca_matrix)\",\n \"def pca_whiten(X):\\n cov = np.cov(X.T)\\n Sigma, U = np.linalv.eig(cov)\\n D = np.diag(np.sqrt(1/Sigma)) # square root inverse of singular value matrix\\n W = D @ U.T # rotation matrix\\n centered = X - X.mean(axis=0)\\n X_white = np.einsum(\\\"ij, ...j -> ...i\\\", W, centered)\\n return X_white\",\n \"def make_acwe(patch: Patch, params: dict):\\r\\n edge_map = 1.0 - patch.image_layers[\\\"Main\\\"]\\r\\n edge_map -= np.min(edge_map)\\r\\n edge_map = edge_map / np.max(edge_map)\\r\\n logger.debug(\\\"Calculating ACWE\\\")\\r\\n\\r\\n seg1 = ms.morphological_geodesic_active_contour(\\r\\n edge_map,\\r\\n iterations=params[\\\"iterations\\\"],\\r\\n init_level_set=patch.image_layers[\\\"total_mask\\\"],\\r\\n smoothing=params[\\\"smoothing\\\"],\\r\\n threshold=params[\\\"threshold\\\"],\\r\\n balloon=params[\\\"balloon\\\"],\\r\\n )\\r\\n outer_mask = ((seg1 * 1.0) > 0) * 2.0\\r\\n patch.image_layers[\\\"acwe\\\"] = outer_mask\\r\\n\\r\\n return patch\",\n \"def test_identity(self, input_shape, eps, device, dtype):\\n data = torch.randn(*input_shape, device=device, dtype=dtype)\\n\\n zca = kornia.enhance.ZCAWhitening(compute_inv=True, eps=eps).fit(data)\\n\\n data_w = zca(data)\\n\\n data_hat = zca.inverse_transform(data_w)\\n\\n self.assert_close(data, data_hat, low_tolerance=True)\",\n \"def zca_whitening_matrix(X):\\n # Covariance matrix [column-wise variables]: Sigma = (X-mu)' * (X-mu) / N\\n sigma = np.cov(X, rowvar=True) # [M x M]\\n # Singular Value Decomposition. X = U * np.diag(S) * V\\n U,S,V = np.linalg.svd(sigma)\\n # U: [M x M] eigenvectors of sigma.\\n # S: [M x 1] eigenvalues of sigma.\\n # V: [M x M] transpose of U\\n # Whitening constant: prevents division by zero\\n epsilon = 1e-5\\n # ZCA Whitening matrix: U * Lambda * U'\\n ZCAMatrix = np.dot(U, np.dot(np.diag(1.0/np.sqrt(S + epsilon)), U.T)) # [M x M]\\n return ZCAMatrix\",\n \"def whiten(X):\\n X = asmatrix(X - mean(asmatrix(X),axis=1))\\n C = X * X.T / X.shape[1]\\n d, V = eigh(C)\\n d[d<0] = 0 # In case d returns very small negative eigenvalues\\n return (V / sqrt(d+spacing(1))) * V.T * X\",\n \"def bayes_matting(img, trimap, sigma_d=10, it=1):\\n assert img.shape[:-1] == trimap.shape\\n\\n img = img / 255.0\\n nrows, ncols = img.shape[:-1]\\n\\n # initial alpha guess\\n alpha = np.zeros(trimap.shape)\\n alpha[trimap == 255] = 1\\n alpha[trimap == 128] = 0.5\\n\\n B = img[alpha == 0] # background pixel mask\\n F = img[alpha == 1] # foreground pixel mask\\n\\n mean_B = np.mean(B, axis=0)\\n cov_B = np.cov(B.T)\\n mean_F = np.mean(F, axis=0)\\n cov_F = np.cov(F.T)\\n\\n try:\\n inv_cov_B = np.linalg.inv(cov_B)\\n inv_cov_F = np.linalg.inv(cov_F)\\n except LinAlgError:\\n print(\\\"LinAlgError\\\")\\n\\n for i in range(it):\\n print(\\\"Iteration {}\\\".format(i))\\n for row in range(nrows):\\n for col in range(ncols):\\n if trimap[row, col] == 128:\\n f, g = calculate_fg(img[row, col], alpha[row, col], mean_F, inv_cov_F, mean_B, inv_cov_B, sigma_d)\\n alpha[row, col] = calculate_alpha(img[row, col], f, g)\\n\\n alpha = np.clip(alpha, 0, 1)\\n\\n return alpha\",\n \"def apply_filter(image: np.ndarray) -> np.ndarray:\\n # choose filters to apply\\n return clahe(image)\",\n \"def apply_filter(self, image):\\n pass\",\n \"def whiten(data):\\n\\n from numpy.linalg import eig\\n\\n eps = 0.01\\n \\n # covariance matrix\\n Sigma = np.cov(data)\\n\\n # eigenvalue decomposition\\n V,U = eig(Sigma)\\n \\n W = U.dot(np.diag((V+eps)**(-0.5)).dot(U.transpose()))\\n\\n return W\",\n \"def clahe(image: np.ndarray) -> np.ndarray:\\n clahe_filter = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))\\n return clahe_filter.apply(image)\",\n \"def computeB(linsys_setup):\\n datamaps, ninvs, beams, freqs, power_2d, precond_2d, clumaps, g_nu, \\\\\\n map_prop = linsys_setup\\n nx, ny, pixScaleX, pixScaleY = map_prop\\n nFreq = len(g_nu); nCluster = len(clumaps[0])\\n ksz = False\\n if len(clumaps)==2: ksz = True\\n \\n def computeCMBY(d0):\\n \\\"\\\"\\\"\\n For CMB, y = S^1/2 A N^-1 d, where S is CMB signal covariance matrix (Cl's)\\n \\\"\\\"\\\"\\n # N.B. Reshaping operations required to go between 2D pixel arrays and \\n # 1D vector (for linear system)\\n d2 = 0\\n for freq in range(nFreq):\\n d1 = d0[freq].data.copy().reshape((ny,nx))\\n d1 *= ninvs[freq]\\n a_l = fft.fft(d1,axes=[-2,-1])\\n a_l *= beams[freq]*precond_2d\\n d1 = numpy.real(fft.ifft(a_l,axes=[-2,-1],normalize=True))\\n d1 = numpy.reshape(d1,(nx*ny))\\n d2 += d1\\n return d2\\n \\n def computeClusterY(d0):\\n \\\"\\\"\\\"\\n For cluster, y = F^T A^T N^-1 d, where F is TSZ spatial template for cluster.\\n \\\"\\\"\\\"\\n d2 = numpy.zeros(nCluster)\\n for ic in range(nCluster):\\n for freq in range(nFreq):\\n d1 = d0[freq].data.copy().reshape((ny, nx))\\n d2[ic] += numpy.sum(d1 * ninvs[freq] * clumaps[0][ic][freq] * g_nu[freq])\\n return d2\\n \\n def computeClusterKSZY(d0):\\n \\\"\\\"\\\"\\n For cluster, y = K^T A^T N^-1 d, where K is KSZ spatial template for cluster.\\n \\\"\\\"\\\"\\n d2 = numpy.zeros(nCluster)\\n for ic in range(nCluster):\\n for freq in range(nFreq):\\n d1 = d0[freq].data.copy().reshape((ny, nx))\\n d2[ic] += numpy.sum(d1 * ninvs[freq] * clumaps[1][ic][freq])\\n return d2\\n \\n def computeMonopoleY(d0):\\n \\\"\\\"\\\"\\n Overall monopole amplitude.\\n \\\"\\\"\\\"\\n d2 = 0\\n for freq in range(nFreq):\\n d1 = d0[freq].data.copy().reshape((ny, nx))\\n d2 += numpy.sum(d1 * ninvs[freq])\\n return(d2)\\n \\n \\n # CMB realisation; convolve white noise map with beam and multiply by \\n # signal covmat S^1/2 in harmonic space\\n b0 = numpy.random.randn(ny,nx)\\n a_l = numpy.fft.fft2(b0, b0.shape)\\n a_l *= precond_2d * power_2d**(-0.5)\\n b0 = numpy.fft.irfft2(a_l, b0.shape)\\n \\n # Calculate per-band noise realisation.\\n # Multiply by pixel-space N^1/2, convolve with beam, and sum over \\n # cluster pixels to get RHS\\n b1 = 0; b4 = 0\\n b2 = numpy.zeros(nCluster)\\n if ksz: b3 = numpy.zeros(nCluster)\\n \\n for freq in range(nFreq):\\n _b = numpy.random.randn(ny,nx) * ninvs[freq]**0.5\\n a_l = numpy.fft.fft2(_b) * beams[freq] * precond_2d\\n b1 += numpy.fft.irfft2(a_l, _b.shape)\\n b4 += numpy.sum(_b)\\n for ic in range(nCluster):\\n b2[ic] += numpy.sum( _b * g_nu[freq] * clumaps[0][ic][freq] )\\n if ksz: b3[ic] += numpy.sum( _b * clumaps[1][ic][freq] )\\n\\n b0 = numpy.reshape(b0,(nx*ny))\\n b1 = numpy.reshape(b1,(nx*ny))\\n \\n\\n # Compute CMB and cluster data parts of b\\n b_CMB = computeCMBY(datamaps) + b0 + b1\\n b_mono = computeMonopoleY(datamaps) + b4\\n b_tsz = computeClusterY(datamaps) + b2\\n if ksz: b_ksz = computeClusterKSZY(datamaps) + b3\\n \\n # Return total b vector (Ncmbpix + 1 + (1|2)*Ncluster elements in vector)\\n b = numpy.append(b_CMB, b_mono)\\n b = numpy.append(b, b_tsz)\\n if ksz: b = numpy.append(b, b_ksz)\\n return b\",\n \"def filterClusters(inputFile, maskImage, outputFile):\\n os.system('3drefit -space MNI ' + maskImage)\\n os.system('3dcalc -a ' + maskImage \\\\\\n + ' -b ' + inputFile \\\\\\n + \\\" -expr 'step(a) * b'\\\" \\\\\\n + ' -prefix ' + outputFile)\",\n \"def filterClusters(inputFile, maskImage, outputFile):\\n os.system('3drefit -space MNI ' + maskImage)\\n os.system('3dcalc -a ' + maskImage \\\\\\n + ' -b ' + inputFile \\\\\\n + \\\" -expr 'step(a) * b'\\\" \\\\\\n + ' -prefix ' + outputFile)\",\n \"def _augment(img):\\r\\n return flip(img, axis=2)\",\n \"def ICA_Denoise(Y, ica_model, noise_std):\\n\\n # TODO: YOUR CODE HERE\",\n \"def do_transform(self):\\n # TODO: after unit tests are added switch to astropy fftconvolve here.\\n from scipy.signal import fftconvolve\\n total_background = self.model + self.background + self.approx\\n excess = self.image - total_background\\n for key, kern in self.kernbase.items():\\n self.transform[key] = fftconvolve(excess, kern, mode='same')\\n self.error[key] = np.sqrt(fftconvolve(total_background, kern ** 2, mode='same'))\\n\\n self.approx = fftconvolve(self.image - self.model - self.bkg,\\n self.kern_approx, mode='same')\\n self.approx_bkg = fftconvolve(self.bkg, self.kern_approx, mode='same')\",\n \"def _augment(img):\\n return flip(img, axis=2)\",\n \"def zca(x, xtest, bias=0.1):\\n covariance = np.dot(x.T, x) / x.shape[0]\\n covariance += bias * np.eye(x.shape[1])\\n U, S, _ = np.linalg.svd(covariance)\\n pc = U @ np.diag(1. / np.sqrt(S)) @ U.T\\n X = x @ pc\\n Xtest = xtest @ pc\\n return X, Xtest\",\n \"def edges(image):\\n #store image width and height and initialize new image\\n image_width = image['width']\\n image_height = image['height']\\n new_image = {'height': image['height'], 'width': image['width'], 'pixels': len(image['pixels'])*[0]}\\n \\n #sobel operator kernels\\n kernel_x = {'height': 3, 'width': 3, 'pixels': [-1,0,1,-2,0,2,-1,0,1]}\\n kernel_y = {'height': 3, 'width': 3, 'pixels': [-1,-2,-1,0,0,0,1,2,1]}\\n \\n #creating the filters\\n o_x = correlate(image, kernel_x)\\n o_y = correlate(image, kernel_y)\\n\\n #perform relvant calculation for each pixel \\n for x in range(image_width):\\n for y in range(image_height):\\n a = ((get_pixel(o_x, x, y))**2+(get_pixel(o_y, x, y))**2)**0.5\\n set_pixel(new_image, x, y, a)\\n return round_and_clip_image(new_image)\",\n \"def coherenceFilter(img, sigma=11, str_sigma=11, blend=0.5, iter_n=4):\\n h, w = img.shape[:2]\\n tmp = img.copy()\\n for i in xrange(iter_n):\\n gray = cv2.cvtColor(tmp, cv2.COLOR_BGR2GRAY)\\n eigen = cv2.cornerEigenValsAndVecs(gray, str_sigma, 3)\\n eigen = eigen.reshape(h, w, 3, 2) # [[e1, e2], v1, v2]\\n x, y = eigen[:,:,1,0], eigen[:,:,1,1]\\n gxx = cv2.Sobel(gray, cv2.CV_32F, 2, 0, ksize=sigma)\\n gxy = cv2.Sobel(gray, cv2.CV_32F, 1, 1, ksize=sigma)\\n gyy = cv2.Sobel(gray, cv2.CV_32F, 0, 2, ksize=sigma)\\n gvv = x*x*gxx + 2*x*y*gxy + y*y*gyy\\n m = gvv < 0\\n ero = cv2.erode(tmp, None)\\n dil = cv2.dilate(tmp, None)\\n img1 = ero\\n img1[m] = dil[m]\\n tmp = np.uint8(tmp*(1.0 - blend) + img1*blend)\\n return tmp\",\n \"def apply(self, mode='lateral'):\\n num_lat_slices = self.img3d.shape[0]\\n num_cor_slices = self.img3d.shape[2]\\n bin_mask = np.zeros(self.mask3d.shape)\\n x,y,z = np.where(self.mask3d==self.vertebra_id)\\n bin_mask[np.min(x):np.max(x), np.min(y):np.max(y), np.min(z):np.max(z)] = 1\\n if mode=='lateral' or mode=='fuse':\\n mask_lat = np.zeros((6, self.mask3d.shape[0], self.mask3d.shape[1], self.mask3d.shape[2]))\\n img_lat = np.zeros(self.img3d.shape)\\n binary_lat = np.zeros(self.mask3d.shape)\\n # for each lateral slice\\n for idx in range(num_lat_slices):\\n img_slice, mask_slice = np.copy(self.img3d[idx, :, :]), np.copy(self.mask3d[idx, :, :])\\n xloc, yloc = np.where(mask_slice==self.vertebra_id)\\n # check if vertebra is present in image\\n if xloc.shape[0]==0:\\n # if not keep mask as it is\\n mask_lat[:,idx, :, :] = self.get_one_hot(mask_slice)\\n img_lat[idx, :, :] = img_slice\\n else:\\n min_x, max_x = np.min(xloc), np.max(xloc)\\n min_y, max_y = np.min(yloc), np.max(yloc)\\n inpainted_img, inpainted_mask, binary_mask = self.inpaint(img_slice, mask_slice, min_x, max_x, min_y, max_y)\\n mask_lat[:,idx, :, :] = inpainted_mask\\n img_lat[idx,:, :] = inpainted_img\\n binary_lat[idx,:,:] = binary_mask\\n\\n\\n if mode=='coronal' or mode=='fuse':\\n mask_cor = np.zeros((6, self.mask3d.shape[0], self.mask3d.shape[1], self.mask3d.shape[2]))\\n img_cor = np.zeros(self.img3d.shape)\\n binary_cor = np.zeros(self.mask3d.shape)\\n # for each coronal slice\\n for idx in range(num_cor_slices):\\n img_slice, mask_slice = np.copy(self.img3d[:, :, idx]), np.copy(self.mask3d[:, :, idx])\\n xloc, yloc = np.where(mask_slice==self.vertebra_id)\\n # check if vertebra is present in image\\n if xloc.shape[0]==0:\\n # if not keep mask as it is\\n mask_cor[:, :, :, idx] = self.get_one_hot(mask_slice)\\n img_cor[:, :, idx] = img_slice\\n else:\\n min_x, max_x = np.min(xloc), np.max(xloc)\\n min_y, max_y = np.min(yloc), np.max(yloc)\\n # else remove fractured vertebra and inpaint\\n inpainted_img, inpainted_mask, binary_mask = self.inpaint(img_slice, mask_slice, min_x, max_x, min_y, max_y, 'coronal')\\n mask_cor[:, :, :, idx] = inpainted_mask\\n img_cor[:, :, idx] = inpainted_img\\n binary_cor[:,:,idx] = binary_mask\\n \\n # return to a one channel mask and convert labels back\\n if mode=='lateral':\\n mask_lat = np.argmax(mask_lat, axis=0)\\n mask_lat = self.map_class_to_vert(mask_lat)\\n self.mask3d = mask_lat\\n self.img3d = img_lat\\n elif mode=='coronal':\\n mask_cor = np.argmax(mask_cor, axis=0)\\n mask_cor = self.map_class_to_vert(mask_cor)\\n self.mask3d = mask_cor\\n self.img3d = img_cor\\n elif mode=='fuse':\\n mask_fuse = mask_cor*0.5+mask_lat*0.5\\n mask_fuse = np.argmax(mask_fuse, axis=0)\\n mask_fuse = self.map_class_to_vert(mask_fuse)\\n self.mask3d = mask_fuse\\n self.img3d = (img_lat+img_cor)/2\\n \\n # save result\\n self.mask3d = self.mask3d.astype(np.uint8)\\n self.img3d = self.img3d.astype(np.float32)\\n \\n # put back if we padded and cropped\\n if self.padz and self.padx:\\n self.orig_img3d[:,self.ymin:self.ymax, :] = self.img3d[self.xcrop1:-self.xcrop2,:,self.zcrop1:-self.zcrop2]\\n self.orig_mask3d[:,self.ymin:self.ymax, :] = self.mask3d[self.xcrop1:-self.xcrop2,:,self.zcrop1:-self.zcrop2]\\n elif self.padz and not self.padx:\\n self.orig_img3d[self.xcrop1:self.xcrop2,self.ymin:self.ymax, :] = self.img3d[:,:,self.zcrop1:-self.zcrop2]\\n self.orig_mask3d[self.xcrop1:self.xcrop2,self.ymin:self.ymax, :] = self.mask3d[:,:,self.zcrop1:-self.zcrop2]\\n elif not self.padz and self.padx:\\n self.orig_img3d[:,self.ymin:self.ymax, self.zcrop1:self.zcrop2] = self.img3d[self.xcrop1:-self.xcrop2,:,:]\\n self.orig_mask3d[:,self.ymin:self.ymax, self.zcrop1:self.zcrop2] = self.mask3d[self.xcrop1:-self.xcrop2,:,:]\\n else:\\n self.orig_img3d[self.xcrop1:self.xcrop2,self.ymin:self.ymax, self.zcrop1:self.zcrop2] = self.img3d\\n self.orig_mask3d[self.xcrop1:self.xcrop2,self.ymin:self.ymax, self.zcrop1:self.zcrop2] = self.mask3d\\n \\n img = return_scan_to_orig(self.orig_img3d, self.mask_affine, self.mask_header, self.zooms)\\n nib.save(img, self.inpainted_img_path)\\n\\n mask_fuse = return_scan_to_orig(self.orig_mask3d, self.mask_affine, self.mask_header, self.zooms, np.uint8)\\n nib.save(mask_fuse, self.inpainted_mask_path)\\n print('Inpaint mask and image saved at: ', self.inpainted_mask_path, self.inpainted_img_path)\",\n \"def process(data,patch_dim,W=None):\\n\\n # pull patches from image\\n patches = extract_patches(data,patch_dim)\\n\\n # remove dc component and contrast normalize\\n patches = normalize(patches)\\n\\n if W is None:\\n # build whitening matrix\\n W = whiten(patches)\\n\\n # apply whitening\\n patches = W.dot(patches)\\n\\n return patches,W\",\n \"def run(self):\\n #calculate platescale of first input image\\n try:\\n det = np.linalg.det(wcs.WCS(self.datain[0].header).wcs.cd)\\n pscale = np.sqrt(np.abs(det))*3600.\\n except:\\n try:\\n det = np.linalg.det(wcs.WCS(self.datain[0].header).wcs.pc)\\n pscale = np.sqrt(np.abs(det))*3600.\\n except:\\n pscale = self.datain[0].header['PIXSCAL']\\n #filtering out images which are too far away from the others\\n #passing images added to a list of (image, WCS) tuples\\n '''\\n image_centers = []\\n for f in self.datain:\\n image_centers.append((f.header['CRVAL1'], f.header['CRVAL2']))\\n filtered_datain = []\\n dist_list = [[[0]*(len(image_centers)-1)]*len(image_centers)]\\n for i in range(len(image_centers)):\\n for j in range(len(image_centers)-1):\\n dist_list[i][j+1] = np.sqrt((image_)**2+()**2)\\n '''\\n #calculations necessary for updating wcs information\\n px = []\\n py = []\\n \\n #in order to avoid NaN interactions, creating weight map\\n weights=[]\\n for f in self.datain:\\n weights.append((np.where(np.isnan(f.image) == True, 0, 1)))\\n \\n for f in self.datain:\\n px.extend(wcs.WCS(f.header).calc_footprint()[:,0])\\n py.extend(wcs.WCS(f.header).calc_footprint()[:,1])\\n x0 = (max(px)+min(px))/2.\\n y0 = (max(py)+min(py))/2.\\n sx = (max(px)-min(px))*np.cos(y0/180*np.pi) # arcsec\\n sy = (max(py)-min(py)) # arcsec\\n size = (sx*3600+self.getarg('pad')*2, sy*3600+self.getarg('pad')*2)\\n xpix = size[0]//pscale\\n ypix = size[1]//pscale\\n cdelt = [pscale/3600.]*2\\n \\n #create self.dataout and give it a copy of an input's header\\n self.dataout = DataFits(config = self.config)\\n self.dataout.header = self.datain[0].header.copy()\\n \\n #update header wcs information\\n self.log.info('Creating new WCS header')\\n \\n self.dataout.header['CRPIX1'] = xpix/2\\n self.dataout.header['CRPIX2'] = ypix/2\\n self.dataout.header['CRVAL1'] = x0\\n self.dataout.header['CRVAL2'] = y0\\n self.dataout.header['CD1_1'] = -cdelt[0]\\n self.dataout.header['CD1_2'] = self.dataout.header['CD2_1'] = 0.\\n self.dataout.header['CD2_2'] = cdelt[1]\\n self.dataout.header['NAXIS1'] = int(xpix)\\n self.dataout.header['NAXIS2'] = int(ypix)\\n self.dataout.header['CTYPE1'] = 'RA---TAN-SIP'\\n self.dataout.header['CTYPE2'] = 'DEC--TAN-SIP'\\n self.dataout.header['RADESYS'] = 'ICRS'\\n self.dataout.header['EQUINOX'] = 2000\\n self.dataout.header['LATPOLE'] = self.datain[0].header['CRVAL2']\\n self.dataout.header['LONPOLE'] = 180\\n self.dataout.header['PIXASEC'] = pscale\\n \\n theta_rad = np.deg2rad(self.getarg('outangle'))\\n rot_matrix = np.array([[np.cos(theta_rad), -np.sin(theta_rad)], \\n [np.sin(theta_rad), np.cos(theta_rad)]])\\n rot_cd = np.dot(rot_matrix, np.array([[self.dataout.header['CD1_1'], 0.],[0., self.dataout.header['CD2_2']]]))\\n for i in [0,1]:\\n for j in [0,1]:\\n self.dataout.header['CD{0:d}_{1:d}'.format(i+1, j+1)] = rot_cd[i,j]\\n \\n #check drizzle arguments\\n if self.getarg('kernel') == 'smoothing':\\n kernel = 'lanczos3'\\n elif self.getarg('kernel') in ['square', 'point', 'gaussian', 'tophat']:\\n kernel = self.getarg('kernel')\\n else:\\n self.log.error('Kernel name not recognized, using default')\\n kernel = 'square'\\n if self.getarg('drizzleweights') == 'uniform':\\n driz_wt = ''\\n elif self.getarg('drizzleweights') in ['exptime', 'expsq']:\\n driz_wt = self.getarg('drizzleweights')\\n else:\\n self.log.error('Drizzle weighting not recognized, using default')\\n driz_wt = ''\\n \\n #create drizzle object and add input images\\n fullwcs = wcs.WCS(self.dataout.header)\\n self.log.info('Starting drizzle')\\n driz = drz.Drizzle(outwcs = fullwcs, pixfrac=self.getarg('pixfrac'), \\\\\\n kernel=kernel, fillval='10000', wt_scl=driz_wt)\\n for i,f in enumerate(self.datain):\\n self.log.info('Adding %s to drizzle stack' % f.filename)\\n driz.add_image(f.imgdata[0], wcs.WCS(f.header), inwht=weights[i])\\n \\n try:\\n fillval=float(self.getarg('fillval'))\\n except:\\n fillval=np.nan\\n self.log.error('Fillvalue not recognized or missing, using default')\\n \\n #creates output fits file from drizzle output\\n self.dataout.imageset(np.where(driz.outsci == 10000, fillval, driz.outsci))\\n self.dataout.imageset(driz.outwht,'OutWeight', self.dataout.header)\\n self.dataout.filename = self.datain[0].filename\\n\\n #add history\\n self.dataout.setheadval('HISTORY','Coadd: %d files combined with %s kernel, pixfrac %f at %f times resolution' \\\\\\n % (len(self.datain), kernel, self.getarg('pixfrac'), self.getarg('resolution')))\",\n \"def custom_filter(image: Image) -> Image:\\n image = image.filter(ImageFilter.Kernel(\\n size=(3, 3), kernel=(1, 0, 1, 0, 0, 0, 1, 0, 1)))\\n return image\",\n \"def elastic_transform(image, alpha_param, sigma_param, alpha_affine_param, random_state=None):\\n image = np.asarray(image)\\n #im_np = im_np.transpose(1,0,2) # when we go from pil to numpy array the W and L dimensions are swaped\\n\\n if len(image.shape) < 3: # if there is less than 3 channels (black&white) we triplicate the image\\n image = np.concatenate((image[:,:, np.newaxis], image[:,:, np.newaxis], image[:,:, np.newaxis]), axis = 2)\\n\\n alpha = image.shape[1] * alpha_param\\n sigma = image.shape[1] * sigma_param\\n alpha_affine = image.shape[1] * alpha_affine_param\\n\\n if random_state is None:\\n random_state = np.random.RandomState(None)\\n\\n shape = image.shape\\n shape_size = shape[:2]\\n\\n # Random affine\\n center_square = np.float32(shape_size) // 2\\n square_size = min(shape_size) // 3\\n pts1 = np.float32([center_square + square_size, [center_square[0]+square_size, center_square[1]-square_size], center_square - square_size])\\n pts2 = pts1 + random_state.uniform(-alpha_affine, alpha_affine, size=pts1.shape).astype(np.float32)\\n M = cv2.getAffineTransform(pts1, pts2)\\n image = cv2.warpAffine(image, M, shape_size[::-1], borderMode=cv2.BORDER_REFLECT_101)\\n\\n dx = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma) * alpha\\n dy = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma) * alpha\\n dz = np.zeros_like(dx)\\n\\n x, y, z = np.meshgrid(np.arange(shape[1]), np.arange(shape[0]), np.arange(shape[2]))\\n indices = np.reshape(y+dy, (-1, 1)), np.reshape(x+dx, (-1, 1)), np.reshape(z, (-1, 1))\\n\\n im_elastic = map_coordinates(image, indices, order=1, mode='reflect').reshape(shape)\\n\\n return Image.fromarray(np.uint8(im_elastic))\",\n \"def _pca(self):\\n mean_beam = np.mean(self.beam_images, axis=1, keepdims=False)\\n mask = self.mask\\n beam_images = self.beam_images[:, :self.n_beam_images]\\n\\n # Subtract mean_beam from images and apply the mask. Element-wise\\n # multiplication and subtraction using numpy broadcasting (as commented\\n # out below) requires 3 large matrices in memory at an intermediate\\n # point in the computation, namely right after (beam_images -\\n # mean_beam_2d) is evaluated and memory for centered_masked_images is\\n # allocated.\\n # mask_2d = mask[:,np.newaxis]\\n # mean_beam_2d = mean_beam[:,np.newaxis]\\n # centered_masked_images = mask_2d * (beam_images - mean_beam_2d)\\n\\n # Instead of that direct approach, use self._center_and_mask_numba() or\\n # self._center_and_mask_in_place(). As of this writing the _in_place\\n # version is faster, but this may change in the future since the numba\\n # version supports parallelization.\\n centered_masked_images = self._center_and_mask_in_place(\\n beam_images,\\n mask,\\n mean_beam,\\n )\\n # centered_masked_images should be C-contiguous already but it's good to\\n # make sure.\\n centered_masked_images = np.ascontiguousarray(centered_masked_images)\\n\\n # Compute the masked principal components\\n # -1 since last eigenvector isn't necessarily orthogonal to the others.\\n n_eigs = min(self.n_beam_images - 1, self.max_principal_components)\\n n_eigs = max(n_eigs, 1) # Need at least one.\\n # .T means transpose, @ means matrix multiplication.\\n cov_mat = centered_masked_images.T @ centered_masked_images\\n del centered_masked_images # Free up memory.\\n if self.use_sparse_routines:\\n variances, principal_components = eigsh(\\n cov_mat, k=n_eigs, which='LM')\\n else:\\n eigvals_param = (\\n self.n_beam_images - n_eigs,\\n self.n_beam_images - 1)\\n # overwrite_a might reduce memory usage\\n variances, principal_components = eigh(\\n cov_mat, eigvals=eigvals_param, overwrite_a=True)\\n del cov_mat # Free up memory.\\n\\n # Reverse ordering to put largest eigenvectors/eigenvalues first\\n principal_components = np.fliplr(principal_components)\\n variances = np.flip(variances)\\n\\n # principal_components isn't always C-contiguous, and when it's not the\\n # matrix multiplication below becomes extremely slow. It's much faster\\n # to make it C-contiguous first so that numpy can use faster matrix\\n # multiplication routines behind the scenes.\\n principal_components = np.ascontiguousarray(principal_components)\\n\\n # Construct the un-masked basis vectors.\\n centered_images = beam_images - mean_beam[:, np.newaxis]\\n # centered_images should be C-contiguous already but it's good to make\\n # sure.\\n centered_images = np.ascontiguousarray(centered_images)\\n principal_components = centered_images @ principal_components\\n del centered_images # Free up memory.\\n\\n # As of this writing, self._normalize_vectorized() is faster than using\\n # self._normalize_numba() despite the fact that the latter is uses numba\\n # and allows for parallelization. That may change in the future though.\\n principal_components = self._normalize_vectorized(\\n principal_components,\\n mask,\\n )\\n\\n return mean_beam, principal_components, variances\",\n \"def __call__(self, image: torch.Tensor) -> torch.Tensor:\\n # Convert torch tensor to numpy array for scipy\\n image = image.numpy()\\n # Save basic shape\\n shape = image.shape[1:]\\n # Sample offsets\\n dx = gaussian_filter((np.random.rand(*shape) * 2 - 1), self.sigma, mode=\\\"constant\\\", cval=0) * self.alpha\\n dy = gaussian_filter((np.random.rand(*shape) * 2 - 1), self.sigma, mode=\\\"constant\\\", cval=0) * self.alpha\\n x, y = np.meshgrid(np.arange(shape[0]), np.arange(shape[1]), indexing='ij')\\n indices = np.reshape(x + dx, (-1, 1)), np.reshape(y + dy, (-1, 1))\\n # Perform deformation\\n for index in range(image.shape[0]):\\n image[index] = map_coordinates(image[index], indices, order=1).reshape(shape)\\n return torch.from_numpy(image)\",\n \"def augment_image(im):\\n # First crop out the face to save reduce computation load\\n bb = im.landmarks['bb'].lms\\n bb_vec = bb.as_vector()\\n bb_ul = (np.array([bb_vec[0], bb_vec[1]]) - bb.centre()) * 2\\n bb_lr = (np.array([bb_vec[4], bb_vec[5]]) - bb.centre()) * 2\\n ul = bb_ul + bb.centre()\\n lr = bb_lr + bb.centre()\\n im = im.crop(ul, lr, constrain_to_boundary=True)\\n if im.pixels.shape[0] == 1:\\n pix = np.zeros((3, im.pixels.shape[1], im.pixels.shape[2]))\\n pix[:,] = im.pixels\\n im.pixels = pix\\n\\n beta = 0.3\\n cx = np.random.uniform(-beta, beta)\\n cy = np.random.uniform(-beta, beta)\\n fx = 1.0\\n fy = np.random.uniform(0.6, 1.4)\\n max_rotation = 30\\n theta = np.random.uniform(-max_rotation, max_rotation)\\n\\n rotation = menpo.transform.Rotation.init_from_2d_ccw_angle(theta)\\n shear = menpo.transform.Affine(np.array([[1, cx, 0],[cy, 1, 0], [0,0,1]]))\\n scale = menpo.transform.Affine(np.array([[fx, 0, 0],[0, fy, 0], [0,0,1]]))\\n T = scale.compose_after(shear).compose_after(rotation)\\n\\n t_im = im.transform_about_centre(T)\\n\\n t_im = add_color_jetting(t_im)\\n t_im = add_occlusion(t_im)\\n\\n\\n new_bb = t_im.landmarks['PTS'].lms.bounding_box()\\n\\n #new_bb contains the gt bounding box\\n augmented_bb = add_bb_noise(new_bb)\\n augmented_bb = augmented_bb.reshape((4,2))\\n augmented_bb = menpo.shape.PointCloud(augmented_bb)\\n t_im.landmarks['bb'] = menpo.landmark.LandmarkGroup.init_with_all_label(augmented_bb)\\n\\n return t_im\",\n \"def warp_channel(image, homography):\\n\\n\\n boundings = compute_bounding_box(homography,image.shape[1],image.shape[0])\\n x_vals = np.arange(boundings[0][0], boundings[1][0])\\n y_vals = np.arange(boundings[0][1], boundings[1][1])\\n x_vals,y_vals = np.meshgrid(x_vals,y_vals)\\n\\n x_vals_f, y_vals_f = x_vals.flatten(),y_vals.flatten()\\n coor_lst = np.array([x_vals_f.tolist(),y_vals_f.tolist()])\\n inv_hom = np.linalg.inv(homography)\\n new_coor = apply_homography(coor_lst.transpose(),inv_hom).reshape(x_vals.shape[0],x_vals.shape[1],2)\\n warped_im = map_coordinates(image,[new_coor[:, :, 1], new_coor[:, :, 0]],order=1,prefilter=False)\\n return warped_im\",\n \"def GenerateMapAffinity(img,nb_vertex,pointsInterest,objects_centroid,scale):\\n\\n # Apply the downscale right now, so the vectors are correct. \\n img_affinity = Image.new(img.mode, (int(img.size[0]/scale),int(img.size[1]/scale)), \\\"black\\\")\\n # Create the empty tensors\\n totensor = transforms.Compose([transforms.ToTensor()])\\n\\n affinities = []\\n for i_points in range(nb_vertex):\\n affinities.append(torch.zeros(2,int(img.size[1]/scale),int(img.size[0]/scale)))\\n \\n for i_pointsImage in range(len(pointsInterest)): \\n pointsImage = pointsInterest[i_pointsImage]\\n center = objects_centroid[i_pointsImage]\\n for i_points in range(nb_vertex):\\n point = pointsImage[i_points]\\n affinity_pair, img_affinity = getAfinityCenter(int(img.size[0]/scale),\\n int(img.size[1]/scale),\\n tuple((np.array(pointsImage[i_points])/scale).tolist()),\\n tuple((np.array(center)/scale).tolist()), \\n img_affinity = img_affinity, radius=1)\\n\\n affinities[i_points] = (affinities[i_points] + affinity_pair)/2\\n\\n\\n # Normalizing\\n v = affinities[i_points].numpy() \\n \\n xvec = v[0]\\n yvec = v[1]\\n\\n norms = np.sqrt(xvec * xvec + yvec * yvec)\\n nonzero = norms > 0\\n\\n xvec[nonzero]/=norms[nonzero]\\n yvec[nonzero]/=norms[nonzero]\\n\\n affinities[i_points] = torch.from_numpy(np.concatenate([[xvec],[yvec]]))\\n affinities = torch.cat(affinities,0)\\n\\n return affinities\",\n \"def setUp(self):\\n test_file_1 = path.join(\\n path.dirname(datasets.__file__), \\\"twod_image_1.npy\\\"\\n )\\n\\n original_image = np.load(test_file_1)\\n\\n # get a single tile from the image to test\\n # note this image is currently unpadded.\\n # how many boundary elements are needed to pad?\\n extracted_image = original_image[0:32, 0:32]\\n\\n self.img = np.expand_dims(extracted_image, axis=-1)\\n\\n # Don't make this too huge for brevity.\\n self.J = 3\\n # 0 = no overlap etc.\\n self.overlap_log_2 = 0\\n # apply to all available orders\\n self.order = 3\\n # Should be one or more to avoid aliasing, if you want overlapping\\n # tiles this can increase too.\\n self.oversampling = 1\\n\\n self.num_angles = 3\\n self.angles = tuple(\\n [\\n 90.0\\n - np.rad2deg(\\n (int(self.num_angles - self.num_angles / 2 - 1) - theta)\\n * np.pi\\n / self.num_angles\\n )\\n for theta in range(self.num_angles)\\n ]\\n )\\n\\n # details of the input data\\n self.sample_rate = 0.004 * 3\\n\\n # vanilla filter bank\\n wavelets = [\\n vanilla_morlet_2d(self.sample_rate, j=i) for i in range(0, self.J)\\n ]\\n father_wavelet = vanilla_gabor_2d(self.sample_rate, j=self.J)\\n\\n # extract the kernels of each of the wavelets for manual convolution\\n # we'll test using three different angles that we used to create the\\n # transform above.\\n wav1 = wavelets[0]\\n wav2 = wavelets[1]\\n wav3 = wavelets[2]\\n\\n # extract the kernels of each of the wavelets for manual convolution\\n # we'll test using three different angles that we used to create the\\n # transform above.\\n wav1_k = wav1.kernel(self.angles[0])\\n wav2_k = wav2.kernel(self.angles[1])\\n wav3_k = wav3.kernel(self.angles[2])\\n\\n phi = father_wavelet.kernel(0.0)\\n\\n npad = 31\\n img_pad = np.pad(\\n self.img, ((npad, npad), (npad, npad), (0, 0)), mode=\\\"reflect\\\"\\n )\\n # get numpy array of the test input image\\n x = img_pad[:, :, 0]\\n\\n # manual convolution, |x * psi_1|\\n conv = np.abs(convolve2d(x, wav1_k, mode=\\\"same\\\"))\\n conv2 = np.abs(convolve2d(conv, wav2_k, mode=\\\"same\\\"))\\n conv3 = np.abs(convolve2d(conv2, wav3_k, mode=\\\"same\\\"))\\n\\n # unpad the original image, and convolve with the phi\\n # note that the dimensions for phi are one less than the\\n # conv result, so we get a 4x4 result. Take the first one\\n self.manual_result1 = convolve2d(\\n conv[npad:-npad, npad:-npad], phi.real, mode=\\\"valid\\\"\\n )[0, 0]\\n self.manual_result2 = convolve2d(\\n conv2[npad:-npad, npad:-npad], phi.real, mode=\\\"valid\\\"\\n )[0, 0]\\n self.manual_result3 = convolve2d(\\n conv3[npad:-npad, npad:-npad], phi.real, mode=\\\"valid\\\"\\n )[0, 0]\",\n \"def GenerateMapAffinity(img, nb_vertex, pointsInterest, objects_centroid, scale):\\n\\n # Apply the downscale right now, so the vectors are correct.\\n img_affinity = Image.new(img.mode, (int(img.size[0] / scale), int(img.size[1] / scale)), \\\"black\\\")\\n # Create the empty tensors\\n totensor = transforms.Compose([transforms.ToTensor()])\\n\\n affinities = []\\n for i_points in range(nb_vertex):\\n affinities.append(torch.zeros(2, int(img.size[1] / scale), int(img.size[0] / scale)))\\n\\n for i_pointsImage in range(len(pointsInterest)):\\n pointsImage = pointsInterest[i_pointsImage]\\n center = objects_centroid[i_pointsImage]\\n for i_points in range(nb_vertex):\\n point = pointsImage[i_points]\\n affinity_pair, img_affinity = getAfinityCenter(int(img.size[0] / scale),\\n int(img.size[1] / scale),\\n tuple((np.array(pointsImage[i_points]) / scale).tolist()),\\n tuple((np.array(center) / scale).tolist()),\\n img_affinity=img_affinity, radius=1)\\n\\n affinities[i_points] = (affinities[i_points] + affinity_pair) / 2\\n\\n # Normalizing\\n v = affinities[i_points].numpy()\\n\\n xvec = v[0]\\n yvec = v[1]\\n\\n norms = np.sqrt(xvec * xvec + yvec * yvec)\\n nonzero = norms > 0\\n\\n xvec[nonzero] /= norms[nonzero]\\n yvec[nonzero] /= norms[nonzero]\\n\\n affinities[i_points] = torch.from_numpy(np.concatenate([[xvec], [yvec]]))\\n affinities = torch.cat(affinities, 0)\\n\\n return affinities\",\n \"def convolve_im(im: np.array,\\n kernel: np.array,\\n verbose=True):\\n ### START YOUR CODE HERE ### (You can change anything inside this block)\\n \\\"\\\"\\\"\\n\\tcompared to the 4a solution this just adds padding to the filter if its smaller than the image\\n\\tthis is done by using the second parameter in fft.fft2 \\n\\t\\n\\tfirst it applies fourier transforms on the kernel and the image\\n\\tthen it sets the image to be the pointwise multiplication of the transforms\\n\\n the image is inverse fourier transformed and filtered for real values\\n the domain image is shifted and taken the absolute value of\\n the fourier transform of the image and kernel are also shifted and set to be the absolute value\\n\\tlastly everything is displayed in the subplots\\n \\\"\\\"\\\"\\n conv_result = im \\n \\n if verbose:\\n fftKernel=np.fft.fft2(kernel,im.shape)\\n fftImage=np.fft.fft2(conv_result)\\n\\t\\t\\n\\t\\t\\n\\t\\t\\n conv_result=np.multiply(fftImage,fftKernel)\\n fftImageTransformed=conv_result\\n\\t\\t\\n \\n conv_result=np.fft.ifft2(conv_result)\\n \\n conv_result=np.real(conv_result)\\n\\n fftImageTransformed=np.fft.fftshift(fftImageTransformed)\\n fftImage=np.fft.fftshift(fftImage)\\n fftKernel=np.fft.fftshift(fftKernel)\\n\\n fftImageTransformed=np.absolute(fftImageTransformed)\\n fftImage=np.absolute(fftImage)\\n fftKernel=np.absolute(fftKernel)\\n\\t\\t\\n\\t\\t\\n # Use plt.subplot to place two or more images beside eachother\\n plt.figure(figsize=(20, 4))\\n # plt.subplot(num_rows, num_cols, position (1-indexed))\\n plt.subplot(1, 5, 1)\\n plt.imshow(im, cmap=\\\"gray\\\")\\n plt.subplot(1, 5, 2)\\n plt.imshow(fftImage, cmap=\\\"gray\\\")\\n plt.subplot(1, 5, 3)\\n plt.imshow(fftKernel, cmap=\\\"gray\\\")\\n plt.subplot(1, 5, 4)\\n plt.imshow(fftImageTransformed, cmap=\\\"gray\\\")\\n plt.subplot(1, 5, 5)\\n plt.imshow(conv_result, cmap=\\\"gray\\\")\\n ### END YOUR CODE HERE ###\\n return conv_result\",\n \"def PA_SB_Zx_func(data, weit_data, pix_size, cx, cy, z0, R_bins):\\n\\tDa0 = Test_model.angular_diameter_distance(z0).value ## in unit 'Mpc'\\n\\tNx = data.shape[1]\\n\\tNy = data.shape[0]\\n\\tx0 = np.linspace(0, Nx-1, Nx)\\n\\ty0 = np.linspace(0, Ny-1, Ny)\\n\\tpix_id = np.array(np.meshgrid(x0,y0))\\n\\n\\t#..center pixel point\\n\\tdev_05_x = cx - np.int( cx )\\n\\tdev_05_y = cy - np.int( cy )\\n\\n\\tif dev_05_x > 0.5:\\n\\t\\txn = np.int( cx ) + 1\\n\\telse:\\n\\t\\txn = np.int( cx )\\n\\n\\tif dev_05_y > 0.5:\\n\\t\\tyn = np.int( cy ) + 1\\n\\telse:\\n\\t\\tyn = np.int( cy )\\n\\n\\ttheta = np.arctan2((pix_id[1,:] - yn), (pix_id[0,:] - xn))\\n\\tchi = theta * 180 / np.pi\\n\\n\\trbin = R_bins # have been divided bins, in unit of pixels\\n\\tset_r = rbin * pix_size * Da0 * 1e3 / rad2arcsec # in unit of kpc\\n\\n\\n\\t#. surface brightness along the row direction\\n\\tintens_r_h = np.zeros(len(rbin), dtype = np.float)\\n\\tintens_h = np.zeros(len(rbin), dtype = np.float)\\n\\tintens_h_err = np.zeros(len(rbin), dtype = np.float)\\n\\n\\tN_pix_h = np.zeros(len(rbin), dtype = np.float)\\n\\tnsum_ratio_h = np.zeros(len(rbin), dtype = np.float)\\n\\n\\n\\t#. surface brightness along the column direction\\n\\tintens_r_v = np.zeros(len(rbin), dtype = np.float)\\n\\tintens_v = np.zeros(len(rbin), dtype = np.float)\\n\\tintens_v_err = np.zeros(len(rbin), dtype = np.float)\\n\\n\\tN_pix_v = np.zeros(len(rbin), dtype = np.float)\\n\\tnsum_ratio_v = np.zeros(len(rbin), dtype = np.float)\\n\\n\\n\\t#. surface brightness along the diagonal direction\\n\\tintens_r_d = np.zeros(len(rbin), dtype = np.float)\\n\\tintens_d = np.zeros(len(rbin), dtype = np.float)\\n\\tintens_d_err = np.zeros(len(rbin), dtype = np.float)\\t\\n\\n\\tN_pix_d = np.zeros(len(rbin), dtype = np.float)\\n\\tnsum_ratio_d = np.zeros(len(rbin), dtype = np.float)\\n\\n\\n\\tdr = np.sqrt( ( (2*pix_id[0] + 1) / 2 - (2*xn + 1) / 2)**2 + ( (2*pix_id[1] + 1) / 2 - (2*yn + 1) / 2)**2)\\n\\tdiff_x = (2 * pix_id[0] + 1) / 2 - (2 * xn + 1) / 2\\n\\tdiff_y = (2 * pix_id[1] + 1) / 2 - (2 * yn + 1) / 2\\n\\n\\n\\tfor k in range(len(rbin) - 1):\\n\\n\\t\\tcdr = rbin[k + 1] - rbin[k]\\n\\t\\td_phi = (cdr / ( 0.5 * (rbin[k] + rbin[k + 1]) ) ) * 180 / np.pi\\n\\t\\tN_phi = np.int(360 / d_phi) + 1\\n\\t\\tphi = np.linspace(0, 360, N_phi)\\n\\t\\tphi = phi - 180\\n\\n\\t\\tr_iner = set_r[k] ## useing radius in unit of kpc\\n\\t\\tr_out = set_r[k + 1]\\n\\n\\t\\tir = (dr >= rbin[k]) & (dr < rbin[k + 1])\\n\\t\\tbool_sum = np.sum(ir)\\n\\n\\t\\tif bool_sum == 0:\\n\\t\\t\\tintens_r_h[k] = 0.5 * (r_iner + r_out) # in unit of kpc\\n\\t\\t\\tintens_r_v[k] = 0.5 * (r_iner + r_out) # in unit of kpc\\n\\t\\t\\tintens_r_d[k] = 0.5 * (r_iner + r_out) # in unit of kpc\\n\\n\\t\\t\\tcontinue\\n\\n\\t\\telse:\\n\\t\\t\\t#. points located in radius bin\\n\\t\\t\\tid_vx = (dr >= rbin[k]) & (dr < rbin[k + 1])\\n\\n\\n\\t\\t\\t##. points along the row direction\\n\\t\\t\\tid_ux_0 = np.abs( diff_x ) < rbin[ k ]\\n\\t\\t\\tid_uy_0 = ( np.abs( diff_y ) >= rbin[ k ] ) & ( np.abs( diff_y ) < rbin[ k+1 ] )\\n\\t\\t\\tid_lim_0 = ( id_ux_0 & id_uy_0 ) & id_vx\\n\\n\\t\\t\\tweit_arr_0 = weit_data[ id_lim_0 ]\\n\\n\\t\\t\\tsamp_flux = data[ id_lim_0 ]\\n\\t\\t\\tsamp_chi = chi[ id_lim_0 ]\\n\\t\\t\\ttot_flux = np.nansum( samp_flux * weit_arr_0 ) / np.nansum( weit_arr_0 )\\n\\n\\t\\t\\tidnn = np.isnan( samp_flux )\\n\\t\\t\\tN_pix_v[ k ] = np.sum( idnn == False )\\n\\t\\t\\tnsum_ratio_v[ k ] = np.nansum( weit_arr_0 ) / np.sum( idnn == False )\\t\\t\\t\\n\\n\\t\\t\\tintens_v[ k ] = tot_flux\\n\\t\\t\\tcen_r = np.nansum( dr[ id_lim_0 ] * weit_arr_0 ) / np.nansum( weit_arr_0 ) * pix_size\\n\\t\\t\\tintens_r_v[ k ] = cen_r * Da0 * 1e3 / rad2arcsec\\n\\n\\t\\t\\ttmpf = []\\n\\t\\t\\tfor tt in range(len(phi) - 1):\\n\\n\\t\\t\\t\\tiv = (samp_chi >= phi[tt]) & (samp_chi <= phi[tt+1])\\n\\n\\t\\t\\t\\tif np.sum( iv ) == 0:\\n\\t\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tset_samp = samp_flux[ iv ]\\n\\t\\t\\t\\t\\tset_weit = weit_arr_0[ iv ]\\n\\n\\t\\t\\t\\t\\tttf = np.nansum( set_samp * set_weit ) / np.nansum( set_weit )\\n\\t\\t\\t\\t\\ttmpf.append( ttf )\\n\\n\\t\\t\\t# rms of flux\\n\\t\\t\\ttmpf = np.array( tmpf )\\n\\t\\t\\tid_inf = np.isnan( tmpf )\\n\\t\\t\\ttmpf[ id_inf ] = np.nan\\n\\t\\t\\tid_zero = tmpf == 0\\n\\t\\t\\ttmpf[id_zero] = np.nan\\n\\n\\t\\t\\tid_nan = np.isnan( tmpf )\\n\\t\\t\\tid_fals = id_nan == False\\n\\t\\t\\tTmpf = tmpf[ id_fals ]\\n\\n\\t\\t\\tRMS = np.std(Tmpf)\\n\\n\\t\\t\\tif len(Tmpf) > 1:\\n\\t\\t\\t\\tintens_v_err[k] = RMS / np.sqrt(len(Tmpf) - 1)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tintens_v_err[k] = RMS\\n\\n\\n\\t\\t\\t##. points along the columns direction\\n\\t\\t\\tid_ux_1 = np.abs( diff_y ) < rbin[ k ]\\n\\t\\t\\tid_uy_1 = ( np.abs( diff_x ) >= rbin[ k ] ) & ( np.abs( diff_x ) < rbin[ k+1 ] )\\n\\t\\t\\tid_lim_1 = ( id_ux_1 & id_uy_1 ) & id_vx\\n\\n\\t\\t\\tweit_arr_1 = weit_data[ id_lim_1 ]\\n\\n\\t\\t\\tsamp_flux = data[ id_lim_1 ]\\n\\t\\t\\tsamp_chi = chi[ id_lim_1 ]\\n\\t\\t\\ttot_flux = np.nansum( samp_flux * weit_arr_1 ) / np.nansum( weit_arr_1 )\\n\\n\\t\\t\\tidnn = np.isnan( samp_flux )\\n\\t\\t\\tN_pix_h[ k ] = np.sum( idnn == False )\\n\\t\\t\\tnsum_ratio_h[ k ] = np.nansum( weit_arr_1 ) / np.sum( idnn == False )\\t\\t\\t\\n\\n\\t\\t\\tintens_h[ k ] = tot_flux\\n\\t\\t\\tcen_r = np.nansum( dr[ id_lim_1 ] * weit_arr_1 ) / np.nansum( weit_arr_1 ) * pix_size\\n\\t\\t\\tintens_r_h[ k ] = cen_r * Da0 * 1e3 / rad2arcsec\\n\\n\\t\\t\\ttmpf = []\\n\\t\\t\\tfor tt in range(len(phi) - 1):\\n\\n\\t\\t\\t\\tiv = (samp_chi >= phi[tt]) & (samp_chi <= phi[tt+1])\\n\\n\\t\\t\\t\\tif np.sum( iv ) == 0:\\n\\t\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tset_samp = samp_flux[ iv ]\\n\\t\\t\\t\\t\\tset_weit = weit_arr_1[ iv ]\\n\\n\\t\\t\\t\\t\\tttf = np.nansum( set_samp * set_weit ) / np.nansum( set_weit )\\n\\t\\t\\t\\t\\ttmpf.append( ttf )\\n\\n\\t\\t\\t# rms of flux\\n\\t\\t\\ttmpf = np.array( tmpf )\\n\\t\\t\\tid_inf = np.isnan( tmpf )\\n\\t\\t\\ttmpf[ id_inf ] = np.nan\\n\\t\\t\\tid_zero = tmpf == 0\\n\\t\\t\\ttmpf[id_zero] = np.nan\\n\\n\\t\\t\\tid_nan = np.isnan( tmpf )\\n\\t\\t\\tid_fals = id_nan == False\\n\\t\\t\\tTmpf = tmpf[ id_fals ]\\n\\n\\t\\t\\tRMS = np.std(Tmpf)\\n\\n\\t\\t\\tif len(Tmpf) > 1:\\n\\t\\t\\t\\tintens_h_err[k] = RMS / np.sqrt(len(Tmpf) - 1)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tintens_h_err[k] = RMS\\n\\n\\n\\t\\t\\t##. points along the diagonal direction\\n\\t\\t\\tid_qx = ( np.abs( diff_x ) <= rbin[ k ] ) & ( np.abs( diff_y ) <= rbin[ k ] )\\n\\t\\t\\tid_lim_2 = id_qx & id_vx\\n\\n\\t\\t\\tweit_arr_2 = weit_data[ id_lim_2 ]\\n\\n\\t\\t\\tsamp_flux = data[ id_lim_2 ]\\n\\t\\t\\tsamp_chi = chi[ id_lim_2 ]\\n\\t\\t\\ttot_flux = np.nansum( samp_flux * weit_arr_2 ) / np.nansum( weit_arr_2 )\\n\\n\\t\\t\\tidnn = np.isnan( samp_flux )\\n\\t\\t\\tN_pix_d[ k ] = np.sum( idnn == False )\\n\\t\\t\\tnsum_ratio_d[ k ] = np.nansum( weit_arr_2 ) / np.sum( idnn == False )\\t\\t\\t\\n\\n\\t\\t\\tintens_d[ k ] = tot_flux\\n\\t\\t\\tcen_r = np.nansum( dr[ id_lim_2 ] * weit_arr_2 ) / np.nansum( weit_arr_2 ) * pix_size\\n\\t\\t\\tintens_r_d[ k ] = cen_r * Da0 * 1e3 / rad2arcsec\\n\\n\\t\\t\\ttmpf = []\\n\\t\\t\\tfor tt in range(len(phi) - 1):\\n\\n\\t\\t\\t\\tiv = (samp_chi >= phi[tt]) & (samp_chi <= phi[tt+1])\\n\\n\\t\\t\\t\\tif np.sum( iv ) == 0:\\n\\t\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tset_samp = samp_flux[ iv ]\\n\\t\\t\\t\\t\\tset_weit = weit_arr_2[ iv ]\\n\\n\\t\\t\\t\\t\\tttf = np.nansum( set_samp * set_weit ) / np.nansum( set_weit )\\n\\t\\t\\t\\t\\ttmpf.append( ttf )\\n\\n\\t\\t\\t# rms of flux\\n\\t\\t\\ttmpf = np.array( tmpf )\\n\\t\\t\\tid_inf = np.isnan( tmpf )\\n\\t\\t\\ttmpf[ id_inf ] = np.nan\\n\\t\\t\\tid_zero = tmpf == 0\\n\\t\\t\\ttmpf[id_zero] = np.nan\\n\\n\\t\\t\\tid_nan = np.isnan( tmpf )\\n\\t\\t\\tid_fals = id_nan == False\\n\\t\\t\\tTmpf = tmpf[ id_fals ]\\n\\n\\t\\t\\tRMS = np.std(Tmpf)\\n\\n\\t\\t\\tif len(Tmpf) > 1:\\n\\t\\t\\t\\tintens_d_err[k] = RMS / np.sqrt(len(Tmpf) - 1)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tintens_d_err[k] = RMS\\n\\n\\t#..\\n\\tidzo = N_pix_h < 1\\n\\n\\tSB_h = intens_h.copy()\\n\\tSB_h[idzo] = 0.\\n\\tSB_h_err = intens_h_err.copy()\\n\\tSB_h_err[idzo] = 0.\\n\\n\\tSB_h_R = intens_r_h.copy()\\n\\tnsum_ratio_h[idzo] = 0.\\n\\tSB_h, SB_h_err = SB_h / pix_size**2, SB_h_err / pix_size**2\\n\\n\\n\\tidzo = N_pix_v < 1\\n\\n\\tSB_v = intens_v.copy()\\n\\tSB_v[idzo] = 0.\\n\\tSB_v_err = intens_v_err.copy()\\n\\tSB_v_err[idzo] = 0.\\n\\n\\tSB_v_R = intens_r_v.copy()\\n\\tnsum_ratio_v[idzo] = 0.\\n\\tSB_v, SB_v_err = SB_v / pix_size**2, SB_v_err / pix_size**2\\n\\n\\n\\tidzo = N_pix_d < 1\\n\\n\\tSB_d = intens_d.copy()\\n\\tSB_d[idzo] = 0.\\n\\tSB_d_err = intens_d_err.copy()\\n\\tSB_d_err[idzo] = 0.\\n\\n\\tSB_d_R = intens_r_d.copy()\\n\\tnsum_ratio_d[idzo] = 0.\\n\\tSB_d, SB_d_err = SB_d / pix_size**2, SB_d_err / pix_size**2\\n\\n\\n\\th_array = [ SB_h_R, SB_h, SB_h_err, N_pix_h, nsum_ratio_h ]\\n\\tv_array = [ SB_v_R, SB_v, SB_v_err, N_pix_v, nsum_ratio_v ]\\n\\td_array = [ SB_d_R, SB_d, SB_d_err, N_pix_d, nsum_ratio_d ]\\n\\n\\treturn h_array, v_array, d_array\",\n \"def elasticTransform_legacy(image, mask, sigma, alpha_affine, random_seed=None):\\n\\t\\n\\trandom_state = np.random.RandomState(random_seed)\\n\\t\\n\\tif len(image.shape)<3:\\n\\t\\timage = np.expand_dims(image,-1)\\n\\tif len(mask.shape)<3:\\n\\t\\tmask = np.expand_dims(mask,-1)\\n\\t\\n\\tshape = image.shape\\n\\tshape_size = shape[:2]\\n\\n\\t# Random affine\\n\\tcenter_square = np.float32(shape_size) // 2\\n\\tsquare_size = min(shape_size) // 3\\n\\tpts1 = np.float32([center_square + square_size, [center_square[0] + square_size,center_square[1] - square_size], center_square - square_size])\\n\\tpts2 = pts1 + random_state.uniform(-alpha_affine,alpha_affine, size=pts1.shape).astype(np.float32)\\n\\t\\n\\tM = cv2.getAffineTransform(pts1, pts2)\\n\\t\\n\\timage_w = np.zeros_like(image)\\n\\tfor i in range(image.shape[-1]):\\n\\t\\timage_w[...,i] = cv2.warpAffine(image[...,i], M, shape_size[::-1], borderMode=cv2.BORDER_CONSTANT, borderValue=int(np.min(image[...,i])))\\n\\t\\n\\tmask_w = np.zeros_like(mask)\\n\\tfor i in range(mask.shape[-1]):\\n\\t\\tmask_w[...,i] = cv2.warpAffine(mask[...,i] , M, shape_size[::-1], borderMode=cv2.BORDER_REPLICATE)\\n\\n\\tblur_size = int(2*sigma) | 1\\n\\tdx = cv2.GaussianBlur((random_state.rand(*shape) * 2 - 1), ksize=(blur_size, blur_size), sigmaX=sigma)\\n\\tdy = cv2.GaussianBlur((random_state.rand(*shape) * 2 - 1), ksize=(blur_size, blur_size), sigmaX=sigma)\\n\\t\\n\\tif len(dx.shape) < 3:\\n\\t\\tdx = np.expand_dims(dx,-1)\\n\\t\\tdy = np.expand_dims(dy,-1)\\n\\n\\tgx, gy = np.meshgrid(np.arange(shape_size[1]), np.arange(shape_size[0]))\\n\\tgx = np.expand_dims(gx,-1)\\n\\tgy = np.expand_dims(gy,-1)\\n\\n\\tgx = np.repeat(gx,dx.shape[-1], -1)\\n\\tgy = np.repeat(gy,dy.shape[-1], -1)\\n\\n\\tgx = (gx + dx).astype(np.float32)\\n\\tgy = (gy + dy).astype(np.float32)\\n\\n\\timage_d = np.zeros_like(image_w)\\n\\tmask_d = np.zeros_like(mask_w)\\n\\n\\tfor i in range(image.shape[-1]):\\n\\t\\timage_d[...,i] = cv2.remap(image_w[...,i], gx[...,i], gy[...,i], interpolation=cv2.INTER_LINEAR)\\n\\t\\n\\tradix = gx.shape[-1]\\n\\tfor i in range(mask.shape[-1]):\\n\\t\\tmask_d[...,i] = cv2.remap(mask_w[...,i], gx[...,i%radix], gy[...,i%radix], interpolation=cv2.INTER_LINEAR)\\n\\t\\n\\treturn image_d, mask_d\",\n \"def applyIncidenceFilter(image, bandNames, classDictionary, numChangesCutoff = 8, connectedPixelCutoff=6):\\n #Calculate the number of times a pixel changes throughout the time series and determine if it is over the numChangesCutoff\\n num_changes = calculateNumberOfChanges(image, bandNames)\\n too_many_changes = num_changes.gt(numChangesCutoff)\\n \\n #Get binary images of the land cover classifications for the current year\\n binary_class_images = npv.convertClassificationsToBinaryImages(image, classDictionary)\\n \\n #Calculate the number of connected pixels for each land cover class and year, reduce to a single band image representing the number\\n #of connected pixels of the same land cover class as the central pixel, and determine if it is over the connectedPixelCutoff\\n connected_pixel_count = ee.ImageCollection(binary_class_images.map(lambda x: x.mask(x).connectedPixelCount(100,False).reduce(ee.Reducer.sum()).lt(connectedPixelCutoff)))\\n \\n #Get a bitwiseAnd determination if the number of connected pixels <= connectedPixelCutoff and the number of changes > numChangesCutoff \\n incidence_filter = ee.ImageCollection(connected_pixel_count.map(lambda x: x.bitwiseAnd(too_many_changes))).toBands().rename(bandNames)\\n \\n #Get an image that represents the mode of the land cover classes in each pixel\\n mode_image = image.reduce(ee.Reducer.mode())\\n \\n #Replace pixels of image where incidence_filter is True with mode_image\\n incidence_filtered = image.where(incidence_filter, mode_image)\\n \\n return incidence_filtered\",\n \"def preprocess(self, img):\\n undistorted = undistort(img, self.mtx, self.dist)\\n warped = warp(self.transform_matrix, undistorted)\\n binary_img = binarize(warped, s_thres=(100, 255), l_thres=(50, 255))\\n return binary_img\",\n \"def normalise(image):\",\n \"def azizen(self):\\n # x0,y0 array pixel coordinates relative to cx,cy\\n# ndy0,ndx0=img.shape\\n ndy0=self.ndy0\\n ndx0=self.ndx0\\n x0,y0=np.meshgrid(np.linspace(0,ndx0-1,ndx0)-self.cx,np.linspace(0,ndy0-1,ndy0)-self.cy)\\n r0=np.sqrt(x0**2+y0**2)/self.pr0 # fractional radial distance from 0,0\\n# self.roi=np.s_[ystart:ystart+self.ny0,xstart:xstart+self.nx0]\\n # why not model the zenith angle dependence with polynomial directly\\n # rather than linear interpolation between roots.\\n roots=np.zeros(51)\\n rr=np.arange(51)/100.0\\n for i,ref in enumerate(rr):\\n roots[i]=np.real(np.roots([self.c3,0,self.c2,0,self.c1,-ref])[-1])\\n theta0 = np.interp(r0/2,rr,roots)\\n \\n phi0 = np.arctan2(x0,y0) - self.rot ####phi (i.e., azimuth) is reckoned with -pi corresponding to north, increasing clockwise, NOTE: pysolar use sub-standard definition\\n phi0 = phi0%(2*np.pi)\\n\\n #####correction for the tilt of the camera\\n k=np.array((np.sin(self.azm),np.cos(self.azm),0))\\n a=np.array([np.sin(theta0)*np.cos(phi0),np.sin(theta0)*np.sin(phi0),np.cos(theta0)]); \\n a = np.transpose(a,[1,2,0])\\n b=np.cos(self.beta)*a + np.sin(self.beta)*np.cross(k,a,axisb=2) \\\\\\n + np.reshape(np.outer(np.dot(a,k),k),(self.ndy0,self.ndx0,3))*(1-np.cos(self.beta))\\n theta0=np.arctan(np.sqrt(b[:,:,0]**2+b[:,:,1]**2)/b[:,:,2])\\n phi0=np.arctan2(b[:,:,1],b[:,:,0])%(2*np.pi)\\n# max_theta *= deg2rad \\n# valid0 = (theta0<max_theta) & (theta0>0); \\n# theta0[valid0]=np.nan;\\n self.theta0,self.phi0=theta0,phi0\",\n \"def filtering(self):\\r\\n # 1 ###########################################################################################################\\r\\n fft_image = np.fft.fft2(self.image)\\r\\n # 2 ###########################################################################################################\\r\\n fft_shift_image = np.fft.fftshift(fft_image)\\r\\n\\r\\n ###\\r\\n mag_dft = np.log(np.abs(fft_shift_image))\\r\\n mag_dft = (255 * (mag_dft / np.max(mag_dft))).astype(dtype='uint8')\\r\\n ###\\r\\n\\r\\n # 3 ###########################################################################################################\\r\\n if self.filter_name == 'butterworth_l' or self.filter_name == 'butterworth_h':\\r\\n mask = self.filter(fft_shift_image.shape, self.cutoff, self.order)\\r\\n else:\\r\\n mask = self.filter(fft_shift_image.shape, self.cutoff)\\r\\n # 4 ###########################################################################################################\\r\\n # multiply the dft (fft shift image) by the mask\\r\\n filtered_image = fft_shift_image * mask\\r\\n\\r\\n ###\\r\\n mag_filtered_image = mag_dft * mask\\r\\n ###\\r\\n\\r\\n # 5 ###########################################################################################################\\r\\n inverse_fft_shift_image = np.fft.ifftshift(filtered_image)\\r\\n # 6 ###########################################################################################################\\r\\n inverse_fft_image = np.fft.ifft2(inverse_fft_shift_image)\\r\\n # 7 ###########################################################################################################\\r\\n mag_image = np.zeros(inverse_fft_image.shape, dtype=complex)\\r\\n for i in range(inverse_fft_image.shape[0]):\\r\\n for j in range(inverse_fft_image.shape[1]):\\r\\n if inverse_fft_image[i][j] < 0:\\r\\n mag_image[i][j] = -1 * inverse_fft_image[i][j]\\r\\n else:\\r\\n mag_image[i][j] = inverse_fft_image[i][j]\\r\\n # magnitude of inverse fft is complete\\r\\n # 8 ###########################################################################################################\\r\\n full_contrast_image = self.post_process_image(mag_image)\\r\\n\\r\\n return [mag_dft, mag_filtered_image, full_contrast_image]\",\n \"def _apply_cz(self, state, axes, **kwargs):\\n ndim = self._ndim(state)\\n sl_0 = _get_slice(0, axes[0], ndim)\\n sl_1 = _get_slice(1, axes[0], ndim)\\n\\n if axes[1] > axes[0]:\\n target_axes = [axes[1] - 1]\\n else:\\n target_axes = [axes[1]]\\n\\n state_z = self._apply_z(state[sl_1], axes=target_axes)\\n return self._stack([state[sl_0], state_z], axis=axes[0])\",\n \"def zncc(template, image):\\n std_template = np.std(template)\\n if std_template == 0:\\n return 0\\n\\n std_image = np.std(image)\\n if std_image == 0:\\n return 0\\n\\n template_t = template - np.mean(template)\\n image_t = image - np.mean(image)\\n\\n cross_correlation = np.mean(np.multiply(template_t, image_t)) / (std_template * std_image)\\n return cross_correlation\",\n \"def testComputeImage(self):\\n for fiberId in self.detMap.fiberId:\\n for fraction in (0.1, 0.5, 0.9):\\n yy = self.synthConfig.height*fraction\\n if yy == int(yy):\\n # Ensure we have a non-integer pixel position,\\n # so computeImage and computeKernelImage differ\\n yy += 0.5\\n wavelength = self.detMap.findWavelength(fiberId, yy)\\n image = self.psf.computeImage(fiberId, wavelength)\\n kernel = self.psf.computeKernelImage(fiberId, wavelength)\\n\\n # Image should have xy0 set somewhere in the middle of the larger image\\n self.assertNotEqual(image.getX0(), 0)\\n self.assertNotEqual(image.getY0(), 0)\\n\\n # Kernel should have xy0 set to the half-size\\n halfSize = (self.size - 1)//2\\n self.assertEqual(kernel.getX0(), -halfSize)\\n self.assertEqual(kernel.getY0(), -halfSize)\\n\\n # Centroid on image should be at the point of interest\\n xx, yy = self.detMap.findPoint(fiberId, wavelength)\\n centroid = calculateCentroid(image)\\n self.assertFloatsAlmostEqual(xx, centroid.x, atol=2.0e-2)\\n self.assertFloatsAlmostEqual(yy, centroid.y, atol=2.0e-2)\\n\\n # Centroid on kernel should be zero\\n centroid = calculateCentroid(kernel)\\n self.assertFloatsAlmostEqual(centroid.x, 0.0, atol=1.0e-7)\\n self.assertFloatsAlmostEqual(centroid.y, 0.0, atol=1.0e-7)\",\n \"def kalman_filter(x, x_cov, u, u_cov, Z, z_cov):\\n for i in range(len(Z)):\\n x, x_cov = predict_new_belief(x, x_cov, u, u_cov)\\n x, x_cov = incorporate_measurement(x, x_cov, Z[i], z_cov)\\n\\n return x, x_cov\",\n \"def ACS_zeropoint(image):\\n logging.debug('Calculating zeropoint for {}'.format(image))\\n\\n PHOTFLAM = fits.getheader(image,1)['PHOTFLAM']\\n PHOTPLAM = fits.getheader(image,1)['PHOTPLAM']\\n\\n ABMAG_ZEROPOINT=-2.5*np.log10(PHOTFLAM)-5*np.log10(PHOTPLAM)-2.408\\n\\n return ABMAG_ZEROPOINT\",\n \"def stfbss(X,nsources=5,ng=2**5-1,nh=2**9-1,tstep=2**6-1,df=1.0,nfbins=2**10,\\r\\n tftol=1.E-8,normalize=True):\\r\\n \\r\\n \\r\\n #get shape of timeseries matrix, \\r\\n #m=number of channels\\r\\n #tlen=length of timeseries\\r\\n m,maxn=X.shape\\r\\n \\r\\n n=nsources\\r\\n #get number of time bins\\r\\n ntbins=int(float(maxn)/tstep)\\r\\n \\r\\n tfkwargs={'ng':ng,'nh':nh,'df':df,'nfbins':nfbins,'tstep':tstep}\\r\\n \\r\\n \\r\\n #remove dc component from time series and normalize\\r\\n if normalize==True:\\r\\n for ii in range(m):\\r\\n X[ii,:]=X[ii,:]-np.mean(X[ii,:])\\r\\n X[ii,:]=X[ii,:]/X[ii,:].std() \\r\\n \\r\\n #===============================================================================\\r\\n # Whiten data and Compute Whitening matrix\\r\\n #===============================================================================\\r\\n #whiten data to get a unitary matrix with unit variance and zero mean\\r\\n #compute covariance matrix\\r\\n Rxx=(np.dot(X,X.T))/float(maxn)\\r\\n \\r\\n #calculate eigen decomposition\\r\\n [l,u]=np.linalg.eig(Rxx)\\r\\n \\r\\n #sort eigenvalues from smallest to largest assuming largest are sources and \\r\\n #smallest are noise\\r\\n lspot=l.argsort()\\r\\n eigval=l[lspot]\\r\\n eigvec=u[:,lspot]\\r\\n \\r\\n #calculate the noise variance as mean of non-principal components\\r\\n sigman=np.mean(eigval[0:m-n])\\r\\n \\r\\n #compute scaling factor for whitening matrix\\r\\n wscale=1/np.sqrt(eigval[m-n:m]-sigman)\\r\\n \\r\\n #compute whitening matrix\\r\\n W=np.zeros((m,n))\\r\\n for kk in range(n):\\r\\n W[:,kk]=wscale[kk]*eigvec[:,m-n+kk].T\\r\\n W=W.T\\r\\n #compute whitened signal vector. Note the dimensionality is reduced from [mxn] \\r\\n #to [nxn] making the computation simpler.\\r\\n Z=np.dot(W,X)\\r\\n \\r\\n #===============================================================================\\r\\n # Compute Spatial Time Frequency Distribution\\r\\n #===============================================================================\\r\\n \\r\\n stfd=np.zeros((n,n,nfbins,ntbins+1),dtype='complex128')\\r\\n Za=np.array(Z.copy())\\r\\n #compute auto terms\\r\\n for ii in range(n):\\r\\n pswvd,tswvd,fswvd=spwvd(Za[ii].reshape(maxn),**tfkwargs)\\r\\n stfd[ii,ii,:,:]=pswvd\\r\\n \\r\\n #compute cross terms\\r\\n for jj in range(n):\\r\\n for kk in range(jj,n):\\r\\n pswvd,tswvd,fswvd=spwvd([Za[jj].reshape(maxn),Za[kk].reshape(maxn)],\\r\\n **tfkwargs)\\r\\n stfd[jj,kk,:,:]=pswvd\\r\\n stfd[kk,jj,:,:]=pswvd.conj()\\r\\n \\r\\n #===============================================================================\\r\\n # Compute criteria for cross terms \\r\\n #===============================================================================\\r\\n \\r\\n stfdTr=np.zeros((nfbins,ntbins))\\r\\n C=np.zeros((nfbins,ntbins))\\r\\n \\r\\n for ff in range(nfbins):\\r\\n for tt in range(ntbins):\\r\\n #compensate for noise\\r\\n stfd[:,:,ff,tt]=stfd[:,:,ff,tt]-sigman*np.matrix(W)*np.matrix(W.T)\\r\\n #compute the trace\\r\\n stfdTr[ff,tt]=abs(np.trace(stfd[:,:,ff,tt]))\\r\\n #compute mean over entire t-f plane\\r\\n trmean=stfdTr.mean()\\r\\n \\r\\n #find t-f points that meet the criteria\\r\\n fspot,tspot=np.nonzero(stfdTr>trmean)\\r\\n \\r\\n for ll in range(len(fspot)):\\r\\n treig=abs(np.linalg.eig(stfd[:,:,fspot[ll],tspot[ll]])[0])\\r\\n if sum(treig)!=0 and sum(treig)>tftol:\\r\\n C[fspot[ll],tspot[ll]]=max(treig)/sum(treig)\\r\\n else:\\r\\n C[fspot[ll],tspot[ll]]=0\\r\\n \\r\\n #compute gradients and jacobi matrices\\r\\n negjacobi=np.zeros((nfbins,ntbins))\\r\\n smallgrad=np.zeros((nfbins,ntbins))\\r\\n maxpoints=np.zeros((nfbins,ntbins))\\r\\n \\r\\n gradt,gradf=np.gradient(C)\\r\\n Jtt,Jtf=np.gradient(gradt)\\r\\n Jft,Jff=np.gradient(gradf)\\r\\n \\r\\n #get points when L2 of gradient is smaller than tolerance level\\r\\n smallgrad=np.where(np.sqrt(gradt**2+gradf**2)<tftol,1,0)\\r\\n \\r\\n #get points where the Jacobi is negative definite\\r\\n detjacobi=Jtt*Jff-Jtf*Jft\\r\\n negjacobi=np.where(detjacobi>0,1,0)*np.where(Jtt<0,1,0)\\\\\\r\\n *np.where((Jtt+Jff)<0,1,0)\\r\\n \\r\\n maxpoints=smallgrad*negjacobi\\r\\n \\r\\n gfspot,gtspot=np.nonzero(maxpoints)\\r\\n ntfpoints=len(gfspot)\\r\\n \\r\\n if ntfpoints==0:\\r\\n raise ValueError('Found no tf points, relax tolerance')\\r\\n else:\\r\\n print 'Found '+str(ntfpoints)+' t-f points'\\r\\n \\r\\n for rr in range(ntfpoints):\\r\\n if rr==0:\\r\\n Rjd=stfd[:,:,gfspot[rr],gtspot[rr]]\\r\\n else:\\r\\n Rjd=np.concatenate((Rjd,stfd[:,:,gfspot[rr],gtspot[rr]]),axis=1)\\r\\n Rjd=np.array(Rjd)\\r\\n \\r\\n #===============================================================================\\r\\n # Calculate Joint Diagonalization\\r\\n #===============================================================================\\r\\n #get size of array of matrices to be diagonalized\\r\\n mtf,nm=Rjd.shape #mtf is number of t-f points, nm is number of matrices\\r\\n #set up some initial parameters\\r\\n V=np.eye(mtf)\\r\\n \\r\\n #update boolean\\r\\n encore=True \\r\\n #Total number of rotations\\r\\n updates=0\\r\\n sweep=0\\r\\n #print 'Computing Joint Diagonalization'\\r\\n # Joint diagonalization proper\\r\\n # ============================\\r\\n while encore:\\r\\n #reset some parameters\\r\\n encore=False\\r\\n sweep+=1 \\r\\n upds=0\\r\\n Vkeep=V\\r\\n for p in range(mtf):\\r\\n \\r\\n for q in range(p+1,mtf):\\r\\n #set up indices\\r\\n qi=np.arange(start=q,stop=nm,step=mtf)\\r\\n pi=np.arange(start=p,stop=nm,step=mtf)\\r\\n # computation of Givens angle\\r\\n g=np.array([Rjd[p,pi]-Rjd[q,qi],Rjd[p,qi],Rjd[q,pi]])\\r\\n gg=np.real(np.dot(g,g.T))\\r\\n ton=gg[0,0]-gg[1,1] \\r\\n toff=gg[0,1]+gg[1,0]\\r\\n theta=0.5*np.arctan2(toff,ton+np.sqrt(ton**2+toff**2))\\r\\n # Givens update\\r\\n if abs(theta) > tftol:\\r\\n encore=True\\r\\n upds+=1\\r\\n c=np.cos(theta) \\r\\n s=np.sin(theta)\\r\\n G=np.matrix([[c,-s],[s,c]])\\r\\n pair =np.array([p,q])\\r\\n V[:,pair]=V[:,pair]*G\\r\\n Rjd[pair,:]=G.T*Rjd[pair,:]\\r\\n Rjd[:,np.concatenate([pi,qi])]=np.append(\\r\\n c*Rjd[:,pi]+s*Rjd[:,qi],\\r\\n -s*Rjd[:,pi]+c*Rjd[:,qi],axis=1)\\r\\n updates+=upds\\r\\n print 'Updated '+str(updates)+' times.'\\r\\n \\r\\n #compute estimated signal matrix\\r\\n Se=np.dot(V.T,Z)\\r\\n #compute estimated mixing matrix\\r\\n Ae=np.dot(np.linalg.pinv(W),V)\\r\\n \\r\\n return Se,Ae\",\n \"def data_augmenter(image, label, shift, rotate, scale, intensity, flip):\\n image2 = np.zeros(image.shape, dtype=np.float32)\\n label2 = np.zeros(label.shape, dtype=np.int32)\\n for i in range(image.shape[0]):\\n # For each image slice, generate random affine transformation parameters\\n # using the Gaussian distribution\\n shift_val = [np.clip(np.random.normal(), -3, 3) * shift,\\n np.clip(np.random.normal(), -3, 3) * shift]\\n rotate_val = np.clip(np.random.normal(), -3, 3) * rotate\\n scale_val = 1 + np.clip(np.random.normal(), -3, 3) * scale\\n intensity_val = 1 + np.clip(np.random.normal(), -3, 3) * intensity\\n\\n # Apply the affine transformation (rotation + scale + shift) to the image\\n row, col = image.shape[1:3]\\n M = cv2.getRotationMatrix2D((row / 2, col / 2), rotate_val, 1.0 / scale_val)\\n M[:, 2] += shift_val\\n for c in range(image.shape[3]):\\n image2[i, :, :, c] = ndimage.interpolation.affine_transform(image[i, :, :, c],\\n M[:, :2], M[:, 2], order=1)\\n\\n # Apply the affine transformation (rotation + scale + shift) to the label map\\n label2[i, :, :] = ndimage.interpolation.affine_transform(label[i, :, :],\\n M[:, :2], M[:, 2], order=0)\\n\\n # Apply intensity variation\\n image2[i] *= intensity_val\\n\\n # Apply random horizontal or vertical flipping\\n if flip:\\n if np.random.uniform() >= 0.5:\\n image2[i] = image2[i, ::-1, :, :]\\n label2[i] = label2[i, ::-1, :]\\n else:\\n image2[i] = image2[i, :, ::-1, :]\\n label2[i] = label2[i, :, ::-1]\\n return image2, label2\",\n \"def fit(self, x,\\n augment=False,\\n rounds=1,\\n seed=None):\\n x = np.asarray(x, dtype=self.dtype)\\n if x.ndim != 4:\\n raise ValueError('Input to `.fit()` should have rank 4. '\\n 'Got array with shape: ' + str(x.shape))\\n if seed is not None:\\n np.random.seed(seed)\\n\\n x = np.copy(x)\\n if augment:\\n ax = np.zeros(\\n tuple([rounds * x.shape[0]] + list(x.shape)[1:]),\\n dtype=self.dtype)\\n for r in range(rounds):\\n for i in range(x.shape[0]):\\n ax[i + r * x.shape[0]] = self.random_transform(x[i])\\n x = ax\\n\\n if self.featurewise_center:\\n self.mean = np.mean(x, axis=(0, self.row_axis, self.col_axis))\\n broadcast_shape = [1, 1, 1]\\n broadcast_shape[self.channel_axis - 1] = x.shape[self.channel_axis]\\n self.mean = np.reshape(self.mean, broadcast_shape)\\n x -= self.mean\\n\\n if self.featurewise_std_normalization:\\n self.std = np.std(x, axis=(0, self.row_axis, self.col_axis))\\n broadcast_shape = [1, 1, 1]\\n broadcast_shape[self.channel_axis - 1] = x.shape[self.channel_axis]\\n self.std = np.reshape(self.std, broadcast_shape)\\n x /= (self.std + 1e-6)\\n\\n if self.zca_whitening:\\n if scipy is None:\\n raise ImportError('Using zca_whitening requires SciPy. '\\n 'Install SciPy.')\\n flat_x = np.reshape(\\n x, (x.shape[0], x.shape[1] * x.shape[2] * x.shape[3]))\\n sigma = np.dot(flat_x.T, flat_x) / flat_x.shape[0]\\n u, s, _ = linalg.svd(sigma)\\n s_inv = 1. / np.sqrt(s[np.newaxis] + self.zca_epsilon)\\n self.principal_components = (u * s_inv).dot(u.T)\\n return x\",\n \"def addseeingImgFFTmoffat(img = None,fwhm=None):\\n beta = 3.5\\n alpha = fwhm/scale/(2.*np.sqrt(2**(1/beta)-1))\\n kern = moffat_seeing(npix,alpha=alpha,beta=beta)\\n img = img.astype('f') # required for the fftconvolve\\n covimg = convolveH(img,kern)\\n covimg = covimg/covimg.sum()\\n return covimg\",\n \"def backgroundEstimator(self, image):\\n return self.bg_filter.convolve(image)\",\n \"def aveEz2CC(self):\\n if self.dim < 3:\\n return None\\n if getattr(self, '_aveEz2CC', None) is None:\\n # The number of cell centers in each direction\\n n = self.vnC\\n if(self.dim == 3):\\n self._aveEz2CC = kron3(speye(n[2]), av(n[1]), av(n[0]))\\n return self._aveEz2CC\",\n \"def add_zca_whitening(self, pc=None):\\n self.global_pc.is_required = True\\n self.global_pc.value = pc\\n self.methods.append(self._zca_whitening)\\n self.args.append(None)\",\n \"def ledaps(image):\\n cmask = image.select('QA')\\n\\n valid_data_mask = tools.compute_bits(cmask, 1, 1, 'valid_data')\\n cloud_mask = tools.compute_bits(cmask, 2, 2, 'cloud')\\n snow_mask = tools.compute_bits(cmask, 4, 4, 'snow')\\n\\n good_pix = cloud_mask.eq(0).And(valid_data_mask.eq(0)).And(snow_mask.eq(0))\\n result = image.updateMask(good_pix)\\n\\n return result\",\n \"def perform_coszen_flipback(cz_kern_cdf, flipback_mask, keep):\\n flipback = np.where(flipback_mask)[0]\\n\\n flipup = flipback[:int(len(flipback)/2)]\\n flipdown = flipback[int(len(flipback)/2):]\\n no_flipback = np.where(np.logical_not(flipback_mask))[0]\\n\\n cz_kern_cdf = (cz_kern_cdf[flipup][::-1] + cz_kern_cdf[flipdown][::-1] +\\n cz_kern_cdf[no_flipback])[keep-int(len(flipback)/2)]\\n\\n return cz_kern_cdf\",\n \"def image_conv(image, kernel):\\n \\n # Filter2D used for performance\\n return cv2.filter2D(image, -1, kernel)\",\n \"def denoise_image(image,dest):\\n beta = 1e-3\\n eta = 2e-4\\n argh = 0.0\\n kmax = 10\\n data = sign(image.getdata(), {0: -1, 255: 1}) # convert to {-1, 1}\\n E, localized_E = E_generator(beta, eta, argh)\\n temp_dir = os.path.dirname(os.path.realpath(os.path.join('submits', 'img', dest)))\\n y = data.reshape(image.size[::-1]) # convert 1-d array to matrix\\n result = simulated_annealing(\\n y, kmax, E, localized_E, temp_dir)\\n result = sign(result, {-1: 0, 1: 255})\\n output_image = Image.fromarray(result).convert('1', dither=Image.NONE)\\n return output_image\",\n \"def __init__(self, n_x, n_z, qz_hid, px_hid, filters, seq_length=50, nonlinearity=rectify,\\r\\n px_nonlinearity=None, x_dist='linear', batchnorm=False, seed=1234):\\r\\n super(CVAE, self).__init__(n_x, qz_hid + px_hid, n_z, nonlinearity)\\r\\n self.x_dist = x_dist\\r\\n self.n_x = n_x\\r\\n self.seq_length = seq_length\\r\\n self.n_z = n_z\\r\\n self.batchnorm = batchnorm\\r\\n self._srng = RandomStreams(seed)\\r\\n\\r\\n # Pool layer cache\\r\\n pool_layers = []\\r\\n\\r\\n # Decide Glorot initializaiton of weights.\\r\\n init_w = 1e-3\\r\\n hid_w = \\\"\\\"\\r\\n if nonlinearity == rectify or nonlinearity == softplus:\\r\\n hid_w = \\\"relu\\\"\\r\\n\\r\\n # Define symbolic variables for theano functions.\\r\\n self.sym_x = T.tensor3('x') # inputs\\r\\n self.sym_z = T.matrix('z')\\r\\n self.sym_samples = T.iscalar('samples') # MC samples\\r\\n\\r\\n # Assist methods for collecting the layers\\r\\n def dense_layer(layer_in, n, dist_w=init.GlorotNormal, dist_b=init.Normal):\\r\\n dense = DenseLayer(layer_in, n, dist_w(hid_w), dist_b(init_w), None)\\r\\n if batchnorm:\\r\\n dense = bn(dense)\\r\\n return NonlinearityLayer(dense, self.transf)\\r\\n\\r\\n def stochastic_layer(layer_in, n, samples, nonlin=None):\\r\\n mu = DenseLayer(layer_in, n, init.Normal(init_w), init.Normal(init_w), nonlin)\\r\\n logvar = DenseLayer(layer_in, n, init.Normal(init_w), init.Normal(init_w), nonlin)\\r\\n return SampleLayer(mu, logvar, eq_samples=samples, iw_samples=1), mu, logvar\\r\\n\\r\\n def conv_layer(layer_in, filter, stride=(1, 1), pool=1, name='conv'):\\r\\n l_conv = Conv2DLayer(layer_in, num_filters=filter, filter_size=(3, 1), stride=stride, pad='full', name=name)\\r\\n if pool > 1:\\r\\n l_conv = MaxPool2DLayer(l_conv, pool_size=(pool, 1))\\r\\n pool_layers.append(l_conv)\\r\\n return l_conv\\r\\n\\r\\n # Reshape input\\r\\n l_x_in = InputLayer((None, seq_length, n_x), name='Input')\\r\\n l_x_in_reshp = ReshapeLayer(l_x_in, (-1, 1, seq_length, n_x))\\r\\n print(\\\"l_x_in_reshp\\\", l_x_in_reshp.output_shape)\\r\\n\\r\\n # CNN encoder implementation\\r\\n l_conv_enc = l_x_in_reshp\\r\\n for filter, stride, pool in filters:\\r\\n l_conv_enc = conv_layer(l_conv_enc, filter, stride, pool)\\r\\n print(\\\"l_conv_enc\\\", l_conv_enc.output_shape)\\r\\n\\r\\n # Pool along last 2 axes\\r\\n l_global_pool_enc = GlobalPoolLayer(l_conv_enc)\\r\\n l_enc = dense_layer(l_global_pool_enc, n_z)\\r\\n print(\\\"l_enc\\\", l_enc.output_shape)\\r\\n\\r\\n # Recognition q(z|x)\\r\\n l_qz = l_enc\\r\\n for hid in qz_hid:\\r\\n l_qz = dense_layer(l_qz, hid)\\r\\n l_qz, l_qz_mu, l_qz_logvar = stochastic_layer(l_qz, n_z, self.sym_samples)\\r\\n print(\\\"l_qz\\\", l_qz.output_shape)\\r\\n\\r\\n # Inverse pooling\\r\\n l_global_depool = InverseLayer(l_qz, l_global_pool_enc)\\r\\n print(\\\"l_global_depool\\\", l_global_depool.output_shape)\\r\\n\\r\\n # Reverse pool layer order\\r\\n pool_layers = pool_layers[::-1]\\r\\n\\r\\n # Decode\\r\\n l_deconv = l_global_depool\\r\\n for idx, filter in enumerate(filters[::-1]):\\r\\n filter, stride, pool = filter\\r\\n if pool > 1:\\r\\n l_deconv = InverseLayer(l_deconv, pool_layers[idx])\\r\\n l_deconv = Conv2DLayer(l_deconv, num_filters=filter, filter_size=(3, 1), stride=(stride, 1), W=init.GlorotNormal('relu'))\\r\\n print(\\\"l_deconv\\\", l_deconv.output_shape)\\r\\n\\r\\n # The last l_conv layer should give us the input shape\\r\\n l_dec = Conv2DLayer(l_deconv, num_filters=1, filter_size=(3, 1), pad='same', nonlinearity=None)\\r\\n print(\\\"l_dec\\\", l_dec.output_shape)\\r\\n\\r\\n # Flatten first two dimensions\\r\\n l_dec = ReshapeLayer(l_dec, (-1, n_x))\\r\\n\\r\\n l_px = l_dec\\r\\n if x_dist == 'bernoulli':\\r\\n l_px = DenseLayer(l_px, n_x, init.GlorotNormal(), init.Normal(init_w), sigmoid)\\r\\n elif x_dist == 'multinomial':\\r\\n l_px = DenseLayer(l_px, n_x, init.GlorotNormal(), init.Normal(init_w), softmax)\\r\\n elif x_dist == 'gaussian':\\r\\n l_px, l_px_mu, l_px_logvar = stochastic_layer(l_px, n_x, self.sym_samples, px_nonlinearity)\\r\\n elif x_dist == 'linear':\\r\\n l_px = DenseLayer(l_px, n_x, nonlinearity=None)\\r\\n\\r\\n # Reshape all the model layers to have the same size\\r\\n self.l_x_in = l_x_in\\r\\n\\r\\n self.l_qz = ReshapeLayer(l_qz, (-1, self.sym_samples, 1, n_z))\\r\\n self.l_qz_mu = DimshuffleLayer(l_qz_mu, (0, 'x', 'x', 1))\\r\\n self.l_qz_logvar = DimshuffleLayer(l_qz_logvar, (0, 'x', 'x', 1))\\r\\n\\r\\n self.l_px = DimshuffleLayer(ReshapeLayer(l_px, (-1, seq_length, self.sym_samples, 1, n_x)), (0, 2, 3, 1, 4))\\r\\n self.l_px_mu = DimshuffleLayer(ReshapeLayer(l_px_mu, (-1, seq_length, self.sym_samples, 1, n_x)), (0, 2, 3, 1, 4)) \\\\\\r\\n if x_dist == \\\"gaussian\\\" else None\\r\\n self.l_px_logvar = DimshuffleLayer(ReshapeLayer(l_px_logvar, (-1, seq_length, self.sym_samples, 1, n_x)), (0, 2, 3, 1, 4)) \\\\\\r\\n if x_dist == \\\"gaussian\\\" else None\\r\\n\\r\\n # Predefined functions\\r\\n inputs = {self.l_x_in: self.sym_x}\\r\\n outputs = get_output(l_qz, inputs, deterministic=True)\\r\\n self.f_qz = theano.function([self.sym_x, self.sym_samples], outputs)\\r\\n\\r\\n inputs = {l_qz: self.sym_z}\\r\\n outputs = get_output(self.l_px, inputs, deterministic=True).mean(axis=(1, 2))\\r\\n self.f_px = theano.function([self.sym_z, self.sym_samples], outputs)\\r\\n\\r\\n outputs = get_output(self.l_px_mu, inputs, deterministic=True).mean(axis=(1, 2))\\r\\n self.f_mu = theano.function([self.sym_z, self.sym_samples], outputs)\\r\\n\\r\\n outputs = get_output(self.l_px_logvar, inputs, deterministic=True).mean(axis=(1, 2))\\r\\n self.f_var = theano.function([self.sym_z, self.sym_samples], outputs)\\r\\n\\r\\n # Define model parameters\\r\\n self.model_params = get_all_params([self.l_px])\\r\\n self.trainable_model_params = get_all_params([self.l_px], trainable=True)\",\n \"def computeInverse2DDCT(self, imge):\\n \\n # Assuming a square image\\n N = imge.shape[0]\\n finalInverse2DDCT = np.zeros([N, N], dtype=float)\\n for x in xrange(N):\\n for y in xrange(N):\\n #Compute the DCT value for each cells/points in the resulting transformed image.\\n finalInverse2DDCT[x, y] = DCT.__computeSinglePointInverse2DCT(imge, x, y, N)\\n return finalInverse2DDCT\",\n \"def pca(image):\\n # Reshape image.\\n reshaped_image = np.reshape(image, (224 * 224, 3))\\n # Find the covariance.\\n cov = np.cov(reshaped_image, rowvar=0)\\n # Eigenvalues and vectors.\\n eigvals, eigvecs = np.linalg.eigh(cov)\\n\\n # Pick random gaussian values.\\n a = np.random.normal(0, 0.1, size=(3,))\\n\\n scaled = eigvals * a\\n delta = np.dot(eigvecs, scaled.T)\\n return np.add(delta, scaled)\",\n \"def applyMat(my_map, linsys_setup):\\n \\n datamaps, ninvs, beams, freqs, power_2d, precond_2d, clumaps, g_nu, \\\\\\n map_prop = linsys_setup\\n \\n \\n\\n nx, ny, pixScaleX, pixScaleY = map_prop\\n nFreq = len(g_nu); nCluster = len(clumaps[0])\\n\\n #Always apply beam * precond\\n beam_prec=[]\\n\\n for f in range(nFreq):\\n beam_prec+=[beams[f][:,:ny/2+1]*precond_2d[:,:ny/2+1]]\\n precond_2d=precond_2d[:,:ny/2+1]\\n power_2d=power_2d[:,:ny/2+1]\\n \\n ksz = False\\n if len(clumaps) == 2: ksz = True\\n \\n # Routines to perform block matrix multiplication defined in Eriksen Eq. 19\\n \\n def apply_cmb_cmb(d0):\\n \\\"\\\"\\\"\\n Apply (S^-1 + A N^-1 A) x\\n \\\"\\\"\\\"\\n d1 = d0.copy()\\n d1 = numpy.reshape(d1,(nx,ny))\\n a_l = fft.rfft(d1,axes=[-2,-1])\\n \\n c_l = 0\\n for f in range(nFreq):\\n\\n b_l = a_l * beam_prec[f]\\n d2 = fft.irfft(b_l,axes=[-2,-1],normalize=True)\\n d2 *= ninvs[f]\\n b_l = fft.rfft(d2,axes=[-2,-1])\\n c_l += b_l * beam_prec[f]\\n \\n d2 = fft.irfft(c_l,axes=[-2,-1],normalize=True)\\n d1 = fft.irfft(precond_2d**2 * a_l/power_2d,axes=[-2,-1],normalize=True)\\n \\n d2 += d1\\n \\n return d2.reshape((nx*ny,))\\n \\n \\\"\\\"\\\"\\n def apply_tsz_tsz(d0): # DONE\\n \\\\\\\"\\\"\\\"\\n Apply (F^T A^T N^-1 A F) x\\n \\\\\\\"\\\"\\\"\\n d1 = numpy.zeros(nCluster)\\n mat = numpy.zeros((nCluster, nCluster))\\n # TODO: This could probably be more efficient (e.g. using np.outer)\\n for freq in range(nFreq):\\n for ic in range(nCluster):\\n for jc in range(0, ic+1):\\n mat[ic,jc] = numpy.sum( ninvs[freq] * g_nu[freq]**2. \\\\\\n * clumaps[0][ic][freq] * clumaps[0][jc][freq] )\\n if ic != jc: mat[jc,ic] = mat[ic,jc]\\n d1 += numpy.dot(mat, d0)\\n return d1\\n \\n def apply_ksz_ksz(d0): # DONE\\n \\\\\\\"\\\"\\\"\\n Apply (K^T A^T N^-1 A K) x\\n \\\\\\\"\\\"\\\"\\n # FIXME: Missing factor of ivcov\\n d1 = numpy.zeros(nCluster)\\n mat = numpy.zeros((nCluster, nCluster))\\n # TODO: This could probably be more efficient (e.g. using np.outer)\\n for freq in range(nFreq):\\n for ic in range(nCluster):\\n for jc in range(0, ic+1):\\n mat[ic,jc] = numpy.sum( ninvs[freq] \\\\\\n * clumaps[1][ic][freq] * clumaps[1][jc][freq] )\\n if ic != jc: mat[jc,ic] = mat[ic,jc]\\n d1 += numpy.dot(mat, d0)\\n d1 += numpy.dot(ivcov, d0) # Add prior term\\n return d1\\n \\\"\\\"\\\"\\n \\n def apply_cmb_foreground_block(dc, dm, dt, dk=None):\\n \\\"\\\"\\\"\\n Apply the CMB x (Monopole + TSZ + KSZ) terms in one block:\\n (A^T N^-1 A T) x_mono\\n (A^T N^-1 A F) x_tsz\\n (A^T N^-1 A K) x_ksz\\n \\n (T^T A^T N^-1 A) x_cmb\\n (F^T A^T N^-1 A) x_cmb\\n (K^T A^T N^-1 A) x_cmb\\n \\\"\\\"\\\"\\n ksz = False\\n if dk is not None: ksz = True\\n \\n # (A^T N^-1 A T) x_mono; (A^T N^-1 A F) x_tsz; (A^T N^-1 A K) x_ksz\\n b_lt = 0; b_lk = 0; b_lm = 0\\n for f in range(nFreq):\\n mct = 0; mck = 0\\n for ic in range(nCluster):\\n mct += dt[ic] * ninvs[f] * clumaps[0][ic][f] * g_nu[f]\\n if ksz: mck += dk[ic] * ninvs[f] * clumaps[1][ic][f]\\n \\n b_lm += fft.rfft(dm * ninvs[f],axes=[-2,-1]) * beam_prec[f]\\n b_lt += fft.rfft(mct,axes=[-2,-1]) * beam_prec[f]\\n if ksz: b_lk += fft.rfft(mck,axes=[-2,-1]) * beam_prec[f]\\n\\n mcm = fft.irfft(b_lm,axes=[-2,-1],normalize=True).reshape((nx*ny,))\\n mct = fft.irfft(b_lt,axes=[-2,-1],normalize=True).reshape((nx*ny,))\\n if ksz: mck = fft.irfft(b_lk,axes=[-2,-1],normalize=True).reshape((nx*ny,))\\n \\n # (T^T A^T N^-1 A) x_cmb; (F^T A^T N^-1 A) x_cmb; (K^T A^T N^-1 A) x_cmb\\n mc = dc.copy().reshape((nx,ny))\\n a_l = fft.rfft(mc,axes=[-2,-1])\\n mtc = numpy.zeros(nCluster)\\n mkc = numpy.zeros(nCluster)\\n mmc = 0\\n for f in range(nFreq):\\n b_l = a_l * beam_prec[f]\\n mc = fft.irfft(b_l,axes=[-2,-1],normalize=True)\\n mmc += numpy.sum(mc * ninvs[f])\\n for ic in range(nCluster):\\n mtc[ic] += numpy.sum(mc * ninvs[f] * clumaps[0][ic][f] * g_nu[f])\\n if ksz: mkc[ic] += numpy.sum(mc * ninvs[f] * clumaps[1][ic][f])\\n \\n if ksz: return mct, mcm, mck, mtc, mmc, mkc\\n return mct, mcm, mtc, mmc\\n \\n \\n def apply_foreground_block(m0, t0, k0=None):\\n \\\"\\\"\\\"\\n Apply the TSZ + KSZ + Monopole terms in one block:\\n [ (T^T A^T N^-1 A F) (T^T A^T N^-1 A K) (T^T A^T N^-1 A T) ] (x_mono)\\n [ (F^T A^T N^-1 A F) (F^T A^T N^-1 A K) (F^T A^T N^-1 A T) ] (x_tsz)\\n [ (K^T A^T N^-1 A F) (K^T A^T N^-1 A K) (K^T A^T N^-1 A T) ] (x_ksz)\\n \\\"\\\"\\\"\\n ksz = True if k0 is not None else False\\n \\n dtt, dkk, dtk, dkt = [numpy.zeros(nCluster) for i in range(4)]\\n mtt, mkk, mtk, mkt = [numpy.zeros((nCluster, nCluster)) for i in range(4)]\\n dmm, dmk, dmt = [0 for i in range(3)]\\n dkm, dtm = [numpy.zeros(nCluster) for i in range(2)]\\n \\n # TODO: This could probably be more efficient (e.g. using np.outer)\\n for f in range(nFreq):\\n dmm += numpy.sum(ninvs[f]) * m0\\n \\n # Loop through clusters\\n for ic in range(nCluster):\\n dmt += numpy.sum( ninvs[f] * g_nu[f] * clumaps[0][ic][f] * t0[ic] )\\n dtm[ic] += numpy.sum( ninvs[f] * g_nu[f] * clumaps[0][ic][f] * m0 )\\n if ksz:\\n dmk += numpy.sum( ninvs[f] * clumaps[1][ic][f] * k0[ic] )\\n dkm[ic] += numpy.sum( ninvs[f] * clumaps[1][ic][f] * m0 )\\n \\n for jc in range(0, ic+1):\\n mtt[ic,jc] = numpy.sum( ninvs[f] * g_nu[f]**2. \\\\\\n * clumaps[0][ic][f] * clumaps[0][jc][f] )\\n if ksz:\\n mkk[ic,jc] = numpy.sum( ninvs[f] \\\\\\n * clumaps[1][ic][f] * clumaps[1][jc][f] )\\n mtk[ic,jc] = numpy.sum( ninvs[f] * g_nu[f] \\\\\\n * clumaps[0][ic][f] * clumaps[1][jc][f] )\\n mkt[ic,jc] = numpy.sum( ninvs[f] * g_nu[f] \\\\\\n * clumaps[1][ic][f] * clumaps[0][jc][f] )\\n # Mirror indices\\n mtt[jc,ic] = mtt[ic,jc]\\n if ksz:\\n mkk[jc,ic] = mkk[ic,jc]\\n mtk[jc,ic] = mtk[ic,jc]\\n mkt[jc,ic] = mkt[ic,jc]\\n \\n # Add total contribs. for this band\\n dtt += numpy.dot(mtt, t0)\\n if ksz:\\n dkk += numpy.dot(mkk, k0)\\n dtk += numpy.dot(mtk, k0)\\n dkt += numpy.dot(mkt, t0)\\n \\n if ksz: return dtt, dkk, dmm, dtk, dkt, dmk, dkm, dtm, dmt\\n return dtt, dmm, dtm, dmt\\n \\n # Apply block matrix multiplications and return\\n # FIXME: What if KSZ not used?\\n x0 = my_map[:nx*ny]\\n x1 = my_map[nx*ny:nx*ny+1]\\n x2 = my_map[nx*ny+1:nx*ny+nCluster+1]\\n if ksz: x3 = my_map[nx*ny+nCluster+1:nx*ny+2*nCluster+1]\\n \\n # Multiply input vector in blocks\\n #t=time.time()\\n dcc = apply_cmb_cmb(x0)\\n #print 'CMB', time.time()-t\\n if ksz:\\n dct, dcm, dck, dtc, dmc, dkc = apply_cmb_foreground_block(x0, x1, x2, x3)\\n dtt, dkk, dmm, dtk, dkt, dmk, dkm, dtm, dmt = apply_foreground_block(x1, x2, x3)\\n x_new_0 = dcc + dct + dck + dcm\\n x_new_1= dmc + dmt + dmk + dmm\\n x_new_2 = dtc + dtt + dtk + dtm\\n x_new_3 = dkc + dkt + dkk + dkm\\n x_new = numpy.concatenate((x_new_0, x_new_1, x_new_2, x_new_3))\\n else:\\n #t=time.time()\\n dct, dcm, dtc, dmc = apply_cmb_foreground_block(x0, x1, x2)\\n #print 'CMB-F', time.time()-t\\n \\n #t=time.time()\\n dtt, dmm, dtm, dmt = apply_foreground_block(x1, x2)\\n #print 'F', time.time()-t\\n \\n x_new_0 = dcc + dct + dcm\\n x_new_1 = dmc + dmt + dmm\\n x_new_2 = dtc + dtt + dtm\\n x_new = numpy.concatenate((x_new_0, x_new_1, x_new_2))\\n\\n\\n#sys.exit()\\n return x_new\",\n \"def post_process_image(self, image):\\r\\n A = np.min(image)\\r\\n B = np.max(image)\\r\\n k = 255\\r\\n R, C = image.shape\\r\\n for i in range(R):\\r\\n for j in range(C):\\r\\n image[i][j] = (k / (B-A)) * (image[i][j] - A)\\r\\n average_image = np.average(image)\\r\\n if average_image > 50:\\r\\n return image.astype(dtype='uint8')\\r\\n else:\\r\\n return (255-image).astype(dtype='uint8')\",\n \"def apply_clahe(img, clip_limit=2.0, tile_grid_size=(8, 8)):\\r\\n shape = img.shape\\r\\n if len(shape) > 2 and shape[2] == 1:\\r\\n img = img.reshape(shape[:2])\\r\\n\\r\\n assert img.dtype == np.uint8, '0 to 255 uint8 for pixel values are expected'\\r\\n assert len(img.shape) == 2, 'only on one channel'\\r\\n\\r\\n clahe = cv2.createCLAHE(clipLimit=clip_limit, tileGridSize=tile_grid_size)\\r\\n return clahe.apply(np.array(img, dtype=np.uint8)).reshape(shape)\",\n \"def transform(self, previousimage):\",\n \"def process_image_for_heuristic_af(self, tile_key):\\n\\n # image provided as numpy array from dictionary,\\n # already cropped to 512x512\\n img = self.img[tile_key]\\n mean = int(np.mean(img))\\n # recast as int16 before mean subtraction\\n img = img.astype(np.int16)\\n img -= mean\\n # Autocorrelation:\\n norm = np.sum(img ** 2)\\n autocorr = fftconvolve(img, img[::-1, ::-1])/norm\\n height, width = autocorr.shape[0], autocorr.shape[1]\\n # Crop to 64-pixel central region:\\n autocorr = autocorr[int(height/2 - 32):int(height/2 + 32),\\n int(width/2 - 32):int(width/2 + 32)]\\n # Calculate coefficients:\\n fi = self.muliply_with_mask(autocorr, self.fi_mask)\\n fo = self.muliply_with_mask(autocorr, self.fo_mask)\\n apx = self.muliply_with_mask(autocorr, self.apx_mask)\\n amx = self.muliply_with_mask(autocorr, self.amx_mask)\\n apy = self.muliply_with_mask(autocorr, self.apy_mask)\\n amy = self.muliply_with_mask(autocorr, self.amy_mask)\\n # Check if tile_key already in dictionary:\\n if not (tile_key in self.foc_est):\\n self.foc_est[tile_key] = []\\n if not (tile_key in self.astgx_est):\\n self.astgx_est[tile_key] = []\\n if not (tile_key in self.astgy_est):\\n self.astgy_est[tile_key] = []\\n # Calculate single-image estimators for current tile key:\\n if len(self.foc_est[tile_key]) > 1:\\n self.foc_est[tile_key].pop(0)\\n self.foc_est[tile_key].append(\\n (fi - fo) / (fi + fo))\\n if len(self.astgx_est[tile_key]) > 1:\\n self.astgx_est[tile_key].pop(0)\\n self.astgx_est[tile_key].append(\\n (apx - amx) / (apx + amx))\\n if len(self.astgy_est[tile_key]) > 1:\\n self.astgy_est[tile_key].pop(0)\\n self.astgy_est[tile_key].append(\\n (apy - amy) / (apy + amy))\",\n \"def askapsoft_decimate_n_extract(af, over_sampling, kernel_support):\\n\\n # why is this normalization required..?\\n rescale = over_sampling*over_sampling\\n #rescale = 1\\n\\n cSize = 2 * kernel_support + 1\\n itsConvFunc=np.zeros((over_sampling, over_sampling, cSize, cSize), dtype=complex)\\n\\n for fracu in range(0,over_sampling):\\n for fracv in range(0,over_sampling):\\n\\n # Now cut out the inner part of the convolution function and\\n # insert it into the convolution function\\n for iy in range(-kernel_support,kernel_support+1):\\n for ix in range(-kernel_support,kernel_support+1):\\n\\n nx = af.shape[0]\\n ny = af.shape[1]\\n\\n # assumes support is the same for all w-planes:\\n xval = (ix) * over_sampling + fracu + nx / 2\\n yval = (iy) * over_sampling + fracv + ny / 2\\n\\n itsConvFunc[fracu, fracv, ix+cSize/2, iy+cSize/2] \\\\\\n = rescale * af[xval, yval]\\n\\n return itsConvFunc[::-1,::-1]\",\n \"def image_local_enhance_contrast(image: np.ndarray):\\n \\n # Resize image to a shape of (48, 48)\\n image = image_as_square(image)\\n\\n image = filters.rank.enhance_contrast(image, morphology.disk(2))\\n\\n # Resize the iamge back to a shape of (2304, )\\n return image_as_array(image)\",\n \"def execute(self, image):\\n undist = self.undistort(image)\\n result = self.threshold_image(undist, self.thresholds['ksize'],\\n self.thresholds['sobel'],\\n self.thresholds['magnitude'],\\n self.thresholds['direction'],\\n self.thresholds['saturation'],\\n self.thresholds['lightness'],\\n self.thresholds['blue-yellow'])\\n warped = self.warp(result)\\n if self.args.is_test:\\n self.image_logger.save_image(warped, 'warped_image.png')\\n ploty, left_fit, right_fit, left_fitx, right_fitx = self.get_line_fit(warped)\\n left_rad, right_rad = measure_curvature(warped, left_fitx, right_fitx, self.args.is_test)\\n self.left_line.update(left_fit, left_rad)\\n self.right_line.update(right_fit, right_rad)\\n result = self.draw_final_image(image, warped, undist, ploty, left_fitx, right_fitx, self.Minv,\\n self.left_line.best_curvature,\\n self.right_line.best_curvature)\\n return result\",\n \"def convolve(kerns, kshp, nkern, images, imgshp, step=(1, 1), bias=None,\\r\\n mode='valid', flatten=True):\\r\\n N = numpy\\r\\n # start by computing output dimensions, size, etc\\r\\n kern_size = N.int64(N.prod(kshp))\\r\\n\\r\\n # inshp contains either 2 entries (height,width) or 3 (nfeatures,h,w)\\r\\n # in the first case, default nfeatures to 1\\r\\n if N.size(imgshp) == 2:\\r\\n imgshp = (1,) + imgshp\\r\\n\\r\\n # construct indices and index pointers for sparse matrix, which,\\r\\n # when multiplied with input images will generate a stack of image\\r\\n # patches\\r\\n indices, indptr, spmat_shape, sptype, outshp = \\\\\\r\\n convolution_indices.conv_eval(imgshp, kshp, step, mode)\\r\\n\\r\\n # build sparse matrix, then generate stack of image patches\\r\\n csc = theano.sparse.CSM(sptype)(N.ones(indices.size), indices,\\r\\n indptr, spmat_shape)\\r\\n patches = (sparse.structured_dot(csc, images.T)).T\\r\\n\\r\\n # compute output of linear classifier\\r\\n pshape = tensor.stack(images.shape[0] * tensor.as_tensor(N.prod(outshp)),\\\\\\r\\n tensor.as_tensor(imgshp[0] * kern_size))\\r\\n patch_stack = tensor.reshape(patches, pshape, ndim=2)\\r\\n\\r\\n # kern is of shape: nkern x ksize*number_of_input_features\\r\\n # output is thus of shape: bsize*outshp x nkern\\r\\n output = tensor.dot(patch_stack, kerns.T)\\r\\n\\r\\n # add bias across each feature map (more efficient to do it now)\\r\\n if bias is not None:\\r\\n output += bias\\r\\n\\r\\n # now to have feature maps in raster order ...\\r\\n # go from bsize*outshp x nkern to bsize x nkern*outshp\\r\\n newshp = tensor.stack(images.shape[0],\\\\\\r\\n tensor.as_tensor(N.prod(outshp)),\\\\\\r\\n tensor.as_tensor(nkern))\\r\\n tensout = tensor.reshape(output, newshp, ndim=3)\\r\\n output = tensor.DimShuffle((False,) * tensout.ndim, (0, 2, 1))(tensout)\\r\\n if flatten:\\r\\n output = tensor.flatten(output, 2)\\r\\n\\r\\n return output, N.hstack((nkern, outshp))\",\n \"def nitidez(img):\\n kernel = np.array([\\n [0, -1, 0],\\n [-1, 5, -1],\\n [0, -1, 0]\\n ])\\n if img.modo == \\\"L\\\":\\n return convoluir(img, kernel)\\n canais = [\\n filtrar_canal(img, \\\"R\\\"), filtrar_canal(img, \\\"G\\\"), filtrar_canal(img, \\\"B\\\") \\n ]\\n canais = [convoluir(i, kernel) for i in canais]\\n return reunir_canais(*canais)\",\n \"def warp_channel(image, homography):\\n\\n ## calc canvas\\n top, bottom = compute_bounding_box(homography, image.shape[1],\\n image.shape[0])\\n\\n canvas_shape = tuple(np.diff([top,bottom], axis=0).flatten()[::-1])\\n\\n ## create index map\\n x,y = np.meshgrid(np.arange(top[0], bottom[0]),\\n np.arange(top[1], bottom[1]))\\n\\n ## calc inv indecies\\n orig_pts = np.vstack((x.flatten(), y.flatten())).T\\n inv_index_map = apply_homography(orig_pts,\\n np.linalg.inv(homography) )\\n\\n ## calc back images\\n warped = map_coordinates(image, [inv_index_map[:,1],\\n inv_index_map[:,0]], order=1,\\n prefilter=False)\\n\\n warped = warped.reshape(canvas_shape)\\n return warped\",\n \"def affine(self, image, random_state):\\n shape = image.shape\\n shape_size = shape[:2]\\n transform_std = self.alpha_affine*image.shape[1]\\n\\n center_square = np.float32(shape[:2]) // 2\\n square_size = min(shape[:2]) // 3\\n\\n source = np.float32([center_square + square_size, [center_square[0]+square_size, center_square[1]-square_size], center_square - square_size])\\n destination = source + random_state.uniform(-transform_std, transform_std, size=source.shape).astype(np.float32)\\n M = cv2.getAffineTransform(source, destination)\\n\\n return cv2.warpAffine(image, M, shape_size[::-1], borderMode=cv2.BORDER_REPLICATE)\",\n \"def snic(image, seeds, compactness, nd_computation=None, image_distance=None, update_func=None):\\n image_size = [len(image), len(image[0])]\\n label_map = [[-1] * image_size[1] for _ in range(image_size[0])]\\n distance_map = [[sys.float_info.max] * image_size[1] for _ in range(image_size[0])]\\n\\n if nd_computation is None:\\n nd_computation = nd_computations[\\\"3\\\"]\\n nd_lerp = nd_computation.lerp\\n\\n if type(seeds) is int:\\n # generate equidistant grid and flatten into list\\n grid = [seed for row in compute_grid(image_size, seeds) for seed in row]\\n\\n real_number_of_pixels = len(grid)\\n else:\\n # assume seeds is an iterable\\n grid = seeds\\n real_number_of_pixels = len(seeds)\\n\\n if image_distance is None:\\n image_distance = create_augmented_snic_distance(image_size, real_number_of_pixels, compactness)\\n\\n # store centroids\\n centroids_pos = grid # flatten grid\\n centroids = [[pos, image[pos[0]][pos[1]], 0] for pos in centroids_pos] # [position, color at position, #pixels]\\n\\n # create priority queue\\n queue = Queue(image_size[0] * image_size[1] * 4) # [position, color, centroid_idx]\\n q_add = queue.add # cache some functions\\n q_pop = queue.pop\\n # we create a priority queue and fill with the centroids itself. Since the python priority queue can not\\n # handle multiple entries with the same key, we start inserting the super pixel seeds with negative values. This\\n # makes sure they get processed before any other pixels. Since distances can not be negative, all new\\n # pixels will have a positive value, and therefore will be handles only after all seeds have been processed.\\n for k in range(real_number_of_pixels):\\n init_centroid = centroids[k]\\n\\n q_len = -queue.length()\\n q_add(q_len, [init_centroid[0], init_centroid[1], k])\\n distance_map[init_centroid[0][0]][init_centroid[0][1]] = q_len\\n\\n # classification\\n classified_pixels = 0\\n # while not q_empty(): -> replaced with \\\"try: while True:\\\" to speed-up code (~1sec with 50k iterations)\\n try:\\n while True:\\n # get pixel that has the currently smallest distance to a centroid\\n item = q_pop()\\n candidate_distance = item._key\\n candidate = item.value\\n candidate_pos = candidate[0]\\n\\n # test if pixel is not already labeled\\n # if label_map[candidate_pos[1] * im_width + candidate_pos[0]] == -1:\\n if label_map[candidate_pos[0]][candidate_pos[1]] == -1:\\n centroid_idx = candidate[2]\\n\\n # label new pixel\\n label_map[candidate_pos[0]][candidate_pos[1]] = centroid_idx\\n #\\n distance_map[candidate_pos[0]][candidate_pos[1]] = candidate_distance\\n # label_map[candidate_pos[1] * im_width + candidate_pos[0]] = centroid_idx\\n classified_pixels += 1\\n\\n # online update of centroid\\n centroid = centroids[centroid_idx]\\n num_pixels = centroid[2] + 1\\n lerp_ratio = 1 / num_pixels\\n\\n # adjust centroid position\\n centroid[0] = lerp2(centroid[0], candidate_pos, lerp_ratio)\\n # update centroid color\\n centroid[1] = nd_lerp(centroid[1], candidate[1], lerp_ratio)\\n # adjust number of pixels counted towards this super pixel\\n centroid[2] = num_pixels\\n\\n # add new candidates to queue\\n neighbours, neighbour_num = get_4_neighbourhood_1(candidate_pos, image_size)\\n for i in range(neighbour_num):\\n neighbour_pos = neighbours[i]\\n # Check if neighbour is already labeled, as these pixels would get discarded later on.\\n # We filter them here as queue insertions are expensive\\n # if label_map[neighbour_pos[1] * im_width + neighbour_pos[0]] == -1:\\n if label_map[neighbour_pos[0]][neighbour_pos[1]] == -1:\\n neighbour_color = image[neighbour_pos[0]][neighbour_pos[1]]\\n neighbour = [neighbour_pos, neighbour_color, centroid_idx]\\n\\n distance = image_distance(neighbour_pos, centroid[0], neighbour_color, centroid[1])\\n\\n # test if another candidate with a lower distance, is not already\\n # registered to this pixel\\n if distance_map[neighbour_pos[0]][neighbour_pos[1]] >= distance:\\n distance_map[neighbour_pos[0]][neighbour_pos[1]] = distance\\n q_add(distance, neighbour)\\n\\n # status update\\n if (update_func is not None) and (classified_pixels % 10000 == 0):\\n update_func(classified_pixels)\\n except IndexError:\\n pass\\n\\n return label_map, distance_map, real_number_of_pixels, centroids\",\n \"def cml_encrypt(im, key, iterations, cycles):\\n pixels = np.array(im)\\n p, s = key\\n seed(s)\\n\\n for i in range(3):\\n cml_encrypt_channel(pixels[:, :, i], p, iterations, cycles)\\n\\n return Image.fromarray(pixels)\",\n \"def clConvolution(self, size, mask):\",\n \"def main():\\n test_image = load_image()\\n\\n pixelate_image(\\n normalize_image(test_image)\\n )\\n pass\",\n \"def find_img2d_candidates(image, **kwargs):\\n\\n # filter_kernel = np.array([[-1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225],\\n # [-1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225],\\n # [-1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225],\\n # [-1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225],\\n # [-1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225],\\n # [-1/225, -1/225, -1/225, -1/225, -1/225, 8/225, 8/225, 8/225, 8/225, 8/225, -1/225, -1/225, -1/225, -1/225, -1/225],\\n # [-1/225, -1/225, -1/225, -1/225, -1/225, 8/225, 8/225, 8/225, 8/225, 8/225, -1/225, -1/225, -1/225, -1/225, -1/225],\\n # [-1/225, -1/225, -1/225, -1/225, -1/225, 8/225, 8/225, 8/225, 8/225, 8/225, -1/225, -1/225, -1/225, -1/225, -1/225],\\n # [-1/225, -1/225, -1/225, -1/225, -1/225, 8/225, 8/225, 8/225, 8/225, 8/225, -1/225, -1/225, -1/225, -1/225, -1/225],\\n # [-1/225, -1/225, -1/225, -1/225, -1/225, 8/225, 8/225, 8/225, 8/225, 8/225, -1/225, -1/225, -1/225, -1/225, -1/225],\\n # [-1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225],\\n # [-1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225],\\n # [-1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225],\\n # [-1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225],\\n # [-1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225, -1/225]])\\n\\n filter_kernel = np.array([[-2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2/324, -2/324, -2/324],\\n [-2 / 324, -2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1/324, -2/324, -2/324],\\n [-2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1/324, -1/324, -2/324],\\n [-2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1/324, -1/324, -2/324],\\n [-2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -2 / 324, -2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -2 / 324, -1 / 324, -1 / 324, -1/324, -1/324, -2/324],\\n [-2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -1 / 324, -1 / 324, -1/324, -1/324, -2/324],\\n [-2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -2 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, -2 / 324, -1 / 324, -1 / 324, -1/324, -1/324, -2/324],\\n [-2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -2 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, -2 / 324, -1 / 324, -1 / 324, -1/324, -1/324, -2/324],\\n [-2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -2 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, -2 / 324, -1 / 324, -1 / 324, -1/324, -1/324, -2/324],\\n [-2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -2 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, -2 / 324, -1 / 324, -1 / 324, -1/324, -1/324, -2/324],\\n [-2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -2 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, -2 / 324, -1 / 324, -1 / 324, -1/324, -1/324, -2/324],\\n [-2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -2 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, 11 / 324, -2 / 324, -1 / 324, -1 / 324, -1/324, -1/324, -2/324],\\n [-2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -1 / 324, -1 / 324, -1/324, -1/324, -2/324],\\n [-2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -2 / 324, -2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -2 / 324, -2 / 324, -1 / 324, -1 / 324, -1/324, -1/324, -2/324],\\n [-2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1/324, -1/324, -2/324],\\n [-2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1/324, -1/324, -2/324],\\n [-2 / 324, -2 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1 / 324, -1/324, -2/324, -2/324],\\n [-2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2 / 324, -2/324, -2/324, -2/324]])\\n\\n res = sg.convolve2d(image, filter_kernel, mode='same', boundary='fill', fillvalue=0)\\n coord_x, coord_y = find_max_coords(np.absolute(res))\\n\\n return coord_x, coord_y\",\n \"def image_augmentation(img):\\n return np.fliplr(img)\",\n \"def compute(\\n self,\\n image,\\n exclude_center_feature: bool = False,\\n exclude_center_value: bool = False,\\n features: ndarray = None,\\n feature_last_dim: bool = True,\\n passthrough_channels: Optional[Tuple[bool]] = None,\\n num_reserved_features: int = 0,\\n excluded_voxels: Optional[List[Tuple[int]]] = None,\\n spatial_feature_offset: Optional[Tuple[float, ...]] = None,\\n spatial_feature_scale: Optional[Tuple[float, ...]] = None,\\n ):\\n raise NotImplementedError()\",\n \"def pipeline(image, plot = False):\\n # undistort image\\n undistorted_image = undistort_image(image)\\n \\n # R&S|sobel-x thresholding\\n _, _, _, _, threshold_image = thresholding(undistorted_image)\\n \\n # yellow mask\\n _, mask_yellow = filter_color(undistorted_image, np.array([20,100,100]), np.array([50,255,255]))\\n \\n # white mask\\n _, mask_white = filter_color(undistorted_image, np.array([0,0,220]), np.array([255,35,255]))\\n \\n # combine yellow and white mask\\n mask = cv2.bitwise_or(mask_yellow, mask_white)\\n comb_image = np.zeros_like(threshold_image)\\n \\n # combine mask and thresholded image\\n comb_image[(mask > 0)&(threshold_image == 1)] = 1\\n \\n # warp the binary image\\n warped_image, Minv = warp(comb_image, src, dst)\\n if plot:\\n plt.figure(2)\\n plt.imshow(warped_image, cmap = \\\"gray\\\")\\n plt.title(\\\"Binary warped image\\\")\\n \\n # calculate polynomial fit\\n left_fitx, right_fitx, ploty, left_curverad, right_curverad, offset = fit_polynomial(warped_image, plot)\\n \\n # superimpose lines on top of the polynomial\\n superimposed_image = mark_lane_lines(undistorted_image, warped_image, ploty, left_fitx, right_fitx, Minv)\\n cv2.putText(superimposed_image, \\\"Left curvature = \\\" + str(np.round(left_curverad, 2)) + \\\" m\\\",(40,40), \\\\\\n cv2.FONT_HERSHEY_PLAIN, 2, (255,0,0), 2)\\n cv2.putText(superimposed_image,\\\"Right curvature = \\\" + str(np.round(right_curverad, 2)) + \\\" m\\\",(40,80), \\\\\\n cv2.FONT_HERSHEY_PLAIN, 2, (255,0,0), 2)\\n cv2.putText(superimposed_image,\\\"Offset = \\\" + str(np.round(offset*100, 2)) + \\\" cm\\\",(40,120), \\\\\\n cv2.FONT_HERSHEY_PLAIN, 2, (255,0,0), 2)\\n \\n return superimposed_image\",\n \"def apply_filter(self, image):\\n return cv2.fastNlMeansDenoising(image.astype('uint8'), h=self._strength)\",\n \"def cs4243_filter(image, kernel):\\n Hi, Wi = image.shape\\n Hk, Wk = kernel.shape\\n filtered_image = np.zeros((Hi, Wi))\\n\\n ###Your code here####\\n # pad image to handle border pixels\\n pad_height = (int)((Hk - 1)/2)\\n pad_width = (int)((Wk - 1)/2)\\n image_pad = pad_zeros(image, pad_height, pad_width)\\n\\n # Flip the kernel horizontal and vertical\\n kernel = cs4243_rotate180(kernel)\\n \\n # compute effective output size, assume stride=1\\n out_height = 1 + Hi - Hk + 2*pad_height\\n out_width = 1 + Wi - Wk + 2*pad_width\\n \\n # get initial nodes of receptive fields\\n recep_fields_h = [i for i in range(out_height)]\\n recep_fields_w = [i for i in range(out_width)]\\n \\n for i in recep_fields_h:\\n for j in recep_fields_w: \\n # get receptive area\\n recep_area = image_pad[i:i+Hk, j:j+Wk] \\n\\n # multiply recep_area with kernel\\n conv_sum = 0.0\\n for y in range(Hk):\\n for x in range(Wk): \\n conv_sum += kernel[y][x] * recep_area[y][x]\\n filtered_image[i, j] = conv_sum\\n ###\\n\\n return filtered_image\",\n \"def apply_CLAHE(input_file, output_file):\\n img = cv2.imread(input_file, 0)\\n\\n # Convert image to gray channgel\\n img_eq = None\\n\\n cv2.imwrite(output_file, img_eq)\",\n \"def fit(self, X, seed=None):\\n X = np.copy(X)\\n\\n if self.featurewise_center:\\n self.mean = np.mean(X, axis=0)\\n X -= self.mean\\n\\n if self.featurewise_std_normalization:\\n self.std = np.std(X, axis=0)\\n X /= self.std\\n\\n if self.zca_whitening:\\n flatX = np.reshape(X, (X.shape[0], X.shape[1]*X.shape[2]*X.shape[3]))\\n fudge = 10e-6\\n sigma = np.dot(flatX.T, flatX) / flatX.shape[1]\\n U, S, V = linalg.svd(sigma)\\n self.principal_components = np.dot(np.dot(U, np.diag(1. / np.sqrt(S + fudge))), U.T)\",\n \"def filtering(self):\\n from numpy import fft\\n import numpy as np\\n\\n _image_dft = fft.fft2(self.image)\\n _image_dft = fft.fftshift(_image_dft)\\n # dft = DFT.DFT()\\n # plt.figure(1) \\n # plt.imshow(self.image)\\n # plt.figure(2)\\n # plt.imshow(20*np.log10(abs(_image_dft))) \\n # print(_image_dft)\\n # print(abs(_image_dft))\\n # plt.show()\\n filter = self.filter(self.image.shape, self.cutoff, self.order) \\\\\\n if self.filter_name.startswith('butterworth') \\\\\\n else self.filter(self.image.shape, self.cutoff)\\n \\n _image_dft_filtered = _image_dft * filter\\n _image_filtered = abs(fft.ifft2(_image_dft_filtered))\\n \\n return [ self.post_process_image(_image_filtered), \\\\\\n self.post_process_image(20*np.log10(abs(_image_dft)+.00001)), \\\\\\n self.post_process_image(20*np.log10(abs(_image_dft_filtered)+.00001)) ]\",\n \"def inverse_cayley_transform(z: torch.Tensor) -> torch.Tensor:\\n identity = identity_like(z)\\n i_identity = multiply_by_i(identity)\\n\\n z_minus_id = z - i_identity\\n inv_z_plus_id = inverse(z + i_identity)\\n return z_minus_id @ inv_z_plus_id\",\n \"def test_cupy_conv(array, func):\\n weights = cupy.ones(array.ndim * (3,), dtype=cupy.float32)\\n result = func(array, weights)\\n result.compute()\",\n \"def img2heliovec(bxImg,byImg,bzImg,lon,lat,lonc,latc,pAng):\\n a11 = -np.sin(latc)*np.sin(pAng)*np.sin(lon - lonc) + np.cos(pAng)*np.cos(lon - lonc)\\n a12 = np.sin(latc)*np.cos(pAng)*np.sin(lon - lonc) + np.sin(pAng)*np.cos(lon - lonc)\\n a13 = -np.cos(latc)*np.sin(lon - lonc)\\n a21 = -np.sin(lat)*(np.sin(latc)*np.sin(pAng)*np.cos(lon - lonc) + np.cos(pAng)*np.sin(lon - lonc)) - np.cos(lat)*np.cos(latc)*np.sin(pAng)\\n a22 = np.sin(lat)*(np.sin(latc)*np.cos(pAng)*np.cos(lon - lonc) - np.sin(pAng)*np.sin(lon - lonc)) + np.cos(lat)*np.cos(latc)*np.cos(pAng)\\n a23 = -np.cos(latc)*np.sin(lat)*np.cos(lon - lonc) + np.sin(latc)*np.cos(lat)\\n a31 = np.cos(lat)*(np.sin(latc)*np.sin(pAng)*np.cos(lon - lonc) + np.cos(pAng)*np.sin(lon - lonc)) - np.sin(lat)*np.cos(latc)*np.sin(pAng)\\n a32 = -np.cos(lat)*(np.sin(latc)*np.cos(pAng)*np.cos(lon - lonc) - np.sin(pAng)*np.sin(lon - lonc)) + np.sin(lat)*np.cos(latc)*np.cos(pAng)\\n a33 = np.cos(lat)*np.cos(latc)*np.cos(lon - lonc) + np.sin(lat)*np.sin(latc)\\n\\n bxHelio = a11 * bxImg + a12 * byImg + a13 * bzImg\\n byHelio = a21 * bxImg + a22 * byImg + a23 * bzImg\\n bzHelio = a31 * bxImg + a32 * byImg + a33 * bzImg\\n\\n return bxHelio,byHelio,bzHelio\",\n \"def perform(self, node, inp, out):\\r\\n img2d, filtersflipped = inp\\r\\n z, = out\\r\\n if not imported_scipy_signal:\\r\\n raise theano.gof.utils.MethodNotDefined(\\r\\n \\\"c_headers\\\", type(self), self.__class__.__name__,\\r\\n \\\"Need the python package for scipy.signal to be installed \\\"\\r\\n \\\"for the python implementation. You can use the C\\\"\\r\\n \\\" implementation instead.\\\")\\r\\n\\r\\n # TODO: move these back out to global scope when they no longer\\r\\n # cause an atexit error\\r\\n imshp = self.imshp\\r\\n if imshp is None or any([x is None for x in imshp]):\\r\\n imshp = tuple(img2d.shape[1:])\\r\\n kshp = self.kshp\\r\\n if kshp is None or any([x is None for x in kshp]):\\r\\n kshp = tuple(filtersflipped.shape[2:])\\r\\n bsize = self.bsize\\r\\n if bsize is None:\\r\\n bsize = img2d.shape[0]\\r\\n nkern = self.nkern\\r\\n if nkern is None:\\r\\n nkern = filtersflipped.shape[0]\\r\\n\\r\\n imshp_logical = self.imshp_logical\\r\\n if imshp_logical is None:\\r\\n imshp_logical = imshp\\r\\n if numpy.any([x is None for x in imshp_logical]):\\r\\n imshp_logical = tuple(img2d.shape[1:])\\r\\n\\r\\n kshp_logical = self.kshp_logical\\r\\n if kshp_logical is None:\\r\\n kshp_logical = kshp\\r\\n if numpy.any([x is None for x in kshp_logical]):\\r\\n kshp = tuple(filtersflipped.shape[2:])\\r\\n\\r\\n if self.fulloutshp is not None:\\r\\n fulloutshp = tuple(self.fulloutshp)\\r\\n else:\\r\\n fulloutshp = tuple(ConvOp.getOutputShape(imshp_logical[\\r\\n 1:], kshp_logical, (1, 1), self.out_mode))\\r\\n\\r\\n if z[0] is None or z[0].shape != (bsize, nkern,) + fulloutshp:\\r\\n z[0] = numpy.zeros((bsize, nkern,) + fulloutshp,\\r\\n dtype=img2d.dtype)\\r\\n zz = z[0]\\r\\n\\r\\n stacklen = imshp[0]\\r\\n\\r\\n img2d = img2d.reshape((bsize,) + imshp)\\r\\n filtersflipped = filtersflipped.reshape((nkern, stacklen) + kshp)\\r\\n\\r\\n if self.imshp != self.imshp_logical:\\r\\n # assuming that to get from imshp to imshp logical we insert zeros in missing spots\\r\\n rstride = int(numpy.ceil(imshp_logical[1] / float(imshp[1])))\\r\\n cstride = int(numpy.ceil(imshp_logical[2] / float(imshp[2])))\\r\\n buf = numpy.zeros((bsize,) + imshp_logical, dtype=img2d.dtype)\\r\\n buf[:, :, ::rstride, ::cstride] = img2d\\r\\n img2d = buf\\r\\n del buf, rstride, cstride\\r\\n\\r\\n if kshp != kshp_logical:\\r\\n rstride = int(numpy.ceil(kshp_logical[0] / float(kshp[0])))\\r\\n cstride = int(numpy.ceil(kshp_logical[1] / float(kshp[1])))\\r\\n buf = numpy.zeros((nkern, stacklen) +\\r\\n self.kshp_logical, dtype=filtersflipped.dtype)\\r\\n if self.kshp_logical_top_aligned:\\r\\n roffset = coffset = 0\\r\\n else:\\r\\n roffset = (kshp_logical[0] - (kshp[0] *\\r\\n rstride) - 1 + rstride) % rstride\\r\\n coffset = (kshp_logical[1] - (kshp[1] *\\r\\n cstride) - 1 + cstride) % cstride\\r\\n assert roffset >= 0\\r\\n assert coffset >= 0\\r\\n buf[:, :, roffset::rstride, coffset::cstride] = filtersflipped\\r\\n filtersflipped = buf\\r\\n del buf, rstride, cstride\\r\\n\\r\\n val = _valfrommode(self.out_mode)\\r\\n bval = _bvalfromboundary('fill')\\r\\n\\r\\n for b in xrange(bsize):\\r\\n for n in xrange(nkern):\\r\\n zz[b, n, ...].fill(0)\\r\\n for im0 in xrange(stacklen):\\r\\n zz[b, n, ...] += _convolve2d(img2d[b, im0, ...],\\r\\n filtersflipped[n, im0, ...],\\r\\n 1, val, bval, 0)\\r\\n\\r\\n if False:\\r\\n if False and self.out_mode == \\\"full\\\":\\r\\n img2d2 = numpy.zeros((bsize, stacklen,\\r\\n imshp[1] + 2 * kshp[0] - 2,\\r\\n imshp[2] + 2 * kshp[1] - 2))\\r\\n img2d2[:, :, kshp[0] - 1:kshp[0] - 1 + imshp[1],\\r\\n kshp[1] - 1:kshp[1] - 1 + imshp[2]] = img2d\\r\\n img2d = img2d2\\r\\n #N_image_shape = image_data.shape\\r\\n\\r\\n for b in xrange(bsize):\\r\\n for n in xrange(nkern):\\r\\n zz[b, n, ...].fill(0)\\r\\n for im0 in xrange(stacklen):\\r\\n for row in xrange(0, zz.shape[2], self.dx):\\r\\n for col in xrange(0, zz.shape[3], self.dy):\\r\\n zz[b, n, row, col] += (img2d[b, im0, row:row + kshp[0], col:col + kshp[1]] *\\r\\n filtersflipped[n, im0, ::-1, ::-1]).sum()\\r\\n\\r\\n #We copy it to remove the Stride mismatch warning from DEBUG_MODE.\\r\\n #The copy make that we return an object with the same stride as the c version.\\r\\n #The copy don't affect the performence during our experience as in that case we\\r\\n #execute the c version which is much faster.\\r\\n if self.dx > 1 or self.dy > 1:\\r\\n zz = zz[:, :, 0::self.dx, 0::self.dy].copy()\\r\\n\\r\\n z[0] = zz\",\n \"def __call__(self, img: Image):\\n if self.K <= 1:\\n return self.transform(img)\\n else:\\n return [self.transform(img) for _ in range(self.K)]\",\n \"def anoise(this, *args, **kargs):\\n\\t\\t\\n\\t\\t# Arguments\\n\\t\\tif not args: args = [50]\\n\\t\\t\\n\\t\\t# Kernel's retrieval\\n\\t\\tanoisek = this._ANOISEK\\n\\t\\tif anoisek is None: return None\\n\\t\\t\\n\\t\\t# More magic\\n\\t\\tbin = this._BINARY\\n\\t\\tfor thresh in args:\\n\\t\\t\\tbin[:,:] = (cv2.filter2D(bin, -1, anoisek) / 2.55 > thresh) * 255\\n\\t\\treturn True\",\n \"def WFC3_zeropoint(image):\\n logging.debug('Calculating zeropoint for {}'.format(image))\\n\\n PHOTFLAM = fits.getheader(image)['PHOTFLAM']\\n try:\\n PHOTPLAM = fits.getheader(image)['PHOTPLAM']\\n except:\\n PHOTPLAM = fits.getheader(image, 1)['PHOTPLAM']\\n\\n ABMAG_ZEROPOINT=-2.5*np.log10(PHOTFLAM)-5*np.log10(PHOTPLAM)-2.408\\n\\n return ABMAG_ZEROPOINT\",\n \"def aortic_data_augmenter(image, label, shift, rotate, scale, intensity, flip):\\n image2 = np.zeros(image.shape, dtype=np.float32)\\n label2 = np.zeros(label.shape, dtype=np.int32)\\n\\n # For N image. which come come from the same subject in the LSTM model,\\n # generate the same random affine transformation parameters.\\n shift_val = [np.clip(np.random.normal(), -3, 3) * shift,\\n np.clip(np.random.normal(), -3, 3) * shift]\\n rotate_val = np.clip(np.random.normal(), -3, 3) * rotate\\n scale_val = 1 + np.clip(np.random.normal(), -3, 3) * scale\\n intensity_val = 1 + np.clip(np.random.normal(), -3, 3) * intensity\\n\\n # The affine transformation (rotation + scale + shift)\\n row, col = image.shape[1:3]\\n M = cv2.getRotationMatrix2D(\\n (row / 2, col / 2), rotate_val, 1.0 / scale_val)\\n M[:, 2] += shift_val\\n\\n # Apply the transformation to the image\\n for i in range(image.shape[0]):\\n for c in range(image.shape[3]):\\n image2[i, :, :, c] = ndimage.interpolation.affine_transform(\\n image[i, :, :, c], M[:, :2], M[:, 2], order=1)\\n\\n label2[i, :, :] = ndimage.interpolation.affine_transform(\\n label[i, :, :], M[:, :2], M[:, 2], order=0)\\n\\n # Apply intensity variation\\n image2[i] *= intensity_val\\n\\n # Apply random horizontal or vertical flipping\\n if flip:\\n if np.random.uniform() >= 0.5:\\n image2[i] = image2[i, ::-1, :, :]\\n label2[i] = label2[i, ::-1, :]\\n else:\\n image2[i] = image2[i, :, ::-1, :]\\n label2[i] = label2[i, :, ::-1]\\n return image2, label2\",\n \"def elastic_transform(\\n img: np.ndarray,\\n alpha: float,\\n sigma: float,\\n alpha_affine: float,\\n interpolation: int = cv2.INTER_LINEAR,\\n border_mode: int = cv2.BORDER_REFLECT_101,\\n value: Optional[ImageColorType] = None,\\n random_state: Optional[np.random.RandomState] = None,\\n approximate: bool = False,\\n same_dxdy: bool = False,\\n):\\n height, width = img.shape[:2]\\n\\n # Random affine\\n center_square = np.array((height, width), dtype=np.float32) // 2\\n square_size = min((height, width)) // 3\\n alpha = float(alpha)\\n sigma = float(sigma)\\n alpha_affine = float(alpha_affine)\\n\\n pts1 = np.array(\\n [\\n center_square + square_size,\\n [center_square[0] + square_size, center_square[1] - square_size],\\n center_square - square_size,\\n ],\\n dtype=np.float32,\\n )\\n pts2 = pts1 + random_utils.uniform(-alpha_affine, alpha_affine, size=pts1.shape, random_state=random_state).astype(\\n np.float32\\n )\\n matrix = cv2.getAffineTransform(pts1, pts2)\\n\\n warp_fn = _maybe_process_in_chunks(\\n cv2.warpAffine, M=matrix, dsize=(width, height), flags=interpolation, borderMode=border_mode, borderValue=value\\n )\\n img = warp_fn(img)\\n\\n if approximate:\\n # Approximate computation smooth displacement map with a large enough kernel.\\n # On large images (512+) this is approximately 2X times faster\\n dx = random_utils.rand(height, width, random_state=random_state).astype(np.float32) * 2 - 1\\n cv2.GaussianBlur(dx, (17, 17), sigma, dst=dx)\\n dx *= alpha\\n if same_dxdy:\\n # Speed up even more\\n dy = dx\\n else:\\n dy = random_utils.rand(height, width, random_state=random_state).astype(np.float32) * 2 - 1\\n cv2.GaussianBlur(dy, (17, 17), sigma, dst=dy)\\n dy *= alpha\\n else:\\n dx = np.float32(\\n gaussian_filter((random_utils.rand(height, width, random_state=random_state) * 2 - 1), sigma) * alpha\\n )\\n if same_dxdy:\\n # Speed up\\n dy = dx\\n else:\\n dy = np.float32(\\n gaussian_filter((random_utils.rand(height, width, random_state=random_state) * 2 - 1), sigma) * alpha\\n )\\n\\n x, y = np.meshgrid(np.arange(width), np.arange(height))\\n\\n map_x = np.float32(x + dx)\\n map_y = np.float32(y + dy)\\n\\n remap_fn = _maybe_process_in_chunks(\\n cv2.remap, map1=map_x, map2=map_y, interpolation=interpolation, borderMode=border_mode, borderValue=value\\n )\\n return remap_fn(img)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6916947","0.65716195","0.6485328","0.6384206","0.63341457","0.62049633","0.5988863","0.5755377","0.56526095","0.55399","0.5451515","0.5449809","0.54059184","0.5369222","0.53182316","0.530681","0.52628165","0.5259321","0.5207307","0.5207307","0.5117338","0.5109342","0.5090614","0.50388736","0.5033801","0.5030104","0.5005629","0.4993525","0.49735722","0.4972905","0.49684963","0.49667567","0.49661204","0.49597102","0.49512604","0.49506253","0.49461222","0.49450028","0.4929515","0.49256203","0.49250248","0.49126697","0.49096668","0.49020585","0.49010205","0.4896682","0.48881763","0.4885127","0.48835817","0.4877408","0.48767522","0.4872253","0.48703563","0.48659015","0.4864198","0.48633766","0.48586443","0.48585993","0.48394164","0.48233634","0.48133668","0.4796841","0.4794797","0.47942647","0.4791048","0.47899958","0.47896937","0.47887784","0.47789642","0.47700983","0.47650543","0.4764626","0.4763446","0.47631478","0.47603863","0.47495443","0.47492966","0.4746892","0.47408274","0.47359887","0.47354716","0.4735206","0.47351417","0.47286397","0.47279656","0.47276816","0.4726545","0.47247508","0.47217882","0.47191554","0.4712008","0.4711333","0.47099903","0.47099125","0.47056824","0.47012466","0.46947366","0.4689343","0.46887788","0.46832073"],"string":"[\n \"0.6916947\",\n \"0.65716195\",\n \"0.6485328\",\n \"0.6384206\",\n \"0.63341457\",\n \"0.62049633\",\n \"0.5988863\",\n \"0.5755377\",\n \"0.56526095\",\n \"0.55399\",\n \"0.5451515\",\n \"0.5449809\",\n \"0.54059184\",\n \"0.5369222\",\n \"0.53182316\",\n \"0.530681\",\n \"0.52628165\",\n \"0.5259321\",\n \"0.5207307\",\n \"0.5207307\",\n \"0.5117338\",\n \"0.5109342\",\n \"0.5090614\",\n \"0.50388736\",\n \"0.5033801\",\n \"0.5030104\",\n \"0.5005629\",\n \"0.4993525\",\n \"0.49735722\",\n \"0.4972905\",\n \"0.49684963\",\n \"0.49667567\",\n \"0.49661204\",\n \"0.49597102\",\n \"0.49512604\",\n \"0.49506253\",\n \"0.49461222\",\n \"0.49450028\",\n \"0.4929515\",\n \"0.49256203\",\n \"0.49250248\",\n \"0.49126697\",\n \"0.49096668\",\n \"0.49020585\",\n \"0.49010205\",\n \"0.4896682\",\n \"0.48881763\",\n \"0.4885127\",\n \"0.48835817\",\n \"0.4877408\",\n \"0.48767522\",\n \"0.4872253\",\n \"0.48703563\",\n \"0.48659015\",\n \"0.4864198\",\n \"0.48633766\",\n \"0.48586443\",\n \"0.48585993\",\n \"0.48394164\",\n \"0.48233634\",\n \"0.48133668\",\n \"0.4796841\",\n \"0.4794797\",\n \"0.47942647\",\n \"0.4791048\",\n \"0.47899958\",\n \"0.47896937\",\n \"0.47887784\",\n \"0.47789642\",\n \"0.47700983\",\n \"0.47650543\",\n \"0.4764626\",\n \"0.4763446\",\n \"0.47631478\",\n \"0.47603863\",\n \"0.47495443\",\n \"0.47492966\",\n \"0.4746892\",\n \"0.47408274\",\n \"0.47359887\",\n \"0.47354716\",\n \"0.4735206\",\n \"0.47351417\",\n \"0.47286397\",\n \"0.47279656\",\n \"0.47276816\",\n \"0.4726545\",\n \"0.47247508\",\n \"0.47217882\",\n \"0.47191554\",\n \"0.4712008\",\n \"0.4711333\",\n \"0.47099903\",\n \"0.47099125\",\n \"0.47056824\",\n \"0.47012466\",\n \"0.46947366\",\n \"0.4689343\",\n \"0.46887788\",\n \"0.46832073\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5035"},"document_rank":{"kind":"string","value":"24"}}},{"rowIdx":22893,"cells":{"query":{"kind":"string","value":"Apply Gaussian noise to an input tensor."},"document":{"kind":"string","value":"def gaussian_noise(tensor, mean, stddev):\n noise = Variable(tensor.data.new(tensor.size()).normal_(mean, std))\n return tensor + noise"},"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 gaussian_noise(self, tensor):\n return tensor.new_empty(tensor.size()).normal_(std=self._discreteness)","def task_gaussian_noise(input_array, noise_factor):\n return(np.random.normal(0, noise_factor, input_array.shape))","def add_gaussian_noise(X, mu=0, sigma=0.1):\n noise = np.random.normal(0.0, sigma, size=X.size)\n return X + noise.reshape(X.shape)","def add_gaussian_noise(x, std):\n noise = x.new_zeros(x.size()).normal_(std=std)\n return x + noise","def __call__(self, input: torch.Tensor) -> torch.Tensor:\n # Get noise\n noise = self.mean + torch.randn_like(input) * self.std\n # Apply nose to image\n input = input + noise\n return input","def _gaussian_for_learn_denosing_model(image):\n return add_gaussian_noise(image, 0, 0.2)","def gaussian_noise_layer(input_layer, std):\r\n\r\n noise = tf.random_normal(tf.shape(input_layer), mean=0.0, stddev=std, dtype=tf.float32)\r\n\r\n output = tf.add_n([input_layer, noise])\r\n\r\n return output","def noise(x: np.ndarray) -> np.ndarray:\n\n return np.random.normal(loc=MEAN, scale=1e-2, size=1)","def gaussian_noise(shape, mean, std):\n return tf.random.normal(shape=shape, mean=mean, stddev=std, dtype=tf.float32)","def gaussian_noise(inputs: torch.Tensor, stddev=None, sigma_max=0.06, channel_wise=1):\n if stddev is None:\n stddev = torch.rand(channel_wise) * sigma_max\n stddev = torch.tensor(stddev, device=inputs.device)\n if DATA_FORMAT == 'channels_first':\n stddev = stddev.reshape([1, -1] + [1] * (inputs.ndim - 2))\n else:\n stddev = stddev.reshape([1] * (inputs.ndim - 1) + [-1])\n noise_map = torch.randn_like(inputs) * stddev\n return noise_map","def random_gaussian_noise(image ):\n sigma = image.std()\n for ch in range(image.shape[2] ):\n sigma = min(sigma, image[:,:,ch].std() )\n image = random_noise(image, var = sigma**2)\n return image","def awgn(input, noise_std):\n\tif not isinstance(noise_std, (list, tuple)):\n\t\tsigma = noise_std\n\telse: # uniform sampling of sigma\n\t\tsigma = noise_std[0] + \\\n\t\t (noise_std[1] - noise_std[0])*torch.rand(len(input),1,1,1, device=input.device)\n\treturn input + torch.randn_like(input) * (sigma/255)","def awgn(input, noise_std):\n\tif not isinstance(noise_std, (list, tuple)):\n\t\tsigma = noise_std\n\telse: # uniform sampling of sigma\n\t\tsigma = noise_std[0] + \\\n\t\t (noise_std[1] - noise_std[0])*torch.rand(len(input),1,1,1, device=input.device)\n\treturn input + torch.randn_like(input) * (sigma/255)","def model_gauss_noise(sigma, nx, ny=1, nz=1):\n\te = EMData()\n\te.set_size(nx, ny, nz)\n\te.process_inplace(\"testimage.noise.gauss\", {\"sigma\":sigma})\n\treturn e","def apply_gaussian(X, sigma):\n return np.array([ndimage.gaussian_filter(x, sigma) for x in X])","def add_gaussian_noise(self, samples):\n\n if 'sigma' in self.gaussian_component:\n sigma = self.gaussian_component['sigma']\n return samples + self.random_state.normal(size=samples.shape) * sigma\n if 'sigmas' in self.gaussian_component:\n sigmas = self.gaussian_component['sigmas']\n return samples + self.random_state.normal(size=samples.shape) * sigmas\n\n return samples","def sampleGaussian(self, mu, log_sigma):\n # reparameterization trick\n epsilon = tf.random_normal(tf.shape(log_sigma), name=\"epsilon\")\n return mu + epsilon * tf.exp(log_sigma) # N(mu, I * sigma**2)","def _gaussian_distribution(self, x: ndarray, mu: float, sigma: float) -> ndarray:\n return 1 / (np.sqrt(2 * np.pi) * sigma) * np.exp(\n -np.power(\n (x - mu) / sigma, 2) / 2)","def noiseless_function(x):\n return 1/(1+np.exp(-x+5))-0.5","def add_gaussian_noise(\n key: Array,\n action: Array,\n stddev: float\n) -> Array:\n chex.assert_type(action, float)\n\n noise = jax.random.normal(key, shape=action.shape) * stddev\n return action + noise","def GaussianKernel(radius, std):\n size = 2 * radius + 1\n weight = torch.ones(size, size)\n weight.requires_grad = False\n for i in range(-radius, radius+1):\n for j in range(-radius, radius+1):\n dis = (i * i) + (j * j)\n weight[i+radius][j+radius] = np.exp(-dis / (2 * std * std))\n weight = weight / weight.sum()\n return weight","def SampleFromGaussian(shape, noise_mean=0., noise_std=1., name='gaussian-sample'):\n def instantiate(args):\n mean, log_var = args\n return layers.Lambda(gaussian_noise(noise_mean=noise_mean, noise_std=noise_std),\n output_shape=shape,\n name=name)([mean, log_var])\n return instantiate","def apply_noise(self, input):\n mask = np.random.binomial(1, 1-self.noise_prob, len(input)) \n noisy_input = mask * input\n \n return noisy_input","def generate_gaussian():\n amp = 10 * numpy.random.chisquare(3)\n width = numpy.random.chisquare(3)\n mean = numpy.random.uniform(-10 + width, 10 - width)\n x = numpy.linspace(-10, 10, 500)\n y = amp * numpy.exp(- (x - mean) ** 2 / width ** 2)\n add_noise(y, 0.1)\n return x, y","def sample_noise(batch_size, dim):\n temp = torch.rand(batch_size, dim) + torch.rand(batch_size, dim)*(-1)\n\n return temp","def gaussian(window_size, sigma):\n gauss = torch.Tensor([math.exp(-(x - window_size//2)**2/float(2*sigma**2)) for x in range(window_size)])\n return gauss/gauss.sum()","def noise_data(self, x):\n return x + np.random.normal(size=x.shape)","def gaussian_gen(ngaussian, nd, batchSize, seed, random=True):\n torch.manual_seed(seed)\n np.random.seed(seed)\n\n means, covars, weights = get_means_covars(nd, ngaussian, random)\n while True:\n # yield multi_normal.sample((batchSize,))\n yield mm_gaussian(batchSize, means, covars, weights) / 1.414","def add_gaussian_noise(image, min_sigma, max_sigma):\n assert(max_sigma >= min_sigma)\n sigma = np.random.uniform(min_sigma, max_sigma)\n noise = np.random.normal(loc=0, scale=sigma, size=image.shape)\n noisy_im = np.floor((image + noise) * 255) / 255\n noisy_im = np.clip(noisy_im, 0, 1)\n return noisy_im","def gen_noise(sample_size, latent):\r\n\treturn Variable(torch.randn(sample_size, latent))","def Gaussian(x,t,sigma):\n return np.exp(-(x-t)**2/(2*sigma**2))","def random_gaussian_noise(self, img, p = 0.5):\n if self.decision(p):\n mean = 30.0\n std = 80.0\n img = img + np.random.normal(mean, std, img.shape)\n\n img = np.clip(img, 0, 255).astype('uint8')\n return img","def sample_gaussian(self, probabilities):\n return tf.add(probabilities, tf.random.normal(probabilities.shape, mean=0.0, stddev=1.0))","def addNoise(self, sigma=1.0):\n noise = numpy.random.normal(loc=0, scale=sigma, size=(self.ny, self.nx))\n self.image += noise\n return","def naive_gaussian_noise(true_depth: np.ndarray) -> np.ndarray:\n return true_depth + np.random.normal(0, 0.0012 + 0.0019 * np.square(true_depth - 0.4))","def random_gaussian(img, mu=0.0, sigma=4.0):\n\n out = np.copy(img.astype(np.float))\n rows, cols, depth = img.shape\n noise = np.random.normal(mu, sigma, (rows, cols))\n for dim in range(depth):\n out[:, :, dim] = img[:, :, dim] + noise\n out[out > 255] = 255\n out[out < 0] = 0\n out = out.astype(np.uint8)\n\n return out","def gaussian_nonorm(t, params):\n # TODO Add zeroes for t>t_final\n t_final = tf.cast(params['t_final'].get_value(), dtype=tf.float64)\n sigma = params['sigma'].get_value()\n gauss = tf.exp(-(t - t_final / 2) ** 2 / (2 * sigma ** 2))\n return gauss","def _gauss_noise(self, shape):\n\n n = np.random.normal(0, 1, shape)\n return self.e*n","def gaussianise_series(self, train_x):\n\n n_batches = train_x.shape[0]\n\n for batch in range(n_batches):\n train_x[batch, :, :] = gaussianise(train_x[batch, :, :], target_sigma=1.0)\n\n return train_x","def add_noise(arr, sigma):\n dims = arr.shape\n arr += sigma * noise(*dims)","def add_noise(Y, sigma):\r\n return Y + np.random.normal(0, sigma, Y.shape)","def sample_gaussian(self, batch_size):\n return Variable(t.randn([batch_size, self.params.latent_variable_size])) # Dimension [batch_size x latent_dim]","def add_noise(image):\n image += 10e-10 * np.random.randn(image.shape[0], image.shape[1], 1)\n \n return image","def sample(args):\n mu = args[0]\n log_sigma = args[1]\n noise = tf.random_normal(tf.shape(mu), 0, 1, dtype=tf.float32)\n z = mu + tf.exp(log_sigma/2.0) * noise\n return z","def noise(self, stddev):\n #add noise to weights\n pass","def additive_gaussian_noise(img, seed=None, std=(0, 0.4)):\n if seed is None:\n random_state = np.random.RandomState(None)\n else:\n random_state = np.random.RandomState(seed)\n sigma = std[0] + random_state.rand() * std[1]\n gaussian_noise = random_state.randn(*img.shape) * sigma\n noisy_img = img + gaussian_noise\n # noisy_img = np.clip(noisy_img, 0, 1)\n return noisy_img","def _sample_noise(\n self, x: torch.tensor, num: int, batch_size,\n device: torch.device = torch.device('cuda:0')\n ) -> np.ndarray:\n with torch.no_grad():\n # counts = np.zeros(self.num_classes, dtype=int)\n counts = torch.zeros(self.num_classes, dtype=float, device=device)\n for _ in range(ceil(num / batch_size)):\n this_batch_size = min(batch_size, num)\n num -= this_batch_size\n\n batch = x.repeat((this_batch_size, 1, 1, 1))\n noise = self.certificate.sample_noise(batch, self.sigma)\n # noise = torch.randn_like(batch, device='cuda') * self.sigma\n predictions = self.base_classifier(batch + noise).argmax(1)\n counts += self._count_arr(predictions,\n device, self.num_classes)\n return counts.cpu().numpy()","def normal_sample(mu, sigma):\n return mu + sigma * torch.randn_like(sigma)","def p_sample(self, pred_noise, x, t, clip_denoised=True):\n model_mean, _, model_log_variance = self.p_mean_variance(\n pred_noise, x=x, t=t, clip_denoised=clip_denoised\n )\n noise = tf.random.normal(shape=x.shape, dtype=x.dtype)\n # No noise when t == 0\n nonzero_mask = tf.reshape(\n 1 - tf.cast(tf.equal(t, 0), tf.float32), [tf.shape(x)[0], 1, 1, 1])\n return model_mean + nonzero_mask * tf.exp(0.5 * model_log_variance) * noise","def softing_noise(image, kn):\n\n s_noise = cv2.GaussianBlur(image, (kn, kn), 0)\n\n return s_noise","def gauss_noise(_spec, stdev):\n t, f = _spec.shape\n awgn = np.random.normal(0, stdev, (t, f))\n # gauss = gauss.reshape(t, f)\n _spec_noise = _spec + awgn\n return _spec_noise","def Gaussian(x, t, sigma):\n return np.exp(-(x - t)**2 / (2 * sigma**2))","def add_gaussian_noise(image, min_sigma, max_sigma):\r\n sigma = np.random.uniform(min_sigma, max_sigma)\r\n corrupted_im = image + np.random.normal(0, sigma, image.shape)\r\n rounded_im = (np.round(corrupted_im * MAX_PIXEL_NUMBER)) / MAX_PIXEL_NUMBER\r\n return np.clip(rounded_im, 0, 1).astype(np.float64)","def add_gaussian_noise(images: list, var: list, random_var: float=None, gauss_noise: list=None):\n if random_var is None:\n random_var = np.random.uniform(var[0], var[1])\n mean = 0\n new_images = []\n gauss_noise_out = []\n for i,image in enumerate(images):\n row, col, c = image.shape\n if gauss_noise is None or \\\n (gauss_noise is not None and row*col*c !=\n gauss_noise[i].shape[0]*gauss_noise[i].shape[1] * gauss_noise[i].shape[2]):\n gauss = np.random.normal(mean, random_var * 127.5, (row, col, c))\n else:\n gauss = gauss_noise[i]\n gauss_noise_out.append(gauss)\n gauss = gauss.reshape(row, col, c)\n image1 = np.clip(image + gauss, 0., 255.)\n new_images.append(image1)\n return new_images, random_var, gauss_noise_out","def set_gaussian(self, X, sigma=0):\n sigma = float(sigma)\n if sigma < 0:\n raise ValueError('sigma should be positive')\n self.set_euclidian(X)\n d = self.weights\n\n if sigma == 0:\n sigma = (d ** 2).mean()\n\n w = np.exp(- (d ** 2) / (2 * sigma))\n self.weights = w","def addNoise(img, sigma=2.0, mean=0):\n img2 = np.random.normal(mean, sigma, size=img.shape)\n\n img2 += img\n img2 = np.uint8(img2.clip(0, 255))\n return img2","def gaussian_white(z, mu: 'normal' = 0, sigma: (0.4, 1) = 0.7):\n return 1 - gaussian_black(z, mu, sigma)","def all_views_gaussian_noise_layer(input_layer, std):\r\n\r\n input_l_cc, input_r_cc = input_layer\r\n\r\n output_l_cc = gaussian_noise_layer(input_l_cc, std)\r\n output_r_cc = gaussian_noise_layer(input_r_cc, std)\r\n\r\n\r\n output = (output_l_cc, output_r_cc)\r\n\r\n return output","def get_noise(batch_size, total_continuous_noise_dims):\n # Get unstructurd noise.\n noise = tf.random_normal(\n [batch_size, total_continuous_noise_dims])\n\n return noise","def poisson_noise(inputs: torch.Tensor, stddev=None, sigma_max=0.16, channel_wise=1):\n if stddev is None:\n stddev = torch.rand(channel_wise) * sigma_max\n stddev = torch.tensor(stddev, device=inputs.device)\n if DATA_FORMAT == 'channels_first':\n stddev = stddev.reshape([1, -1] + [1] * (inputs.ndim - 2))\n else:\n stddev = stddev.reshape([1] * (inputs.ndim - 1) + [-1])\n sigma_map = (1 - inputs) * stddev\n return torch.randn_like(inputs) * sigma_map","def sample_noise(batch_size, dim):\n\n return tf.random_uniform([batch_size, dim], minval=-1, maxval=1)","def gaussian(mu, wid, x):\n return np.exp(-((x - mu) / (0.6005612 * wid))**2)","def add_image_noise(\n self, mu=0, sigma=0.005, only_positive=False, random_seed=None):\n if random_seed is not None:\n np.random.seed(random_seed)\n shape = self.signal.axes_manager.shape\n noise = normal(mu, sigma, shape)\n if only_positive:\n self._image_noise = np.absolute(noise)\n else:\n self._image_noise = noise","def sample_noise(batch_size, dim):\n noise = torch.rand(batch_size, dim) * 2 - 1\n return noise.view(batch_size, dim, 1, 1)","def gaussian_filter(x):\n return _gaussian_filter(x, 3)","def transform(self, X):\n # Note: This maps to mean of distribution, we could alternatively\n # sample from Gaussian distribution\n return self.sess.run(self.z_mean, feed_dict={self.x_raw: X})","def nll_gaussian(params: ztyping.ParamTypeInput, observation: ztyping.NumericalScalarType,\n uncertainty: ztyping.NumericalScalarType) -> tf.Tensor:\n\n return GaussianConstraint(params=params, observation=observation, uncertainty=uncertainty)","def gaussian(x, mean, sigma):\n return np.exp(-np.square(x-mean)/(2*np.square(sigma))) / (np.sqrt(2*np.pi*sigma**2))","def _make_noisy(x, the_noise):\n noise_sample = the_noise[np.random.choice(the_noise.shape[0],\n x.shape[0],\n replace=False)]\n return x + noise_sample","def generate_fake_noise(inputs, size):\n return np.random.normal(-0.0289923828125, 1.9391296947313124, (inputs, size)).astype(np.float32)","def GaussianKernel(sigma: float = 1., width: int = 0):\n assert not ((width is None or width == 0) and\n (sigma is None or sigma == 0)), \\\n \"GaussianKernel :: both sigma ({}) & width ({}) are not valid\".format(\n sigma, width)\n\n if width is None or width == 0:\n width = int(2.0 * 3.0 * sigma + 1.0)\n if width % 2 == 0:\n width += 1\n\n if sigma is None or sigma == 0:\n sigma = (width - 1)/6.\n half = width//2\n x, y = np.meshgrid(np.linspace(-half, half, width),\n np.linspace(-half, half, width), indexing='xy')\n w = np.exp(- (x**2 + y**2) / (2.*(sigma**2)))\n w /= np.sum(w)\n return torch.from_numpy(w.astype(np.float32)).view(1, 1, width, width)","def sample_gaussian(params, typ='numpy', batch_size=100):\n if typ =='tensorflow':\n means, covs = tf.split(params,2,axis=-1)\n shape = tf.shape(means)\n eps = tf.random.normal(shape, dtype=tf.float32)\n noise = means + tf.multiply(eps,tf.sqrt(1e-10+covs))\n elif typ =='numpy':\n means, covs = np.split(params,2,axis=-1)\n if len(np.shape(means))<2:\n shape = (batch_size,)+np.shape(means)\n else:\n shape = np.shape(means)\n eps = np.random.normal(0.,1.,shape).astype(np.float32)\n noise = means + np.multiply(eps,np.sqrt(1e-10+covs))\n return noise","def gaussian_denoiser(z_noisy, u, size):\n\n a1 = tf.Variable(0. * tf.ones([size]), name='a1')\n a2 = tf.Variable(1. * tf.ones([size]), name='a2')\n a3 = tf.Variable(0. * tf.ones([size]), name='a3')\n a4 = tf.Variable(0. * tf.ones([size]), name='a4')\n a5 = tf.Variable(0. * tf.ones([size]), name='a5')\n\n # v\n a6 = tf.Variable(0. * tf.ones([size]), name='a6')\n a7 = tf.Variable(1. * tf.ones([size]), name='a7')\n a8 = tf.Variable(0. * tf.ones([size]), name='a8')\n a9 = tf.Variable(0. * tf.ones([size]), name='a9')\n a10 = tf.Variable(0. * tf.ones([size]), name='a10')\n\n mu = a1 * tf.sigmoid(a2 * u + a3) + a4 * u + a5\n v = a6 * tf.sigmoid(a7 * u + a8) + a9 * u + a10\n\n z = (z_noisy - mu) * v + mu\n return z","def apply_noise(input_image, noise_level):\n n,m = input_image.shape\n # generate binomial noise\n ksi = np.random.binomial(size=n*m, n=1, p=noise_level).reshape(input_image.shape)\n noised_image = ksi^input_image\n return noised_image","def add_noise(self):\n self.noise = np.random.poisson(lam=self.lam, size=self.image.shape)\n self.image += self.noise\n return","def add_noise(self):\n self.noise = torch.normal(0.5, .2, self.state.shape).double()\n self.noise *= torch.sqrt(2 *\n self.vars['T']*torch.tensor(self.vars['dt']))","def gaussian(amp, fwhm, mean, x):\n return amp * np.exp(-4. * np.log(2) * (x-mean)**2 / fwhm**2)","def gaussian_likelihood(x, mu, log_std):\n std = tf.exp(log_std)\n pre_sum = tf.square((x - mu)/std) + 2*log_std + np.log(2*np.pi)\n return -0.5 * tf.reduce_sum(pre_sum, axis=1)","def add_noise(self):\n self.noise = np.random.poisson(lam=self.lam, size=self.im.shape)\n self.im += self.noise\n return","def _sample_new_noise(self, *, tf_sess=None):\n if self.framework == \"tf\":\n tf_sess.run(self.tf_sample_new_noise_op)\n elif self.framework == \"tf2\":\n self._tf_sample_new_noise_op()\n else:\n for i in range(len(self.noise)):\n self.noise[i] = torch.normal(\n mean=torch.zeros(self.noise[i].size()), std=self.stddev\n ).to(self.device)","def xavier_normal_init(tensor, gain=1., random_state=None):\n # type: (Tensor, float) -> Tensor\n fan_in, fan_out = _calculate_fan_in_and_fan_out(tensor)\n std = gain * math.sqrt(2.0 / float(fan_in + fan_out))\n\n normal_init(tensor, 0., std, random_state)\n return tensor","def get_noise(n_samples, noise_dims):\n return torch.randn(n_samples, noise_dims).to(device)","def add_gaussian_noise(projections, noise_var):\n noise_sigma = noise_var**0.5\n nproj,row,col = projections.shape\n gauss_noise = np.random.normal(0, noise_sigma, (nproj, row, col))\n gauss_noise = gauss_noise.reshape(nproj, row, col) \n projections = projections + gauss_noise\n return projections","def tf_gaussian_kernel(size: int,mean: float,std: float,):\n d = tf.distributions.Normal(mean, std)\n vals = d.prob(tf.range(start = -size, limit = size + 1, dtype = tf.float32))\n gauss_kernel = tf.einsum('i,j->ij',vals,vals)\n return gauss_kernel / tf.reduce_sum(gauss_kernel)","def generate_with_noise(self, noise):\n with tf.compat.v1.Session() as sess:\n self.saver.restore(sess, \"data/\" + self.name + \".ckpt\")\n return self.X_fake.eval(feed_dict={self.z: noise, self.is_training: False})","def sample_gaussian(m, v, repeat=1):\n if repeat > 1:\n v = v.squeeze()\n m = m.squeeze()\n sqrt_v = torch.cat([torch.sqrt(v)] * repeat, dim=0)\n m = torch.cat([m] * repeat, dim=0)\n else:\n sqrt_v = torch.sqrt(v)\n sample = m + torch.randn_like(sqrt_v) * sqrt_v\n return sample","def noiseReduction(self):\n pass","def transform(self, sess, xs):\n return sess.run( [self.z_mean, self.z_log_sigma_sq],\n feed_dict={self.x: xs} )","def noise_input_fn(params):\n batch_size = params['batch_size']\n noise_dim = params['noise_dim']\n # Use constant seed to obtain same noise\n np.random.seed(0)\n noise_dataset = tf.data.Dataset.from_tensors(\n {'random_noise': tf.constant(\n np.random.randn(batch_size, noise_dim), dtype=tf.float32)\n })\n noise = noise_dataset.make_one_shot_iterator().get_next()\n tf.logging.debug('Noise input %s', noise)\n return noise_dataset","def add_noise(image, noise, rate=0.05):\n\n if noise == \"gaussian\":\n row, col = image.shape\n var = ndimage.laplace(image).var()\n sigma = (var*rate) ** 0.5\n print(var, sigma)\n gauss = np.random.normal(loc=0, scale=sigma, size=(row, col)) * rate\n noisy = image + gauss\n # noisy = image + gauss\n return noisy\n\n elif noise == \"salt_pepper\":\n output = image.copy()\n black = 0\n white = 255\n probs = np.random.random(image.shape[:2])\n output[probs < (rate / 2)] = black\n output[probs > 1 - (rate / 2)] = white\n\n return output\n\n else:\n return image","def gaussian_nll(x, mean, ln_var):\n\n x_prec = torch.exp(-ln_var)\n x_diff = x - mean\n x_power = (x_diff * x_diff) * x_prec * -0.5\n loss = (ln_var + math.log(2 * (math.pi))) / 2 - x_power\n return loss","def diag_gaussian_sample(key, mean, logvar, varmin=1e-16):\n logvar_wm = np.log(np.exp(logvar) + varmin)\n return mean + np.exp(0.5*logvar_wm) * random.normal(key, mean.shape)","def noisysphere(self, x, noise=4.0, cond=1.0):\r\n return self.elli(x, cond=cond) * (1 + noise * np.random.randn() / len(x))","def add_gaussian_noise(self, stdev, iteration, method = 'absolute', normalize = \"on\"):\n for time in self.mdvtc.keys():\n self.mdvtc[time].add_gaussian_noise(stdev, iteration, method, normalize)","def generate_noise_vector(self, ):\n self.noise.resize_(\n self.batch_size, int(self.opt.nz), 1, 1).normal_(0, 1)\n self.noisev = Variable(self.noise) # TODO: Add volatile=True???","def gaussian_dataset(ngaussian, nd, nsample, random=True):\n means, covars, weights = get_means_covars(nd, ngaussian, random)\n return mm_gaussian(nsample, means, covars, weights)","def gaussian(x, *parameters):\n position, sigma, amplitude, background = parameters\n return amplitude * np.exp(-(x - position)**2 / (2.0 * sigma**2)) + background","def gaussian(amp, fwhm, mean):\n return lambda x: amp * np.exp(-4. * np.log(2) * (x-mean)**2 / fwhm**2)","def scale_noise(size: int) -> torch.Tensor:\n x = torch.FloatTensor(np.random.normal(loc=0.0, scale=1.0, size=size))\n\n return x.sign().mul(x.abs().sqrt())","def run_gaussian_smoothing(image, kernel_size=5):\n return cv2.GaussianBlur(image, (kernel_size, kernel_size), 0)"],"string":"[\n \"def gaussian_noise(self, tensor):\\n return tensor.new_empty(tensor.size()).normal_(std=self._discreteness)\",\n \"def task_gaussian_noise(input_array, noise_factor):\\n return(np.random.normal(0, noise_factor, input_array.shape))\",\n \"def add_gaussian_noise(X, mu=0, sigma=0.1):\\n noise = np.random.normal(0.0, sigma, size=X.size)\\n return X + noise.reshape(X.shape)\",\n \"def add_gaussian_noise(x, std):\\n noise = x.new_zeros(x.size()).normal_(std=std)\\n return x + noise\",\n \"def __call__(self, input: torch.Tensor) -> torch.Tensor:\\n # Get noise\\n noise = self.mean + torch.randn_like(input) * self.std\\n # Apply nose to image\\n input = input + noise\\n return input\",\n \"def _gaussian_for_learn_denosing_model(image):\\n return add_gaussian_noise(image, 0, 0.2)\",\n \"def gaussian_noise_layer(input_layer, std):\\r\\n\\r\\n noise = tf.random_normal(tf.shape(input_layer), mean=0.0, stddev=std, dtype=tf.float32)\\r\\n\\r\\n output = tf.add_n([input_layer, noise])\\r\\n\\r\\n return output\",\n \"def noise(x: np.ndarray) -> np.ndarray:\\n\\n return np.random.normal(loc=MEAN, scale=1e-2, size=1)\",\n \"def gaussian_noise(shape, mean, std):\\n return tf.random.normal(shape=shape, mean=mean, stddev=std, dtype=tf.float32)\",\n \"def gaussian_noise(inputs: torch.Tensor, stddev=None, sigma_max=0.06, channel_wise=1):\\n if stddev is None:\\n stddev = torch.rand(channel_wise) * sigma_max\\n stddev = torch.tensor(stddev, device=inputs.device)\\n if DATA_FORMAT == 'channels_first':\\n stddev = stddev.reshape([1, -1] + [1] * (inputs.ndim - 2))\\n else:\\n stddev = stddev.reshape([1] * (inputs.ndim - 1) + [-1])\\n noise_map = torch.randn_like(inputs) * stddev\\n return noise_map\",\n \"def random_gaussian_noise(image ):\\n sigma = image.std()\\n for ch in range(image.shape[2] ):\\n sigma = min(sigma, image[:,:,ch].std() )\\n image = random_noise(image, var = sigma**2)\\n return image\",\n \"def awgn(input, noise_std):\\n\\tif not isinstance(noise_std, (list, tuple)):\\n\\t\\tsigma = noise_std\\n\\telse: # uniform sampling of sigma\\n\\t\\tsigma = noise_std[0] + \\\\\\n\\t\\t (noise_std[1] - noise_std[0])*torch.rand(len(input),1,1,1, device=input.device)\\n\\treturn input + torch.randn_like(input) * (sigma/255)\",\n \"def awgn(input, noise_std):\\n\\tif not isinstance(noise_std, (list, tuple)):\\n\\t\\tsigma = noise_std\\n\\telse: # uniform sampling of sigma\\n\\t\\tsigma = noise_std[0] + \\\\\\n\\t\\t (noise_std[1] - noise_std[0])*torch.rand(len(input),1,1,1, device=input.device)\\n\\treturn input + torch.randn_like(input) * (sigma/255)\",\n \"def model_gauss_noise(sigma, nx, ny=1, nz=1):\\n\\te = EMData()\\n\\te.set_size(nx, ny, nz)\\n\\te.process_inplace(\\\"testimage.noise.gauss\\\", {\\\"sigma\\\":sigma})\\n\\treturn e\",\n \"def apply_gaussian(X, sigma):\\n return np.array([ndimage.gaussian_filter(x, sigma) for x in X])\",\n \"def add_gaussian_noise(self, samples):\\n\\n if 'sigma' in self.gaussian_component:\\n sigma = self.gaussian_component['sigma']\\n return samples + self.random_state.normal(size=samples.shape) * sigma\\n if 'sigmas' in self.gaussian_component:\\n sigmas = self.gaussian_component['sigmas']\\n return samples + self.random_state.normal(size=samples.shape) * sigmas\\n\\n return samples\",\n \"def sampleGaussian(self, mu, log_sigma):\\n # reparameterization trick\\n epsilon = tf.random_normal(tf.shape(log_sigma), name=\\\"epsilon\\\")\\n return mu + epsilon * tf.exp(log_sigma) # N(mu, I * sigma**2)\",\n \"def _gaussian_distribution(self, x: ndarray, mu: float, sigma: float) -> ndarray:\\n return 1 / (np.sqrt(2 * np.pi) * sigma) * np.exp(\\n -np.power(\\n (x - mu) / sigma, 2) / 2)\",\n \"def noiseless_function(x):\\n return 1/(1+np.exp(-x+5))-0.5\",\n \"def add_gaussian_noise(\\n key: Array,\\n action: Array,\\n stddev: float\\n) -> Array:\\n chex.assert_type(action, float)\\n\\n noise = jax.random.normal(key, shape=action.shape) * stddev\\n return action + noise\",\n \"def GaussianKernel(radius, std):\\n size = 2 * radius + 1\\n weight = torch.ones(size, size)\\n weight.requires_grad = False\\n for i in range(-radius, radius+1):\\n for j in range(-radius, radius+1):\\n dis = (i * i) + (j * j)\\n weight[i+radius][j+radius] = np.exp(-dis / (2 * std * std))\\n weight = weight / weight.sum()\\n return weight\",\n \"def SampleFromGaussian(shape, noise_mean=0., noise_std=1., name='gaussian-sample'):\\n def instantiate(args):\\n mean, log_var = args\\n return layers.Lambda(gaussian_noise(noise_mean=noise_mean, noise_std=noise_std),\\n output_shape=shape,\\n name=name)([mean, log_var])\\n return instantiate\",\n \"def apply_noise(self, input):\\n mask = np.random.binomial(1, 1-self.noise_prob, len(input)) \\n noisy_input = mask * input\\n \\n return noisy_input\",\n \"def generate_gaussian():\\n amp = 10 * numpy.random.chisquare(3)\\n width = numpy.random.chisquare(3)\\n mean = numpy.random.uniform(-10 + width, 10 - width)\\n x = numpy.linspace(-10, 10, 500)\\n y = amp * numpy.exp(- (x - mean) ** 2 / width ** 2)\\n add_noise(y, 0.1)\\n return x, y\",\n \"def sample_noise(batch_size, dim):\\n temp = torch.rand(batch_size, dim) + torch.rand(batch_size, dim)*(-1)\\n\\n return temp\",\n \"def gaussian(window_size, sigma):\\n gauss = torch.Tensor([math.exp(-(x - window_size//2)**2/float(2*sigma**2)) for x in range(window_size)])\\n return gauss/gauss.sum()\",\n \"def noise_data(self, x):\\n return x + np.random.normal(size=x.shape)\",\n \"def gaussian_gen(ngaussian, nd, batchSize, seed, random=True):\\n torch.manual_seed(seed)\\n np.random.seed(seed)\\n\\n means, covars, weights = get_means_covars(nd, ngaussian, random)\\n while True:\\n # yield multi_normal.sample((batchSize,))\\n yield mm_gaussian(batchSize, means, covars, weights) / 1.414\",\n \"def add_gaussian_noise(image, min_sigma, max_sigma):\\n assert(max_sigma >= min_sigma)\\n sigma = np.random.uniform(min_sigma, max_sigma)\\n noise = np.random.normal(loc=0, scale=sigma, size=image.shape)\\n noisy_im = np.floor((image + noise) * 255) / 255\\n noisy_im = np.clip(noisy_im, 0, 1)\\n return noisy_im\",\n \"def gen_noise(sample_size, latent):\\r\\n\\treturn Variable(torch.randn(sample_size, latent))\",\n \"def Gaussian(x,t,sigma):\\n return np.exp(-(x-t)**2/(2*sigma**2))\",\n \"def random_gaussian_noise(self, img, p = 0.5):\\n if self.decision(p):\\n mean = 30.0\\n std = 80.0\\n img = img + np.random.normal(mean, std, img.shape)\\n\\n img = np.clip(img, 0, 255).astype('uint8')\\n return img\",\n \"def sample_gaussian(self, probabilities):\\n return tf.add(probabilities, tf.random.normal(probabilities.shape, mean=0.0, stddev=1.0))\",\n \"def addNoise(self, sigma=1.0):\\n noise = numpy.random.normal(loc=0, scale=sigma, size=(self.ny, self.nx))\\n self.image += noise\\n return\",\n \"def naive_gaussian_noise(true_depth: np.ndarray) -> np.ndarray:\\n return true_depth + np.random.normal(0, 0.0012 + 0.0019 * np.square(true_depth - 0.4))\",\n \"def random_gaussian(img, mu=0.0, sigma=4.0):\\n\\n out = np.copy(img.astype(np.float))\\n rows, cols, depth = img.shape\\n noise = np.random.normal(mu, sigma, (rows, cols))\\n for dim in range(depth):\\n out[:, :, dim] = img[:, :, dim] + noise\\n out[out > 255] = 255\\n out[out < 0] = 0\\n out = out.astype(np.uint8)\\n\\n return out\",\n \"def gaussian_nonorm(t, params):\\n # TODO Add zeroes for t>t_final\\n t_final = tf.cast(params['t_final'].get_value(), dtype=tf.float64)\\n sigma = params['sigma'].get_value()\\n gauss = tf.exp(-(t - t_final / 2) ** 2 / (2 * sigma ** 2))\\n return gauss\",\n \"def _gauss_noise(self, shape):\\n\\n n = np.random.normal(0, 1, shape)\\n return self.e*n\",\n \"def gaussianise_series(self, train_x):\\n\\n n_batches = train_x.shape[0]\\n\\n for batch in range(n_batches):\\n train_x[batch, :, :] = gaussianise(train_x[batch, :, :], target_sigma=1.0)\\n\\n return train_x\",\n \"def add_noise(arr, sigma):\\n dims = arr.shape\\n arr += sigma * noise(*dims)\",\n \"def add_noise(Y, sigma):\\r\\n return Y + np.random.normal(0, sigma, Y.shape)\",\n \"def sample_gaussian(self, batch_size):\\n return Variable(t.randn([batch_size, self.params.latent_variable_size])) # Dimension [batch_size x latent_dim]\",\n \"def add_noise(image):\\n image += 10e-10 * np.random.randn(image.shape[0], image.shape[1], 1)\\n \\n return image\",\n \"def sample(args):\\n mu = args[0]\\n log_sigma = args[1]\\n noise = tf.random_normal(tf.shape(mu), 0, 1, dtype=tf.float32)\\n z = mu + tf.exp(log_sigma/2.0) * noise\\n return z\",\n \"def noise(self, stddev):\\n #add noise to weights\\n pass\",\n \"def additive_gaussian_noise(img, seed=None, std=(0, 0.4)):\\n if seed is None:\\n random_state = np.random.RandomState(None)\\n else:\\n random_state = np.random.RandomState(seed)\\n sigma = std[0] + random_state.rand() * std[1]\\n gaussian_noise = random_state.randn(*img.shape) * sigma\\n noisy_img = img + gaussian_noise\\n # noisy_img = np.clip(noisy_img, 0, 1)\\n return noisy_img\",\n \"def _sample_noise(\\n self, x: torch.tensor, num: int, batch_size,\\n device: torch.device = torch.device('cuda:0')\\n ) -> np.ndarray:\\n with torch.no_grad():\\n # counts = np.zeros(self.num_classes, dtype=int)\\n counts = torch.zeros(self.num_classes, dtype=float, device=device)\\n for _ in range(ceil(num / batch_size)):\\n this_batch_size = min(batch_size, num)\\n num -= this_batch_size\\n\\n batch = x.repeat((this_batch_size, 1, 1, 1))\\n noise = self.certificate.sample_noise(batch, self.sigma)\\n # noise = torch.randn_like(batch, device='cuda') * self.sigma\\n predictions = self.base_classifier(batch + noise).argmax(1)\\n counts += self._count_arr(predictions,\\n device, self.num_classes)\\n return counts.cpu().numpy()\",\n \"def normal_sample(mu, sigma):\\n return mu + sigma * torch.randn_like(sigma)\",\n \"def p_sample(self, pred_noise, x, t, clip_denoised=True):\\n model_mean, _, model_log_variance = self.p_mean_variance(\\n pred_noise, x=x, t=t, clip_denoised=clip_denoised\\n )\\n noise = tf.random.normal(shape=x.shape, dtype=x.dtype)\\n # No noise when t == 0\\n nonzero_mask = tf.reshape(\\n 1 - tf.cast(tf.equal(t, 0), tf.float32), [tf.shape(x)[0], 1, 1, 1])\\n return model_mean + nonzero_mask * tf.exp(0.5 * model_log_variance) * noise\",\n \"def softing_noise(image, kn):\\n\\n s_noise = cv2.GaussianBlur(image, (kn, kn), 0)\\n\\n return s_noise\",\n \"def gauss_noise(_spec, stdev):\\n t, f = _spec.shape\\n awgn = np.random.normal(0, stdev, (t, f))\\n # gauss = gauss.reshape(t, f)\\n _spec_noise = _spec + awgn\\n return _spec_noise\",\n \"def Gaussian(x, t, sigma):\\n return np.exp(-(x - t)**2 / (2 * sigma**2))\",\n \"def add_gaussian_noise(image, min_sigma, max_sigma):\\r\\n sigma = np.random.uniform(min_sigma, max_sigma)\\r\\n corrupted_im = image + np.random.normal(0, sigma, image.shape)\\r\\n rounded_im = (np.round(corrupted_im * MAX_PIXEL_NUMBER)) / MAX_PIXEL_NUMBER\\r\\n return np.clip(rounded_im, 0, 1).astype(np.float64)\",\n \"def add_gaussian_noise(images: list, var: list, random_var: float=None, gauss_noise: list=None):\\n if random_var is None:\\n random_var = np.random.uniform(var[0], var[1])\\n mean = 0\\n new_images = []\\n gauss_noise_out = []\\n for i,image in enumerate(images):\\n row, col, c = image.shape\\n if gauss_noise is None or \\\\\\n (gauss_noise is not None and row*col*c !=\\n gauss_noise[i].shape[0]*gauss_noise[i].shape[1] * gauss_noise[i].shape[2]):\\n gauss = np.random.normal(mean, random_var * 127.5, (row, col, c))\\n else:\\n gauss = gauss_noise[i]\\n gauss_noise_out.append(gauss)\\n gauss = gauss.reshape(row, col, c)\\n image1 = np.clip(image + gauss, 0., 255.)\\n new_images.append(image1)\\n return new_images, random_var, gauss_noise_out\",\n \"def set_gaussian(self, X, sigma=0):\\n sigma = float(sigma)\\n if sigma < 0:\\n raise ValueError('sigma should be positive')\\n self.set_euclidian(X)\\n d = self.weights\\n\\n if sigma == 0:\\n sigma = (d ** 2).mean()\\n\\n w = np.exp(- (d ** 2) / (2 * sigma))\\n self.weights = w\",\n \"def addNoise(img, sigma=2.0, mean=0):\\n img2 = np.random.normal(mean, sigma, size=img.shape)\\n\\n img2 += img\\n img2 = np.uint8(img2.clip(0, 255))\\n return img2\",\n \"def gaussian_white(z, mu: 'normal' = 0, sigma: (0.4, 1) = 0.7):\\n return 1 - gaussian_black(z, mu, sigma)\",\n \"def all_views_gaussian_noise_layer(input_layer, std):\\r\\n\\r\\n input_l_cc, input_r_cc = input_layer\\r\\n\\r\\n output_l_cc = gaussian_noise_layer(input_l_cc, std)\\r\\n output_r_cc = gaussian_noise_layer(input_r_cc, std)\\r\\n\\r\\n\\r\\n output = (output_l_cc, output_r_cc)\\r\\n\\r\\n return output\",\n \"def get_noise(batch_size, total_continuous_noise_dims):\\n # Get unstructurd noise.\\n noise = tf.random_normal(\\n [batch_size, total_continuous_noise_dims])\\n\\n return noise\",\n \"def poisson_noise(inputs: torch.Tensor, stddev=None, sigma_max=0.16, channel_wise=1):\\n if stddev is None:\\n stddev = torch.rand(channel_wise) * sigma_max\\n stddev = torch.tensor(stddev, device=inputs.device)\\n if DATA_FORMAT == 'channels_first':\\n stddev = stddev.reshape([1, -1] + [1] * (inputs.ndim - 2))\\n else:\\n stddev = stddev.reshape([1] * (inputs.ndim - 1) + [-1])\\n sigma_map = (1 - inputs) * stddev\\n return torch.randn_like(inputs) * sigma_map\",\n \"def sample_noise(batch_size, dim):\\n\\n return tf.random_uniform([batch_size, dim], minval=-1, maxval=1)\",\n \"def gaussian(mu, wid, x):\\n return np.exp(-((x - mu) / (0.6005612 * wid))**2)\",\n \"def add_image_noise(\\n self, mu=0, sigma=0.005, only_positive=False, random_seed=None):\\n if random_seed is not None:\\n np.random.seed(random_seed)\\n shape = self.signal.axes_manager.shape\\n noise = normal(mu, sigma, shape)\\n if only_positive:\\n self._image_noise = np.absolute(noise)\\n else:\\n self._image_noise = noise\",\n \"def sample_noise(batch_size, dim):\\n noise = torch.rand(batch_size, dim) * 2 - 1\\n return noise.view(batch_size, dim, 1, 1)\",\n \"def gaussian_filter(x):\\n return _gaussian_filter(x, 3)\",\n \"def transform(self, X):\\n # Note: This maps to mean of distribution, we could alternatively\\n # sample from Gaussian distribution\\n return self.sess.run(self.z_mean, feed_dict={self.x_raw: X})\",\n \"def nll_gaussian(params: ztyping.ParamTypeInput, observation: ztyping.NumericalScalarType,\\n uncertainty: ztyping.NumericalScalarType) -> tf.Tensor:\\n\\n return GaussianConstraint(params=params, observation=observation, uncertainty=uncertainty)\",\n \"def gaussian(x, mean, sigma):\\n return np.exp(-np.square(x-mean)/(2*np.square(sigma))) / (np.sqrt(2*np.pi*sigma**2))\",\n \"def _make_noisy(x, the_noise):\\n noise_sample = the_noise[np.random.choice(the_noise.shape[0],\\n x.shape[0],\\n replace=False)]\\n return x + noise_sample\",\n \"def generate_fake_noise(inputs, size):\\n return np.random.normal(-0.0289923828125, 1.9391296947313124, (inputs, size)).astype(np.float32)\",\n \"def GaussianKernel(sigma: float = 1., width: int = 0):\\n assert not ((width is None or width == 0) and\\n (sigma is None or sigma == 0)), \\\\\\n \\\"GaussianKernel :: both sigma ({}) & width ({}) are not valid\\\".format(\\n sigma, width)\\n\\n if width is None or width == 0:\\n width = int(2.0 * 3.0 * sigma + 1.0)\\n if width % 2 == 0:\\n width += 1\\n\\n if sigma is None or sigma == 0:\\n sigma = (width - 1)/6.\\n half = width//2\\n x, y = np.meshgrid(np.linspace(-half, half, width),\\n np.linspace(-half, half, width), indexing='xy')\\n w = np.exp(- (x**2 + y**2) / (2.*(sigma**2)))\\n w /= np.sum(w)\\n return torch.from_numpy(w.astype(np.float32)).view(1, 1, width, width)\",\n \"def sample_gaussian(params, typ='numpy', batch_size=100):\\n if typ =='tensorflow':\\n means, covs = tf.split(params,2,axis=-1)\\n shape = tf.shape(means)\\n eps = tf.random.normal(shape, dtype=tf.float32)\\n noise = means + tf.multiply(eps,tf.sqrt(1e-10+covs))\\n elif typ =='numpy':\\n means, covs = np.split(params,2,axis=-1)\\n if len(np.shape(means))<2:\\n shape = (batch_size,)+np.shape(means)\\n else:\\n shape = np.shape(means)\\n eps = np.random.normal(0.,1.,shape).astype(np.float32)\\n noise = means + np.multiply(eps,np.sqrt(1e-10+covs))\\n return noise\",\n \"def gaussian_denoiser(z_noisy, u, size):\\n\\n a1 = tf.Variable(0. * tf.ones([size]), name='a1')\\n a2 = tf.Variable(1. * tf.ones([size]), name='a2')\\n a3 = tf.Variable(0. * tf.ones([size]), name='a3')\\n a4 = tf.Variable(0. * tf.ones([size]), name='a4')\\n a5 = tf.Variable(0. * tf.ones([size]), name='a5')\\n\\n # v\\n a6 = tf.Variable(0. * tf.ones([size]), name='a6')\\n a7 = tf.Variable(1. * tf.ones([size]), name='a7')\\n a8 = tf.Variable(0. * tf.ones([size]), name='a8')\\n a9 = tf.Variable(0. * tf.ones([size]), name='a9')\\n a10 = tf.Variable(0. * tf.ones([size]), name='a10')\\n\\n mu = a1 * tf.sigmoid(a2 * u + a3) + a4 * u + a5\\n v = a6 * tf.sigmoid(a7 * u + a8) + a9 * u + a10\\n\\n z = (z_noisy - mu) * v + mu\\n return z\",\n \"def apply_noise(input_image, noise_level):\\n n,m = input_image.shape\\n # generate binomial noise\\n ksi = np.random.binomial(size=n*m, n=1, p=noise_level).reshape(input_image.shape)\\n noised_image = ksi^input_image\\n return noised_image\",\n \"def add_noise(self):\\n self.noise = np.random.poisson(lam=self.lam, size=self.image.shape)\\n self.image += self.noise\\n return\",\n \"def add_noise(self):\\n self.noise = torch.normal(0.5, .2, self.state.shape).double()\\n self.noise *= torch.sqrt(2 *\\n self.vars['T']*torch.tensor(self.vars['dt']))\",\n \"def gaussian(amp, fwhm, mean, x):\\n return amp * np.exp(-4. * np.log(2) * (x-mean)**2 / fwhm**2)\",\n \"def gaussian_likelihood(x, mu, log_std):\\n std = tf.exp(log_std)\\n pre_sum = tf.square((x - mu)/std) + 2*log_std + np.log(2*np.pi)\\n return -0.5 * tf.reduce_sum(pre_sum, axis=1)\",\n \"def add_noise(self):\\n self.noise = np.random.poisson(lam=self.lam, size=self.im.shape)\\n self.im += self.noise\\n return\",\n \"def _sample_new_noise(self, *, tf_sess=None):\\n if self.framework == \\\"tf\\\":\\n tf_sess.run(self.tf_sample_new_noise_op)\\n elif self.framework == \\\"tf2\\\":\\n self._tf_sample_new_noise_op()\\n else:\\n for i in range(len(self.noise)):\\n self.noise[i] = torch.normal(\\n mean=torch.zeros(self.noise[i].size()), std=self.stddev\\n ).to(self.device)\",\n \"def xavier_normal_init(tensor, gain=1., random_state=None):\\n # type: (Tensor, float) -> Tensor\\n fan_in, fan_out = _calculate_fan_in_and_fan_out(tensor)\\n std = gain * math.sqrt(2.0 / float(fan_in + fan_out))\\n\\n normal_init(tensor, 0., std, random_state)\\n return tensor\",\n \"def get_noise(n_samples, noise_dims):\\n return torch.randn(n_samples, noise_dims).to(device)\",\n \"def add_gaussian_noise(projections, noise_var):\\n noise_sigma = noise_var**0.5\\n nproj,row,col = projections.shape\\n gauss_noise = np.random.normal(0, noise_sigma, (nproj, row, col))\\n gauss_noise = gauss_noise.reshape(nproj, row, col) \\n projections = projections + gauss_noise\\n return projections\",\n \"def tf_gaussian_kernel(size: int,mean: float,std: float,):\\n d = tf.distributions.Normal(mean, std)\\n vals = d.prob(tf.range(start = -size, limit = size + 1, dtype = tf.float32))\\n gauss_kernel = tf.einsum('i,j->ij',vals,vals)\\n return gauss_kernel / tf.reduce_sum(gauss_kernel)\",\n \"def generate_with_noise(self, noise):\\n with tf.compat.v1.Session() as sess:\\n self.saver.restore(sess, \\\"data/\\\" + self.name + \\\".ckpt\\\")\\n return self.X_fake.eval(feed_dict={self.z: noise, self.is_training: False})\",\n \"def sample_gaussian(m, v, repeat=1):\\n if repeat > 1:\\n v = v.squeeze()\\n m = m.squeeze()\\n sqrt_v = torch.cat([torch.sqrt(v)] * repeat, dim=0)\\n m = torch.cat([m] * repeat, dim=0)\\n else:\\n sqrt_v = torch.sqrt(v)\\n sample = m + torch.randn_like(sqrt_v) * sqrt_v\\n return sample\",\n \"def noiseReduction(self):\\n pass\",\n \"def transform(self, sess, xs):\\n return sess.run( [self.z_mean, self.z_log_sigma_sq],\\n feed_dict={self.x: xs} )\",\n \"def noise_input_fn(params):\\n batch_size = params['batch_size']\\n noise_dim = params['noise_dim']\\n # Use constant seed to obtain same noise\\n np.random.seed(0)\\n noise_dataset = tf.data.Dataset.from_tensors(\\n {'random_noise': tf.constant(\\n np.random.randn(batch_size, noise_dim), dtype=tf.float32)\\n })\\n noise = noise_dataset.make_one_shot_iterator().get_next()\\n tf.logging.debug('Noise input %s', noise)\\n return noise_dataset\",\n \"def add_noise(image, noise, rate=0.05):\\n\\n if noise == \\\"gaussian\\\":\\n row, col = image.shape\\n var = ndimage.laplace(image).var()\\n sigma = (var*rate) ** 0.5\\n print(var, sigma)\\n gauss = np.random.normal(loc=0, scale=sigma, size=(row, col)) * rate\\n noisy = image + gauss\\n # noisy = image + gauss\\n return noisy\\n\\n elif noise == \\\"salt_pepper\\\":\\n output = image.copy()\\n black = 0\\n white = 255\\n probs = np.random.random(image.shape[:2])\\n output[probs < (rate / 2)] = black\\n output[probs > 1 - (rate / 2)] = white\\n\\n return output\\n\\n else:\\n return image\",\n \"def gaussian_nll(x, mean, ln_var):\\n\\n x_prec = torch.exp(-ln_var)\\n x_diff = x - mean\\n x_power = (x_diff * x_diff) * x_prec * -0.5\\n loss = (ln_var + math.log(2 * (math.pi))) / 2 - x_power\\n return loss\",\n \"def diag_gaussian_sample(key, mean, logvar, varmin=1e-16):\\n logvar_wm = np.log(np.exp(logvar) + varmin)\\n return mean + np.exp(0.5*logvar_wm) * random.normal(key, mean.shape)\",\n \"def noisysphere(self, x, noise=4.0, cond=1.0):\\r\\n return self.elli(x, cond=cond) * (1 + noise * np.random.randn() / len(x))\",\n \"def add_gaussian_noise(self, stdev, iteration, method = 'absolute', normalize = \\\"on\\\"):\\n for time in self.mdvtc.keys():\\n self.mdvtc[time].add_gaussian_noise(stdev, iteration, method, normalize)\",\n \"def generate_noise_vector(self, ):\\n self.noise.resize_(\\n self.batch_size, int(self.opt.nz), 1, 1).normal_(0, 1)\\n self.noisev = Variable(self.noise) # TODO: Add volatile=True???\",\n \"def gaussian_dataset(ngaussian, nd, nsample, random=True):\\n means, covars, weights = get_means_covars(nd, ngaussian, random)\\n return mm_gaussian(nsample, means, covars, weights)\",\n \"def gaussian(x, *parameters):\\n position, sigma, amplitude, background = parameters\\n return amplitude * np.exp(-(x - position)**2 / (2.0 * sigma**2)) + background\",\n \"def gaussian(amp, fwhm, mean):\\n return lambda x: amp * np.exp(-4. * np.log(2) * (x-mean)**2 / fwhm**2)\",\n \"def scale_noise(size: int) -> torch.Tensor:\\n x = torch.FloatTensor(np.random.normal(loc=0.0, scale=1.0, size=size))\\n\\n return x.sign().mul(x.abs().sqrt())\",\n \"def run_gaussian_smoothing(image, kernel_size=5):\\n return cv2.GaussianBlur(image, (kernel_size, kernel_size), 0)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.78414464","0.7245466","0.71811473","0.71459424","0.68363976","0.6799063","0.66733646","0.66543114","0.65751487","0.6564241","0.6492763","0.64736784","0.64736784","0.64586484","0.64251614","0.6397649","0.6334172","0.63252485","0.6302892","0.6299813","0.62774134","0.6248578","0.62465584","0.6232843","0.6185732","0.61472136","0.6144347","0.6142519","0.6140931","0.61349994","0.6131424","0.61188656","0.61169523","0.61008245","0.6078374","0.60760444","0.60687065","0.6061302","0.60610926","0.6059117","0.605858","0.60532993","0.60462856","0.6027305","0.60221624","0.6012633","0.6010799","0.6003729","0.5997549","0.59734464","0.59720033","0.59433234","0.5940594","0.5928182","0.59274626","0.59274554","0.5911367","0.5903784","0.5900043","0.58956337","0.58642936","0.58599615","0.585346","0.5848094","0.58420396","0.5839911","0.5822471","0.58121336","0.5796349","0.5796173","0.57838875","0.5773711","0.57635725","0.5762891","0.57399106","0.5735808","0.5732842","0.5732585","0.571531","0.57147145","0.57094866","0.5708398","0.5704345","0.5690446","0.5683594","0.56829417","0.56800133","0.5674544","0.56655836","0.5660392","0.5646765","0.56344974","0.563444","0.56300014","0.5626809","0.5624552","0.5624206","0.56219196","0.56211245","0.56158704"],"string":"[\n \"0.78414464\",\n \"0.7245466\",\n \"0.71811473\",\n \"0.71459424\",\n \"0.68363976\",\n \"0.6799063\",\n \"0.66733646\",\n \"0.66543114\",\n \"0.65751487\",\n \"0.6564241\",\n \"0.6492763\",\n \"0.64736784\",\n \"0.64736784\",\n \"0.64586484\",\n \"0.64251614\",\n \"0.6397649\",\n \"0.6334172\",\n \"0.63252485\",\n \"0.6302892\",\n \"0.6299813\",\n \"0.62774134\",\n \"0.6248578\",\n \"0.62465584\",\n \"0.6232843\",\n \"0.6185732\",\n \"0.61472136\",\n \"0.6144347\",\n \"0.6142519\",\n \"0.6140931\",\n \"0.61349994\",\n \"0.6131424\",\n \"0.61188656\",\n \"0.61169523\",\n \"0.61008245\",\n \"0.6078374\",\n \"0.60760444\",\n \"0.60687065\",\n \"0.6061302\",\n \"0.60610926\",\n \"0.6059117\",\n \"0.605858\",\n \"0.60532993\",\n \"0.60462856\",\n \"0.6027305\",\n \"0.60221624\",\n \"0.6012633\",\n \"0.6010799\",\n \"0.6003729\",\n \"0.5997549\",\n \"0.59734464\",\n \"0.59720033\",\n \"0.59433234\",\n \"0.5940594\",\n \"0.5928182\",\n \"0.59274626\",\n \"0.59274554\",\n \"0.5911367\",\n \"0.5903784\",\n \"0.5900043\",\n \"0.58956337\",\n \"0.58642936\",\n \"0.58599615\",\n \"0.585346\",\n \"0.5848094\",\n \"0.58420396\",\n \"0.5839911\",\n \"0.5822471\",\n \"0.58121336\",\n \"0.5796349\",\n \"0.5796173\",\n \"0.57838875\",\n \"0.5773711\",\n \"0.57635725\",\n \"0.5762891\",\n \"0.57399106\",\n \"0.5735808\",\n \"0.5732842\",\n \"0.5732585\",\n \"0.571531\",\n \"0.57147145\",\n \"0.57094866\",\n \"0.5708398\",\n \"0.5704345\",\n \"0.5690446\",\n \"0.5683594\",\n \"0.56829417\",\n \"0.56800133\",\n \"0.5674544\",\n \"0.56655836\",\n \"0.5660392\",\n \"0.5646765\",\n \"0.56344974\",\n \"0.563444\",\n \"0.56300014\",\n \"0.5626809\",\n \"0.5624552\",\n \"0.5624206\",\n \"0.56219196\",\n \"0.56211245\",\n \"0.56158704\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7755156"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":22894,"cells":{"query":{"kind":"string","value":"Add a `canon` option to `f` which toggles canonicalizes the return value of `f`."},"document":{"kind":"string","value":"def canon(f):\n @wraps(f)\n def wrapped(G, H, canon=True):\n game = f(G, H)\n if canon:\n game = canonicalize(game)\n return game\n\n return wrapped"},"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 pony_func(func):\n func.is_pony_func = True\n return func","def main():\n parser = argparse.ArgumentParser(description=(\n 'Canonicalize Call Graphs to FASTEN Canonical Call Graphs'))\n parser.add_argument('directory', help=(\n 'a directory with the Call Graph, and description files'))\n parser.add_argument('-f', '--forge', default='debian', help=(\n 'forge of the analyzed project. For example, it could be debian, '\n 'or GitHub'))\n parser.add_argument('-v', '--verbose', dest='verbose', action='store_true',\n help='print logs to the console')\n parser.add_argument('-L', '--file-logging', dest='file_logging',\n action='store_true',\n help='save logs to a file')\n parser.add_argument('-l', '--logging-level', dest='logging_level',\n choices=['CRITICAL', 'ERROR', 'WARNING', 'INFO',\n 'DEBUG'],\n default='DEBUG', help='logging level for logs')\n parser.add_argument('-c', '--custom-deps', dest='custom_deps',\n default=None, help='custom user defined dependencies')\n parser.add_argument('-r', '--regex-product', dest='regex_product',\n default=None, help='regex to match product\\'s files')\n parser.add_argument('-o', '--output', dest='output', default=None,\n help='file to save the canonicalized call graph')\n args = parser.parse_args()\n can = C_Canonicalizer(args.directory,\n forge=args.forge,\n console_logging=args.verbose,\n file_logging=args.file_logging,\n logging_level=args.logging_level,\n custom_deps=args.custom_deps,\n product_regex=args.regex_product)\n can.canonicalize()","def supcanon(f, Iab, theta=45, DIRECTION=\"CLOCKWISE\"):\n from string import upper\n\n DIRECTION = upper(DIRECTION) \n y = intersec(f,0)\n for t in xrange(0,360,theta):\n Irot = interot( Iab, t, DIRECTION )\n y = union( y, supgen(f, Irot))\n return y","def canonicalize(self, url):\n pass","def mobius_transform(f):\n return dirichlet_conv(f, mobius)","def lift(f):\n @wraps(f)\n def inner(value):\n result = f(value)\n return SuperBool(result, f.__doc__) if not isinstance(result, SuperBool) else result\n return inner","def canonicalize(self):\n return _libsbml.ASTNode_canonicalize(self)","def ag_to_canon(agparams, f0):\n A, B, C, D, E, F = agparams\n\n B2 = B * B\n AmC = A - C\n\n disc = B2 - A * C\n idisc = 1.0 / disc\n\n xc = idisc * f0 * (C * D - B * E)\n yc = idisc * f0 * (A * E - B * D)\n center = (xc, yc)\n\n lambda_ = idisc * f0 * (f0 * F + D * xc + E * yc)\n\n gamma = A + C\n kappa = numpy.sqrt(4 * B2 + AmC * AmC)\n\n sgn = numpy.abs(lambda_) / lambda_\n\n a = numpy.sqrt(0.5 * lambda_ * (gamma + sgn * kappa))\n b = numpy.sqrt(0.5 * lambda_ * (gamma - sgn * kappa))\n\n tilt = 0.5 * numpy.arctan2(-sgn * 2.0 * B / kappa, -sgn * AmC / kappa)\n\n return center, a, b, tilt","def transform(self, f):\n\n return f(self)","def expand_function(f, argspec):\n return _autogen.expand_function_autogen(f, argspec)","def cry_f(s : str) -> CryptolTerm:\n return CryptolTerm(to_cryptol_str_customf(s, frames=1))","def unwrap_self_f(arg, **kwarg): \r\n return Multiscale_Assimilation.single_patch_assimilation(*arg,**kwarg)","def realify(fn, imag_tol=1e-12):\n\n @functools.wraps(fn)\n def realified_fn(*args, **kwargs):\n return realify_scalar(fn(*args, **kwargs), imag_tol=imag_tol)\n\n return realified_fn","def selfie_depreceated(f):\n return partial(f, f)","def test_right_canonize():\n\n for n in range(Nmin, Nmax+1):\n random_state = new_random_state(d, n)\n\n MPS_full = to_full_MPS(random_state, n, d) #this is in left-canonical form\n \n MPS_rightcanonical = right_canonize(MPS_full)\n \n assert check_right_canonization(MPS_rightcanonical[1:]), \"right_canonize error\"","def coherent_trans(f, NA, n, delta_z):\n\n f2 = f[0]**2 + f[1]**2\n mask = f2 < NA**2\n return mask * np.exp(2j * np.pi * delta_z * np.sqrt(mask*(n**2 - f2)))","def clean_feature(f):\n\n if f.startswith(\"a \"):\n f = f[2:]\n\n if f.startswith(\"an \"):\n f = f[3:]\n\n return str(f)","def decorate_function(cls, f: 'Callable', **setting_kwds) -> None:\n # Filter out builtins.\n if not get_file_of_object(f):\n return\n\n caller_frame = sys._getframe(1) # caller's frame\n namespace = caller_frame.f_globals\n namespace[f.__name__] = cls(**setting_kwds)(f)","def canonical(self):\r\n if not hasattr(self, '_canonical'):\r\n self._canonical = conf.lib.clang_getCanonicalCursor(self)\r\n\r\n return self._canonical","def orig_function(inputs, outputs, mode=None, accept_inplace=False,\r\n name=None, profile=None, on_unused_input=None):\r\n\r\n # Every element of the input list will be upgraded to an `In` instance if\r\n # necessary, using the rules implemented by the `convert_function_input`\r\n # function.\r\n\r\n # Similarly, every element of the output list will be upgraded to an `Out`\r\n # instance if necessary:\r\n\r\n t1 = time.time()\r\n mode = theano.compile.mode.get_mode(mode)\r\n\r\n inputs = map(convert_function_input, inputs)\r\n if outputs is not None:\r\n if isinstance(outputs, (list, tuple)):\r\n outputs = map(FunctionMaker.wrap_out, outputs)\r\n else:\r\n outputs = FunctionMaker.wrap_out(outputs)\r\n\r\n defaults = [getattr(input, 'value', None) for input in inputs]\r\n\r\n if isinstance(mode, (list, tuple)): # \"mode comparison\" semantics\r\n raise Exception(\"We do not support the passing of multiple modes\")\r\n else:\r\n Maker = getattr(mode, 'function_maker', FunctionMaker)\r\n fn = Maker(inputs,\r\n outputs,\r\n mode,\r\n accept_inplace=accept_inplace,\r\n profile=profile,\r\n on_unused_input=on_unused_input).create(\r\n defaults)\r\n\r\n t2 = time.time()\r\n if profile:\r\n profile.compile_time += t2 - t1\r\n\r\n fn.name = name\r\n fn.maker.fgraph.name = name\r\n return fn","def set_unc_f(self, unc):\n self.uncf = unc","def zeroify(fn, tol=1e-14):\n\n @functools.wraps(fn)\n def zeroified_f(*args, **kwargs):\n x = fn(*args, **kwargs)\n return 0.0 if abs(x) < tol else x\n\n return zeroified_f","def safe(f):\n\tdef safe_f(*args,**kwargs):\n\t\ttry:\n\t\t\treturn f(*args,**kwargs)\n\t\texcept:\n\t\t\treturn float('inf')\n\treturn safe_f","def canon(raw_attr_name: str) -> str:\n if raw_attr_name: # do not dereference None, and \"\" is already canonical\n return raw_attr_name.replace(\" \", \"\").lower()\n return raw_attr_name","def conj_inplace(a):","def test__canonizeURL(self):\n self.run_script_for_compat('alert(e._canonizeURL(foo));')\n self.assert_silent()\n self.assert_compat_error()","def sharemind(f: callable):\n from conclave.codegen import sharemind\n from conclave import CodeGenConfig\n\n def wrap():\n code = sharemind.SharemindCodeGen(CodeGenConfig(), f())._generate(None, None)\n return code\n\n return wrap","def to01(f):\n def wrap(x, *args, **kwargs):\n y = x * 2 - 1\n z = f(y, *args, **kwargs)\n return (z + 1) / 2\n return wrap","def cancan(self, f):\n return uncan(can(f), self.user_ns)","def canonicalize(self):\n self.rules = canonicalize_grammar(self,self.empty)\n self.is_canonical = True","def canonicalize(smile):\n\n return Chem.MolToSmiles(Chem.MolFromSmiles(smile))","def transform_fn(self):\n if hasattr(self._transform_fn, 'forward'):\n return self._transform_fn.forward\n return self._transform_fn","def needs_decomp(f): #move\n @functools.wraps(f)\n def wrapper(arg):\n if type(arg) is Decomposition:\n return f(arg)\n assert_natural(arg)\n return f(decompose(arg))\n return wrapper","def _canonify(self, rut):\n rut = smart_unicode(rut).replace(' ', '').replace('.', '').replace('-', '')\n return rut[:-1], rut[-1]","def conventionalize_function(self, function: str) -> str:\n return _conventionalize(self.options, \"function\", function)","def indirect_proof(proof_function):\n\tdef indirect_proof_result(proof_function, assumption):\n\t\tchecked_proposition(assumption)\n\t\tinterp = _strict_match((A, conj, (neg, A)), proof_function(assumption))\n\t\treturn _proposition_class((neg, assumption[:]))\n\t\n\tif type(proof_function) != types.FunctionType:\n\t\traise TypeError()\n\treturn lambda assumption: indirect_proof_result(proof_function, assumption)","def compact(fun: _CallableT) -> _CallableT:\n fun.compact = True\n return fun","def canonical(self):\n args = tuple([i.canonical if isinstance(i, Relational) else i for i in self.args])\n if args != self.args:\n r = self.func(*args)\n if not isinstance(r, Relational):\n return r\n else:\n r = self\n if r.rhs.is_number:\n if r.rhs.is_Number and r.lhs.is_Number and r.lhs > r.rhs:\n r = r.reversed\n elif r.lhs.is_number:\n r = r.reversed\n elif tuple(ordered(args)) != args:\n r = r.reversed\n\n LHS_CEMS = getattr(r.lhs, 'could_extract_minus_sign', None)\n RHS_CEMS = getattr(r.rhs, 'could_extract_minus_sign', None)\n\n if isinstance(r.lhs, BooleanAtom) or isinstance(r.rhs, BooleanAtom):\n return r\n\n # Check if first value has negative sign\n if LHS_CEMS and LHS_CEMS():\n return r.reversedsign\n elif not r.rhs.is_number and RHS_CEMS and RHS_CEMS():\n # Right hand side has a minus, but not lhs.\n # How does the expression with reversed signs behave?\n # This is so that expressions of the type\n # Eq(x, -y) and Eq(-x, y)\n # have the same canonical representation\n expr1, _ = ordered([r.lhs, -r.rhs])\n if expr1 != r.lhs:\n return r.reversed.reversedsign\n\n return r","def safe(f):\n def safe_f(*args, **kwargs):\n try:\n return f(*args, ** kwargs)\n except:\n return float('inf')\n return safe_f","def connection_point_nonterminating_orbit(x, f):\n return convergent_point(\n x, f(collision_point_nonterminating_orbit(x, f)), f)","def symbolic_fn_opts(**kwargs):\r\n def deco(f):\r\n return symbolic_fn(f, **kwargs)\r\n return deco","def soul(f):\n\n def is_soul(self, *args, **kwargs):\n # TODO\n return f(self, *args, **kwargs)\n\n return is_soul","def make_safe_f(f, allowed_params):\n def inner(*args, **kwargs):\n if kwargs:\n new_kwargs = {}\n for k, v in kwargs.items():\n if k in allowed_params:\n new_kwargs[k] = v\n return f(*args, **new_kwargs)\n return f(*args, **kwargs)\n return inner","def conj(fs):\n def feature(s, i):\n return all(f(s, i) for f in fs)\n return feature","def to_cdnf(self):\n return Or(*[term for term in self.iter_minterms()])","def make_safe_f(f, allowed_params):\r\n def inner(*args, **kwargs):\r\n if kwargs:\r\n new_kwargs = {}\r\n for k, v in kwargs.items():\r\n if k in allowed_params:\r\n new_kwargs[k] = v\r\n return f(*args, **new_kwargs)\r\n return f(*args, **kwargs)\r\n return inner","def is_canonical(self):\n return False","def safe(f):\n\n def safe_f(*args, **kwargs):\n try:\n return f(*args, **kwargs)\n except:\n return float('inf') # this means \"infinity\" in Python\n\n return safe_f","def run_simpatico(self, f):\n s = Styler(f, True, False)\n return s","def encoding_cctf(self, value):\n\n if value is not None:\n assert hasattr(\n value,\n '__call__'), ('\"{0}\" attribute: \"{1}\" is not callable!'.format(\n 'encoding_cctf', value))\n self._encoding_cctf = value","def debuggable(f):\n \n debugging = f.func_globals.get(\"DEBUGGING\",False)\n if debugging: return f\n\n f.func_code = __transform_codeobjects__(f.func_code,__debuggable__)\n return f","def is_canonical(self):\n if self.canonical_acceptor == self.acceptor:\n return True\n else:\n return False","def safe(f):\n def safe_f(*args, **kwargs):\n try:\n return f(*args, **kwargs)\n except:\n return float('inf') # this means infinity in python\n return safe_f","def _collapse_fastq(in_fn):\n args = argparse.Namespace()\n args.fastq = in_fn\n args.minimum = 1\n args.out = op.dirname(in_fn)\n return collapse_fastq(args)","def canonical(_signed: Json) -> bytes:\n return encode_canonical(_signed).encode(\"utf-8\")","def test_make_safe_f(self):\r\n def f(x, y):\r\n return x * y\r\n self.assertEqual(f(3, 4), 12)\r\n g = make_safe_f(f, ['x', 'y'])\r\n self.assertEqual(g(3, 4), 12)\r\n self.assertEqual(g(x=3, y=4, z=10, xxx=11), 12)","def f_unc(x, a, b):\n return f_raw(x, a, b)","def _deco_base_f_wrapper_(*args, **kwargs):\n # *** Part of the DecoSettingsMapping \"API\" --\n # (4) using self._settings_mapping.get_final_value in wrapper\n # [[[ This/these is/are 4th chronologically ]]]\n\n # inner/local fn -- save a few cycles and characters -\n # we call this a lot (<= 9x).\n def _get_final_value(setting_name):\n \"Use outer scope's kwargs and self.f_params\"\n return self._settings_mapping.get_final_value(\n setting_name, kwargs, fparams=self.f_params)\n\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n # if nothing to do, hurry up & don't do it.\n # NOTE: call_chain_to_next_log_calls_fn looks in stack frames\n # to find (0.2.4) STACKFRAME_HACK_DICT_NAME (really!)\n # It and its values (the following _XXX variables)\n # must be set before calling f.\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n _enabled = _get_final_value('enabled')\n # 0.3.0 in case f calls log_message (no output if f disabled)\n self._enabled_state_push(_enabled)\n\n # 0.2.4.post5 \"true bypass\": if 'enabled' < 0 then scram\n if _enabled < 0:\n ret = f(*args, **kwargs)\n self._enabled_state_pop()\n return ret\n\n # Bump call counters, before calling fn.\n # Note: elapsed_secs, process_secs not reflected yet of course\n self._add_call(logged=_enabled)\n\n _log_call_numbers = _get_final_value('log_call_numbers')\n # counters just got bumped\n _active_call_number = (self._stats.num_calls_logged\n if _log_call_numbers else\n 0)\n # Get list of callers up to & including first log_call's-deco'd fn\n # (or just caller, if no such fn)\n call_list, prev_indent_level = self.call_chain_to_next_log_calls_fn()\n\n # Bump _extra_indent_level if last fn on call_list is deco'd AND enabled,\n # o/w it's the _extra_indent_level which that fn 'inherited'.\n # _extra_indent_level: prev_indent_level, or prev_indent_level + 1\n do_indent = _get_final_value('indent')\n _extra_indent_level = (prev_indent_level +\n int(not not do_indent and not not _enabled))\n # 0.3.0\n ########## prefixed_fname = _get_final_value('prefix') + f.__name__\n prefixed_fname = _get_final_value('prefix') + self.f_display_name\n\n # Stackframe hack:\n assert '_deco_base__active_call_items__' == STACKFRAME_HACK_DICT_NAME\n _deco_base__active_call_items__ = {\n '_enabled': _enabled,\n '_log_call_numbers': _log_call_numbers,\n '_prefixed_fname': prefixed_fname, # Hack alert (Pt 1)\n '_active_call_number': _active_call_number,\n '_extra_indent_level': _extra_indent_level,\n # 0.3.0 for _get_own_deco_wrapper\n '_wrapper_deco': self\n }\n\n # Get logging function IF ANY.\n # For the benefit of callees further down the call chain,\n # if this f is not enabled (_enabled <= 0).\n # Subclass can return None to suppress printed/logged output.\n logging_fn = self.get_logging_fn(_get_final_value)\n\n # Only do global indentation for print, not for loggers\n global_indent_len = max(_extra_indent_level, 0) * self.INDENT\n\n # 0.2.2.post1 - save output_fname for log_message use\n call_number_str = ((' [%d]' % _active_call_number)\n if _log_call_numbers else '')\n output_fname = prefixed_fname + call_number_str\n\n # 0.3.0\n # Note: DON'T combine with global_mute(),\n # cuz this value will be pushed,\n # and when popped any realtime changes to global mute\n # made during call to f would be ignored.\n mute = _get_final_value('mute')\n\n # 0.2.2 -- self._log_message() will use\n # the logging_fn, indent_len and output_fname at top of these stacks;\n # thus, verbose functions should use log_calls.print (~ log_message)\n # to write their blather.\n # There's a stack of logging-state ,\n # used by self._log_message(), maintained in this wrapper.\n self._logging_state_push(logging_fn, global_indent_len, output_fname, mute)\n\n # (_xxx variables set, ok to call f)\n if not _enabled:\n ret = f(*args, **kwargs)\n self._logging_state_pop(enabled_too=True)\n return ret\n\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n # Set up context, for pre-call handlers\n # (after calling f, add to it for post-call handlers)\n # THIS is the time sink - 23x slower than other 'blocks'\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n # Key/values of \"context\" whose values we know so far:\n context = {\n 'decorator': self,\n 'settings': self._settings_mapping,\n 'stats': self._stats,\n 'prefixed_fname': prefixed_fname,\n 'fparams': self.f_params,\n 'call_list': call_list,\n 'args': args,\n 'kwargs': kwargs,\n 'indent': \" \" * self.INDENT, # our unit of indentation\n 'output_fname': output_fname,\n }\n\n # Gather all the things we need (for log output, & for history)\n # Use inspect module's Signature.bind method.\n # bound_args.arguments -- contains only explicitly bound arguments\n # 0.2.4.post5 - using\n # inspect.signature(f).bind(*args, **kwargs)\n # took 45% of execution time of entire wrapper; this takes 23%:\n # 0.3.1 TODO BUG No args is a problem?!\n bound_args = self.f_signature.bind(*args, **kwargs)\n \"\"\"\n File \"/Users/brianoneill/Desktop/Programming/Python-package-staging/log_calls/log_calls/tests/_temp.py\", line 12, in <module>\n g(f())\n File \"/Users/brianoneill/Desktop/Programming/Python-package-staging/log_calls/log_calls/log_calls.py\", line 1935, in _deco_base_f_wrapper_\n bound_args = self.f_signature.bind(*args, **kwargs)\n File \"/Library/Frameworks/Python.framework/Versions/3.4/lib/python3.4/inspect.py\", line 2646, in bind\n return args[0]._bind(args[1:], kwargs)\n File \"/Library/Frameworks/Python.framework/Versions/3.4/lib/python3.4/inspect.py\", line 2571, in _bind\n raise TypeError('too many positional arguments') from None\n TypeError: too many positional arguments\n \"\"\"\n\n varargs_pos = get_args_pos(self.f_params) # -1 if no *args in signature\n argcount = varargs_pos if varargs_pos >= 0 else len(args)\n context['argcount'] = argcount\n # The first argcount-many things in bound_args\n context['argnames'] = list(bound_args.arguments)[:argcount]\n context['argvals'] = args[:argcount]\n\n context['varargs'] = args[argcount:]\n (context['varargs_name'],\n context['kwargs_name']) = get_args_kwargs_param_names(self.f_params)\n\n # These 3 statements = 31% of execution time of wrapper\n context['defaulted_kwargs'] = get_defaulted_kwargs_OD(self.f_params, bound_args)\n context['explicit_kwargs'] = get_explicit_kwargs_OD(self.f_params, bound_args, kwargs)\n # context['implicit_kwargs'] = {\n # k: kwargs[k] for k in kwargs if k not in context['explicit_kwargs']\n # }\n # At least 2x as fast:\n context['implicit_kwargs'] = \\\n difference_update(kwargs.copy(), context['explicit_kwargs'])\n\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n # Call pre-call handlers, collect nonempty return values\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n # only consult global mute in r/t\n if not (mute or self.global_mute()): # 0.3.0\n pre_msgs = []\n for setting_name in self._settings_mapping._pre_call_handlers: # keys\n if _get_final_value(setting_name):\n info = self._settings_mapping._get_DecoSetting(setting_name)\n msg = info.pre_call_handler(context)\n if msg:\n pre_msgs.append(msg)\n\n # Write pre-call messages\n if logging_fn:\n for msg in pre_msgs:\n self._log_message(msg, extra_indent_level=0)\n\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n # Call f(*args, **kwargs) and get its retval; time it.\n # Add timestamp, elapsed time(s) and retval to context.\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n # No dictionary overhead between timer(s) start & stop.\n t0 = time.time() # for timestamp\n t0_wall = wall_time_fn()\n t0_process = process_time_fn()\n retval = f(*args, **kwargs)\n t_end_wall = wall_time_fn()\n t_end_process = process_time_fn()\n context['elapsed_secs'] = (t_end_wall - t0_wall)\n context['process_secs'] = (t_end_process - t0_process)\n context['timestamp'] = t0\n context['retval'] = retval\n\n self._add_to_elapsed(context['elapsed_secs'], context['process_secs'])\n\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n # Call post-call handlers, collect nonempty return values\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n # only consult global mute in r/t\n if not (mute or self.global_mute()): # 0.3.0\n post_msgs = []\n for setting_name in self._settings_mapping._post_call_handlers: # keys\n if _get_final_value(setting_name):\n info = self._settings_mapping._get_DecoSetting(setting_name)\n msg = info.post_call_handler(context)\n if msg:\n post_msgs.append(msg)\n\n # Write post-call messages\n if logging_fn:\n for msg in post_msgs:\n self._log_message(msg, extra_indent_level=0)\n # v0.3.0b22 -- if recording history, add record of call even if we're muted(!)\n elif _get_final_value('record_history'):\n info = self._settings_mapping._get_DecoSetting('record_history')\n _ = info.post_call_handler(context)\n\n self._logging_state_pop(enabled_too=True)\n\n return retval","def make_transform_fn(self, ):\n return self._transform_fn","def TransformFlags(self) -> _n_2_t_0[bool]:","def canon(self, t):\n if isinstance(t, basestring):\n if t in self.base_types:\n return t\n elif t in self.type_aliases:\n return self.canon(self.type_aliases[t])\n elif t in self.refined_types:\n return (self.canon(self.refined_types[t]), t)\n elif self.isdependent(t):\n return self._resolve_dependent_type(t)\n else:\n _raise_type_error(t)\n # BELOW this would be for complicated string representations,\n # such as 'char *' or 'map<nucid, double>'. Would need to write\n # the parse_type() function and that might be a lot of work.\n #parse_type(t)\n elif isinstance(t, Sequence):\n t0 = t[0]\n tlen = len(t)\n if 0 == tlen:\n _raise_type_error(t)\n last_val = 0 if tlen == 1 else t[-1]\n if not isinstance(t0, basestring) and not isinstance(t0, Sequence):\n _raise_type_error(t)\n if self.isdependent(t0):\n return self._resolve_dependent_type(t0, t)\n elif t0 in self.template_types:\n templen = len(self.template_types[t0])\n last_val = 0 if tlen == 1 + templen else t[-1]\n filledt = [t0]\n for tt in t[1:1+templen]:\n \n if isinstance(tt, Number): # includes bool!\n filledt.append(tt)\n elif isinstance(tt, basestring):\n try:\n canontt = self.canon(tt)\n except TypeError:\n canontt = tt\n except:\n raise\n filledt.append(canontt)\n elif isinstance(tt, Sequence):\n if len(tt) == 2 and tt[0] in Arg:\n filledt.append(self.canon(tt[1]))\n else:\n filledt.append(self.canon(tt))\n else:\n _raise_type_error(tt)\n filledt.append(last_val)\n return tuple(filledt)\n else:\n return (self.canon(t0), last_val)\n else:\n _raise_type_error(t)","def _replace_contractions(text):\n return contractions.fix(text)","def get_unc_f(self):\n return self.uncf","def decorate_package_function(cls, f: 'Callable', **setting_kwds) -> None:\n # Filter out builtins.\n if not get_file_of_object(f):\n return\n\n f_deco = cls(**setting_kwds)(f)\n\n namespace = vars(inspect.getmodule(f))\n\n fmodname = inspect.getmodule(f).__name__\n\n # 'sklearn.cluster.k_means_'\n basic_modname = inspect.getmodulename(fmodname.replace('.', '/') + '.py')\n # 'k_means_' or 'some_module', or None\n if basic_modname and '.' in fmodname:\n fpackagename = namespace['__package__'] # '.'.join(fmodname.split('.')[:-1])\n exec(\"import \" + fpackagename)\n package_dict = eval(\"vars(%s)\" % fpackagename)\n package_dict[f.__name__] = f_deco\n\n namespace[f.__name__] = f_deco","def compress(clean):\n if clean is None:\n return None\n clean = re.sub(r'[\\r\\n\\t\\xa0]', ' ', clean)\n clean = re.sub(r' ?', ' ', clean)\n clean = re.sub(r'\\s+', ' ', clean)\n return clean.strip()","def canonical_name(self, name):\n raise NotImplementedError","def decorate_module_function(cls, f: 'Callable', **setting_kwds) -> None:\n # Filter out builtins.\n if not get_file_of_object(f):\n return\n\n namespace = vars(inspect.getmodule(f))\n namespace[f.__name__] = cls(**setting_kwds)(f)","def make_qual(sff_fp, output_fp, use_sfftools=False, no_trim=False):\r\n if use_sfftools:\r\n _fail_on_gzipped_sff(sff_fp)\r\n check_sffinfo()\r\n if no_trim:\r\n _check_call(['sffinfo', '-notrim', '-q', sff_fp],\r\n stdout=open(output_fp, 'w'))\r\n else:\r\n _check_call(['sffinfo', '-q', sff_fp], stdout=open(output_fp, 'w'))\r\n else:\r\n try:\r\n format_binary_sff_as_fna(\r\n qiime_open(sff_fp, 'rb'), open(output_fp, 'w'), qual=True)\r\n except:\r\n raise IOError(\"Could not parse SFF %s\" % sff_fp)","def canon_to_ag(canonparams, f0):\n (xc, yc), a, b, tilt = canonparams\n\n a2, b2 = a * a, b * b\n st, ct = numpy.sin(tilt), numpy.cos(tilt)\n st2, ct2 = st * st, ct * ct\n\n if0 = 1.0 / f0\n\n A = b2 * ct2 + a2 * st2\n B = (b2 - a2) * st * ct\n C = b2 * st2 + a2 * ct2\n D = -if0 * (A * xc + B * yc)\n E = -if0 * (B * xc + C * yc)\n F = -if0 * (D * xc + E * yc + if0 * a2 * b2)\n\n return A, B, C, D, E, F","def wrap_gate(fn):\n return lambda parms: fn(**parms) if len(parms) > 0 else fn","def execute_on_optree(self, node, fct=None, fct_group=None, memoization_map=None):\n return self.simplifier.simplify(node)","def execute_on_optree(self, node, fct=None, fct_group=None, memoization_map=None):\n return self.simplifier.simplify(node)","def conToCelc(faren):\n return (faren - 32)*(5/9)","def make_synopsis_one_function(f, number):\n ns = CL.get_namespace(f) + '::' # to remove the myclass:: from the types of arg and rtype\n is_not_constructor = not getattr(f, 'is_constructor', False)\n\n template = make_synopsis_template_decl(f)\n\n result_type = (process_type_name(f.result_type) + ' ') if is_not_constructor else ''\n name = \" %s \"%f.spelling.strip() if is_not_constructor else f.spelling.split('<',1)[0] # eliminate the <> in the constructor name\n qualif = CL.get_method_qualification(f) + (' noexcept' if getattr(f,'noexcept',False) else '')\n\n params1 = [(p.type, p.spelling, CL.get_param_default_value(p)) for p in CL.get_params(f)]\n params = [\"%s %s\"%(process_type_name(t), \":param:`%s`\"%n if n else '') + (\" = %s\"%d if d else \"\") for t,n,d in params1]\n # same with no rst decoration\n params_no_role = [\"%s %s\"%(t.spelling, n) + (\" = %s\"%d if d else \"\") for t,n,d in params1]\n\n # first attempt : one line, else multiple line\n nspace = 8 if number>=10 else 7\n sep = nspace*' ' + '| '\n sep2 = ',\\n' + sep + ' '*len(name)\n res1 = sep + result_type + \":red:`%s` \"%name.strip() + '('\n\n # First compute the result without any rst decoroation to compute the lengths\n res_no_role = res1 + ', '.join(x for x in params_no_role)\n if len(res_no_role) > global_vars.synopsis_maxlen_function: # not good, need to split\n res = res1 + sep2.join(x for x in params) # DEBUG + \"%s %s\"%(len(res_no_role) , global_vars.synopsis_maxlen_function)\n else:\n res = res1 + ', '.join(x for x in params)\n\n # brief = f.processed_doc.brief_doc\n #r = ('%s:cppbrief:`%s`\\n'%(sep,brief) if brief else '') + ('%s:green:`%s`\\n'%(sep,template) if template else '') + res + ') ' + qualif\n r = ('%s:green:`%s`\\n'%(sep,template) if template else '') + res + ') ' + qualif\n\n return r.strip()","def scotch(f: callable):\n\n from conclave.codegen import scotch\n from conclave import CodeGenConfig\n\n def wrap():\n code = scotch.ScotchCodeGen(CodeGenConfig(), f())._generate(None, None)\n return code\n\n return wrap","def _canonize(self, *, input, document_loader: DocumentLoaderMethod) -> str:\n # application/n-quads format always returns str\n missing_properties = get_properties_without_context(input, document_loader)\n\n if len(missing_properties) > 0:\n raise LinkedDataProofException(\n f\"{len(missing_properties)} attributes dropped. \"\n f\"Provide definitions in context to correct. {missing_properties}\"\n )\n\n return jsonld.normalize(\n input,\n {\n \"algorithm\": \"URDNA2015\",\n \"format\": \"application/n-quads\",\n \"documentLoader\": document_loader,\n },\n )","def semicolon(f: Callable) -> Callable:\n\n @functools.wraps(f)\n def wrapper(*args, **kwargs):\n return f(*args, **kwargs) + \";\"\n\n return wrapper","def celsius_conv(self, f):\n if f == 0:\n return -17.7778\n else:\n return (f - 32.0) * (5.0 / 9.0)","def test_mixed_canonize():\n \n for n in range(Nmin, Nmax+1):\n random_state = new_random_state(d, n)\n rand_mps = []\n MPS_full = to_full_MPS(random_state, n, d) #just for the shapes\n \n for shape in [a.shape for a in MPS_full]: #Generate an unnormalized mps (since MPS_full would be already in left-canonical form by construction)\n rand_mps.append(np.random.rand(*shape)) \n \n MPS_mixedcanonical = rand_mps\n for pos in range(n): \n #set the site at pos as center of orthogonality\n if pos > 0:\n MPS_mixedcanonical = left_canonize(MPS_mixedcanonical[:pos+1]) + MPS_mixedcanonical[pos+1:]\n if pos < n-1:\n MPS_mixedcanonical = MPS_mixedcanonical[:pos] + right_canonize(MPS_mixedcanonical[pos:])\n\n if pos > 0:\n assert check_left_canonization(MPS_mixedcanonical[:pos+1]), \"Error in mixed left\"\n if pos < n-1:\n assert check_right_canonization(MPS_mixedcanonical[pos:]), \"Error in mixed right\"","def getCanonicalLink(self, article):\n kwargs = {'tag':'link', 'attr':'rel', 'value':'canonical'}\n meta = Parser.getElementsByTag(article.doc, **kwargs)\n if meta is not None and len(meta) > 0:\n href = meta[0].attrib.get('href')\n if href:\n href = href.strip()\n o = urlparse(href)\n if not o.hostname:\n z = urlparse(article.finalUrl)\n domain = '%s://%s' % (z.scheme, z.hostname)\n href = urljoin(domain, href)\n return href\n return article.finalUrl","def map_short_circuit_law(\n container: 'MaybeLikeN[_FirstType, _SecondType, _ThirdType]',\n function: Callable[[_FirstType], _NewType1],\n ) -> None:\n assert_equal(\n container.from_optional(None).map(function),\n container.from_optional(None),\n )","def to_cnf(self):\n f = self.factor()\n if isinstance(f, Expression):\n f = f._flatten(Or)\n if isinstance(f, Expression):\n f = f.absorb()\n return f","def apply(self, f):\n\n self.f = f\n self.fs.append(self.f)\n self.plane = f(self.plane) #Applies the function to the complex numbers\n return self.plane","def get_canonical_link(self):\n if self.article.final_url:\n kwargs = {'tag': 'link', 'attr': 'rel', 'value': 'canonical'}\n meta = self.parser.getElementsByTag(self.article.doc, **kwargs)\n if meta is not None and len(meta) > 0:\n href = self.parser.getAttribute(meta[0], 'href')\n if href:\n href = href.strip()\n o = urlparse(href)\n if not o.hostname:\n z = urlparse(self.article.final_url)\n domain = '%s://%s' % (z.scheme, z.hostname)\n href = urljoin(domain, href)\n return href\n return self.article.final_url","def clean(self, value = None):\n if self.rut:\n value = self.rut\n rut, verificador = self._canonify(value)\n if self._algorithm(rut) == verificador:\n return self._format(rut, verificador)\n else:\n return False","def f(x, a, b):\n return f_raw(x, a, b)","def MapstoRef(f):\n #so given a mixture, find each of the n alpha maps\n n = f.n\n d = f.d\n \n A = np.zeros([n,d,d])\n L = np.zeros([n,d,d])\n b = np.zeros([n,d])\n \n for i in range(n):\n A[i,:,:] = fmp(f.cov[i,:,:],-1/2)\n L[i,:,:] = np.linalg.cholesky(A[i,:,:])\n b[i,:] = - A[i,:,:] @ f.m[i,:]\n \n ToRef = Affine_Maps(L,b)\n \n return ToRef","def up(f):\n return f()","def lash_short_circuit_law(\n raw_value: _FirstType,\n container: 'MaybeLikeN[_FirstType, _SecondType, _ThirdType]',\n function: Callable[\n [_SecondType],\n KindN['MaybeLikeN', _FirstType, _NewType1, _ThirdType],\n ],\n ) -> None:\n assert_equal(\n container.from_value(raw_value).lash(function),\n container.from_value(raw_value),\n )","def selfie(f):\n return f.__get__(f, type(f))","def inheritTransform(*args, off: bool=True, on: bool=True, preserve: bool=True, toggle:\n bool=True, q=True, query=True, **kwargs)->Union[None, Any]:\n pass","def flags(self, f):\n if f.is_inlined:\n return \" (inlined)\"\n return \"\"","def cpfclamp(f, min_, max_):\n return min(max(f, min_), max_)","def get_canonical(self, id):\n canonical = None\n if id in self.canonicals:\n canonical = self.canonicals[id]\n return canonical","def replace_contractions(text):\n return contractions.fix(text)","def replace_contractions(text):\n return contractions.fix(text)","def replace_contractions(text):\r\n return contractions.fix(text)","def canonic(filename):\r\n if filename is None:\r\n return ''\r\n\r\n if filename == (\"<\" + filename[1:-1] + \">\"):\r\n return filename\r\n canonic_ = os.path.realpath(filename)\r\n canonic_ = os.path.normcase(canonic_)\r\n return canonic_","def instrument(f):\n @wraps(f)\n def wrapper(*args, **kwargs):\n arg_str = ', '.join(str(a) for a in args)\n if instrument.TRIM_ARGS is not None and len(arg_str) > instrument.TRIM_ARGS:\n arg_str = arg_str[:instrument.TRIM_ARGS] + \" ...\"\n if instrument.SHOW_CALL:\n sys.stderr.write(\" \"*wrapper._depth + \"call to \" + f.__name__ + \": \" + arg_str + \"\\n\")\n wrapper._count += 1\n wrapper._depth += 1\n wrapper._max_depth = max(wrapper._depth, wrapper._max_depth)\n result = f(*args, **kwargs)\n wrapper._depth -= 1\n res_str = str(result)\n if instrument.TRIM_RET is not None and len(res_str) > instrument.TRIM_RET:\n res_str = res_str[:instrument.TRIM_RET] + \" ...\"\n if instrument.SHOW_RET:\n sys.stderr.write(\" \"*wrapper._depth + f.__name__ + \" returns: \" + res_str + \"\\n\")\n return result\n wrapper._count = 0\n wrapper._depth = 0\n wrapper._max_depth = 0\n return wrapper","def unprint(f):\n \n f.func_code = __transform_codeobjects__(f.func_code,__unprint__)\n return f"],"string":"[\n \"def pony_func(func):\\n func.is_pony_func = True\\n return func\",\n \"def main():\\n parser = argparse.ArgumentParser(description=(\\n 'Canonicalize Call Graphs to FASTEN Canonical Call Graphs'))\\n parser.add_argument('directory', help=(\\n 'a directory with the Call Graph, and description files'))\\n parser.add_argument('-f', '--forge', default='debian', help=(\\n 'forge of the analyzed project. For example, it could be debian, '\\n 'or GitHub'))\\n parser.add_argument('-v', '--verbose', dest='verbose', action='store_true',\\n help='print logs to the console')\\n parser.add_argument('-L', '--file-logging', dest='file_logging',\\n action='store_true',\\n help='save logs to a file')\\n parser.add_argument('-l', '--logging-level', dest='logging_level',\\n choices=['CRITICAL', 'ERROR', 'WARNING', 'INFO',\\n 'DEBUG'],\\n default='DEBUG', help='logging level for logs')\\n parser.add_argument('-c', '--custom-deps', dest='custom_deps',\\n default=None, help='custom user defined dependencies')\\n parser.add_argument('-r', '--regex-product', dest='regex_product',\\n default=None, help='regex to match product\\\\'s files')\\n parser.add_argument('-o', '--output', dest='output', default=None,\\n help='file to save the canonicalized call graph')\\n args = parser.parse_args()\\n can = C_Canonicalizer(args.directory,\\n forge=args.forge,\\n console_logging=args.verbose,\\n file_logging=args.file_logging,\\n logging_level=args.logging_level,\\n custom_deps=args.custom_deps,\\n product_regex=args.regex_product)\\n can.canonicalize()\",\n \"def supcanon(f, Iab, theta=45, DIRECTION=\\\"CLOCKWISE\\\"):\\n from string import upper\\n\\n DIRECTION = upper(DIRECTION) \\n y = intersec(f,0)\\n for t in xrange(0,360,theta):\\n Irot = interot( Iab, t, DIRECTION )\\n y = union( y, supgen(f, Irot))\\n return y\",\n \"def canonicalize(self, url):\\n pass\",\n \"def mobius_transform(f):\\n return dirichlet_conv(f, mobius)\",\n \"def lift(f):\\n @wraps(f)\\n def inner(value):\\n result = f(value)\\n return SuperBool(result, f.__doc__) if not isinstance(result, SuperBool) else result\\n return inner\",\n \"def canonicalize(self):\\n return _libsbml.ASTNode_canonicalize(self)\",\n \"def ag_to_canon(agparams, f0):\\n A, B, C, D, E, F = agparams\\n\\n B2 = B * B\\n AmC = A - C\\n\\n disc = B2 - A * C\\n idisc = 1.0 / disc\\n\\n xc = idisc * f0 * (C * D - B * E)\\n yc = idisc * f0 * (A * E - B * D)\\n center = (xc, yc)\\n\\n lambda_ = idisc * f0 * (f0 * F + D * xc + E * yc)\\n\\n gamma = A + C\\n kappa = numpy.sqrt(4 * B2 + AmC * AmC)\\n\\n sgn = numpy.abs(lambda_) / lambda_\\n\\n a = numpy.sqrt(0.5 * lambda_ * (gamma + sgn * kappa))\\n b = numpy.sqrt(0.5 * lambda_ * (gamma - sgn * kappa))\\n\\n tilt = 0.5 * numpy.arctan2(-sgn * 2.0 * B / kappa, -sgn * AmC / kappa)\\n\\n return center, a, b, tilt\",\n \"def transform(self, f):\\n\\n return f(self)\",\n \"def expand_function(f, argspec):\\n return _autogen.expand_function_autogen(f, argspec)\",\n \"def cry_f(s : str) -> CryptolTerm:\\n return CryptolTerm(to_cryptol_str_customf(s, frames=1))\",\n \"def unwrap_self_f(arg, **kwarg): \\r\\n return Multiscale_Assimilation.single_patch_assimilation(*arg,**kwarg)\",\n \"def realify(fn, imag_tol=1e-12):\\n\\n @functools.wraps(fn)\\n def realified_fn(*args, **kwargs):\\n return realify_scalar(fn(*args, **kwargs), imag_tol=imag_tol)\\n\\n return realified_fn\",\n \"def selfie_depreceated(f):\\n return partial(f, f)\",\n \"def test_right_canonize():\\n\\n for n in range(Nmin, Nmax+1):\\n random_state = new_random_state(d, n)\\n\\n MPS_full = to_full_MPS(random_state, n, d) #this is in left-canonical form\\n \\n MPS_rightcanonical = right_canonize(MPS_full)\\n \\n assert check_right_canonization(MPS_rightcanonical[1:]), \\\"right_canonize error\\\"\",\n \"def coherent_trans(f, NA, n, delta_z):\\n\\n f2 = f[0]**2 + f[1]**2\\n mask = f2 < NA**2\\n return mask * np.exp(2j * np.pi * delta_z * np.sqrt(mask*(n**2 - f2)))\",\n \"def clean_feature(f):\\n\\n if f.startswith(\\\"a \\\"):\\n f = f[2:]\\n\\n if f.startswith(\\\"an \\\"):\\n f = f[3:]\\n\\n return str(f)\",\n \"def decorate_function(cls, f: 'Callable', **setting_kwds) -> None:\\n # Filter out builtins.\\n if not get_file_of_object(f):\\n return\\n\\n caller_frame = sys._getframe(1) # caller's frame\\n namespace = caller_frame.f_globals\\n namespace[f.__name__] = cls(**setting_kwds)(f)\",\n \"def canonical(self):\\r\\n if not hasattr(self, '_canonical'):\\r\\n self._canonical = conf.lib.clang_getCanonicalCursor(self)\\r\\n\\r\\n return self._canonical\",\n \"def orig_function(inputs, outputs, mode=None, accept_inplace=False,\\r\\n name=None, profile=None, on_unused_input=None):\\r\\n\\r\\n # Every element of the input list will be upgraded to an `In` instance if\\r\\n # necessary, using the rules implemented by the `convert_function_input`\\r\\n # function.\\r\\n\\r\\n # Similarly, every element of the output list will be upgraded to an `Out`\\r\\n # instance if necessary:\\r\\n\\r\\n t1 = time.time()\\r\\n mode = theano.compile.mode.get_mode(mode)\\r\\n\\r\\n inputs = map(convert_function_input, inputs)\\r\\n if outputs is not None:\\r\\n if isinstance(outputs, (list, tuple)):\\r\\n outputs = map(FunctionMaker.wrap_out, outputs)\\r\\n else:\\r\\n outputs = FunctionMaker.wrap_out(outputs)\\r\\n\\r\\n defaults = [getattr(input, 'value', None) for input in inputs]\\r\\n\\r\\n if isinstance(mode, (list, tuple)): # \\\"mode comparison\\\" semantics\\r\\n raise Exception(\\\"We do not support the passing of multiple modes\\\")\\r\\n else:\\r\\n Maker = getattr(mode, 'function_maker', FunctionMaker)\\r\\n fn = Maker(inputs,\\r\\n outputs,\\r\\n mode,\\r\\n accept_inplace=accept_inplace,\\r\\n profile=profile,\\r\\n on_unused_input=on_unused_input).create(\\r\\n defaults)\\r\\n\\r\\n t2 = time.time()\\r\\n if profile:\\r\\n profile.compile_time += t2 - t1\\r\\n\\r\\n fn.name = name\\r\\n fn.maker.fgraph.name = name\\r\\n return fn\",\n \"def set_unc_f(self, unc):\\n self.uncf = unc\",\n \"def zeroify(fn, tol=1e-14):\\n\\n @functools.wraps(fn)\\n def zeroified_f(*args, **kwargs):\\n x = fn(*args, **kwargs)\\n return 0.0 if abs(x) < tol else x\\n\\n return zeroified_f\",\n \"def safe(f):\\n\\tdef safe_f(*args,**kwargs):\\n\\t\\ttry:\\n\\t\\t\\treturn f(*args,**kwargs)\\n\\t\\texcept:\\n\\t\\t\\treturn float('inf')\\n\\treturn safe_f\",\n \"def canon(raw_attr_name: str) -> str:\\n if raw_attr_name: # do not dereference None, and \\\"\\\" is already canonical\\n return raw_attr_name.replace(\\\" \\\", \\\"\\\").lower()\\n return raw_attr_name\",\n \"def conj_inplace(a):\",\n \"def test__canonizeURL(self):\\n self.run_script_for_compat('alert(e._canonizeURL(foo));')\\n self.assert_silent()\\n self.assert_compat_error()\",\n \"def sharemind(f: callable):\\n from conclave.codegen import sharemind\\n from conclave import CodeGenConfig\\n\\n def wrap():\\n code = sharemind.SharemindCodeGen(CodeGenConfig(), f())._generate(None, None)\\n return code\\n\\n return wrap\",\n \"def to01(f):\\n def wrap(x, *args, **kwargs):\\n y = x * 2 - 1\\n z = f(y, *args, **kwargs)\\n return (z + 1) / 2\\n return wrap\",\n \"def cancan(self, f):\\n return uncan(can(f), self.user_ns)\",\n \"def canonicalize(self):\\n self.rules = canonicalize_grammar(self,self.empty)\\n self.is_canonical = True\",\n \"def canonicalize(smile):\\n\\n return Chem.MolToSmiles(Chem.MolFromSmiles(smile))\",\n \"def transform_fn(self):\\n if hasattr(self._transform_fn, 'forward'):\\n return self._transform_fn.forward\\n return self._transform_fn\",\n \"def needs_decomp(f): #move\\n @functools.wraps(f)\\n def wrapper(arg):\\n if type(arg) is Decomposition:\\n return f(arg)\\n assert_natural(arg)\\n return f(decompose(arg))\\n return wrapper\",\n \"def _canonify(self, rut):\\n rut = smart_unicode(rut).replace(' ', '').replace('.', '').replace('-', '')\\n return rut[:-1], rut[-1]\",\n \"def conventionalize_function(self, function: str) -> str:\\n return _conventionalize(self.options, \\\"function\\\", function)\",\n \"def indirect_proof(proof_function):\\n\\tdef indirect_proof_result(proof_function, assumption):\\n\\t\\tchecked_proposition(assumption)\\n\\t\\tinterp = _strict_match((A, conj, (neg, A)), proof_function(assumption))\\n\\t\\treturn _proposition_class((neg, assumption[:]))\\n\\t\\n\\tif type(proof_function) != types.FunctionType:\\n\\t\\traise TypeError()\\n\\treturn lambda assumption: indirect_proof_result(proof_function, assumption)\",\n \"def compact(fun: _CallableT) -> _CallableT:\\n fun.compact = True\\n return fun\",\n \"def canonical(self):\\n args = tuple([i.canonical if isinstance(i, Relational) else i for i in self.args])\\n if args != self.args:\\n r = self.func(*args)\\n if not isinstance(r, Relational):\\n return r\\n else:\\n r = self\\n if r.rhs.is_number:\\n if r.rhs.is_Number and r.lhs.is_Number and r.lhs > r.rhs:\\n r = r.reversed\\n elif r.lhs.is_number:\\n r = r.reversed\\n elif tuple(ordered(args)) != args:\\n r = r.reversed\\n\\n LHS_CEMS = getattr(r.lhs, 'could_extract_minus_sign', None)\\n RHS_CEMS = getattr(r.rhs, 'could_extract_minus_sign', None)\\n\\n if isinstance(r.lhs, BooleanAtom) or isinstance(r.rhs, BooleanAtom):\\n return r\\n\\n # Check if first value has negative sign\\n if LHS_CEMS and LHS_CEMS():\\n return r.reversedsign\\n elif not r.rhs.is_number and RHS_CEMS and RHS_CEMS():\\n # Right hand side has a minus, but not lhs.\\n # How does the expression with reversed signs behave?\\n # This is so that expressions of the type\\n # Eq(x, -y) and Eq(-x, y)\\n # have the same canonical representation\\n expr1, _ = ordered([r.lhs, -r.rhs])\\n if expr1 != r.lhs:\\n return r.reversed.reversedsign\\n\\n return r\",\n \"def safe(f):\\n def safe_f(*args, **kwargs):\\n try:\\n return f(*args, ** kwargs)\\n except:\\n return float('inf')\\n return safe_f\",\n \"def connection_point_nonterminating_orbit(x, f):\\n return convergent_point(\\n x, f(collision_point_nonterminating_orbit(x, f)), f)\",\n \"def symbolic_fn_opts(**kwargs):\\r\\n def deco(f):\\r\\n return symbolic_fn(f, **kwargs)\\r\\n return deco\",\n \"def soul(f):\\n\\n def is_soul(self, *args, **kwargs):\\n # TODO\\n return f(self, *args, **kwargs)\\n\\n return is_soul\",\n \"def make_safe_f(f, allowed_params):\\n def inner(*args, **kwargs):\\n if kwargs:\\n new_kwargs = {}\\n for k, v in kwargs.items():\\n if k in allowed_params:\\n new_kwargs[k] = v\\n return f(*args, **new_kwargs)\\n return f(*args, **kwargs)\\n return inner\",\n \"def conj(fs):\\n def feature(s, i):\\n return all(f(s, i) for f in fs)\\n return feature\",\n \"def to_cdnf(self):\\n return Or(*[term for term in self.iter_minterms()])\",\n \"def make_safe_f(f, allowed_params):\\r\\n def inner(*args, **kwargs):\\r\\n if kwargs:\\r\\n new_kwargs = {}\\r\\n for k, v in kwargs.items():\\r\\n if k in allowed_params:\\r\\n new_kwargs[k] = v\\r\\n return f(*args, **new_kwargs)\\r\\n return f(*args, **kwargs)\\r\\n return inner\",\n \"def is_canonical(self):\\n return False\",\n \"def safe(f):\\n\\n def safe_f(*args, **kwargs):\\n try:\\n return f(*args, **kwargs)\\n except:\\n return float('inf') # this means \\\"infinity\\\" in Python\\n\\n return safe_f\",\n \"def run_simpatico(self, f):\\n s = Styler(f, True, False)\\n return s\",\n \"def encoding_cctf(self, value):\\n\\n if value is not None:\\n assert hasattr(\\n value,\\n '__call__'), ('\\\"{0}\\\" attribute: \\\"{1}\\\" is not callable!'.format(\\n 'encoding_cctf', value))\\n self._encoding_cctf = value\",\n \"def debuggable(f):\\n \\n debugging = f.func_globals.get(\\\"DEBUGGING\\\",False)\\n if debugging: return f\\n\\n f.func_code = __transform_codeobjects__(f.func_code,__debuggable__)\\n return f\",\n \"def is_canonical(self):\\n if self.canonical_acceptor == self.acceptor:\\n return True\\n else:\\n return False\",\n \"def safe(f):\\n def safe_f(*args, **kwargs):\\n try:\\n return f(*args, **kwargs)\\n except:\\n return float('inf') # this means infinity in python\\n return safe_f\",\n \"def _collapse_fastq(in_fn):\\n args = argparse.Namespace()\\n args.fastq = in_fn\\n args.minimum = 1\\n args.out = op.dirname(in_fn)\\n return collapse_fastq(args)\",\n \"def canonical(_signed: Json) -> bytes:\\n return encode_canonical(_signed).encode(\\\"utf-8\\\")\",\n \"def test_make_safe_f(self):\\r\\n def f(x, y):\\r\\n return x * y\\r\\n self.assertEqual(f(3, 4), 12)\\r\\n g = make_safe_f(f, ['x', 'y'])\\r\\n self.assertEqual(g(3, 4), 12)\\r\\n self.assertEqual(g(x=3, y=4, z=10, xxx=11), 12)\",\n \"def f_unc(x, a, b):\\n return f_raw(x, a, b)\",\n \"def _deco_base_f_wrapper_(*args, **kwargs):\\n # *** Part of the DecoSettingsMapping \\\"API\\\" --\\n # (4) using self._settings_mapping.get_final_value in wrapper\\n # [[[ This/these is/are 4th chronologically ]]]\\n\\n # inner/local fn -- save a few cycles and characters -\\n # we call this a lot (<= 9x).\\n def _get_final_value(setting_name):\\n \\\"Use outer scope's kwargs and self.f_params\\\"\\n return self._settings_mapping.get_final_value(\\n setting_name, kwargs, fparams=self.f_params)\\n\\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\\n # if nothing to do, hurry up & don't do it.\\n # NOTE: call_chain_to_next_log_calls_fn looks in stack frames\\n # to find (0.2.4) STACKFRAME_HACK_DICT_NAME (really!)\\n # It and its values (the following _XXX variables)\\n # must be set before calling f.\\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\\n _enabled = _get_final_value('enabled')\\n # 0.3.0 in case f calls log_message (no output if f disabled)\\n self._enabled_state_push(_enabled)\\n\\n # 0.2.4.post5 \\\"true bypass\\\": if 'enabled' < 0 then scram\\n if _enabled < 0:\\n ret = f(*args, **kwargs)\\n self._enabled_state_pop()\\n return ret\\n\\n # Bump call counters, before calling fn.\\n # Note: elapsed_secs, process_secs not reflected yet of course\\n self._add_call(logged=_enabled)\\n\\n _log_call_numbers = _get_final_value('log_call_numbers')\\n # counters just got bumped\\n _active_call_number = (self._stats.num_calls_logged\\n if _log_call_numbers else\\n 0)\\n # Get list of callers up to & including first log_call's-deco'd fn\\n # (or just caller, if no such fn)\\n call_list, prev_indent_level = self.call_chain_to_next_log_calls_fn()\\n\\n # Bump _extra_indent_level if last fn on call_list is deco'd AND enabled,\\n # o/w it's the _extra_indent_level which that fn 'inherited'.\\n # _extra_indent_level: prev_indent_level, or prev_indent_level + 1\\n do_indent = _get_final_value('indent')\\n _extra_indent_level = (prev_indent_level +\\n int(not not do_indent and not not _enabled))\\n # 0.3.0\\n ########## prefixed_fname = _get_final_value('prefix') + f.__name__\\n prefixed_fname = _get_final_value('prefix') + self.f_display_name\\n\\n # Stackframe hack:\\n assert '_deco_base__active_call_items__' == STACKFRAME_HACK_DICT_NAME\\n _deco_base__active_call_items__ = {\\n '_enabled': _enabled,\\n '_log_call_numbers': _log_call_numbers,\\n '_prefixed_fname': prefixed_fname, # Hack alert (Pt 1)\\n '_active_call_number': _active_call_number,\\n '_extra_indent_level': _extra_indent_level,\\n # 0.3.0 for _get_own_deco_wrapper\\n '_wrapper_deco': self\\n }\\n\\n # Get logging function IF ANY.\\n # For the benefit of callees further down the call chain,\\n # if this f is not enabled (_enabled <= 0).\\n # Subclass can return None to suppress printed/logged output.\\n logging_fn = self.get_logging_fn(_get_final_value)\\n\\n # Only do global indentation for print, not for loggers\\n global_indent_len = max(_extra_indent_level, 0) * self.INDENT\\n\\n # 0.2.2.post1 - save output_fname for log_message use\\n call_number_str = ((' [%d]' % _active_call_number)\\n if _log_call_numbers else '')\\n output_fname = prefixed_fname + call_number_str\\n\\n # 0.3.0\\n # Note: DON'T combine with global_mute(),\\n # cuz this value will be pushed,\\n # and when popped any realtime changes to global mute\\n # made during call to f would be ignored.\\n mute = _get_final_value('mute')\\n\\n # 0.2.2 -- self._log_message() will use\\n # the logging_fn, indent_len and output_fname at top of these stacks;\\n # thus, verbose functions should use log_calls.print (~ log_message)\\n # to write their blather.\\n # There's a stack of logging-state ,\\n # used by self._log_message(), maintained in this wrapper.\\n self._logging_state_push(logging_fn, global_indent_len, output_fname, mute)\\n\\n # (_xxx variables set, ok to call f)\\n if not _enabled:\\n ret = f(*args, **kwargs)\\n self._logging_state_pop(enabled_too=True)\\n return ret\\n\\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\\n # Set up context, for pre-call handlers\\n # (after calling f, add to it for post-call handlers)\\n # THIS is the time sink - 23x slower than other 'blocks'\\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\\n # Key/values of \\\"context\\\" whose values we know so far:\\n context = {\\n 'decorator': self,\\n 'settings': self._settings_mapping,\\n 'stats': self._stats,\\n 'prefixed_fname': prefixed_fname,\\n 'fparams': self.f_params,\\n 'call_list': call_list,\\n 'args': args,\\n 'kwargs': kwargs,\\n 'indent': \\\" \\\" * self.INDENT, # our unit of indentation\\n 'output_fname': output_fname,\\n }\\n\\n # Gather all the things we need (for log output, & for history)\\n # Use inspect module's Signature.bind method.\\n # bound_args.arguments -- contains only explicitly bound arguments\\n # 0.2.4.post5 - using\\n # inspect.signature(f).bind(*args, **kwargs)\\n # took 45% of execution time of entire wrapper; this takes 23%:\\n # 0.3.1 TODO BUG No args is a problem?!\\n bound_args = self.f_signature.bind(*args, **kwargs)\\n \\\"\\\"\\\"\\n File \\\"/Users/brianoneill/Desktop/Programming/Python-package-staging/log_calls/log_calls/tests/_temp.py\\\", line 12, in <module>\\n g(f())\\n File \\\"/Users/brianoneill/Desktop/Programming/Python-package-staging/log_calls/log_calls/log_calls.py\\\", line 1935, in _deco_base_f_wrapper_\\n bound_args = self.f_signature.bind(*args, **kwargs)\\n File \\\"/Library/Frameworks/Python.framework/Versions/3.4/lib/python3.4/inspect.py\\\", line 2646, in bind\\n return args[0]._bind(args[1:], kwargs)\\n File \\\"/Library/Frameworks/Python.framework/Versions/3.4/lib/python3.4/inspect.py\\\", line 2571, in _bind\\n raise TypeError('too many positional arguments') from None\\n TypeError: too many positional arguments\\n \\\"\\\"\\\"\\n\\n varargs_pos = get_args_pos(self.f_params) # -1 if no *args in signature\\n argcount = varargs_pos if varargs_pos >= 0 else len(args)\\n context['argcount'] = argcount\\n # The first argcount-many things in bound_args\\n context['argnames'] = list(bound_args.arguments)[:argcount]\\n context['argvals'] = args[:argcount]\\n\\n context['varargs'] = args[argcount:]\\n (context['varargs_name'],\\n context['kwargs_name']) = get_args_kwargs_param_names(self.f_params)\\n\\n # These 3 statements = 31% of execution time of wrapper\\n context['defaulted_kwargs'] = get_defaulted_kwargs_OD(self.f_params, bound_args)\\n context['explicit_kwargs'] = get_explicit_kwargs_OD(self.f_params, bound_args, kwargs)\\n # context['implicit_kwargs'] = {\\n # k: kwargs[k] for k in kwargs if k not in context['explicit_kwargs']\\n # }\\n # At least 2x as fast:\\n context['implicit_kwargs'] = \\\\\\n difference_update(kwargs.copy(), context['explicit_kwargs'])\\n\\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\\n # Call pre-call handlers, collect nonempty return values\\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\\n # only consult global mute in r/t\\n if not (mute or self.global_mute()): # 0.3.0\\n pre_msgs = []\\n for setting_name in self._settings_mapping._pre_call_handlers: # keys\\n if _get_final_value(setting_name):\\n info = self._settings_mapping._get_DecoSetting(setting_name)\\n msg = info.pre_call_handler(context)\\n if msg:\\n pre_msgs.append(msg)\\n\\n # Write pre-call messages\\n if logging_fn:\\n for msg in pre_msgs:\\n self._log_message(msg, extra_indent_level=0)\\n\\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\\n # Call f(*args, **kwargs) and get its retval; time it.\\n # Add timestamp, elapsed time(s) and retval to context.\\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\\n # No dictionary overhead between timer(s) start & stop.\\n t0 = time.time() # for timestamp\\n t0_wall = wall_time_fn()\\n t0_process = process_time_fn()\\n retval = f(*args, **kwargs)\\n t_end_wall = wall_time_fn()\\n t_end_process = process_time_fn()\\n context['elapsed_secs'] = (t_end_wall - t0_wall)\\n context['process_secs'] = (t_end_process - t0_process)\\n context['timestamp'] = t0\\n context['retval'] = retval\\n\\n self._add_to_elapsed(context['elapsed_secs'], context['process_secs'])\\n\\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\\n # Call post-call handlers, collect nonempty return values\\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\\n # only consult global mute in r/t\\n if not (mute or self.global_mute()): # 0.3.0\\n post_msgs = []\\n for setting_name in self._settings_mapping._post_call_handlers: # keys\\n if _get_final_value(setting_name):\\n info = self._settings_mapping._get_DecoSetting(setting_name)\\n msg = info.post_call_handler(context)\\n if msg:\\n post_msgs.append(msg)\\n\\n # Write post-call messages\\n if logging_fn:\\n for msg in post_msgs:\\n self._log_message(msg, extra_indent_level=0)\\n # v0.3.0b22 -- if recording history, add record of call even if we're muted(!)\\n elif _get_final_value('record_history'):\\n info = self._settings_mapping._get_DecoSetting('record_history')\\n _ = info.post_call_handler(context)\\n\\n self._logging_state_pop(enabled_too=True)\\n\\n return retval\",\n \"def make_transform_fn(self, ):\\n return self._transform_fn\",\n \"def TransformFlags(self) -> _n_2_t_0[bool]:\",\n \"def canon(self, t):\\n if isinstance(t, basestring):\\n if t in self.base_types:\\n return t\\n elif t in self.type_aliases:\\n return self.canon(self.type_aliases[t])\\n elif t in self.refined_types:\\n return (self.canon(self.refined_types[t]), t)\\n elif self.isdependent(t):\\n return self._resolve_dependent_type(t)\\n else:\\n _raise_type_error(t)\\n # BELOW this would be for complicated string representations,\\n # such as 'char *' or 'map<nucid, double>'. Would need to write\\n # the parse_type() function and that might be a lot of work.\\n #parse_type(t)\\n elif isinstance(t, Sequence):\\n t0 = t[0]\\n tlen = len(t)\\n if 0 == tlen:\\n _raise_type_error(t)\\n last_val = 0 if tlen == 1 else t[-1]\\n if not isinstance(t0, basestring) and not isinstance(t0, Sequence):\\n _raise_type_error(t)\\n if self.isdependent(t0):\\n return self._resolve_dependent_type(t0, t)\\n elif t0 in self.template_types:\\n templen = len(self.template_types[t0])\\n last_val = 0 if tlen == 1 + templen else t[-1]\\n filledt = [t0]\\n for tt in t[1:1+templen]:\\n \\n if isinstance(tt, Number): # includes bool!\\n filledt.append(tt)\\n elif isinstance(tt, basestring):\\n try:\\n canontt = self.canon(tt)\\n except TypeError:\\n canontt = tt\\n except:\\n raise\\n filledt.append(canontt)\\n elif isinstance(tt, Sequence):\\n if len(tt) == 2 and tt[0] in Arg:\\n filledt.append(self.canon(tt[1]))\\n else:\\n filledt.append(self.canon(tt))\\n else:\\n _raise_type_error(tt)\\n filledt.append(last_val)\\n return tuple(filledt)\\n else:\\n return (self.canon(t0), last_val)\\n else:\\n _raise_type_error(t)\",\n \"def _replace_contractions(text):\\n return contractions.fix(text)\",\n \"def get_unc_f(self):\\n return self.uncf\",\n \"def decorate_package_function(cls, f: 'Callable', **setting_kwds) -> None:\\n # Filter out builtins.\\n if not get_file_of_object(f):\\n return\\n\\n f_deco = cls(**setting_kwds)(f)\\n\\n namespace = vars(inspect.getmodule(f))\\n\\n fmodname = inspect.getmodule(f).__name__\\n\\n # 'sklearn.cluster.k_means_'\\n basic_modname = inspect.getmodulename(fmodname.replace('.', '/') + '.py')\\n # 'k_means_' or 'some_module', or None\\n if basic_modname and '.' in fmodname:\\n fpackagename = namespace['__package__'] # '.'.join(fmodname.split('.')[:-1])\\n exec(\\\"import \\\" + fpackagename)\\n package_dict = eval(\\\"vars(%s)\\\" % fpackagename)\\n package_dict[f.__name__] = f_deco\\n\\n namespace[f.__name__] = f_deco\",\n \"def compress(clean):\\n if clean is None:\\n return None\\n clean = re.sub(r'[\\\\r\\\\n\\\\t\\\\xa0]', ' ', clean)\\n clean = re.sub(r' ?', ' ', clean)\\n clean = re.sub(r'\\\\s+', ' ', clean)\\n return clean.strip()\",\n \"def canonical_name(self, name):\\n raise NotImplementedError\",\n \"def decorate_module_function(cls, f: 'Callable', **setting_kwds) -> None:\\n # Filter out builtins.\\n if not get_file_of_object(f):\\n return\\n\\n namespace = vars(inspect.getmodule(f))\\n namespace[f.__name__] = cls(**setting_kwds)(f)\",\n \"def make_qual(sff_fp, output_fp, use_sfftools=False, no_trim=False):\\r\\n if use_sfftools:\\r\\n _fail_on_gzipped_sff(sff_fp)\\r\\n check_sffinfo()\\r\\n if no_trim:\\r\\n _check_call(['sffinfo', '-notrim', '-q', sff_fp],\\r\\n stdout=open(output_fp, 'w'))\\r\\n else:\\r\\n _check_call(['sffinfo', '-q', sff_fp], stdout=open(output_fp, 'w'))\\r\\n else:\\r\\n try:\\r\\n format_binary_sff_as_fna(\\r\\n qiime_open(sff_fp, 'rb'), open(output_fp, 'w'), qual=True)\\r\\n except:\\r\\n raise IOError(\\\"Could not parse SFF %s\\\" % sff_fp)\",\n \"def canon_to_ag(canonparams, f0):\\n (xc, yc), a, b, tilt = canonparams\\n\\n a2, b2 = a * a, b * b\\n st, ct = numpy.sin(tilt), numpy.cos(tilt)\\n st2, ct2 = st * st, ct * ct\\n\\n if0 = 1.0 / f0\\n\\n A = b2 * ct2 + a2 * st2\\n B = (b2 - a2) * st * ct\\n C = b2 * st2 + a2 * ct2\\n D = -if0 * (A * xc + B * yc)\\n E = -if0 * (B * xc + C * yc)\\n F = -if0 * (D * xc + E * yc + if0 * a2 * b2)\\n\\n return A, B, C, D, E, F\",\n \"def wrap_gate(fn):\\n return lambda parms: fn(**parms) if len(parms) > 0 else fn\",\n \"def execute_on_optree(self, node, fct=None, fct_group=None, memoization_map=None):\\n return self.simplifier.simplify(node)\",\n \"def execute_on_optree(self, node, fct=None, fct_group=None, memoization_map=None):\\n return self.simplifier.simplify(node)\",\n \"def conToCelc(faren):\\n return (faren - 32)*(5/9)\",\n \"def make_synopsis_one_function(f, number):\\n ns = CL.get_namespace(f) + '::' # to remove the myclass:: from the types of arg and rtype\\n is_not_constructor = not getattr(f, 'is_constructor', False)\\n\\n template = make_synopsis_template_decl(f)\\n\\n result_type = (process_type_name(f.result_type) + ' ') if is_not_constructor else ''\\n name = \\\" %s \\\"%f.spelling.strip() if is_not_constructor else f.spelling.split('<',1)[0] # eliminate the <> in the constructor name\\n qualif = CL.get_method_qualification(f) + (' noexcept' if getattr(f,'noexcept',False) else '')\\n\\n params1 = [(p.type, p.spelling, CL.get_param_default_value(p)) for p in CL.get_params(f)]\\n params = [\\\"%s %s\\\"%(process_type_name(t), \\\":param:`%s`\\\"%n if n else '') + (\\\" = %s\\\"%d if d else \\\"\\\") for t,n,d in params1]\\n # same with no rst decoration\\n params_no_role = [\\\"%s %s\\\"%(t.spelling, n) + (\\\" = %s\\\"%d if d else \\\"\\\") for t,n,d in params1]\\n\\n # first attempt : one line, else multiple line\\n nspace = 8 if number>=10 else 7\\n sep = nspace*' ' + '| '\\n sep2 = ',\\\\n' + sep + ' '*len(name)\\n res1 = sep + result_type + \\\":red:`%s` \\\"%name.strip() + '('\\n\\n # First compute the result without any rst decoroation to compute the lengths\\n res_no_role = res1 + ', '.join(x for x in params_no_role)\\n if len(res_no_role) > global_vars.synopsis_maxlen_function: # not good, need to split\\n res = res1 + sep2.join(x for x in params) # DEBUG + \\\"%s %s\\\"%(len(res_no_role) , global_vars.synopsis_maxlen_function)\\n else:\\n res = res1 + ', '.join(x for x in params)\\n\\n # brief = f.processed_doc.brief_doc\\n #r = ('%s:cppbrief:`%s`\\\\n'%(sep,brief) if brief else '') + ('%s:green:`%s`\\\\n'%(sep,template) if template else '') + res + ') ' + qualif\\n r = ('%s:green:`%s`\\\\n'%(sep,template) if template else '') + res + ') ' + qualif\\n\\n return r.strip()\",\n \"def scotch(f: callable):\\n\\n from conclave.codegen import scotch\\n from conclave import CodeGenConfig\\n\\n def wrap():\\n code = scotch.ScotchCodeGen(CodeGenConfig(), f())._generate(None, None)\\n return code\\n\\n return wrap\",\n \"def _canonize(self, *, input, document_loader: DocumentLoaderMethod) -> str:\\n # application/n-quads format always returns str\\n missing_properties = get_properties_without_context(input, document_loader)\\n\\n if len(missing_properties) > 0:\\n raise LinkedDataProofException(\\n f\\\"{len(missing_properties)} attributes dropped. \\\"\\n f\\\"Provide definitions in context to correct. {missing_properties}\\\"\\n )\\n\\n return jsonld.normalize(\\n input,\\n {\\n \\\"algorithm\\\": \\\"URDNA2015\\\",\\n \\\"format\\\": \\\"application/n-quads\\\",\\n \\\"documentLoader\\\": document_loader,\\n },\\n )\",\n \"def semicolon(f: Callable) -> Callable:\\n\\n @functools.wraps(f)\\n def wrapper(*args, **kwargs):\\n return f(*args, **kwargs) + \\\";\\\"\\n\\n return wrapper\",\n \"def celsius_conv(self, f):\\n if f == 0:\\n return -17.7778\\n else:\\n return (f - 32.0) * (5.0 / 9.0)\",\n \"def test_mixed_canonize():\\n \\n for n in range(Nmin, Nmax+1):\\n random_state = new_random_state(d, n)\\n rand_mps = []\\n MPS_full = to_full_MPS(random_state, n, d) #just for the shapes\\n \\n for shape in [a.shape for a in MPS_full]: #Generate an unnormalized mps (since MPS_full would be already in left-canonical form by construction)\\n rand_mps.append(np.random.rand(*shape)) \\n \\n MPS_mixedcanonical = rand_mps\\n for pos in range(n): \\n #set the site at pos as center of orthogonality\\n if pos > 0:\\n MPS_mixedcanonical = left_canonize(MPS_mixedcanonical[:pos+1]) + MPS_mixedcanonical[pos+1:]\\n if pos < n-1:\\n MPS_mixedcanonical = MPS_mixedcanonical[:pos] + right_canonize(MPS_mixedcanonical[pos:])\\n\\n if pos > 0:\\n assert check_left_canonization(MPS_mixedcanonical[:pos+1]), \\\"Error in mixed left\\\"\\n if pos < n-1:\\n assert check_right_canonization(MPS_mixedcanonical[pos:]), \\\"Error in mixed right\\\"\",\n \"def getCanonicalLink(self, article):\\n kwargs = {'tag':'link', 'attr':'rel', 'value':'canonical'}\\n meta = Parser.getElementsByTag(article.doc, **kwargs)\\n if meta is not None and len(meta) > 0:\\n href = meta[0].attrib.get('href')\\n if href:\\n href = href.strip()\\n o = urlparse(href)\\n if not o.hostname:\\n z = urlparse(article.finalUrl)\\n domain = '%s://%s' % (z.scheme, z.hostname)\\n href = urljoin(domain, href)\\n return href\\n return article.finalUrl\",\n \"def map_short_circuit_law(\\n container: 'MaybeLikeN[_FirstType, _SecondType, _ThirdType]',\\n function: Callable[[_FirstType], _NewType1],\\n ) -> None:\\n assert_equal(\\n container.from_optional(None).map(function),\\n container.from_optional(None),\\n )\",\n \"def to_cnf(self):\\n f = self.factor()\\n if isinstance(f, Expression):\\n f = f._flatten(Or)\\n if isinstance(f, Expression):\\n f = f.absorb()\\n return f\",\n \"def apply(self, f):\\n\\n self.f = f\\n self.fs.append(self.f)\\n self.plane = f(self.plane) #Applies the function to the complex numbers\\n return self.plane\",\n \"def get_canonical_link(self):\\n if self.article.final_url:\\n kwargs = {'tag': 'link', 'attr': 'rel', 'value': 'canonical'}\\n meta = self.parser.getElementsByTag(self.article.doc, **kwargs)\\n if meta is not None and len(meta) > 0:\\n href = self.parser.getAttribute(meta[0], 'href')\\n if href:\\n href = href.strip()\\n o = urlparse(href)\\n if not o.hostname:\\n z = urlparse(self.article.final_url)\\n domain = '%s://%s' % (z.scheme, z.hostname)\\n href = urljoin(domain, href)\\n return href\\n return self.article.final_url\",\n \"def clean(self, value = None):\\n if self.rut:\\n value = self.rut\\n rut, verificador = self._canonify(value)\\n if self._algorithm(rut) == verificador:\\n return self._format(rut, verificador)\\n else:\\n return False\",\n \"def f(x, a, b):\\n return f_raw(x, a, b)\",\n \"def MapstoRef(f):\\n #so given a mixture, find each of the n alpha maps\\n n = f.n\\n d = f.d\\n \\n A = np.zeros([n,d,d])\\n L = np.zeros([n,d,d])\\n b = np.zeros([n,d])\\n \\n for i in range(n):\\n A[i,:,:] = fmp(f.cov[i,:,:],-1/2)\\n L[i,:,:] = np.linalg.cholesky(A[i,:,:])\\n b[i,:] = - A[i,:,:] @ f.m[i,:]\\n \\n ToRef = Affine_Maps(L,b)\\n \\n return ToRef\",\n \"def up(f):\\n return f()\",\n \"def lash_short_circuit_law(\\n raw_value: _FirstType,\\n container: 'MaybeLikeN[_FirstType, _SecondType, _ThirdType]',\\n function: Callable[\\n [_SecondType],\\n KindN['MaybeLikeN', _FirstType, _NewType1, _ThirdType],\\n ],\\n ) -> None:\\n assert_equal(\\n container.from_value(raw_value).lash(function),\\n container.from_value(raw_value),\\n )\",\n \"def selfie(f):\\n return f.__get__(f, type(f))\",\n \"def inheritTransform(*args, off: bool=True, on: bool=True, preserve: bool=True, toggle:\\n bool=True, q=True, query=True, **kwargs)->Union[None, Any]:\\n pass\",\n \"def flags(self, f):\\n if f.is_inlined:\\n return \\\" (inlined)\\\"\\n return \\\"\\\"\",\n \"def cpfclamp(f, min_, max_):\\n return min(max(f, min_), max_)\",\n \"def get_canonical(self, id):\\n canonical = None\\n if id in self.canonicals:\\n canonical = self.canonicals[id]\\n return canonical\",\n \"def replace_contractions(text):\\n return contractions.fix(text)\",\n \"def replace_contractions(text):\\n return contractions.fix(text)\",\n \"def replace_contractions(text):\\r\\n return contractions.fix(text)\",\n \"def canonic(filename):\\r\\n if filename is None:\\r\\n return ''\\r\\n\\r\\n if filename == (\\\"<\\\" + filename[1:-1] + \\\">\\\"):\\r\\n return filename\\r\\n canonic_ = os.path.realpath(filename)\\r\\n canonic_ = os.path.normcase(canonic_)\\r\\n return canonic_\",\n \"def instrument(f):\\n @wraps(f)\\n def wrapper(*args, **kwargs):\\n arg_str = ', '.join(str(a) for a in args)\\n if instrument.TRIM_ARGS is not None and len(arg_str) > instrument.TRIM_ARGS:\\n arg_str = arg_str[:instrument.TRIM_ARGS] + \\\" ...\\\"\\n if instrument.SHOW_CALL:\\n sys.stderr.write(\\\" \\\"*wrapper._depth + \\\"call to \\\" + f.__name__ + \\\": \\\" + arg_str + \\\"\\\\n\\\")\\n wrapper._count += 1\\n wrapper._depth += 1\\n wrapper._max_depth = max(wrapper._depth, wrapper._max_depth)\\n result = f(*args, **kwargs)\\n wrapper._depth -= 1\\n res_str = str(result)\\n if instrument.TRIM_RET is not None and len(res_str) > instrument.TRIM_RET:\\n res_str = res_str[:instrument.TRIM_RET] + \\\" ...\\\"\\n if instrument.SHOW_RET:\\n sys.stderr.write(\\\" \\\"*wrapper._depth + f.__name__ + \\\" returns: \\\" + res_str + \\\"\\\\n\\\")\\n return result\\n wrapper._count = 0\\n wrapper._depth = 0\\n wrapper._max_depth = 0\\n return wrapper\",\n \"def unprint(f):\\n \\n f.func_code = __transform_codeobjects__(f.func_code,__unprint__)\\n return f\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.49801686","0.48075998","0.4801738","0.47585616","0.47026438","0.47009388","0.46868795","0.46559855","0.46223104","0.46175477","0.45939246","0.45530087","0.4538339","0.44475698","0.4445085","0.44408873","0.44223046","0.4421128","0.44015473","0.43992308","0.43858254","0.43743497","0.43547687","0.43521175","0.43485126","0.4343929","0.4324946","0.43201676","0.42994517","0.42957133","0.429404","0.42794025","0.42695144","0.4250417","0.42374545","0.4236891","0.42290148","0.4226183","0.42203918","0.42125306","0.42111608","0.4205805","0.42016035","0.41995135","0.41980904","0.4185058","0.4177798","0.41758126","0.4174238","0.41712672","0.41700417","0.41675496","0.41393906","0.41339377","0.41227353","0.4122716","0.41096303","0.41083655","0.4104824","0.4095738","0.40883112","0.40629834","0.40523165","0.4047642","0.40468106","0.40450025","0.40442237","0.40435818","0.40345794","0.4033547","0.4031468","0.4031468","0.40299264","0.4026321","0.40145224","0.4013596","0.39978963","0.39936915","0.39921772","0.39913583","0.3989983","0.3989897","0.39818406","0.39798966","0.39784542","0.39783347","0.39776883","0.3976655","0.3970382","0.39694294","0.39684758","0.39667583","0.3963587","0.396199","0.3955469","0.3955469","0.39533573","0.39532417","0.39456585","0.3942752"],"string":"[\n \"0.49801686\",\n \"0.48075998\",\n \"0.4801738\",\n \"0.47585616\",\n \"0.47026438\",\n \"0.47009388\",\n \"0.46868795\",\n \"0.46559855\",\n \"0.46223104\",\n \"0.46175477\",\n \"0.45939246\",\n \"0.45530087\",\n \"0.4538339\",\n \"0.44475698\",\n \"0.4445085\",\n \"0.44408873\",\n \"0.44223046\",\n \"0.4421128\",\n \"0.44015473\",\n \"0.43992308\",\n \"0.43858254\",\n \"0.43743497\",\n \"0.43547687\",\n \"0.43521175\",\n \"0.43485126\",\n \"0.4343929\",\n \"0.4324946\",\n \"0.43201676\",\n \"0.42994517\",\n \"0.42957133\",\n \"0.429404\",\n \"0.42794025\",\n \"0.42695144\",\n \"0.4250417\",\n \"0.42374545\",\n \"0.4236891\",\n \"0.42290148\",\n \"0.4226183\",\n \"0.42203918\",\n \"0.42125306\",\n \"0.42111608\",\n \"0.4205805\",\n \"0.42016035\",\n \"0.41995135\",\n \"0.41980904\",\n \"0.4185058\",\n \"0.4177798\",\n \"0.41758126\",\n \"0.4174238\",\n \"0.41712672\",\n \"0.41700417\",\n \"0.41675496\",\n \"0.41393906\",\n \"0.41339377\",\n \"0.41227353\",\n \"0.4122716\",\n \"0.41096303\",\n \"0.41083655\",\n \"0.4104824\",\n \"0.4095738\",\n \"0.40883112\",\n \"0.40629834\",\n \"0.40523165\",\n \"0.4047642\",\n \"0.40468106\",\n \"0.40450025\",\n \"0.40442237\",\n \"0.40435818\",\n \"0.40345794\",\n \"0.4033547\",\n \"0.4031468\",\n \"0.4031468\",\n \"0.40299264\",\n \"0.4026321\",\n \"0.40145224\",\n \"0.4013596\",\n \"0.39978963\",\n \"0.39936915\",\n \"0.39921772\",\n \"0.39913583\",\n \"0.3989983\",\n \"0.3989897\",\n \"0.39818406\",\n \"0.39798966\",\n \"0.39784542\",\n \"0.39783347\",\n \"0.39776883\",\n \"0.3976655\",\n \"0.3970382\",\n \"0.39694294\",\n \"0.39684758\",\n \"0.39667583\",\n \"0.3963587\",\n \"0.396199\",\n \"0.3955469\",\n \"0.3955469\",\n \"0.39533573\",\n \"0.39532417\",\n \"0.39456585\",\n \"0.3942752\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.635531"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":22895,"cells":{"query":{"kind":"string","value":"Move in exactly one component."},"document":{"kind":"string","value":"def disjunctive(G, H):\n left_1 = {disjunctive(G_L, H) for G_L in G._left}\n left_2 = {disjunctive(G, H_L) for H_L in H._left}\n right_1 = {disjunctive(G_R, H) for G_R in G._right}\n right_2 = {disjunctive(G, H_R) for H_R in H._right}\n return Game(left_1 | left_2, right_1 | right_2)"},"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 move(self):\n pass","def move(self):\n raise NotImplementedError","def move_to_position1(self):","def move_to_position2(self):","def _move_in_one_more_block():\n with tik_inst.for_range(0, sub_h_align_block_size) as sub_h_idx:\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block * sub_h_idx],\n src[w_offset + w_size * sub_h_idx], 0, 1, sub_w_block, 0, 0)\n # in order to avoid dirty data when multiple core\n with tik_inst.for_range(0, data_cnt_one_block) as sub_h_idx_1:\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block *\n (sub_h_align_block_size + sub_h_idx_1)],\n src[w_offset +\n w_size * (sub_h_size - data_cnt_one_block + sub_h_idx_1)],\n 0, 1, sub_w_block, 0, 0)","def handleMove(self):\n pass","def moveNorth(self):\n north = (self.current[0], self.current[1] - 1)\n mv = self.lab.north()\n self.check_grue(mv)\n self.current = north\n self.visited.add(self.current)","def move(self) -> bool:\n pass","def _ispinnedmove(self, from_, to_):\n return False","def decide_next_move(self):\n pass","def move(x,y):\r\n pass","def move(self):\n vector = vectors[compass.index(self.heading)]\n x = self.position[0] + vector[0]\n y = self.position[1] + vector[1]\n self._check_move(x, self.plateau[0])\n self._check_move(y, self.plateau[1])\n return replace(self, position=(x, y))","def process_IN_MOVE_SELF(self, event):","def move_1_piece(context: GUI, old_coordinate, new_coordinate):\n\n old_tile = context.board.board_dict[old_coordinate]\n new_tile = context.board.board_dict[new_coordinate]\n\n new_tile.piece = old_tile.piece\n old_tile.piece = None\n\n context.update_move_printer(old_coordinate + \" \" + new_coordinate)","def automove(self):\n if self.x < self.end_cinematic_x_pos:\n self.x += self.SHIP_SPEED\n if self.x > self.end_cinematic_x_pos:\n self.x -= self.SHIP_SPEED\n if self.y < self.end_cinematic_y_pos:\n self.y += self.SHIP_SPEED\n if self.y > self.end_cinematic_y_pos:\n self.y -= self.SHIP_SPEED","def move(self) -> None:\n\n if self.move_up:\n self.__moveUpIfPossible()\n if self.move_down:\n self.__moveDownIfPossible()","def moveSpecialOb(self):\n\t\tfor obJ in self.special:\n\t\t\tobJ.moveStep()","def choose_move(self):\r\n \r\n return None","def move(self, direction, cycles):\n\t\tpass","def move(self):\n \n self.position = self.wander()","def move(self, move):\n raise NotImplementedError()","def _move_comp_person(self):\n\n move_tuple = random.choice(self._board.possible())\n self._board[move_tuple] = 'x'","def move_step(self, direction):\n x = self.objects[0].x\n y = self.objects[0].y\n if direction == 0 and y >= 1:\n self.objects[0].y -= 1\n elif direction == 1 and y <= self.size_y - 2:\n self.objects[0].y += 1\n elif direction == 2 and x >= 1:\n self.objects[0].x -= 1\n elif direction == 3 and x <= self.size_x - 2:\n self.objects[0].x += 1","def choose_move(self):\n raise NotImplementedError()","def _move_in_one_more_block():\n with tik_inst.for_range(0, sub_h_align_block_size) as sub_h_idx_0:\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block * sub_h_idx_0],\n src[in_offset + sub_h_idx_0 * w_size],\n 0, 1, sub_w_block, 0, 0)\n # move in one more block of h\n with tik_inst.for_range(0, data_cnt_one_block) as sub_h_idx_1:\n tik_inst.data_move(\n dst[sub_w_block * data_cnt_one_block * (sub_h_align_block_size + sub_h_idx_1)],\n src[in_offset + (sub_h_idx_1 + sub_h_size - data_cnt_one_block) * w_size],\n 0, 1, sub_w_block, 0, 0)","def move(self):\n \n self.position = self.explore()","def move(self, *args, **kw):\n return self.execute_action('move', *args, **kw)","def move(self, _vec):\n\n\t\t_dest = self._grid[0] + _vec[0], self._grid[1] + _vec[1], self._grid[2] + _vec[2]\n\t\tif _vec[2]: # jeśli ruszamy się w z to znaczy że wchodzimy po schodach\n\t\t\tself._map.getLayer('Fields').get(self._pos).getLogic().occupy(None)\n\t\t\tself._grid = _dest\n\t\t\tself._pos = 32 * self._grid[0] + 16, 32 * self._grid[1] + 16\n\t\t\tself._dest = None\n\t\t\treturn\n\n\t\tif self._dest: # nie ma pola docelowego = brak ruchu\n\t\t\treturn\n\n\t\t_field = self._map.getLayer('Fields').get((_dest[0] * 32 + 16, _dest[1] * 32 + 16))\n\t\tif not _field: # brak pola = brak ruchu\n\t\t\treturn\n\t\t\n\t\t_field = _field.getLogic()\n\t\tif _field.getModifier() & field.MODIFIER_BLOCKED or not _field.getOccupied() in (None, self): # pole zablokowane, bądź zajęte przez kogoś innego\n\t\t\treturn\n\n\t\t_field.occupy(self)\n\t\tself._dest = _dest","def move_forward():\n pass","def move(self, rel_pos):\n self.pos = (self.pos[0] + rel_pos[0] * GRID, self.pos[1] + rel_pos[1] * GRID)","def movement(self):","def unmakeMove(self, move):","def interaction_void(self) -> None:\n self.grid.obj_list.swap_obj(self.moving_character, self.target)","def moveBasedOnCurrentMomentum(self):\n self.xPos-=self.xMomentum\n self.yPos-=self.yMomentum\n self.syncSpriteCoordinates()","def move(self, direction):\n # replace with your code\n\n indices = self.direction_indices[direction]\n for coordinate in indices:\n merged_coordinate_list = self.get_list(direction, coordinate)\n self.change_board(merged_coordinate_list, coordinate, direction)\n print(self.__str__())\n if self.board_is_not_full():\n self.new_tile()","def move(self, t, s):\n raise NotImplementedError","def move(self, direction):\n pass","def firstMove(self):\n return (10, 10)","def move(self, x, y):\n if self.computer_first:\n self.app.config(cursor='watch')\n self.board = self.board.move(x, y)\n self.update()\n self.computer_first = 0\n self.app.config(cursor='')\n else:\n self.board = self.board.move(x, y)\n self.update()\n self.app.config(cursor='watch')\n move = self.board.best()\n if move:\n self.board = self.board.move(*move)\n self.update()\n self.app.config(cursor='')","def move(self):\n\n # get the location we WOULD go to\n newX = self.xcor() + self.dx\n newY = self.ycor() + self.dy\n while (abs (newX) > self.BOX_RANGE) or (abs(newY) > self.BOX_RANGE):\n # print(\"choosing new direction... \",end=\"\")\n self.chooseNewDirection()\n # print(self.dx, self.dy)\n newX = self.xcor() + self.dx\n newY = self.ycor() + self.dy\n\n # now move our monster\n super().move()","def move_rel(self):\n pass","def move(self, state):\n raise NotImplementedError(\"Need to implement this method\")","def _onmove(self, event):","def move(self, row, col, player):","def _move(self, d, event):\n\n actor = None\n if event.source in self._crates:\n actor = self._crates[event.source]\n else:\n actor = self._clones[event.source][0]\n\n if d == Direction.NO_ACT or not event.success:\n actor.animation = actor.do_nothing_animation()\n return\n pos = actor.pos\n target = pos.dir_pos(d)\n actor.direction = d\n actor.animation = actor.walk_animation()\n self.repaint()","def move(self, direction):\n # replace with your code\n pass","def move(self, direction):\n # replace with your code\n pass","def move_forward(self):\n self.x, self.y = self.compute_positions()","def step(self, move):","def move(self, board):\n raise NotImplementedError","def move_buildings(self):","def move_north(self):\r\n self.move(dx=0, dy=-1)","def move(self): # AH note. Swich move with extra_steps?\n if self.adjustment < 0:\n self.position += self.extra_steps\n super().move()\n self.no_moves += 1\n # Do the regular move","def move(self, x, y):\n\n #log.info(\"MOVE x:%s y:%s\", x, y)","def move(self):\n self.pos += self.direc\n self.nearest_node = self.pixel_to_node()","def move(self):\n c = self.get_position()\n\n f = c['f']\n if f == 'NORTH':\n c['y'] += 1\n elif f == 'EAST':\n c['x'] += 1\n elif f == 'SOUTH':\n c['y'] -= 1\n elif f == 'WEST':\n c['x'] -= 1\n\n if self.valid_position(c):\n self.update_position(c)\n else:\n raise ValueError('InvalidPosition')","def moveNorth(self):\n self._move('n', - Tile.VerticalDifference)","def move_piece(self, direction=None):\n if self.will_collide(direction=direction):\n return\n self.active_piece.move(direction=direction)\n self.display_piece()","def memmove(self, grid):\n self.moveList.append((self.x, self.y))\n self.moveList2.append((self.x, self.y))\n waysList = []\n for f in range(4):\n if self.test(grid, f):\n if (self.x+SPEED_X[f], self.y+SPEED_Y[f]) not in self.moveList:\n waysList.append(f)\n if len(waysList) == 1:\n self.flag = waysList[0]\n self.move(grid)\n return\n elif len(waysList) == 4:\n self.flag = 0\n self.move(grid)\n return\n elif len(waysList) > 1:\n for f in waysList:\n self.mem.append((self.x, self.y, f))\n self.x, self.y, self.flag = self.mem[-1]\n elif len(waysList) == 0:\n self.x, self.y, self.flag = self.mem[-1]\n for i in range(len(self.moveList2)):\n if self.moveList2[i][0] == self.x and self.moveList2[i][1] == self.y:\n del self.moveList2[i+1:]\n break\n self.move(grid)\n self.mem.pop()","def move(self, is_forward):\n wh, lh = self.get_heading\n self.w += wh\n self.l += lh\n if self.get_pos() == blocks['wall']:\n self.w -= wh\n self.l -= lh","def _move_item(self, src, dst):\n \"Does nothing\"","def move(self, x, y):\n self.x+=x\n self.y+=y","def onMoveLeft(self):\n self.mainGrid.moveLeft()","def moveStep(self):\n\t\tif self.pos[0] <= self.boundsX[0] or \\\n\t\t(self.pos[0]+ 2*(self.radius)) >= self.boundsX[1]:\n\t\t\tself.dir[0] *= -1\n\t\t\t\n\t\tself.pos[0] += self.dir[0]*self.speed\n\t\tself.pos[1] += self.dir[1]*self.speed","def choose_move(self):\n return 0","def _move(self, direction, difference):\n future_tile_number = self.get_number() + difference\n if future_tile_number in range(1, Tile.total_tiles + 1):\n future_tile = Tile.get_tile(future_tile_number)\n if future_tile.walkable:\n self.set_target(future_tile)\n self.rotate(direction)","def firstMove(board):\r\n x = board.size / 2\r\n return (x, x)","def moveStep(self):\n\t\tif self.pos[0] < self.boundsX[0] or \\\n\t\t\tself.pos[0] > (self.boundsX[1] - self.width):\n\t\t\t\tself.dir[0] *= -1\n\t\tif self.pos[1] < self.boundsY[0] or \\\n\t\t self.pos[1] > (self.boundsY[1] - self.height):\n\t\t\t\tself.dir[1] *= -1\n\t\t\t\n\t\tself.pos[0] += self.dir[0]*self.speed\n\t\tself.pos[1] += self.dir[1]*self.speed","def move(self, vel: float) -> None:\n self.first_x -= vel\n self.second_x -= vel\n\n if self.first_x <= -Base.Width:\n self.first_x = self.second_x + Base.Width\n if self.second_x <= -Base.Width:\n self.second_x = self.first_x + Base.Width","def moveTo(self, destination: Coordinates) -> None:\n if self.sprite is not None and self.sprite.rect is not None:\n current_position = self.sprite.rect.center\n if current_position != destination:\n x, y = vectorize(current_position, destination)\n self.sprite.rect.move_ip(x, y)","def moveBy(self, x, y):\n\t\tself.moveTo(self.x + x, self.y + y)","def no_more_move(self):\n if (self.p_no_move + self.c_no_move == 2):\n return True\n return False","def MoveCurrentSpace(self):\n if self.facing == 0:\n self.y -= 1\n elif self.facing == 1:\n self.x += 1\n elif self.facing == 2:\n self.y += 1\n elif self.facing == 3:\n self.x -= 1","def decide_move(self, action):\n x1, y1 = action['xy1']\n x2, y2 = action['xy2']\n self.__state.push(action)","def move(self):\n for index in range(len(self.segments)-1):\n segment = self.segments[index].instance\n x1, y1, x2, y2 = c.coords(self.segments[index+1].instance)\n c.coords(segment, x1, y1, x2, y2)\n\n x1, y1, x2, y2 = c.coords(self.segments[-2].instance)\n c.coords(self.segments[-1].instance,\n x1+self.vector[0]*SEG_SIZE, y1+self.vector[1]*SEG_SIZE,\n x2+self.vector[0]*SEG_SIZE, y2+self.vector[1]*SEG_SIZE)","def move(self):\n self.position[0] += self.velocity[0]\n self.position[1] += self.velocity[1]\n self.position[2] += self.velocity[2]\n return tuple(self.position)","def mouse_move(self, obj, event):\n last_pos = self.iren.GetLastEventPosition()\n next_pos = self.iren.GetEventPosition()\n last_disp_coords = np.asarray([last_pos[0], last_pos[1], 0])\n next_disp_coords = np.asarray([next_pos[0], next_pos[1], 0])\n last_world_coords = self.display_to_world(last_disp_coords)\n next_world_coords = self.display_to_world(next_disp_coords)\n world_direction = (last_world_coords - next_world_coords)[0]\n\n if world_direction > 0:\n direction = 'forwards'\n elif world_direction < 0:\n direction = 'backwards'\n else:\n direction = 'none'\n\n if self.cone_dir == 'start':\n if direction == 'backwards':\n self.start_base_x += .5\n if self.start_base_x.is_integer():\n ind = str(int(self.start_base_x))\n isvalid = self.gaps.set_dragged_start(ind)\n if isvalid:\n self.ren_win.Render()\n else:\n self.start_base_x -= .5\n return\n\n elif direction == 'forwards':\n if self.start_base_x > 0:\n self.start_base_x -= .5\n if self.start_base_x.is_integer():\n ind = str(int(self.start_base_x))\n self.gaps.set_dragged_start(ind)\n self.ren_win.Render()\n\n if self.cone_dir == 'end':\n if direction == 'backwards':\n if self.end_base_x > 0:\n self.end_base_x -= .5\n if self.end_base_x.is_integer():\n ind = str(int(self.end_base_x))\n self.gaps.set_dragged_end(ind)\n self.ren_win.Render()\n\n elif direction == 'forwards':\n self.end_base_x += .5\n if self.end_base_x.is_integer():\n ind = str(int(self.end_base_x))\n isvalid = self.gaps.set_dragged_end(ind)\n if isvalid:\n self.ren_win.Render()\n else:\n self.end_base_x -= .5\n return","def motion(self):\n priority = {\"north\": [-1, 0], \"south\": [1, 0],\n \"east\": [0, 1], \"west\": [0, -1]}\n\n priority_list = [\"north\", \"south\", \"east\", \"west\"]\n\n critical_point = False\n while critical_point is False:\n row = self.curr_cell.row\n column = self.curr_cell.col\n\n if self.allow_to_move(priority_list[0],\n row + priority[priority_list[0]][0],\n column + priority[priority_list[0]][1]):\n\n self.move(priority_list[0])\n\n elif self.allow_to_move(priority_list[1],\n row + priority[priority_list[1]][0],\n column + priority[priority_list[1]][1]):\n\n self.move(priority_list[1])\n\n elif self.allow_to_move(priority_list[2],\n row + priority[priority_list[2]][0],\n column + priority[priority_list[2]][1]):\n\n self.move(priority_list[2])\n\n elif self.allow_to_move(priority_list[3],\n row + priority[priority_list[3]][0],\n column + priority[priority_list[3]][1]):\n\n self.move(priority_list[3])\n\n else:\n # Robot isolated\n critical_point = True\n\n return self.curr_cell, self.path","def moveBy(self, x: int, y: int):\n raise NotImplementedError","def move_to_position(self, position):\n if position[0] == self.current[0]:\n y_distance = position[1] - self.current[1]\n if y_distance > 0:\n self.moveSouth()\n else:\n self.moveNorth()\n elif position[1] == self.current[1]:\n x_distance = position[0] - self.current[0]\n if x_distance > 0:\n self.moveEast()\n else:\n self.moveWest()","def move(self):\n self.old_tail = self.body[-1][:] # save old position of last block\n self.head[0] += self.direction[0] # moves head\n self.head[1] += self.direction[1]\n \n self.head[0] = (self.head[0] + self.xMaxSize) % self.xMaxSize\n self.head[1] = (self.head[1] + self.yMaxSize) % self.yMaxSize\n \n if self.head in self.body[1:]: # if snakes hits himself\n self.alive = False\n self.body.insert(0, self.body.pop()) # each block is replace by predecessor\n self.body[0] = self.head[:] # first block is head","def move(self) -> None:\n\n new_x = self.getX() + self.speed[0]\n new_y = self.getY() + self.speed[1]\n self.setX(new_x)\n self.setY(new_y)","def move(self, surface_size):\n for molecule in self.molecules:\n old_position = copy.copy(molecule.get_position()) # remember old position by shallow copy\n molecule.move()\n if molecule.handle_collide_with_borders(surface_size): # if it has a collision with border\n molecule.set_position(old_position) # restore old position\n collision_molecule = self.is_in_collision_with_other_molecule(molecule)\n if not collision_molecule is None: # if it has a collision with a molecule\n molecule.handle_collision_with_molecule(collision_molecule) # handle the collision\n molecule.set_position(old_position) # restore old position ","def AeroMove(self, pos):\r\n\r\n pass","def __move__(self):\n v = self.velocity\n p = self.position\n p += v\n self.rect.x = round(p.x)\n self.rect.y = round(p.y)","def move(self, *step):\n self.x += step[0]\n self.y += step[1]","def move(self, coordinates, direction):\n pass","def move(name, other, newname=None):","def move(self, heaps: Tuple[int, ...], misere: bool) -> Tuple[int, int]:\r\n pass","def test_object_move(self):\n self.assertTrue(self.obj1 in self.room1.contents)\n # use move_to hook\n self.obj1.move_to(self.room2)\n self.assertFalse(self.obj1 in self.room1.contents)\n self.assertTrue(self.obj1 in self.room2.contents)\n\n # move back via direct setting of .location\n self.obj1.location = self.room1\n self.assertTrue(self.obj1 in self.room1.contents)\n self.assertFalse(self.obj1 in self.room2.contents)","def OnMove(self, event):\r\n\r\n if isinstance(self._frame, AuiFloatingFrame) and self._frame.IsShownOnScreen():\r\n if event is not None:\r\n event.Skip()\r\n return\r\n\r\n docked, hAlign, vAlign, monitor = self._is_docked\r\n if docked:\r\n self.Snap()\r\n\r\n for pane in self._panes:\r\n if pane.IsSnappable():\r\n if pane.IsFloating() and pane.IsShown():\r\n self.SnapPane(pane, pane.floating_pos, pane.floating_size, True)","def movement(self):\n self.rect.left -= self.speedx #to move the asteroid to the left","def move(self, start, distance, p1):\n if (p1):\n #move your piece\n self.p1vec[start] -= 1\n dest = start + distance\n if (dest == 25):\n self.bornoff = True\n else:\n self.p1vec[start+distance] += 1\n #capture your opponent, despite their number\n spot = 25 - start - distance\n self.p2vec[0] += self.p2vec[spot]\n self.p2vec[spot] = 0\n else:\n #move your piece\n self.p2vec[start] -= 1\n dest = start + distance\n if (dest == 25):\n pass\n else:\n self.p2vec[start+distance] += 1\n #capture your opponent\n spot = 25 - start - distance\n self.p2vec[0] += self.p2vec[spot]\n self.p2vec[spot] = 0","def moving(self):\n self.animation()\n assert(self.rect.x % 32 == 0 or self.rect.y % 32 == 0), \\\n 'Not centered on tile'","def move_to(self, x, y):\r\n self.__current_room = x, y","def _move_actor(self, actor):\n\n actor.center_x = actor.center_x + actor.change_x\n actor.center_y = actor.center_y + actor.change_y","def move_me(self):\r\n\t\t#self.start_pos = self.rect.center\t\t\t\r\n\t\tif self.goal_pos is not None:\r\n\t\t\tprint(f'goal_pos: {self.goal_pos}, start_pos: {self.start_pos}')\r\n\t\t\tdx = self.goal_pos[0] - self.start_pos[0]\r\n\t\t\tdy = self.goal_pos[1] - self.start_pos[1]\r\n\r\n\t\t\tdistance = math.sqrt(dx*dx + dy*dy)\r\n\t\t\tself.shift += self.speed\r\n\r\n\t\ttry:\r\n\t\t\tif self.shift/distance < 0.99:\r\n\t\t\t\tself.rect.center = (self.start_pos[0] + self.shift/distance * dx,\r\n\t\t\t\t\t\t\t\t\t self.start_pos[1] + self.shift/distance * dy)\r\n\t\t\t\tprint(f'going to: {self.goal_pos}')\r\n\t\texcept ZeroDivisionError:\r\n\t\t\t\tpass\t\r\n\t\treturn True","def getFirstMove(self):\n while True:\n try:\n move = tuple(int(str.strip()) for str in raw_input('Choose your first move: ').split(','))\n break\n except ValueError:\n print(\"Input is not a integer.\")\n\n while move not in [(1, 1), (self.grid.width/2, self.grid.height/2), \\\n (self.grid.width/2+1, self.grid.height/2+1), (self.grid.width, self.grid.height)]:\n print 'First move is not valid.'\n move = tuple(int(str.strip()) for str in raw_input('Choose your first move: ').split(','))\n return move","def move(self):\r\n if self.last_op_move is None:\r\n return rockyman.move(self)\r\n else:\r\n return self.last_op_move","def move_to(self, mobject_or_point):\n layer_center = self.surrounding_rectangle.get_center()\n if isinstance(mobject_or_point, Mobject):\n target_center = mobject_or_point.get_center() \n else:\n target_center = mobject_or_point\n\n self.shift(target_center - layer_center)","def move(self):\r\n segments = len(self.all_turtles) - 1\r\n for i in range(len(self.all_turtles)):\r\n if segments == 0:\r\n self.all_turtles[segments].forward(MOVE_DISTANCE)\r\n else:\r\n new_x = self.all_turtles[segments - 1].xcor()\r\n new_y = self.all_turtles[segments - 1].ycor()\r\n self.all_turtles[segments].goto(new_x, new_y)\r\n segments -= 1"],"string":"[\n \"def move(self):\\n pass\",\n \"def move(self):\\n raise NotImplementedError\",\n \"def move_to_position1(self):\",\n \"def move_to_position2(self):\",\n \"def _move_in_one_more_block():\\n with tik_inst.for_range(0, sub_h_align_block_size) as sub_h_idx:\\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block * sub_h_idx],\\n src[w_offset + w_size * sub_h_idx], 0, 1, sub_w_block, 0, 0)\\n # in order to avoid dirty data when multiple core\\n with tik_inst.for_range(0, data_cnt_one_block) as sub_h_idx_1:\\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block *\\n (sub_h_align_block_size + sub_h_idx_1)],\\n src[w_offset +\\n w_size * (sub_h_size - data_cnt_one_block + sub_h_idx_1)],\\n 0, 1, sub_w_block, 0, 0)\",\n \"def handleMove(self):\\n pass\",\n \"def moveNorth(self):\\n north = (self.current[0], self.current[1] - 1)\\n mv = self.lab.north()\\n self.check_grue(mv)\\n self.current = north\\n self.visited.add(self.current)\",\n \"def move(self) -> bool:\\n pass\",\n \"def _ispinnedmove(self, from_, to_):\\n return False\",\n \"def decide_next_move(self):\\n pass\",\n \"def move(x,y):\\r\\n pass\",\n \"def move(self):\\n vector = vectors[compass.index(self.heading)]\\n x = self.position[0] + vector[0]\\n y = self.position[1] + vector[1]\\n self._check_move(x, self.plateau[0])\\n self._check_move(y, self.plateau[1])\\n return replace(self, position=(x, y))\",\n \"def process_IN_MOVE_SELF(self, event):\",\n \"def move_1_piece(context: GUI, old_coordinate, new_coordinate):\\n\\n old_tile = context.board.board_dict[old_coordinate]\\n new_tile = context.board.board_dict[new_coordinate]\\n\\n new_tile.piece = old_tile.piece\\n old_tile.piece = None\\n\\n context.update_move_printer(old_coordinate + \\\" \\\" + new_coordinate)\",\n \"def automove(self):\\n if self.x < self.end_cinematic_x_pos:\\n self.x += self.SHIP_SPEED\\n if self.x > self.end_cinematic_x_pos:\\n self.x -= self.SHIP_SPEED\\n if self.y < self.end_cinematic_y_pos:\\n self.y += self.SHIP_SPEED\\n if self.y > self.end_cinematic_y_pos:\\n self.y -= self.SHIP_SPEED\",\n \"def move(self) -> None:\\n\\n if self.move_up:\\n self.__moveUpIfPossible()\\n if self.move_down:\\n self.__moveDownIfPossible()\",\n \"def moveSpecialOb(self):\\n\\t\\tfor obJ in self.special:\\n\\t\\t\\tobJ.moveStep()\",\n \"def choose_move(self):\\r\\n \\r\\n return None\",\n \"def move(self, direction, cycles):\\n\\t\\tpass\",\n \"def move(self):\\n \\n self.position = self.wander()\",\n \"def move(self, move):\\n raise NotImplementedError()\",\n \"def _move_comp_person(self):\\n\\n move_tuple = random.choice(self._board.possible())\\n self._board[move_tuple] = 'x'\",\n \"def move_step(self, direction):\\n x = self.objects[0].x\\n y = self.objects[0].y\\n if direction == 0 and y >= 1:\\n self.objects[0].y -= 1\\n elif direction == 1 and y <= self.size_y - 2:\\n self.objects[0].y += 1\\n elif direction == 2 and x >= 1:\\n self.objects[0].x -= 1\\n elif direction == 3 and x <= self.size_x - 2:\\n self.objects[0].x += 1\",\n \"def choose_move(self):\\n raise NotImplementedError()\",\n \"def _move_in_one_more_block():\\n with tik_inst.for_range(0, sub_h_align_block_size) as sub_h_idx_0:\\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block * sub_h_idx_0],\\n src[in_offset + sub_h_idx_0 * w_size],\\n 0, 1, sub_w_block, 0, 0)\\n # move in one more block of h\\n with tik_inst.for_range(0, data_cnt_one_block) as sub_h_idx_1:\\n tik_inst.data_move(\\n dst[sub_w_block * data_cnt_one_block * (sub_h_align_block_size + sub_h_idx_1)],\\n src[in_offset + (sub_h_idx_1 + sub_h_size - data_cnt_one_block) * w_size],\\n 0, 1, sub_w_block, 0, 0)\",\n \"def move(self):\\n \\n self.position = self.explore()\",\n \"def move(self, *args, **kw):\\n return self.execute_action('move', *args, **kw)\",\n \"def move(self, _vec):\\n\\n\\t\\t_dest = self._grid[0] + _vec[0], self._grid[1] + _vec[1], self._grid[2] + _vec[2]\\n\\t\\tif _vec[2]: # jeśli ruszamy się w z to znaczy że wchodzimy po schodach\\n\\t\\t\\tself._map.getLayer('Fields').get(self._pos).getLogic().occupy(None)\\n\\t\\t\\tself._grid = _dest\\n\\t\\t\\tself._pos = 32 * self._grid[0] + 16, 32 * self._grid[1] + 16\\n\\t\\t\\tself._dest = None\\n\\t\\t\\treturn\\n\\n\\t\\tif self._dest: # nie ma pola docelowego = brak ruchu\\n\\t\\t\\treturn\\n\\n\\t\\t_field = self._map.getLayer('Fields').get((_dest[0] * 32 + 16, _dest[1] * 32 + 16))\\n\\t\\tif not _field: # brak pola = brak ruchu\\n\\t\\t\\treturn\\n\\t\\t\\n\\t\\t_field = _field.getLogic()\\n\\t\\tif _field.getModifier() & field.MODIFIER_BLOCKED or not _field.getOccupied() in (None, self): # pole zablokowane, bądź zajęte przez kogoś innego\\n\\t\\t\\treturn\\n\\n\\t\\t_field.occupy(self)\\n\\t\\tself._dest = _dest\",\n \"def move_forward():\\n pass\",\n \"def move(self, rel_pos):\\n self.pos = (self.pos[0] + rel_pos[0] * GRID, self.pos[1] + rel_pos[1] * GRID)\",\n \"def movement(self):\",\n \"def unmakeMove(self, move):\",\n \"def interaction_void(self) -> None:\\n self.grid.obj_list.swap_obj(self.moving_character, self.target)\",\n \"def moveBasedOnCurrentMomentum(self):\\n self.xPos-=self.xMomentum\\n self.yPos-=self.yMomentum\\n self.syncSpriteCoordinates()\",\n \"def move(self, direction):\\n # replace with your code\\n\\n indices = self.direction_indices[direction]\\n for coordinate in indices:\\n merged_coordinate_list = self.get_list(direction, coordinate)\\n self.change_board(merged_coordinate_list, coordinate, direction)\\n print(self.__str__())\\n if self.board_is_not_full():\\n self.new_tile()\",\n \"def move(self, t, s):\\n raise NotImplementedError\",\n \"def move(self, direction):\\n pass\",\n \"def firstMove(self):\\n return (10, 10)\",\n \"def move(self, x, y):\\n if self.computer_first:\\n self.app.config(cursor='watch')\\n self.board = self.board.move(x, y)\\n self.update()\\n self.computer_first = 0\\n self.app.config(cursor='')\\n else:\\n self.board = self.board.move(x, y)\\n self.update()\\n self.app.config(cursor='watch')\\n move = self.board.best()\\n if move:\\n self.board = self.board.move(*move)\\n self.update()\\n self.app.config(cursor='')\",\n \"def move(self):\\n\\n # get the location we WOULD go to\\n newX = self.xcor() + self.dx\\n newY = self.ycor() + self.dy\\n while (abs (newX) > self.BOX_RANGE) or (abs(newY) > self.BOX_RANGE):\\n # print(\\\"choosing new direction... \\\",end=\\\"\\\")\\n self.chooseNewDirection()\\n # print(self.dx, self.dy)\\n newX = self.xcor() + self.dx\\n newY = self.ycor() + self.dy\\n\\n # now move our monster\\n super().move()\",\n \"def move_rel(self):\\n pass\",\n \"def move(self, state):\\n raise NotImplementedError(\\\"Need to implement this method\\\")\",\n \"def _onmove(self, event):\",\n \"def move(self, row, col, player):\",\n \"def _move(self, d, event):\\n\\n actor = None\\n if event.source in self._crates:\\n actor = self._crates[event.source]\\n else:\\n actor = self._clones[event.source][0]\\n\\n if d == Direction.NO_ACT or not event.success:\\n actor.animation = actor.do_nothing_animation()\\n return\\n pos = actor.pos\\n target = pos.dir_pos(d)\\n actor.direction = d\\n actor.animation = actor.walk_animation()\\n self.repaint()\",\n \"def move(self, direction):\\n # replace with your code\\n pass\",\n \"def move(self, direction):\\n # replace with your code\\n pass\",\n \"def move_forward(self):\\n self.x, self.y = self.compute_positions()\",\n \"def step(self, move):\",\n \"def move(self, board):\\n raise NotImplementedError\",\n \"def move_buildings(self):\",\n \"def move_north(self):\\r\\n self.move(dx=0, dy=-1)\",\n \"def move(self): # AH note. Swich move with extra_steps?\\n if self.adjustment < 0:\\n self.position += self.extra_steps\\n super().move()\\n self.no_moves += 1\\n # Do the regular move\",\n \"def move(self, x, y):\\n\\n #log.info(\\\"MOVE x:%s y:%s\\\", x, y)\",\n \"def move(self):\\n self.pos += self.direc\\n self.nearest_node = self.pixel_to_node()\",\n \"def move(self):\\n c = self.get_position()\\n\\n f = c['f']\\n if f == 'NORTH':\\n c['y'] += 1\\n elif f == 'EAST':\\n c['x'] += 1\\n elif f == 'SOUTH':\\n c['y'] -= 1\\n elif f == 'WEST':\\n c['x'] -= 1\\n\\n if self.valid_position(c):\\n self.update_position(c)\\n else:\\n raise ValueError('InvalidPosition')\",\n \"def moveNorth(self):\\n self._move('n', - Tile.VerticalDifference)\",\n \"def move_piece(self, direction=None):\\n if self.will_collide(direction=direction):\\n return\\n self.active_piece.move(direction=direction)\\n self.display_piece()\",\n \"def memmove(self, grid):\\n self.moveList.append((self.x, self.y))\\n self.moveList2.append((self.x, self.y))\\n waysList = []\\n for f in range(4):\\n if self.test(grid, f):\\n if (self.x+SPEED_X[f], self.y+SPEED_Y[f]) not in self.moveList:\\n waysList.append(f)\\n if len(waysList) == 1:\\n self.flag = waysList[0]\\n self.move(grid)\\n return\\n elif len(waysList) == 4:\\n self.flag = 0\\n self.move(grid)\\n return\\n elif len(waysList) > 1:\\n for f in waysList:\\n self.mem.append((self.x, self.y, f))\\n self.x, self.y, self.flag = self.mem[-1]\\n elif len(waysList) == 0:\\n self.x, self.y, self.flag = self.mem[-1]\\n for i in range(len(self.moveList2)):\\n if self.moveList2[i][0] == self.x and self.moveList2[i][1] == self.y:\\n del self.moveList2[i+1:]\\n break\\n self.move(grid)\\n self.mem.pop()\",\n \"def move(self, is_forward):\\n wh, lh = self.get_heading\\n self.w += wh\\n self.l += lh\\n if self.get_pos() == blocks['wall']:\\n self.w -= wh\\n self.l -= lh\",\n \"def _move_item(self, src, dst):\\n \\\"Does nothing\\\"\",\n \"def move(self, x, y):\\n self.x+=x\\n self.y+=y\",\n \"def onMoveLeft(self):\\n self.mainGrid.moveLeft()\",\n \"def moveStep(self):\\n\\t\\tif self.pos[0] <= self.boundsX[0] or \\\\\\n\\t\\t(self.pos[0]+ 2*(self.radius)) >= self.boundsX[1]:\\n\\t\\t\\tself.dir[0] *= -1\\n\\t\\t\\t\\n\\t\\tself.pos[0] += self.dir[0]*self.speed\\n\\t\\tself.pos[1] += self.dir[1]*self.speed\",\n \"def choose_move(self):\\n return 0\",\n \"def _move(self, direction, difference):\\n future_tile_number = self.get_number() + difference\\n if future_tile_number in range(1, Tile.total_tiles + 1):\\n future_tile = Tile.get_tile(future_tile_number)\\n if future_tile.walkable:\\n self.set_target(future_tile)\\n self.rotate(direction)\",\n \"def firstMove(board):\\r\\n x = board.size / 2\\r\\n return (x, x)\",\n \"def moveStep(self):\\n\\t\\tif self.pos[0] < self.boundsX[0] or \\\\\\n\\t\\t\\tself.pos[0] > (self.boundsX[1] - self.width):\\n\\t\\t\\t\\tself.dir[0] *= -1\\n\\t\\tif self.pos[1] < self.boundsY[0] or \\\\\\n\\t\\t self.pos[1] > (self.boundsY[1] - self.height):\\n\\t\\t\\t\\tself.dir[1] *= -1\\n\\t\\t\\t\\n\\t\\tself.pos[0] += self.dir[0]*self.speed\\n\\t\\tself.pos[1] += self.dir[1]*self.speed\",\n \"def move(self, vel: float) -> None:\\n self.first_x -= vel\\n self.second_x -= vel\\n\\n if self.first_x <= -Base.Width:\\n self.first_x = self.second_x + Base.Width\\n if self.second_x <= -Base.Width:\\n self.second_x = self.first_x + Base.Width\",\n \"def moveTo(self, destination: Coordinates) -> None:\\n if self.sprite is not None and self.sprite.rect is not None:\\n current_position = self.sprite.rect.center\\n if current_position != destination:\\n x, y = vectorize(current_position, destination)\\n self.sprite.rect.move_ip(x, y)\",\n \"def moveBy(self, x, y):\\n\\t\\tself.moveTo(self.x + x, self.y + y)\",\n \"def no_more_move(self):\\n if (self.p_no_move + self.c_no_move == 2):\\n return True\\n return False\",\n \"def MoveCurrentSpace(self):\\n if self.facing == 0:\\n self.y -= 1\\n elif self.facing == 1:\\n self.x += 1\\n elif self.facing == 2:\\n self.y += 1\\n elif self.facing == 3:\\n self.x -= 1\",\n \"def decide_move(self, action):\\n x1, y1 = action['xy1']\\n x2, y2 = action['xy2']\\n self.__state.push(action)\",\n \"def move(self):\\n for index in range(len(self.segments)-1):\\n segment = self.segments[index].instance\\n x1, y1, x2, y2 = c.coords(self.segments[index+1].instance)\\n c.coords(segment, x1, y1, x2, y2)\\n\\n x1, y1, x2, y2 = c.coords(self.segments[-2].instance)\\n c.coords(self.segments[-1].instance,\\n x1+self.vector[0]*SEG_SIZE, y1+self.vector[1]*SEG_SIZE,\\n x2+self.vector[0]*SEG_SIZE, y2+self.vector[1]*SEG_SIZE)\",\n \"def move(self):\\n self.position[0] += self.velocity[0]\\n self.position[1] += self.velocity[1]\\n self.position[2] += self.velocity[2]\\n return tuple(self.position)\",\n \"def mouse_move(self, obj, event):\\n last_pos = self.iren.GetLastEventPosition()\\n next_pos = self.iren.GetEventPosition()\\n last_disp_coords = np.asarray([last_pos[0], last_pos[1], 0])\\n next_disp_coords = np.asarray([next_pos[0], next_pos[1], 0])\\n last_world_coords = self.display_to_world(last_disp_coords)\\n next_world_coords = self.display_to_world(next_disp_coords)\\n world_direction = (last_world_coords - next_world_coords)[0]\\n\\n if world_direction > 0:\\n direction = 'forwards'\\n elif world_direction < 0:\\n direction = 'backwards'\\n else:\\n direction = 'none'\\n\\n if self.cone_dir == 'start':\\n if direction == 'backwards':\\n self.start_base_x += .5\\n if self.start_base_x.is_integer():\\n ind = str(int(self.start_base_x))\\n isvalid = self.gaps.set_dragged_start(ind)\\n if isvalid:\\n self.ren_win.Render()\\n else:\\n self.start_base_x -= .5\\n return\\n\\n elif direction == 'forwards':\\n if self.start_base_x > 0:\\n self.start_base_x -= .5\\n if self.start_base_x.is_integer():\\n ind = str(int(self.start_base_x))\\n self.gaps.set_dragged_start(ind)\\n self.ren_win.Render()\\n\\n if self.cone_dir == 'end':\\n if direction == 'backwards':\\n if self.end_base_x > 0:\\n self.end_base_x -= .5\\n if self.end_base_x.is_integer():\\n ind = str(int(self.end_base_x))\\n self.gaps.set_dragged_end(ind)\\n self.ren_win.Render()\\n\\n elif direction == 'forwards':\\n self.end_base_x += .5\\n if self.end_base_x.is_integer():\\n ind = str(int(self.end_base_x))\\n isvalid = self.gaps.set_dragged_end(ind)\\n if isvalid:\\n self.ren_win.Render()\\n else:\\n self.end_base_x -= .5\\n return\",\n \"def motion(self):\\n priority = {\\\"north\\\": [-1, 0], \\\"south\\\": [1, 0],\\n \\\"east\\\": [0, 1], \\\"west\\\": [0, -1]}\\n\\n priority_list = [\\\"north\\\", \\\"south\\\", \\\"east\\\", \\\"west\\\"]\\n\\n critical_point = False\\n while critical_point is False:\\n row = self.curr_cell.row\\n column = self.curr_cell.col\\n\\n if self.allow_to_move(priority_list[0],\\n row + priority[priority_list[0]][0],\\n column + priority[priority_list[0]][1]):\\n\\n self.move(priority_list[0])\\n\\n elif self.allow_to_move(priority_list[1],\\n row + priority[priority_list[1]][0],\\n column + priority[priority_list[1]][1]):\\n\\n self.move(priority_list[1])\\n\\n elif self.allow_to_move(priority_list[2],\\n row + priority[priority_list[2]][0],\\n column + priority[priority_list[2]][1]):\\n\\n self.move(priority_list[2])\\n\\n elif self.allow_to_move(priority_list[3],\\n row + priority[priority_list[3]][0],\\n column + priority[priority_list[3]][1]):\\n\\n self.move(priority_list[3])\\n\\n else:\\n # Robot isolated\\n critical_point = True\\n\\n return self.curr_cell, self.path\",\n \"def moveBy(self, x: int, y: int):\\n raise NotImplementedError\",\n \"def move_to_position(self, position):\\n if position[0] == self.current[0]:\\n y_distance = position[1] - self.current[1]\\n if y_distance > 0:\\n self.moveSouth()\\n else:\\n self.moveNorth()\\n elif position[1] == self.current[1]:\\n x_distance = position[0] - self.current[0]\\n if x_distance > 0:\\n self.moveEast()\\n else:\\n self.moveWest()\",\n \"def move(self):\\n self.old_tail = self.body[-1][:] # save old position of last block\\n self.head[0] += self.direction[0] # moves head\\n self.head[1] += self.direction[1]\\n \\n self.head[0] = (self.head[0] + self.xMaxSize) % self.xMaxSize\\n self.head[1] = (self.head[1] + self.yMaxSize) % self.yMaxSize\\n \\n if self.head in self.body[1:]: # if snakes hits himself\\n self.alive = False\\n self.body.insert(0, self.body.pop()) # each block is replace by predecessor\\n self.body[0] = self.head[:] # first block is head\",\n \"def move(self) -> None:\\n\\n new_x = self.getX() + self.speed[0]\\n new_y = self.getY() + self.speed[1]\\n self.setX(new_x)\\n self.setY(new_y)\",\n \"def move(self, surface_size):\\n for molecule in self.molecules:\\n old_position = copy.copy(molecule.get_position()) # remember old position by shallow copy\\n molecule.move()\\n if molecule.handle_collide_with_borders(surface_size): # if it has a collision with border\\n molecule.set_position(old_position) # restore old position\\n collision_molecule = self.is_in_collision_with_other_molecule(molecule)\\n if not collision_molecule is None: # if it has a collision with a molecule\\n molecule.handle_collision_with_molecule(collision_molecule) # handle the collision\\n molecule.set_position(old_position) # restore old position \",\n \"def AeroMove(self, pos):\\r\\n\\r\\n pass\",\n \"def __move__(self):\\n v = self.velocity\\n p = self.position\\n p += v\\n self.rect.x = round(p.x)\\n self.rect.y = round(p.y)\",\n \"def move(self, *step):\\n self.x += step[0]\\n self.y += step[1]\",\n \"def move(self, coordinates, direction):\\n pass\",\n \"def move(name, other, newname=None):\",\n \"def move(self, heaps: Tuple[int, ...], misere: bool) -> Tuple[int, int]:\\r\\n pass\",\n \"def test_object_move(self):\\n self.assertTrue(self.obj1 in self.room1.contents)\\n # use move_to hook\\n self.obj1.move_to(self.room2)\\n self.assertFalse(self.obj1 in self.room1.contents)\\n self.assertTrue(self.obj1 in self.room2.contents)\\n\\n # move back via direct setting of .location\\n self.obj1.location = self.room1\\n self.assertTrue(self.obj1 in self.room1.contents)\\n self.assertFalse(self.obj1 in self.room2.contents)\",\n \"def OnMove(self, event):\\r\\n\\r\\n if isinstance(self._frame, AuiFloatingFrame) and self._frame.IsShownOnScreen():\\r\\n if event is not None:\\r\\n event.Skip()\\r\\n return\\r\\n\\r\\n docked, hAlign, vAlign, monitor = self._is_docked\\r\\n if docked:\\r\\n self.Snap()\\r\\n\\r\\n for pane in self._panes:\\r\\n if pane.IsSnappable():\\r\\n if pane.IsFloating() and pane.IsShown():\\r\\n self.SnapPane(pane, pane.floating_pos, pane.floating_size, True)\",\n \"def movement(self):\\n self.rect.left -= self.speedx #to move the asteroid to the left\",\n \"def move(self, start, distance, p1):\\n if (p1):\\n #move your piece\\n self.p1vec[start] -= 1\\n dest = start + distance\\n if (dest == 25):\\n self.bornoff = True\\n else:\\n self.p1vec[start+distance] += 1\\n #capture your opponent, despite their number\\n spot = 25 - start - distance\\n self.p2vec[0] += self.p2vec[spot]\\n self.p2vec[spot] = 0\\n else:\\n #move your piece\\n self.p2vec[start] -= 1\\n dest = start + distance\\n if (dest == 25):\\n pass\\n else:\\n self.p2vec[start+distance] += 1\\n #capture your opponent\\n spot = 25 - start - distance\\n self.p2vec[0] += self.p2vec[spot]\\n self.p2vec[spot] = 0\",\n \"def moving(self):\\n self.animation()\\n assert(self.rect.x % 32 == 0 or self.rect.y % 32 == 0), \\\\\\n 'Not centered on tile'\",\n \"def move_to(self, x, y):\\r\\n self.__current_room = x, y\",\n \"def _move_actor(self, actor):\\n\\n actor.center_x = actor.center_x + actor.change_x\\n actor.center_y = actor.center_y + actor.change_y\",\n \"def move_me(self):\\r\\n\\t\\t#self.start_pos = self.rect.center\\t\\t\\t\\r\\n\\t\\tif self.goal_pos is not None:\\r\\n\\t\\t\\tprint(f'goal_pos: {self.goal_pos}, start_pos: {self.start_pos}')\\r\\n\\t\\t\\tdx = self.goal_pos[0] - self.start_pos[0]\\r\\n\\t\\t\\tdy = self.goal_pos[1] - self.start_pos[1]\\r\\n\\r\\n\\t\\t\\tdistance = math.sqrt(dx*dx + dy*dy)\\r\\n\\t\\t\\tself.shift += self.speed\\r\\n\\r\\n\\t\\ttry:\\r\\n\\t\\t\\tif self.shift/distance < 0.99:\\r\\n\\t\\t\\t\\tself.rect.center = (self.start_pos[0] + self.shift/distance * dx,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t self.start_pos[1] + self.shift/distance * dy)\\r\\n\\t\\t\\t\\tprint(f'going to: {self.goal_pos}')\\r\\n\\t\\texcept ZeroDivisionError:\\r\\n\\t\\t\\t\\tpass\\t\\r\\n\\t\\treturn True\",\n \"def getFirstMove(self):\\n while True:\\n try:\\n move = tuple(int(str.strip()) for str in raw_input('Choose your first move: ').split(','))\\n break\\n except ValueError:\\n print(\\\"Input is not a integer.\\\")\\n\\n while move not in [(1, 1), (self.grid.width/2, self.grid.height/2), \\\\\\n (self.grid.width/2+1, self.grid.height/2+1), (self.grid.width, self.grid.height)]:\\n print 'First move is not valid.'\\n move = tuple(int(str.strip()) for str in raw_input('Choose your first move: ').split(','))\\n return move\",\n \"def move(self):\\r\\n if self.last_op_move is None:\\r\\n return rockyman.move(self)\\r\\n else:\\r\\n return self.last_op_move\",\n \"def move_to(self, mobject_or_point):\\n layer_center = self.surrounding_rectangle.get_center()\\n if isinstance(mobject_or_point, Mobject):\\n target_center = mobject_or_point.get_center() \\n else:\\n target_center = mobject_or_point\\n\\n self.shift(target_center - layer_center)\",\n \"def move(self):\\r\\n segments = len(self.all_turtles) - 1\\r\\n for i in range(len(self.all_turtles)):\\r\\n if segments == 0:\\r\\n self.all_turtles[segments].forward(MOVE_DISTANCE)\\r\\n else:\\r\\n new_x = self.all_turtles[segments - 1].xcor()\\r\\n new_y = self.all_turtles[segments - 1].ycor()\\r\\n self.all_turtles[segments].goto(new_x, new_y)\\r\\n segments -= 1\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6899064","0.66450226","0.6615794","0.63474816","0.62919295","0.6285745","0.62708914","0.6266035","0.6195555","0.61668605","0.61501706","0.6106435","0.60828984","0.6042071","0.6039131","0.60356104","0.6013029","0.60085666","0.59947014","0.5982884","0.5975589","0.5957934","0.59388226","0.59350264","0.5934304","0.5930576","0.5923789","0.5895271","0.58909965","0.58813846","0.5876687","0.5839931","0.583478","0.58316725","0.58249176","0.5814157","0.5811397","0.58094925","0.58077884","0.58037865","0.57945323","0.5790675","0.5786969","0.5785364","0.5782831","0.5782705","0.5782705","0.57719404","0.57718694","0.5753545","0.5745759","0.5744787","0.57436186","0.57370067","0.5725035","0.5724621","0.5722144","0.57217413","0.5718608","0.5713683","0.5709272","0.5700596","0.56951433","0.5691957","0.568809","0.5686237","0.5683333","0.56783825","0.5676193","0.5665958","0.56652474","0.5665165","0.5653584","0.5649946","0.56475556","0.56414014","0.563401","0.5633184","0.56268364","0.5624859","0.56199545","0.5609008","0.5607887","0.56078047","0.5596905","0.5588922","0.558277","0.55798626","0.557885","0.55781","0.5574196","0.55726916","0.5570012","0.55691546","0.5568356","0.55681735","0.556781","0.5565468","0.555871","0.5555863","0.5554121"],"string":"[\n \"0.6899064\",\n \"0.66450226\",\n \"0.6615794\",\n \"0.63474816\",\n \"0.62919295\",\n \"0.6285745\",\n \"0.62708914\",\n \"0.6266035\",\n \"0.6195555\",\n \"0.61668605\",\n \"0.61501706\",\n \"0.6106435\",\n \"0.60828984\",\n \"0.6042071\",\n \"0.6039131\",\n \"0.60356104\",\n \"0.6013029\",\n \"0.60085666\",\n \"0.59947014\",\n \"0.5982884\",\n \"0.5975589\",\n \"0.5957934\",\n \"0.59388226\",\n \"0.59350264\",\n \"0.5934304\",\n \"0.5930576\",\n \"0.5923789\",\n \"0.5895271\",\n \"0.58909965\",\n \"0.58813846\",\n \"0.5876687\",\n \"0.5839931\",\n \"0.583478\",\n \"0.58316725\",\n \"0.58249176\",\n \"0.5814157\",\n \"0.5811397\",\n \"0.58094925\",\n \"0.58077884\",\n \"0.58037865\",\n \"0.57945323\",\n \"0.5790675\",\n \"0.5786969\",\n \"0.5785364\",\n \"0.5782831\",\n \"0.5782705\",\n \"0.5782705\",\n \"0.57719404\",\n \"0.57718694\",\n \"0.5753545\",\n \"0.5745759\",\n \"0.5744787\",\n \"0.57436186\",\n \"0.57370067\",\n \"0.5725035\",\n \"0.5724621\",\n \"0.5722144\",\n \"0.57217413\",\n \"0.5718608\",\n \"0.5713683\",\n \"0.5709272\",\n \"0.5700596\",\n \"0.56951433\",\n \"0.5691957\",\n \"0.568809\",\n \"0.5686237\",\n \"0.5683333\",\n \"0.56783825\",\n \"0.5676193\",\n \"0.5665958\",\n \"0.56652474\",\n \"0.5665165\",\n \"0.5653584\",\n \"0.5649946\",\n \"0.56475556\",\n \"0.56414014\",\n \"0.563401\",\n \"0.5633184\",\n \"0.56268364\",\n \"0.5624859\",\n \"0.56199545\",\n \"0.5609008\",\n \"0.5607887\",\n \"0.56078047\",\n \"0.5596905\",\n \"0.5588922\",\n \"0.558277\",\n \"0.55798626\",\n \"0.557885\",\n \"0.55781\",\n \"0.5574196\",\n \"0.55726916\",\n \"0.5570012\",\n \"0.55691546\",\n \"0.5568356\",\n \"0.55681735\",\n \"0.556781\",\n \"0.5565468\",\n \"0.555871\",\n \"0.5555863\",\n \"0.5554121\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":22896,"cells":{"query":{"kind":"string","value":"Move in all components. Play ends when any one of them terminates."},"document":{"kind":"string","value":"def conjunctive(G, H):\n left = {conjunctive(G_L, H_L) for G_L in G._left for H_L in H._left}\n right = {conjunctive(G_R, H_R) for G_R in G._right for H_R in H._right}\n return Game(left, right)"},"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 move(self):\n pass","def handleMove(self):\n pass","def run(self):\n while not self.turn_over:\n self.go()","def run(self):\n for _ in range(self.num_iteration):\n self.move()\n time.sleep(self.speed)\n if not self.is_running:\n break","def move(self, direction, cycles):\n\t\tpass","def run_logic(self):\n if not self.game_over:\n # Move all the sprites\n self.all_sprites_list.update()","def play_simulation(self):\n self._play(self._move_comp_person)","def move(self):\r\n segments = len(self.all_turtles) - 1\r\n for i in range(len(self.all_turtles)):\r\n if segments == 0:\r\n self.all_turtles[segments].forward(MOVE_DISTANCE)\r\n else:\r\n new_x = self.all_turtles[segments - 1].xcor()\r\n new_y = self.all_turtles[segments - 1].ycor()\r\n self.all_turtles[segments].goto(new_x, new_y)\r\n segments -= 1","def move(self):\n raise NotImplementedError","def move(self):\n self.tick()\n self.pressed = pygame.key.get_pressed()\n\n \"\"\"Do deleting platforms/do losing\"\"\"\n self.player.update(self)\n self.main_platform.update(self)\n\n for i in self.platformsx:\n self.platformsx[i].update(self)\n \n for i in self.platforms:\n self.platforms[i].update(self)\n\n for i in self.to_remove:\n self.platforms.pop(i)\n self.to_remove.clear()\n\n for i in self.platformsx:\n self.platformsx[i].update(self)","def startMovementAll(self):\n self.startMovementX()\n self.startMovementY()\n self.startMovementZ()","def main():\n move()\n move()\n pick_beeper()\n move()\n turn_left()\n for i in range(2):\n move()\n put_beeper()\n turn_around()\n move_to_wall()\n turn_right()\n move_to_wall()\n turn_around()","def move(self) -> None:\n\n if self.move_up:\n self.__moveUpIfPossible()\n if self.move_down:\n self.__moveDownIfPossible()","def play_one_move(self):\n self.print(\"top of move\")\n # 1) grab three cups\n c1 = self.take_cup_after(self.current_cup_idx())\n c2 = self.take_cup_after(self.current_cup_idx())\n c3 = self.take_cup_after(self.current_cup_idx())\n print(f\"pick up: {c1}, {c2}, {c3}\")\n self.print(\"after pickup\")\n\n # 2) find a destination cup\n destination_idx = self.find_next_destination(self.current_cup)\n print(\n f\"destination index is {destination_idx}, cup is {self.cups[destination_idx]}\"\n )\n\n # 3) insert cups back into the circle\n self.add_cups(destination_idx, [c1, c2, c3])\n self.print(\"after adding cups..\")\n\n # 4) select the next cup\n self.select_next_cup()\n\n self.print(\"post move\")","def moveCirc(self):\n\t\tfor circle in self.circles:\n\t\t\tcircle.moveStep()","def move(self):\n # moving each of the obstacles\n time = rospy.get_rostime()\n self.vel_msg1.linear.x = math.sin(time.to_sec())\n self.pub1.publish(self.vel_msg1)\n self.vel_msg2.linear.x = math.cos(1.2 * time.to_sec())\n self.pub2.publish(self.vel_msg2)\n self.vel_msg3.linear.x = math.cos(2 * time.to_sec())\n self.pub3.publish(self.vel_msg3)\n self.vel_msg4.linear.x = math.sin(0.85 * time.to_sec())\n self.pub4.publish(self.vel_msg4)","def move(self):\n # This block is used to move into the living room.\n if self.room_name == \"living\" or self.room_name == \"Living\":\n self.living_room()\n # This block is used to open the door.\n elif self.room_name == \"Door\" or self.room_name == \"door\":\n self.door()\n # This block is used to move into the kitchen.\n elif self.room_name == \"Kitchen\" or self.room_name == \"kitchen\":\n self.kitchen()\n # This block is used to move into the hallway.\n elif self.room_name == \"Hallway\" or self.room_name == \"hallway\":\n self.hallway()\n # This block is used to move into the bathroom.\n elif self.room_name == \"Bathroom\" or self.room_name == \"bathroom\":\n self.bathroom()\n # This block is used to move into the basement.\n elif self.room_name == \"Basement\" or self.room_name == \"basement\":\n self.basement()\n # This block is used to move into the bedroom.\n elif self.room_name == \"Bedroom\" or self.room_name == \"bedroom\":\n self.bedroom()\n # This block is used to move into the attic.\n elif self.room_name == \"Attic\" or \"attic\":\n self.attic()","def stopMovementAll(self):\n self.stopMovementX()\n self.stopMovementY()\n self.stopMovementZ()","def step(self, move):","def play(self):\n\n while self.board.board[self.board.target_location()[0]]\\\n [self.board.target_location()[1]] == \"E\": # the car didn't\n # arrive the exit\n self.__single_turn()\n print(\"you won!\")","def __move_ball(self):\n while not self.__game_is_over():\n self.__ball.move(self.__dx, self.__dy)\n self.__handle_wall_collision()\n if self.__num_lives == 0:\n self.__game_over_picture()\n break\n elif self.__bricks_total == 0:\n self.__game_over_picture('You Win!!')\n break\n pause(FRAME_RATE)","def moveSpecialOb(self):\n\t\tfor obJ in self.special:\n\t\t\tobJ.moveStep()","def move(self) -> bool:\n pass","async def move_channel_loop(self):\n try:\n while self.state == CHANNEL_MOVE_STATE_NONE:\n message = await self.poll_message()\n if message is None:\n break\n \n try:\n await self.move_message(message)\n except DiscordException as err:\n if err.code == ERROR_CODES.unknown_webhook:\n self.set_status_update_waiter_webhook_deleted()\n return\n \n raise\n \n self.last_message_id = message.id\n self.total_moved_messages += 1\n \n except GeneratorExit:\n raise\n \n except CancelledError:\n raise\n \n except BaseException as err:\n self.set_status_update_waiter_error()\n await self.client.events.error(self.client, repr(self), err)\n return\n \n finally:\n self.discard()\n \n self.set_status_update_waiter_finished()","def move_cycle(self, actions, players):\n\n for i in range(len(players)):\n player = players[i]\n action = actions[i]\n player.move(action)\n for other in players:\n if Circle.collide(player, other) and player != other:\n player.revert_move()\n if Circle.collide(player, self.ball):\n self.possession = player.team\n self.ball.move(player)\n\n self.ball.move()\n scored = self.__ball_scored()\n if scored:\n self.ball.replace()\n if scored == TEAM_RED:\n self.score[1] += 1\n return (1, TEAM_RED)\n else:\n self.score[0] += 1\n return (1, TEAM_BLUE)\n elif self.__ball_out_bounds():\n if self.possession == TEAM_BLUE:\n self.ball.restart(Point(WIDTH / 4, HEIGHT / 2))\n else:\n self.ball.restart(Point(WIDTH * 3/4, HEIGHT / 2))\n return (2, self.possession)\n else:\n return (0, None)","def stop(self):\n self.move(None)","def play(self):\n self._play(self._move_person)","def interaction_void(self) -> None:\n self.grid.obj_list.swap_obj(self.moving_character, self.target)","def play_step(self, action):\n self.players[0].moving_left = False\n self.players[0].moving_right = False\n if action == MOVE_LEFT:\n self.players[0].moving_left = True\n for i in range(LOOP_AT_EACH_MOVE_UPDATE):\n self.update(is_a_star=True)\n if self.dead_player or not self.players[0].is_alive:\n break\n self.players[0].moving_left = False\n if self.dead_player or not self.players[0].is_alive:\n return\n elif action == MOVE_RIGHT:\n self.players[0].moving_right = True\n for i in range(LOOP_AT_EACH_MOVE_UPDATE):\n self.update(is_a_star=True)\n if self.dead_player or not self.players[0].is_alive:\n break\n self.players[0].moving_right = False\n if self.dead_player or not self.players[0].is_alive:\n return\n elif action == SHOOT:\n if self.dead_player or not self.players[0].is_alive:\n self.update(is_a_star=True)\n return\n if not self.players[0].weapon.is_active:\n self.players[0].shoot()\n for i in range(LOOP_AT_EACH_MOVE_UPDATE):\n self.update(is_a_star=True)\n if self.dead_player or not self.players[0].is_alive:\n break\n if self.dead_player or not self.players[0].is_alive:\n return","def run(self):\n self.spawn()\n while self.is_alive:\n self.move()\n time.sleep(.2)","def bqm_move_queue(self):\n self.bqm.turn_once()","def _move_forward(self):\n\t\tself.x,self.y = Mario._get_coordinates(Board.prev_i,Board.prev_j,Board.prev_k)\n\t\tif(self.y<=798):\n\t\t\tself.y = self.y+1\n\t\t\tif Board.board[self.x][self.y]=='0':\n\t\t\t\tMario.score += 1\n\t\t\t\tMario._pass(self.x,self.y-1)\n\t\t\t\tBoard.board[self.x][self.y]='M'\n\n\t\t\telif Board.board[self.x][self.y]=='P':\n\t\t\t\tMario.lives+=1\n\t\t\t\tMario._pass(self.x,self.y-1)\n\t\t\t\tBoard.board[self.x][self.y]='M'\n\t\t\t\tcall([\"aplay\",\"-q\",\"smb_1-up.wav\"])\n\n\t\t\telif Board.board[self.x][self.y]=='A':\n\t\t\t\tMario._pass(self.x,self.y-1)\n\t\t\t\tBoard.board[self.x][self.y]='M'\n\t\t\t\tMario.attack = 1\n\t\t\t\tcall([\"aplay\",\"-q\",\"smb_powerup.wav\"])\n\n\t\t\telif Board.board[self.x][self.y]=='@':\n\t\t\t\tMario._pass(self.x,self.y-1)\n\t\t\t\tMario.lives-=1\n\t\t\t\tcall([\"aplay\",\"-q\",\"smb_mariodie.wav\"])\n\t\t\t\tif Mario.lives<=0:\n\t\t\t\t\tcall([\"aplay\",\"-q\",\"smb_gameover.wav\"])\n\t\t\t\t\treturn \"exit\"\n\t\t\t\tos.system('clear')\n\t\t\t\tprint(\"\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\t\\t\\t\\t\\t\\tNumber of Mario left\",Mario.lives)\n\t\t\t\tMario.respawn(self.x,self.y)\n\t\t\t\ttime.sleep(2)\n\t\t\t\tinit_board(Board.prev_i,Board.prev_j,Board.prev_k)\n\n\t\t\telif(Board.board[self.x][self.y]=='/'):\n\t\t\t\tMario._pass(self.x,self.y-1)\n\t\t\t\tBoard.board[self.x-1][self.y]='M'\n\n\t\t\telif Board.board[self.x][self.y]=='I':\n\t\t\t\tMario._pass(self.x,self.y-1)\n\t\t\t\tcall([\"aplay\",\"-q\",\"smb_stage_clear.wav\"])\n\t\t\t\tBoard.bonus_round()\n\n\t\t\telif Board.board[self.x][self.y]=='K':\n\t\t\t\tMario._pass(self.x,self.y-1)\n\t\t\t\tcall([\"aplay\",\"-q\",\"smb_stage_clear.wav\"])\n\t\t\t\tenemy.boss_round()\n\n\t\t\telif(Board.board[self.x][self.y] in obstacles):\n\t\t\t\tMario._pass(self.x,self.y-1)\n\t\t\t\tBoard.board[self.x][self.y-1]='M'\n\n\t\t\telif((Board.board[self.x+1][self.y-1]=='/' or Board.board[self.x+1][self.y-1]=='T') and Board.board[self.x+1][self.y]==' '):\n\t\t\t\tMario._pass(self.x,self.y-1)\n\t\t\t\tBoard.board[self.x][self.y+1]='M'\n\t\t\t\tMario.go_down(self)\n\t\t\telse:\n\t\t\t\tMario._pass(self.x,self.y-1)\n\t\t\t\tBoard.board[self.x][self.y]='M'\n\n\t\tif( self.y-1 >= ((Board.prev_j+Board.prev_k)/2) ):\n\t\t\tos.system('clear')\n\t\t\tBoard.prev_j += 1 \n\t\t\tBoard.prev_k += 1\n\t\t\tinit_board(Board.prev_i,Board.prev_j,Board.prev_k)\n\t\telse:\n\t\t\tos.system('clear')\n\t\t\tinit_board(Board.prev_i,Board.prev_j,Board.prev_k)","def main():\r\n turn_left()\r\n while front_is_clear():\r\n move()\r\n turn_right()\r\n while front_is_clear():\r\n move()\r\n turn_right()\r\n while front_is_clear():\r\n move()\r\n turn_left()","def move(): #py:move\n RUR._move_()","def execute(self):\n while(self._running):\n # get all pygame events from queue\n for event in pygame.event.get():\n self.event_handler(event)\n self.move()\n self.render()\n self.cleanup()","def algo_mover(self):\n self.tick_count = 0 ## reset to start clock on delayed state change\n\n ### Move 1 ring ###\n de, aux, vers = self.instructions.pop(0)\n\n de = self.rods[de]\n aux = self.rods[aux]\n vers = self.rods[vers]\n\n ring = de.pop_ring()\n vers.add_ring(ring)\n\n ### Update the states after -- moved this to main update\n #self.state_updater()","def decide(self):\n self.maybe_shoot()\n next(self.move_cycle)\n\n pass","def run(self):\n for move in self.model.moves:\n pygame.event.get()\n self.model.update_matrix(self.model.board.cars[move[0]], move[1])\n self.setup()\n time.sleep(0.5)\n \n time.sleep(5)\n pygame.quit","def process_IN_MOVE_SELF(self, event):","def play_all(self):\n posicion_actual = self.tiempos.posicion_actual()\n self.tiempos.volver_al_inicio()\n while True:\n try:\n if not self.tiempos.esta_vacia():\n self._reproducir(self.tiempos.actual())\n self.tiempos.siguiente()\n except StopIteration:\n self.tiempos.volver_al_inicio()\n self.tiempos.actualizar(posicion_actual)\n return","def main():\r\n turn_left()\r\n move_three_times()\r\n turn_right()\r\n move_three_times()\r\n turn_right()\r\n move_three_times()\r\n turn_left()","def play_move(self,state):\n raise AIError(\"Must be implemented for child class!\")","def _move(self, move: Tile):\n if not self.game_state:\n raise RuntimeError(\"Cannot call move when the game has not started!\")\n # Adversaries are supposed to be notified of new info right before they move.\n if issubclass(type(self.current_turn), Enemy):\n current_enemy = next(enemy for enemy in self.enemy_list if enemy.entity.name == self.current_turn.entity.name)\n self._notify_adversary(current_enemy)\n # Players that are alive before this move\n pre_players = self.game_state.get_current_characters()\n completed_before_turn = self.game_state.get_completed_characters()\n if move != None:\n self._move_and_update(move)\n else:\n self.current_turn.notify(self._format_move_result_notification(None, Moveresult.OK))\n # Notify players and adversaries of changes to the gamestate, including players who were killed\n # on this turn. Note that this usually results in one rendering per move to all entities.\n self._update_players()\n self._update_adversaries()\n self._handle_completed_characters(completed_before_turn)\n self._handle_killed_players(pre_players)\n self.current_turn = self.turn_order.next()","def stop(self):\n self.move(0, 0)","def run(self):\n # type: () -> None\n self.move_to(self.location)","def move(self, surface_size):\n for molecule in self.molecules:\n old_position = copy.copy(molecule.get_position()) # remember old position by shallow copy\n molecule.move()\n if molecule.handle_collide_with_borders(surface_size): # if it has a collision with border\n molecule.set_position(old_position) # restore old position\n collision_molecule = self.is_in_collision_with_other_molecule(molecule)\n if not collision_molecule is None: # if it has a collision with a molecule\n molecule.handle_collision_with_molecule(collision_molecule) # handle the collision\n molecule.set_position(old_position) # restore old position ","def stop_full(self):\n self.systems[\"driver\"].move(0, 0)","def move(self, direction):\n # replace with your code\n pass","def move(self, direction):\n # replace with your code\n pass","def MULTIPLAYER_LOOP():\n pass","def play_one_move(self, verbose=False):\n if verbose:\n self.print(\"top of move\")\n\n # 1) grab three cups\n c1 = self.cups.remove_next_node()\n c2 = self.cups.remove_next_node()\n c3 = self.cups.remove_next_node()\n if verbose:\n print(f\"pick up: {c1}, {c2}, {c3}\")\n self.print(\"after pickup\")\n\n # 2) find a destination cup\n destination_node = self.find_next_destination(\n self.cups.get_current_node().value\n )\n if verbose:\n print(f\"destination node is {destination_node}\")\n\n # 3) insert cups back into the circle\n self.cups.add_after(destination_node, c3.value)\n self.cups.add_after(destination_node, c2.value)\n self.cups.add_after(destination_node, c1.value)\n if verbose:\n self.print(\"after adding cups..\")\n\n # 4) select the next cup\n target_cup = self.cups.get_current_node().next()\n self.cups.set_current_node(target_cup)\n\n if verbose:\n self.print(\"post move\")","def move_stages(self,positions):\n for ind_move,pos in enumerate(positions): #move all activated modules to specified positions\n #self.move_modules[ind_move].move_Abs(pos)\n self.move_modules_commands[ind_move].emit(utils.ThreadCommand(command=\"move_Abs\", attributes=[pos]))","def run(self):\n while self.direction != \"\":\n if self.direction == \"decrease\":\n if self.position > 200:\n self.position -= 15\n elif self.direction == \"increase\":\n if self.position < 800:\n self.position += 15\n if self.direction != \"neutral\":\n self.move_joint(self.position, 900)\n time.sleep(0.1)","def play_move(self,state):\n #Keep asking for the next move until a valid move.\n while(True):\n childList = state.get_successors()\n print(\"Your possible moves:\")\n i = 0\n for c in childList:\n if i > 0 and i%4 == 0:\n print()\n print(c.get_action().ljust(10),end=\"\\t\");\n i += 1\n print()\n nextMove = input(\"What is your next move? \\ne.g.'F2-E3' or 'Quit'\\n\")\n #Check if the move is valid\n if nextMove.lower() == 'Quit'.lower():\n return None\n for c in childList:\n if c.get_action().upper() == nextMove.upper():\n return c\n # Move not possible \n print(\"Invalid move!! Please try again...\\n\")","def move(self):\n \n self.position = self.explore()","def move(self):\n for index in range(len(self.segments)-1):\n segment = self.segments[index].instance\n x1, y1, x2, y2 = c.coords(self.segments[index+1].instance)\n c.coords(segment, x1, y1, x2, y2)\n\n x1, y1, x2, y2 = c.coords(self.segments[-2].instance)\n c.coords(self.segments[-1].instance,\n x1+self.vector[0]*SEG_SIZE, y1+self.vector[1]*SEG_SIZE,\n x2+self.vector[0]*SEG_SIZE, y2+self.vector[1]*SEG_SIZE)","def Move_Stage(self):\n for i in range(3):\n if self.set_pos[i] == 0:\n continue\n print \"Moving stage %s by %s steps\\n\"%(self.POS_NAME[i], self.set_pos[i])\n self.ser.write('F,C'+self.STEPPER_NAME[i]+str(self.set_pos[i])+',R')\n time.sleep(0.5)\n time.sleep(0.5)\n return","def move_forward():\n pass","def main():\r\n\r\n movetwotimes()\r\n pick_beeper()\r\n move()\r\n turn_left()\r\n movetwotimes()\r\n put_beeper()\r\n turn_left()\r\n turn_left()\r\n movetwotimes()\r\n rotatethreetimes()\r\n movetwotimes()\r\n move()\r\n turn_left()\r\n turn_left()","def move(self):\n t = self.get_time_step() # Get the timestep\n\n for body in self.bodies:\n body.update_pos_revs(t, self.time)\n\n # Once all the positions are updated, update all velocities and\n # accelerations.\n for body in self.bodies:\n body.update_vel_acc(t, self.bodies)\n\n self.get_energies() # Get the total energy\n self.time += t # Increase the time by time step.","def move(self):\n if VERBOSE:\n print('-- move', self.move_number, '--')\n self.display_cups()\n\n picked_up = self.pick_up_cups(3)\n self.update_destination_cup()\n\n if VERBOSE:\n print('pick up: ', end='')\n for pick in picked_up:\n print(pick, end=' ')\n print()\n print('destination:', self.destination)\n print()\n\n self.insert_cups(inserts=picked_up, insert_after=self.destination)\n self.select_new_current_cup()\n\n self.move_number += 1","def update():\n move()\n check_collision()","def make_move(self):\r\n if self.running and self.run:\r\n if self.board is None:\r\n SlTrace.lg(\"sp.board is None\")\r\n return False\r\n \r\n SlTrace.lg(\"running_loop self.running and self.run\", \"running_loop\")\r\n SlTrace.lg(\"running_loop self.start_move\", \"running_loop\")\r\n if self.start_move():\r\n SlTrace.lg(\"running_loop successful start_move\", \"running_loop\")\r\n self.next_move_no()\r\n SlTrace.lg(\"running_loop after start_move\", \"running_loop\")\r\n if self.to_pause:\r\n self.pause_cmd()\r\n self.to_pause = False\r\n return True","def tick():\n move_balls(targets_speed)\n move_super_balls(targets_speed * 2)","def thinking(self):\n if self.motion.moveIsActive():\n # Maneuver occurring. Let's finish it\n # before taking any other measure.\n pass\n\n elif not self.sensors['proximity'][0].imminent_collision:\n # Goes back to moving state.\n self.behavior_ = self.BEHAVIORS.moving\n\n elif all(s.imminent_collision for s in self.sensors['proximity']):\n # There's nothing left to be done, only flag this is a dead-end.\n self.behavior_ = self.BEHAVIORS.stuck\n\n else:\n peripheral_sensors = self.sensors['proximity'][1:]\n for maneuver, sensor in zip(range(1, 4), peripheral_sensors):\n if not sensor.imminent_collision:\n # A sensor that indicates no obstacles were found.\n # Move in that direction.\n self.motion.post.moveTo(0, 0, np.pi / 2)\n break\n\n return self","def move(self):\n \n self.position = self.wander()","def move(self, direction):\n pass","def update(self):\n if not self._move:\n self.get_next_move()\n if self._move:\n self._move.update()","def breakout_loop(self):\n while self.playing:\n self.handle_events()\n self.update()\n if self.game_over:\n self.current_menu = self.fail_menu\n self.playing = False\n self.reset()\n self.draw()","def step(self):\n if not self._is_game_over:\n self._move_snake()\n self._is_game_over = self.is_snake_collides()","def move(self):\n\n # get the location we WOULD go to\n newX = self.xcor() + self.dx\n newY = self.ycor() + self.dy\n while (abs (newX) > self.BOX_RANGE) or (abs(newY) > self.BOX_RANGE):\n # print(\"choosing new direction... \",end=\"\")\n self.chooseNewDirection()\n # print(self.dx, self.dy)\n newX = self.xcor() + self.dx\n newY = self.ycor() + self.dy\n\n # now move our monster\n super().move()","def play_move(self, move):\n color, move_tuple = convert_from_GTP(move, self.size)\n result = self.game.move_stone(move_tuple[0], move_tuple[1], color)\n if result.status != gogame.VALID:\n raise PlayError, result.status\n self.board.PlaceMove(move_tuple, color)\n self.board.ErasePieces(result.prisoners)\n self.board.SwitchCurColor()\n\n self.curWatcher.play(move)\n\n #if there are consecutive passes, end the game, else reset pass count\n if move == \"pass\":\n self.isPass += 1\n if self.isPass == 2:\n self.end_game()\n else:\n self.isPass = 0\n\n #switch the players\n temp = self.curPlayer\n self.curPlayer = self.curWatcher\n self.curWatcher = temp\n \n if self.isPass < 2:\n self.call_for_move()\n else:\n self.end_game()","def _finish_all_moves(self, current_time):\n\t\tfor piece_id in self.all_piece_ids:\n\t\t\tstate = getattr(self, piece_id)\n\t\t\tif len(state) == 0:\n\t\t\t\tcontinue\n\t\t\tpiece = Piece(state)\n\t\t\tif piece.moving:\n\t\t\t\tif piece.end_time <= current_time:\n\t\t\t\t\tself._finish_move(piece_id, piece, current_time)","async def move(self, movement):\n next_position = self.position\n self.position = (next_position + movement) % self.game.positions\n self.game.player_moved(self)\n\n box = None\n for mov in range(movement):\n next_position += 1\n if next_position == self.game.positions:\n next_position = 0\n\n box = self.game.board.get_box(next_position)\n await self.move_position(box)\n\n box.goes_in(self)","def decide_next_move(self):\n pass","def move(self, direction):\n # replace with your code\n\n indices = self.direction_indices[direction]\n for coordinate in indices:\n merged_coordinate_list = self.get_list(direction, coordinate)\n self.change_board(merged_coordinate_list, coordinate, direction)\n print(self.__str__())\n if self.board_is_not_full():\n self.new_tile()","def movement(self):","def move(self):\n new_velocities = self._create_velocities()\n for boid, vel in zip(self.boids, new_velocities):\n boid.change_speed(*vel)\n for obstacle in self.obstacles:\n self.boid_omit_obstacle(boid, obstacle)\n boid.move(self.board_size)","def cancel_move(self):\n self.should_move = False","def step(self, action):\n # print(\"############################\")\n # print(\"action: {}\".format(action))\n\n self.movement_complete.data = False\n\n # 1) Read last joint positions by getting the observation before acting\n old_observation = self.get_obs()\n\n # 2) Get the new joint positions according to chosen action (actions here are the joint increments)\n if self._joint_increment is None:\n next_action_position = action\n else:\n next_action_position = self.get_action_to_position(action, old_observation[1:7])\n\n # 3) Move to position and wait for moveit to complete the execution\n self.publisher_to_moveit_object.pub_joints_to_moveit(next_action_position)\n # rospy.wait_for_message(\"/pickbot/movement_complete\", Bool)\n while not self.movement_complete.data:\n pass\n\n start_ros_time = rospy.Time.now()\n while True:\n # Check collision:\n # invalid_collision = self.get_collisions()\n # if invalid_collision:\n # print(\">>>>>>>>>> Collision: RESET <<<<<<<<<<<<<<<\")\n # observation = self.get_obs()\n # reward = UMath.compute_reward(observation, -200, True)\n # observation = self.get_obs()\n # print(\"Test Joint: {}\".format(np.around(observation[1:7], decimals=3)))\n # return U.get_state(observation), reward, True, {}\n\n elapsed_time = rospy.Time.now() - start_ros_time\n if np.isclose(next_action_position, self.joints_state.position, rtol=0.0, atol=0.01).all():\n break\n elif elapsed_time > rospy.Duration(2): # time out\n break\n # time.sleep(s\n\n \"\"\"\n #execute action as long as the current position is close to the target position and there is no invalid collision and time spend in the while loop is below 1.2 seconds to avoid beeing stuck touching the object and not beeing able to go to the desired position \n time1=time.time()\n while np.linalg.norm(np.asarray(self.joints_state.position)-np.asarray(next_action_position))>0.1 and self.get_collisions()==False and time.time()-time1<0.1: \n rospy.loginfo(\"Not yet reached target position and no collision\")\n \"\"\"\n # 4) Get new observation and update min_distance after performing the action\n new_observation = self.get_obs()\n if new_observation[0] < self.min_distace:\n self.min_distace = new_observation[0]\n # print(\"observ: {}\".format( np.around(new_observation[1:7], decimals=3)))\n\n # 5) Convert Observations into state\n state = U.get_state(new_observation)\n\n # 6) Check if its done, calculate done_reward\n done, done_reward, invalid_contact = self.is_done(new_observation)\n\n # 7) Calculate reward based on Observatin and done_reward and update the accumulated Episode Reward\n reward = UMath.compute_reward(new_observation, done_reward, invalid_contact)\n\n ### TEST ###\n if done:\n joint_pos = self.joints_state.position\n print(\"Joint in step (done): {}\".format(np.around(joint_pos, decimals=3)))\n ### END of TEST ###\n\n self.accumulated_episode_reward += reward\n\n self.episode_steps += 1\n\n return state, reward, done, {}","def move(self, move):\n raise NotImplementedError()","def main_loop(self) -> None:\n while True:\n player = self._players[self._current_player]\n hit = True\n while hit:\n self.select_square(player)\n if self.menu_called: # go to menu\n self.menu_called = False\n return\n hit = player.shoot()\n if player.has_won():\n self.display_manager.display_end_game_message(player)\n self.game_over = True\n return\n self._current_player = (self._current_player + 1) % len(self._players)","def game_loop(self):\n self.interface.game_loop(self)","def move_buildings(self):","def move(self):\n self._move_range_shuffle(3)\n self._move_satisfy_random_constraint()\n # self._move_range_shuffle(3)\n #if (curr_energy > 50):\n # self._move_satisfy_random_constraint()\n #else:\n # self._move_range_shuffle(3)","def stop_moves(self,overshoot):\n self.overshoot = overshoot\n self.stop_scan()\n for mod in self.move_modules:\n mod.stop_Motion()","def move_objects(time_elapsed):\n move_object(ball, time_elapsed)\n\n # Bounce the ball off the sides, if necessary.\n bounce_off_walls(ball, bounds_left, bounds_right,\n bounds_top, bounds_bottom)","def run(self):\n return self.move_bat()","def move(self, board, move_dir):\n if move_dir == \"right\":\n # failsafe: do not move through other cars on board\n if board.positions[self.get_rows()[0]][self.get_cols()[1] + (self.size - 1)].isupper() or board.positions[self.get_rows()[0]][self.get_cols()[1] + (self.size - 1)] == 'r':\n print(\"No movement!\")\n return board\n \n # give board correct new positions (characters)\n else:\n board.positions[self.get_rows()[0]][self.get_cols()[1] + (self.size - 1)] = self.name[0]\n board.positions[self.get_rows()[0]][self.get_cols()[0]] = \"x\"\n\n # change car objects positions\n for i, col in enumerate(self.position):\n self.position[i] = str(self.get_rows()[0]) + \".\" + str(int(col[2]) + 1)\n return board\n elif move_dir == \"left\": \n if board.positions[self.get_rows()[0]][self.get_cols()[0] - 1].isupper() or board.positions[self.get_rows()[0]][self.get_cols()[0] - 1] == 'r':\n print(\"No movement!\")\n return board\n else: \n board.positions[self.get_rows()[0]][self.get_cols()[0] - 1] = self.name[0]\n board.positions[self.get_rows()[0]][self.get_cols()[1] + (self.size - 2)] = \"x\"\n\n for i, col in enumerate(self.position):\n self.position[i] = str(self.get_rows()[0]) + \".\" + str(int(col[2]) - 1)\n return board\n elif move_dir == \"up\":\n #print(board.positions[self.get_rows()[0] - 1][self.get_cols()[0]])\n if board.positions[self.get_rows()[0] - 1][self.get_cols()[0]].isupper() or board.positions[self.get_rows()[0] - 1][self.get_cols()[0]] == 'r':\n print(\"No movement!\")\n return board\n else:\n board.positions[self.get_rows()[0] - 1][self.get_cols()[0]] = self.name[0]\n board.positions[self.get_rows()[1] + (self.size - 2)][self.get_cols()[0]] = \"x\"\n\n for i, row in enumerate(self.position):\n self.position[i] = str(int(row[0]) - 1) + \".\" + str(self.get_cols()[0])\n\n #print(board)\n return board\n elif move_dir == \"down\": \n try: \n if board.positions[self.get_rows()[1] + (self.size - 1)][self.get_cols()[0]].isupper() or board.positions[self.get_rows()[1] + (self.size - 1)][self.get_cols()[0]] == 'r':\n print(\"No movement!\")\n return board\n except IndexError:\n return board\n else: \n board.positions[self.get_rows()[0]][self.get_cols()[0]] = \"x\" \n board.positions[self.get_rows()[1] + (self.size - 1)][self.get_cols()[0]] = self.name[0]\n\n for i, row in enumerate(self.position):\n self.position[i] = str(int(row[0]) + 1) + \".\" + str(self.get_cols()[0]) \n \n #print(self.position)\n #print(board)\n \n return board\n else:\n #print(\"NO MOVEMENT!\")\n return board","def move(self, *args, **kw):\n return self.execute_action('move', *args, **kw)","def run(self):\n for frm_idx in range(self.frames_nbr):\n for player in self.players:\n assert isinstance(player, Player)\n player.play_frame(Frame(pins_nbr=self.pins_nbr))\n\n # Check the last frame for each player\n for player in self.players:\n if player.frames[self.frames_nbr-1].is_strike():\n for _ in range(2):\n player.play_frame(Ball(pins_nbr=self.pins_nbr))\n if player.frames[self.frames_nbr-1].is_spare():\n player.play_frame(Ball(pins_nbr=self.pins_nbr))","def execute(self):\n for move in self._queue:\n move.execute()","def move(self):\n self.old_tail = self.body[-1][:] # save old position of last block\n self.head[0] += self.direction[0] # moves head\n self.head[1] += self.direction[1]\n \n self.head[0] = (self.head[0] + self.xMaxSize) % self.xMaxSize\n self.head[1] = (self.head[1] + self.yMaxSize) % self.yMaxSize\n \n if self.head in self.body[1:]: # if snakes hits himself\n self.alive = False\n self.body.insert(0, self.body.pop()) # each block is replace by predecessor\n self.body[0] = self.head[:] # first block is head","def _play(self, func):\n\n func()\n print('\\nhuman movement:\\n')\n print(self._board)\n\n while self._board.possible() != []:\n self._board.move_computer()\n print('\\ncomputer movement:\\n')\n print(self._board)\n if self._board.check_win():\n print('\\nwinner is computer')\n return\n\n func()\n print('\\nhuman movement:\\n')\n print(self._board)\n if self._board.check_win():\n print('\\nwinner is human')\n return\n print('\\nwinner is friendship :)')","def second_move(self):\n self.play_sound(self.second_key)\n self.end_move()","def play(self):\n for step_i in range(self.max_step):\n player_id = step_i & 1\n player = self.players[player_id]\n action = player.nxt_move()\n if isinstance(player, mcts.MCTSPlayer) and player.value_net.loggable:\n print(f'Player{player_id}: Action: {action}')\n if not self.is_valid_action(action):\n # because now just consider 2 players\n print(f\"Player: {player_id}, Action: {action} Did Not choose a valid action!\")\n self.board[action // self.w][action % self.w] = player_id\n self.winner = 1 - player_id\n else:\n self.board[action // self.w][action % self.w] = player_id\n self.winner = self.k0()\n self.players[1 - player_id].other_nxt_move(action)\n if self.winner != -1:\n break\n print(f'Winner: {self.winner}')\n for player_id in range(len(self.players)):\n self.players[player_id].game_ended()","def cb_move(self, event):\n if not self.move_timer.IsRunning():\n self.move_timer.StartOnce(2000)","def automove(self):\n if self.x < self.end_cinematic_x_pos:\n self.x += self.SHIP_SPEED\n if self.x > self.end_cinematic_x_pos:\n self.x -= self.SHIP_SPEED\n if self.y < self.end_cinematic_y_pos:\n self.y += self.SHIP_SPEED\n if self.y > self.end_cinematic_y_pos:\n self.y -= self.SHIP_SPEED","def move(self, state):\n raise NotImplementedError(\"Need to implement this method\")","def run(self):\n super(MovementControl,self).run()","def computer_move(board,move,player):\r\n com_execution(board, move, player)"],"string":"[\n \"def move(self):\\n pass\",\n \"def handleMove(self):\\n pass\",\n \"def run(self):\\n while not self.turn_over:\\n self.go()\",\n \"def run(self):\\n for _ in range(self.num_iteration):\\n self.move()\\n time.sleep(self.speed)\\n if not self.is_running:\\n break\",\n \"def move(self, direction, cycles):\\n\\t\\tpass\",\n \"def run_logic(self):\\n if not self.game_over:\\n # Move all the sprites\\n self.all_sprites_list.update()\",\n \"def play_simulation(self):\\n self._play(self._move_comp_person)\",\n \"def move(self):\\r\\n segments = len(self.all_turtles) - 1\\r\\n for i in range(len(self.all_turtles)):\\r\\n if segments == 0:\\r\\n self.all_turtles[segments].forward(MOVE_DISTANCE)\\r\\n else:\\r\\n new_x = self.all_turtles[segments - 1].xcor()\\r\\n new_y = self.all_turtles[segments - 1].ycor()\\r\\n self.all_turtles[segments].goto(new_x, new_y)\\r\\n segments -= 1\",\n \"def move(self):\\n raise NotImplementedError\",\n \"def move(self):\\n self.tick()\\n self.pressed = pygame.key.get_pressed()\\n\\n \\\"\\\"\\\"Do deleting platforms/do losing\\\"\\\"\\\"\\n self.player.update(self)\\n self.main_platform.update(self)\\n\\n for i in self.platformsx:\\n self.platformsx[i].update(self)\\n \\n for i in self.platforms:\\n self.platforms[i].update(self)\\n\\n for i in self.to_remove:\\n self.platforms.pop(i)\\n self.to_remove.clear()\\n\\n for i in self.platformsx:\\n self.platformsx[i].update(self)\",\n \"def startMovementAll(self):\\n self.startMovementX()\\n self.startMovementY()\\n self.startMovementZ()\",\n \"def main():\\n move()\\n move()\\n pick_beeper()\\n move()\\n turn_left()\\n for i in range(2):\\n move()\\n put_beeper()\\n turn_around()\\n move_to_wall()\\n turn_right()\\n move_to_wall()\\n turn_around()\",\n \"def move(self) -> None:\\n\\n if self.move_up:\\n self.__moveUpIfPossible()\\n if self.move_down:\\n self.__moveDownIfPossible()\",\n \"def play_one_move(self):\\n self.print(\\\"top of move\\\")\\n # 1) grab three cups\\n c1 = self.take_cup_after(self.current_cup_idx())\\n c2 = self.take_cup_after(self.current_cup_idx())\\n c3 = self.take_cup_after(self.current_cup_idx())\\n print(f\\\"pick up: {c1}, {c2}, {c3}\\\")\\n self.print(\\\"after pickup\\\")\\n\\n # 2) find a destination cup\\n destination_idx = self.find_next_destination(self.current_cup)\\n print(\\n f\\\"destination index is {destination_idx}, cup is {self.cups[destination_idx]}\\\"\\n )\\n\\n # 3) insert cups back into the circle\\n self.add_cups(destination_idx, [c1, c2, c3])\\n self.print(\\\"after adding cups..\\\")\\n\\n # 4) select the next cup\\n self.select_next_cup()\\n\\n self.print(\\\"post move\\\")\",\n \"def moveCirc(self):\\n\\t\\tfor circle in self.circles:\\n\\t\\t\\tcircle.moveStep()\",\n \"def move(self):\\n # moving each of the obstacles\\n time = rospy.get_rostime()\\n self.vel_msg1.linear.x = math.sin(time.to_sec())\\n self.pub1.publish(self.vel_msg1)\\n self.vel_msg2.linear.x = math.cos(1.2 * time.to_sec())\\n self.pub2.publish(self.vel_msg2)\\n self.vel_msg3.linear.x = math.cos(2 * time.to_sec())\\n self.pub3.publish(self.vel_msg3)\\n self.vel_msg4.linear.x = math.sin(0.85 * time.to_sec())\\n self.pub4.publish(self.vel_msg4)\",\n \"def move(self):\\n # This block is used to move into the living room.\\n if self.room_name == \\\"living\\\" or self.room_name == \\\"Living\\\":\\n self.living_room()\\n # This block is used to open the door.\\n elif self.room_name == \\\"Door\\\" or self.room_name == \\\"door\\\":\\n self.door()\\n # This block is used to move into the kitchen.\\n elif self.room_name == \\\"Kitchen\\\" or self.room_name == \\\"kitchen\\\":\\n self.kitchen()\\n # This block is used to move into the hallway.\\n elif self.room_name == \\\"Hallway\\\" or self.room_name == \\\"hallway\\\":\\n self.hallway()\\n # This block is used to move into the bathroom.\\n elif self.room_name == \\\"Bathroom\\\" or self.room_name == \\\"bathroom\\\":\\n self.bathroom()\\n # This block is used to move into the basement.\\n elif self.room_name == \\\"Basement\\\" or self.room_name == \\\"basement\\\":\\n self.basement()\\n # This block is used to move into the bedroom.\\n elif self.room_name == \\\"Bedroom\\\" or self.room_name == \\\"bedroom\\\":\\n self.bedroom()\\n # This block is used to move into the attic.\\n elif self.room_name == \\\"Attic\\\" or \\\"attic\\\":\\n self.attic()\",\n \"def stopMovementAll(self):\\n self.stopMovementX()\\n self.stopMovementY()\\n self.stopMovementZ()\",\n \"def step(self, move):\",\n \"def play(self):\\n\\n while self.board.board[self.board.target_location()[0]]\\\\\\n [self.board.target_location()[1]] == \\\"E\\\": # the car didn't\\n # arrive the exit\\n self.__single_turn()\\n print(\\\"you won!\\\")\",\n \"def __move_ball(self):\\n while not self.__game_is_over():\\n self.__ball.move(self.__dx, self.__dy)\\n self.__handle_wall_collision()\\n if self.__num_lives == 0:\\n self.__game_over_picture()\\n break\\n elif self.__bricks_total == 0:\\n self.__game_over_picture('You Win!!')\\n break\\n pause(FRAME_RATE)\",\n \"def moveSpecialOb(self):\\n\\t\\tfor obJ in self.special:\\n\\t\\t\\tobJ.moveStep()\",\n \"def move(self) -> bool:\\n pass\",\n \"async def move_channel_loop(self):\\n try:\\n while self.state == CHANNEL_MOVE_STATE_NONE:\\n message = await self.poll_message()\\n if message is None:\\n break\\n \\n try:\\n await self.move_message(message)\\n except DiscordException as err:\\n if err.code == ERROR_CODES.unknown_webhook:\\n self.set_status_update_waiter_webhook_deleted()\\n return\\n \\n raise\\n \\n self.last_message_id = message.id\\n self.total_moved_messages += 1\\n \\n except GeneratorExit:\\n raise\\n \\n except CancelledError:\\n raise\\n \\n except BaseException as err:\\n self.set_status_update_waiter_error()\\n await self.client.events.error(self.client, repr(self), err)\\n return\\n \\n finally:\\n self.discard()\\n \\n self.set_status_update_waiter_finished()\",\n \"def move_cycle(self, actions, players):\\n\\n for i in range(len(players)):\\n player = players[i]\\n action = actions[i]\\n player.move(action)\\n for other in players:\\n if Circle.collide(player, other) and player != other:\\n player.revert_move()\\n if Circle.collide(player, self.ball):\\n self.possession = player.team\\n self.ball.move(player)\\n\\n self.ball.move()\\n scored = self.__ball_scored()\\n if scored:\\n self.ball.replace()\\n if scored == TEAM_RED:\\n self.score[1] += 1\\n return (1, TEAM_RED)\\n else:\\n self.score[0] += 1\\n return (1, TEAM_BLUE)\\n elif self.__ball_out_bounds():\\n if self.possession == TEAM_BLUE:\\n self.ball.restart(Point(WIDTH / 4, HEIGHT / 2))\\n else:\\n self.ball.restart(Point(WIDTH * 3/4, HEIGHT / 2))\\n return (2, self.possession)\\n else:\\n return (0, None)\",\n \"def stop(self):\\n self.move(None)\",\n \"def play(self):\\n self._play(self._move_person)\",\n \"def interaction_void(self) -> None:\\n self.grid.obj_list.swap_obj(self.moving_character, self.target)\",\n \"def play_step(self, action):\\n self.players[0].moving_left = False\\n self.players[0].moving_right = False\\n if action == MOVE_LEFT:\\n self.players[0].moving_left = True\\n for i in range(LOOP_AT_EACH_MOVE_UPDATE):\\n self.update(is_a_star=True)\\n if self.dead_player or not self.players[0].is_alive:\\n break\\n self.players[0].moving_left = False\\n if self.dead_player or not self.players[0].is_alive:\\n return\\n elif action == MOVE_RIGHT:\\n self.players[0].moving_right = True\\n for i in range(LOOP_AT_EACH_MOVE_UPDATE):\\n self.update(is_a_star=True)\\n if self.dead_player or not self.players[0].is_alive:\\n break\\n self.players[0].moving_right = False\\n if self.dead_player or not self.players[0].is_alive:\\n return\\n elif action == SHOOT:\\n if self.dead_player or not self.players[0].is_alive:\\n self.update(is_a_star=True)\\n return\\n if not self.players[0].weapon.is_active:\\n self.players[0].shoot()\\n for i in range(LOOP_AT_EACH_MOVE_UPDATE):\\n self.update(is_a_star=True)\\n if self.dead_player or not self.players[0].is_alive:\\n break\\n if self.dead_player or not self.players[0].is_alive:\\n return\",\n \"def run(self):\\n self.spawn()\\n while self.is_alive:\\n self.move()\\n time.sleep(.2)\",\n \"def bqm_move_queue(self):\\n self.bqm.turn_once()\",\n \"def _move_forward(self):\\n\\t\\tself.x,self.y = Mario._get_coordinates(Board.prev_i,Board.prev_j,Board.prev_k)\\n\\t\\tif(self.y<=798):\\n\\t\\t\\tself.y = self.y+1\\n\\t\\t\\tif Board.board[self.x][self.y]=='0':\\n\\t\\t\\t\\tMario.score += 1\\n\\t\\t\\t\\tMario._pass(self.x,self.y-1)\\n\\t\\t\\t\\tBoard.board[self.x][self.y]='M'\\n\\n\\t\\t\\telif Board.board[self.x][self.y]=='P':\\n\\t\\t\\t\\tMario.lives+=1\\n\\t\\t\\t\\tMario._pass(self.x,self.y-1)\\n\\t\\t\\t\\tBoard.board[self.x][self.y]='M'\\n\\t\\t\\t\\tcall([\\\"aplay\\\",\\\"-q\\\",\\\"smb_1-up.wav\\\"])\\n\\n\\t\\t\\telif Board.board[self.x][self.y]=='A':\\n\\t\\t\\t\\tMario._pass(self.x,self.y-1)\\n\\t\\t\\t\\tBoard.board[self.x][self.y]='M'\\n\\t\\t\\t\\tMario.attack = 1\\n\\t\\t\\t\\tcall([\\\"aplay\\\",\\\"-q\\\",\\\"smb_powerup.wav\\\"])\\n\\n\\t\\t\\telif Board.board[self.x][self.y]=='@':\\n\\t\\t\\t\\tMario._pass(self.x,self.y-1)\\n\\t\\t\\t\\tMario.lives-=1\\n\\t\\t\\t\\tcall([\\\"aplay\\\",\\\"-q\\\",\\\"smb_mariodie.wav\\\"])\\n\\t\\t\\t\\tif Mario.lives<=0:\\n\\t\\t\\t\\t\\tcall([\\\"aplay\\\",\\\"-q\\\",\\\"smb_gameover.wav\\\"])\\n\\t\\t\\t\\t\\treturn \\\"exit\\\"\\n\\t\\t\\t\\tos.system('clear')\\n\\t\\t\\t\\tprint(\\\"\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\t\\\\t\\\\t\\\\t\\\\t\\\\tNumber of Mario left\\\",Mario.lives)\\n\\t\\t\\t\\tMario.respawn(self.x,self.y)\\n\\t\\t\\t\\ttime.sleep(2)\\n\\t\\t\\t\\tinit_board(Board.prev_i,Board.prev_j,Board.prev_k)\\n\\n\\t\\t\\telif(Board.board[self.x][self.y]=='/'):\\n\\t\\t\\t\\tMario._pass(self.x,self.y-1)\\n\\t\\t\\t\\tBoard.board[self.x-1][self.y]='M'\\n\\n\\t\\t\\telif Board.board[self.x][self.y]=='I':\\n\\t\\t\\t\\tMario._pass(self.x,self.y-1)\\n\\t\\t\\t\\tcall([\\\"aplay\\\",\\\"-q\\\",\\\"smb_stage_clear.wav\\\"])\\n\\t\\t\\t\\tBoard.bonus_round()\\n\\n\\t\\t\\telif Board.board[self.x][self.y]=='K':\\n\\t\\t\\t\\tMario._pass(self.x,self.y-1)\\n\\t\\t\\t\\tcall([\\\"aplay\\\",\\\"-q\\\",\\\"smb_stage_clear.wav\\\"])\\n\\t\\t\\t\\tenemy.boss_round()\\n\\n\\t\\t\\telif(Board.board[self.x][self.y] in obstacles):\\n\\t\\t\\t\\tMario._pass(self.x,self.y-1)\\n\\t\\t\\t\\tBoard.board[self.x][self.y-1]='M'\\n\\n\\t\\t\\telif((Board.board[self.x+1][self.y-1]=='/' or Board.board[self.x+1][self.y-1]=='T') and Board.board[self.x+1][self.y]==' '):\\n\\t\\t\\t\\tMario._pass(self.x,self.y-1)\\n\\t\\t\\t\\tBoard.board[self.x][self.y+1]='M'\\n\\t\\t\\t\\tMario.go_down(self)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tMario._pass(self.x,self.y-1)\\n\\t\\t\\t\\tBoard.board[self.x][self.y]='M'\\n\\n\\t\\tif( self.y-1 >= ((Board.prev_j+Board.prev_k)/2) ):\\n\\t\\t\\tos.system('clear')\\n\\t\\t\\tBoard.prev_j += 1 \\n\\t\\t\\tBoard.prev_k += 1\\n\\t\\t\\tinit_board(Board.prev_i,Board.prev_j,Board.prev_k)\\n\\t\\telse:\\n\\t\\t\\tos.system('clear')\\n\\t\\t\\tinit_board(Board.prev_i,Board.prev_j,Board.prev_k)\",\n \"def main():\\r\\n turn_left()\\r\\n while front_is_clear():\\r\\n move()\\r\\n turn_right()\\r\\n while front_is_clear():\\r\\n move()\\r\\n turn_right()\\r\\n while front_is_clear():\\r\\n move()\\r\\n turn_left()\",\n \"def move(): #py:move\\n RUR._move_()\",\n \"def execute(self):\\n while(self._running):\\n # get all pygame events from queue\\n for event in pygame.event.get():\\n self.event_handler(event)\\n self.move()\\n self.render()\\n self.cleanup()\",\n \"def algo_mover(self):\\n self.tick_count = 0 ## reset to start clock on delayed state change\\n\\n ### Move 1 ring ###\\n de, aux, vers = self.instructions.pop(0)\\n\\n de = self.rods[de]\\n aux = self.rods[aux]\\n vers = self.rods[vers]\\n\\n ring = de.pop_ring()\\n vers.add_ring(ring)\\n\\n ### Update the states after -- moved this to main update\\n #self.state_updater()\",\n \"def decide(self):\\n self.maybe_shoot()\\n next(self.move_cycle)\\n\\n pass\",\n \"def run(self):\\n for move in self.model.moves:\\n pygame.event.get()\\n self.model.update_matrix(self.model.board.cars[move[0]], move[1])\\n self.setup()\\n time.sleep(0.5)\\n \\n time.sleep(5)\\n pygame.quit\",\n \"def process_IN_MOVE_SELF(self, event):\",\n \"def play_all(self):\\n posicion_actual = self.tiempos.posicion_actual()\\n self.tiempos.volver_al_inicio()\\n while True:\\n try:\\n if not self.tiempos.esta_vacia():\\n self._reproducir(self.tiempos.actual())\\n self.tiempos.siguiente()\\n except StopIteration:\\n self.tiempos.volver_al_inicio()\\n self.tiempos.actualizar(posicion_actual)\\n return\",\n \"def main():\\r\\n turn_left()\\r\\n move_three_times()\\r\\n turn_right()\\r\\n move_three_times()\\r\\n turn_right()\\r\\n move_three_times()\\r\\n turn_left()\",\n \"def play_move(self,state):\\n raise AIError(\\\"Must be implemented for child class!\\\")\",\n \"def _move(self, move: Tile):\\n if not self.game_state:\\n raise RuntimeError(\\\"Cannot call move when the game has not started!\\\")\\n # Adversaries are supposed to be notified of new info right before they move.\\n if issubclass(type(self.current_turn), Enemy):\\n current_enemy = next(enemy for enemy in self.enemy_list if enemy.entity.name == self.current_turn.entity.name)\\n self._notify_adversary(current_enemy)\\n # Players that are alive before this move\\n pre_players = self.game_state.get_current_characters()\\n completed_before_turn = self.game_state.get_completed_characters()\\n if move != None:\\n self._move_and_update(move)\\n else:\\n self.current_turn.notify(self._format_move_result_notification(None, Moveresult.OK))\\n # Notify players and adversaries of changes to the gamestate, including players who were killed\\n # on this turn. Note that this usually results in one rendering per move to all entities.\\n self._update_players()\\n self._update_adversaries()\\n self._handle_completed_characters(completed_before_turn)\\n self._handle_killed_players(pre_players)\\n self.current_turn = self.turn_order.next()\",\n \"def stop(self):\\n self.move(0, 0)\",\n \"def run(self):\\n # type: () -> None\\n self.move_to(self.location)\",\n \"def move(self, surface_size):\\n for molecule in self.molecules:\\n old_position = copy.copy(molecule.get_position()) # remember old position by shallow copy\\n molecule.move()\\n if molecule.handle_collide_with_borders(surface_size): # if it has a collision with border\\n molecule.set_position(old_position) # restore old position\\n collision_molecule = self.is_in_collision_with_other_molecule(molecule)\\n if not collision_molecule is None: # if it has a collision with a molecule\\n molecule.handle_collision_with_molecule(collision_molecule) # handle the collision\\n molecule.set_position(old_position) # restore old position \",\n \"def stop_full(self):\\n self.systems[\\\"driver\\\"].move(0, 0)\",\n \"def move(self, direction):\\n # replace with your code\\n pass\",\n \"def move(self, direction):\\n # replace with your code\\n pass\",\n \"def MULTIPLAYER_LOOP():\\n pass\",\n \"def play_one_move(self, verbose=False):\\n if verbose:\\n self.print(\\\"top of move\\\")\\n\\n # 1) grab three cups\\n c1 = self.cups.remove_next_node()\\n c2 = self.cups.remove_next_node()\\n c3 = self.cups.remove_next_node()\\n if verbose:\\n print(f\\\"pick up: {c1}, {c2}, {c3}\\\")\\n self.print(\\\"after pickup\\\")\\n\\n # 2) find a destination cup\\n destination_node = self.find_next_destination(\\n self.cups.get_current_node().value\\n )\\n if verbose:\\n print(f\\\"destination node is {destination_node}\\\")\\n\\n # 3) insert cups back into the circle\\n self.cups.add_after(destination_node, c3.value)\\n self.cups.add_after(destination_node, c2.value)\\n self.cups.add_after(destination_node, c1.value)\\n if verbose:\\n self.print(\\\"after adding cups..\\\")\\n\\n # 4) select the next cup\\n target_cup = self.cups.get_current_node().next()\\n self.cups.set_current_node(target_cup)\\n\\n if verbose:\\n self.print(\\\"post move\\\")\",\n \"def move_stages(self,positions):\\n for ind_move,pos in enumerate(positions): #move all activated modules to specified positions\\n #self.move_modules[ind_move].move_Abs(pos)\\n self.move_modules_commands[ind_move].emit(utils.ThreadCommand(command=\\\"move_Abs\\\", attributes=[pos]))\",\n \"def run(self):\\n while self.direction != \\\"\\\":\\n if self.direction == \\\"decrease\\\":\\n if self.position > 200:\\n self.position -= 15\\n elif self.direction == \\\"increase\\\":\\n if self.position < 800:\\n self.position += 15\\n if self.direction != \\\"neutral\\\":\\n self.move_joint(self.position, 900)\\n time.sleep(0.1)\",\n \"def play_move(self,state):\\n #Keep asking for the next move until a valid move.\\n while(True):\\n childList = state.get_successors()\\n print(\\\"Your possible moves:\\\")\\n i = 0\\n for c in childList:\\n if i > 0 and i%4 == 0:\\n print()\\n print(c.get_action().ljust(10),end=\\\"\\\\t\\\");\\n i += 1\\n print()\\n nextMove = input(\\\"What is your next move? \\\\ne.g.'F2-E3' or 'Quit'\\\\n\\\")\\n #Check if the move is valid\\n if nextMove.lower() == 'Quit'.lower():\\n return None\\n for c in childList:\\n if c.get_action().upper() == nextMove.upper():\\n return c\\n # Move not possible \\n print(\\\"Invalid move!! Please try again...\\\\n\\\")\",\n \"def move(self):\\n \\n self.position = self.explore()\",\n \"def move(self):\\n for index in range(len(self.segments)-1):\\n segment = self.segments[index].instance\\n x1, y1, x2, y2 = c.coords(self.segments[index+1].instance)\\n c.coords(segment, x1, y1, x2, y2)\\n\\n x1, y1, x2, y2 = c.coords(self.segments[-2].instance)\\n c.coords(self.segments[-1].instance,\\n x1+self.vector[0]*SEG_SIZE, y1+self.vector[1]*SEG_SIZE,\\n x2+self.vector[0]*SEG_SIZE, y2+self.vector[1]*SEG_SIZE)\",\n \"def Move_Stage(self):\\n for i in range(3):\\n if self.set_pos[i] == 0:\\n continue\\n print \\\"Moving stage %s by %s steps\\\\n\\\"%(self.POS_NAME[i], self.set_pos[i])\\n self.ser.write('F,C'+self.STEPPER_NAME[i]+str(self.set_pos[i])+',R')\\n time.sleep(0.5)\\n time.sleep(0.5)\\n return\",\n \"def move_forward():\\n pass\",\n \"def main():\\r\\n\\r\\n movetwotimes()\\r\\n pick_beeper()\\r\\n move()\\r\\n turn_left()\\r\\n movetwotimes()\\r\\n put_beeper()\\r\\n turn_left()\\r\\n turn_left()\\r\\n movetwotimes()\\r\\n rotatethreetimes()\\r\\n movetwotimes()\\r\\n move()\\r\\n turn_left()\\r\\n turn_left()\",\n \"def move(self):\\n t = self.get_time_step() # Get the timestep\\n\\n for body in self.bodies:\\n body.update_pos_revs(t, self.time)\\n\\n # Once all the positions are updated, update all velocities and\\n # accelerations.\\n for body in self.bodies:\\n body.update_vel_acc(t, self.bodies)\\n\\n self.get_energies() # Get the total energy\\n self.time += t # Increase the time by time step.\",\n \"def move(self):\\n if VERBOSE:\\n print('-- move', self.move_number, '--')\\n self.display_cups()\\n\\n picked_up = self.pick_up_cups(3)\\n self.update_destination_cup()\\n\\n if VERBOSE:\\n print('pick up: ', end='')\\n for pick in picked_up:\\n print(pick, end=' ')\\n print()\\n print('destination:', self.destination)\\n print()\\n\\n self.insert_cups(inserts=picked_up, insert_after=self.destination)\\n self.select_new_current_cup()\\n\\n self.move_number += 1\",\n \"def update():\\n move()\\n check_collision()\",\n \"def make_move(self):\\r\\n if self.running and self.run:\\r\\n if self.board is None:\\r\\n SlTrace.lg(\\\"sp.board is None\\\")\\r\\n return False\\r\\n \\r\\n SlTrace.lg(\\\"running_loop self.running and self.run\\\", \\\"running_loop\\\")\\r\\n SlTrace.lg(\\\"running_loop self.start_move\\\", \\\"running_loop\\\")\\r\\n if self.start_move():\\r\\n SlTrace.lg(\\\"running_loop successful start_move\\\", \\\"running_loop\\\")\\r\\n self.next_move_no()\\r\\n SlTrace.lg(\\\"running_loop after start_move\\\", \\\"running_loop\\\")\\r\\n if self.to_pause:\\r\\n self.pause_cmd()\\r\\n self.to_pause = False\\r\\n return True\",\n \"def tick():\\n move_balls(targets_speed)\\n move_super_balls(targets_speed * 2)\",\n \"def thinking(self):\\n if self.motion.moveIsActive():\\n # Maneuver occurring. Let's finish it\\n # before taking any other measure.\\n pass\\n\\n elif not self.sensors['proximity'][0].imminent_collision:\\n # Goes back to moving state.\\n self.behavior_ = self.BEHAVIORS.moving\\n\\n elif all(s.imminent_collision for s in self.sensors['proximity']):\\n # There's nothing left to be done, only flag this is a dead-end.\\n self.behavior_ = self.BEHAVIORS.stuck\\n\\n else:\\n peripheral_sensors = self.sensors['proximity'][1:]\\n for maneuver, sensor in zip(range(1, 4), peripheral_sensors):\\n if not sensor.imminent_collision:\\n # A sensor that indicates no obstacles were found.\\n # Move in that direction.\\n self.motion.post.moveTo(0, 0, np.pi / 2)\\n break\\n\\n return self\",\n \"def move(self):\\n \\n self.position = self.wander()\",\n \"def move(self, direction):\\n pass\",\n \"def update(self):\\n if not self._move:\\n self.get_next_move()\\n if self._move:\\n self._move.update()\",\n \"def breakout_loop(self):\\n while self.playing:\\n self.handle_events()\\n self.update()\\n if self.game_over:\\n self.current_menu = self.fail_menu\\n self.playing = False\\n self.reset()\\n self.draw()\",\n \"def step(self):\\n if not self._is_game_over:\\n self._move_snake()\\n self._is_game_over = self.is_snake_collides()\",\n \"def move(self):\\n\\n # get the location we WOULD go to\\n newX = self.xcor() + self.dx\\n newY = self.ycor() + self.dy\\n while (abs (newX) > self.BOX_RANGE) or (abs(newY) > self.BOX_RANGE):\\n # print(\\\"choosing new direction... \\\",end=\\\"\\\")\\n self.chooseNewDirection()\\n # print(self.dx, self.dy)\\n newX = self.xcor() + self.dx\\n newY = self.ycor() + self.dy\\n\\n # now move our monster\\n super().move()\",\n \"def play_move(self, move):\\n color, move_tuple = convert_from_GTP(move, self.size)\\n result = self.game.move_stone(move_tuple[0], move_tuple[1], color)\\n if result.status != gogame.VALID:\\n raise PlayError, result.status\\n self.board.PlaceMove(move_tuple, color)\\n self.board.ErasePieces(result.prisoners)\\n self.board.SwitchCurColor()\\n\\n self.curWatcher.play(move)\\n\\n #if there are consecutive passes, end the game, else reset pass count\\n if move == \\\"pass\\\":\\n self.isPass += 1\\n if self.isPass == 2:\\n self.end_game()\\n else:\\n self.isPass = 0\\n\\n #switch the players\\n temp = self.curPlayer\\n self.curPlayer = self.curWatcher\\n self.curWatcher = temp\\n \\n if self.isPass < 2:\\n self.call_for_move()\\n else:\\n self.end_game()\",\n \"def _finish_all_moves(self, current_time):\\n\\t\\tfor piece_id in self.all_piece_ids:\\n\\t\\t\\tstate = getattr(self, piece_id)\\n\\t\\t\\tif len(state) == 0:\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\tpiece = Piece(state)\\n\\t\\t\\tif piece.moving:\\n\\t\\t\\t\\tif piece.end_time <= current_time:\\n\\t\\t\\t\\t\\tself._finish_move(piece_id, piece, current_time)\",\n \"async def move(self, movement):\\n next_position = self.position\\n self.position = (next_position + movement) % self.game.positions\\n self.game.player_moved(self)\\n\\n box = None\\n for mov in range(movement):\\n next_position += 1\\n if next_position == self.game.positions:\\n next_position = 0\\n\\n box = self.game.board.get_box(next_position)\\n await self.move_position(box)\\n\\n box.goes_in(self)\",\n \"def decide_next_move(self):\\n pass\",\n \"def move(self, direction):\\n # replace with your code\\n\\n indices = self.direction_indices[direction]\\n for coordinate in indices:\\n merged_coordinate_list = self.get_list(direction, coordinate)\\n self.change_board(merged_coordinate_list, coordinate, direction)\\n print(self.__str__())\\n if self.board_is_not_full():\\n self.new_tile()\",\n \"def movement(self):\",\n \"def move(self):\\n new_velocities = self._create_velocities()\\n for boid, vel in zip(self.boids, new_velocities):\\n boid.change_speed(*vel)\\n for obstacle in self.obstacles:\\n self.boid_omit_obstacle(boid, obstacle)\\n boid.move(self.board_size)\",\n \"def cancel_move(self):\\n self.should_move = False\",\n \"def step(self, action):\\n # print(\\\"############################\\\")\\n # print(\\\"action: {}\\\".format(action))\\n\\n self.movement_complete.data = False\\n\\n # 1) Read last joint positions by getting the observation before acting\\n old_observation = self.get_obs()\\n\\n # 2) Get the new joint positions according to chosen action (actions here are the joint increments)\\n if self._joint_increment is None:\\n next_action_position = action\\n else:\\n next_action_position = self.get_action_to_position(action, old_observation[1:7])\\n\\n # 3) Move to position and wait for moveit to complete the execution\\n self.publisher_to_moveit_object.pub_joints_to_moveit(next_action_position)\\n # rospy.wait_for_message(\\\"/pickbot/movement_complete\\\", Bool)\\n while not self.movement_complete.data:\\n pass\\n\\n start_ros_time = rospy.Time.now()\\n while True:\\n # Check collision:\\n # invalid_collision = self.get_collisions()\\n # if invalid_collision:\\n # print(\\\">>>>>>>>>> Collision: RESET <<<<<<<<<<<<<<<\\\")\\n # observation = self.get_obs()\\n # reward = UMath.compute_reward(observation, -200, True)\\n # observation = self.get_obs()\\n # print(\\\"Test Joint: {}\\\".format(np.around(observation[1:7], decimals=3)))\\n # return U.get_state(observation), reward, True, {}\\n\\n elapsed_time = rospy.Time.now() - start_ros_time\\n if np.isclose(next_action_position, self.joints_state.position, rtol=0.0, atol=0.01).all():\\n break\\n elif elapsed_time > rospy.Duration(2): # time out\\n break\\n # time.sleep(s\\n\\n \\\"\\\"\\\"\\n #execute action as long as the current position is close to the target position and there is no invalid collision and time spend in the while loop is below 1.2 seconds to avoid beeing stuck touching the object and not beeing able to go to the desired position \\n time1=time.time()\\n while np.linalg.norm(np.asarray(self.joints_state.position)-np.asarray(next_action_position))>0.1 and self.get_collisions()==False and time.time()-time1<0.1: \\n rospy.loginfo(\\\"Not yet reached target position and no collision\\\")\\n \\\"\\\"\\\"\\n # 4) Get new observation and update min_distance after performing the action\\n new_observation = self.get_obs()\\n if new_observation[0] < self.min_distace:\\n self.min_distace = new_observation[0]\\n # print(\\\"observ: {}\\\".format( np.around(new_observation[1:7], decimals=3)))\\n\\n # 5) Convert Observations into state\\n state = U.get_state(new_observation)\\n\\n # 6) Check if its done, calculate done_reward\\n done, done_reward, invalid_contact = self.is_done(new_observation)\\n\\n # 7) Calculate reward based on Observatin and done_reward and update the accumulated Episode Reward\\n reward = UMath.compute_reward(new_observation, done_reward, invalid_contact)\\n\\n ### TEST ###\\n if done:\\n joint_pos = self.joints_state.position\\n print(\\\"Joint in step (done): {}\\\".format(np.around(joint_pos, decimals=3)))\\n ### END of TEST ###\\n\\n self.accumulated_episode_reward += reward\\n\\n self.episode_steps += 1\\n\\n return state, reward, done, {}\",\n \"def move(self, move):\\n raise NotImplementedError()\",\n \"def main_loop(self) -> None:\\n while True:\\n player = self._players[self._current_player]\\n hit = True\\n while hit:\\n self.select_square(player)\\n if self.menu_called: # go to menu\\n self.menu_called = False\\n return\\n hit = player.shoot()\\n if player.has_won():\\n self.display_manager.display_end_game_message(player)\\n self.game_over = True\\n return\\n self._current_player = (self._current_player + 1) % len(self._players)\",\n \"def game_loop(self):\\n self.interface.game_loop(self)\",\n \"def move_buildings(self):\",\n \"def move(self):\\n self._move_range_shuffle(3)\\n self._move_satisfy_random_constraint()\\n # self._move_range_shuffle(3)\\n #if (curr_energy > 50):\\n # self._move_satisfy_random_constraint()\\n #else:\\n # self._move_range_shuffle(3)\",\n \"def stop_moves(self,overshoot):\\n self.overshoot = overshoot\\n self.stop_scan()\\n for mod in self.move_modules:\\n mod.stop_Motion()\",\n \"def move_objects(time_elapsed):\\n move_object(ball, time_elapsed)\\n\\n # Bounce the ball off the sides, if necessary.\\n bounce_off_walls(ball, bounds_left, bounds_right,\\n bounds_top, bounds_bottom)\",\n \"def run(self):\\n return self.move_bat()\",\n \"def move(self, board, move_dir):\\n if move_dir == \\\"right\\\":\\n # failsafe: do not move through other cars on board\\n if board.positions[self.get_rows()[0]][self.get_cols()[1] + (self.size - 1)].isupper() or board.positions[self.get_rows()[0]][self.get_cols()[1] + (self.size - 1)] == 'r':\\n print(\\\"No movement!\\\")\\n return board\\n \\n # give board correct new positions (characters)\\n else:\\n board.positions[self.get_rows()[0]][self.get_cols()[1] + (self.size - 1)] = self.name[0]\\n board.positions[self.get_rows()[0]][self.get_cols()[0]] = \\\"x\\\"\\n\\n # change car objects positions\\n for i, col in enumerate(self.position):\\n self.position[i] = str(self.get_rows()[0]) + \\\".\\\" + str(int(col[2]) + 1)\\n return board\\n elif move_dir == \\\"left\\\": \\n if board.positions[self.get_rows()[0]][self.get_cols()[0] - 1].isupper() or board.positions[self.get_rows()[0]][self.get_cols()[0] - 1] == 'r':\\n print(\\\"No movement!\\\")\\n return board\\n else: \\n board.positions[self.get_rows()[0]][self.get_cols()[0] - 1] = self.name[0]\\n board.positions[self.get_rows()[0]][self.get_cols()[1] + (self.size - 2)] = \\\"x\\\"\\n\\n for i, col in enumerate(self.position):\\n self.position[i] = str(self.get_rows()[0]) + \\\".\\\" + str(int(col[2]) - 1)\\n return board\\n elif move_dir == \\\"up\\\":\\n #print(board.positions[self.get_rows()[0] - 1][self.get_cols()[0]])\\n if board.positions[self.get_rows()[0] - 1][self.get_cols()[0]].isupper() or board.positions[self.get_rows()[0] - 1][self.get_cols()[0]] == 'r':\\n print(\\\"No movement!\\\")\\n return board\\n else:\\n board.positions[self.get_rows()[0] - 1][self.get_cols()[0]] = self.name[0]\\n board.positions[self.get_rows()[1] + (self.size - 2)][self.get_cols()[0]] = \\\"x\\\"\\n\\n for i, row in enumerate(self.position):\\n self.position[i] = str(int(row[0]) - 1) + \\\".\\\" + str(self.get_cols()[0])\\n\\n #print(board)\\n return board\\n elif move_dir == \\\"down\\\": \\n try: \\n if board.positions[self.get_rows()[1] + (self.size - 1)][self.get_cols()[0]].isupper() or board.positions[self.get_rows()[1] + (self.size - 1)][self.get_cols()[0]] == 'r':\\n print(\\\"No movement!\\\")\\n return board\\n except IndexError:\\n return board\\n else: \\n board.positions[self.get_rows()[0]][self.get_cols()[0]] = \\\"x\\\" \\n board.positions[self.get_rows()[1] + (self.size - 1)][self.get_cols()[0]] = self.name[0]\\n\\n for i, row in enumerate(self.position):\\n self.position[i] = str(int(row[0]) + 1) + \\\".\\\" + str(self.get_cols()[0]) \\n \\n #print(self.position)\\n #print(board)\\n \\n return board\\n else:\\n #print(\\\"NO MOVEMENT!\\\")\\n return board\",\n \"def move(self, *args, **kw):\\n return self.execute_action('move', *args, **kw)\",\n \"def run(self):\\n for frm_idx in range(self.frames_nbr):\\n for player in self.players:\\n assert isinstance(player, Player)\\n player.play_frame(Frame(pins_nbr=self.pins_nbr))\\n\\n # Check the last frame for each player\\n for player in self.players:\\n if player.frames[self.frames_nbr-1].is_strike():\\n for _ in range(2):\\n player.play_frame(Ball(pins_nbr=self.pins_nbr))\\n if player.frames[self.frames_nbr-1].is_spare():\\n player.play_frame(Ball(pins_nbr=self.pins_nbr))\",\n \"def execute(self):\\n for move in self._queue:\\n move.execute()\",\n \"def move(self):\\n self.old_tail = self.body[-1][:] # save old position of last block\\n self.head[0] += self.direction[0] # moves head\\n self.head[1] += self.direction[1]\\n \\n self.head[0] = (self.head[0] + self.xMaxSize) % self.xMaxSize\\n self.head[1] = (self.head[1] + self.yMaxSize) % self.yMaxSize\\n \\n if self.head in self.body[1:]: # if snakes hits himself\\n self.alive = False\\n self.body.insert(0, self.body.pop()) # each block is replace by predecessor\\n self.body[0] = self.head[:] # first block is head\",\n \"def _play(self, func):\\n\\n func()\\n print('\\\\nhuman movement:\\\\n')\\n print(self._board)\\n\\n while self._board.possible() != []:\\n self._board.move_computer()\\n print('\\\\ncomputer movement:\\\\n')\\n print(self._board)\\n if self._board.check_win():\\n print('\\\\nwinner is computer')\\n return\\n\\n func()\\n print('\\\\nhuman movement:\\\\n')\\n print(self._board)\\n if self._board.check_win():\\n print('\\\\nwinner is human')\\n return\\n print('\\\\nwinner is friendship :)')\",\n \"def second_move(self):\\n self.play_sound(self.second_key)\\n self.end_move()\",\n \"def play(self):\\n for step_i in range(self.max_step):\\n player_id = step_i & 1\\n player = self.players[player_id]\\n action = player.nxt_move()\\n if isinstance(player, mcts.MCTSPlayer) and player.value_net.loggable:\\n print(f'Player{player_id}: Action: {action}')\\n if not self.is_valid_action(action):\\n # because now just consider 2 players\\n print(f\\\"Player: {player_id}, Action: {action} Did Not choose a valid action!\\\")\\n self.board[action // self.w][action % self.w] = player_id\\n self.winner = 1 - player_id\\n else:\\n self.board[action // self.w][action % self.w] = player_id\\n self.winner = self.k0()\\n self.players[1 - player_id].other_nxt_move(action)\\n if self.winner != -1:\\n break\\n print(f'Winner: {self.winner}')\\n for player_id in range(len(self.players)):\\n self.players[player_id].game_ended()\",\n \"def cb_move(self, event):\\n if not self.move_timer.IsRunning():\\n self.move_timer.StartOnce(2000)\",\n \"def automove(self):\\n if self.x < self.end_cinematic_x_pos:\\n self.x += self.SHIP_SPEED\\n if self.x > self.end_cinematic_x_pos:\\n self.x -= self.SHIP_SPEED\\n if self.y < self.end_cinematic_y_pos:\\n self.y += self.SHIP_SPEED\\n if self.y > self.end_cinematic_y_pos:\\n self.y -= self.SHIP_SPEED\",\n \"def move(self, state):\\n raise NotImplementedError(\\\"Need to implement this method\\\")\",\n \"def run(self):\\n super(MovementControl,self).run()\",\n \"def computer_move(board,move,player):\\r\\n com_execution(board, move, player)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67165536","0.6450276","0.642639","0.63869965","0.6380625","0.63037014","0.6282754","0.6249404","0.6245922","0.62315774","0.62287354","0.6171988","0.6170963","0.6135099","0.6109948","0.61098945","0.6106997","0.6100875","0.6084784","0.60692745","0.60664815","0.60551834","0.60430837","0.6031687","0.59905934","0.5970889","0.5970309","0.5951582","0.5913782","0.5900503","0.5897473","0.5885589","0.58787644","0.58590096","0.58473337","0.58400285","0.5838773","0.5827256","0.5824262","0.5821751","0.5820201","0.58136356","0.5808858","0.5798816","0.5773296","0.5770205","0.57286465","0.57259566","0.57259566","0.57195526","0.5718652","0.5712039","0.57094204","0.5708482","0.570673","0.56880033","0.5684509","0.5674727","0.5671478","0.5669837","0.56675595","0.5661917","0.5657067","0.5656929","0.5648097","0.5648022","0.563883","0.5637748","0.56282717","0.5627811","0.5622208","0.56219083","0.5621803","0.56118965","0.56107914","0.56069106","0.56012666","0.55993336","0.55975187","0.55968976","0.5591822","0.5576999","0.55702215","0.5569398","0.5565753","0.5552582","0.5549946","0.5548895","0.5547997","0.5545769","0.55416554","0.55398065","0.5539588","0.5538935","0.5537801","0.553413","0.5533832","0.55330515","0.55300486","0.55298233","0.5520182"],"string":"[\n \"0.67165536\",\n \"0.6450276\",\n \"0.642639\",\n \"0.63869965\",\n \"0.6380625\",\n \"0.63037014\",\n \"0.6282754\",\n \"0.6249404\",\n \"0.6245922\",\n \"0.62315774\",\n \"0.62287354\",\n \"0.6171988\",\n \"0.6170963\",\n \"0.6135099\",\n \"0.6109948\",\n \"0.61098945\",\n \"0.6106997\",\n \"0.6100875\",\n \"0.6084784\",\n \"0.60692745\",\n \"0.60664815\",\n \"0.60551834\",\n \"0.60430837\",\n \"0.6031687\",\n \"0.59905934\",\n \"0.5970889\",\n \"0.5970309\",\n \"0.5951582\",\n \"0.5913782\",\n \"0.5900503\",\n \"0.5897473\",\n \"0.5885589\",\n \"0.58787644\",\n \"0.58590096\",\n \"0.58473337\",\n \"0.58400285\",\n \"0.5838773\",\n \"0.5827256\",\n \"0.5824262\",\n \"0.5821751\",\n \"0.5820201\",\n \"0.58136356\",\n \"0.5808858\",\n \"0.5798816\",\n \"0.5773296\",\n \"0.5770205\",\n \"0.57286465\",\n \"0.57259566\",\n \"0.57259566\",\n \"0.57195526\",\n \"0.5718652\",\n \"0.5712039\",\n \"0.57094204\",\n \"0.5708482\",\n \"0.570673\",\n \"0.56880033\",\n \"0.5684509\",\n \"0.5674727\",\n \"0.5671478\",\n \"0.5669837\",\n \"0.56675595\",\n \"0.5661917\",\n \"0.5657067\",\n \"0.5656929\",\n \"0.5648097\",\n \"0.5648022\",\n \"0.563883\",\n \"0.5637748\",\n \"0.56282717\",\n \"0.5627811\",\n \"0.5622208\",\n \"0.56219083\",\n \"0.5621803\",\n \"0.56118965\",\n \"0.56107914\",\n \"0.56069106\",\n \"0.56012666\",\n \"0.55993336\",\n \"0.55975187\",\n \"0.55968976\",\n \"0.5591822\",\n \"0.5576999\",\n \"0.55702215\",\n \"0.5569398\",\n \"0.5565753\",\n \"0.5552582\",\n \"0.5549946\",\n \"0.5548895\",\n \"0.5547997\",\n \"0.5545769\",\n \"0.55416554\",\n \"0.55398065\",\n \"0.5539588\",\n \"0.5538935\",\n \"0.5537801\",\n \"0.553413\",\n \"0.5533832\",\n \"0.55330515\",\n \"0.55300486\",\n \"0.55298233\",\n \"0.5520182\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":22897,"cells":{"query":{"kind":"string","value":"Move in any number of components, but at least one."},"document":{"kind":"string","value":"def selective(G, H):\n left_1 = {selective(G_L, H) for G_L in G._left}\n left_2 = {selective(G, H_L) for H_L in H._left}\n left_3 = {selective(G_L, H_L) for G_L in G._left for H_L in H._left}\n right_1 = {selective(G_R, H) for G_R in G._right}\n right_2 = {selective(G, H_R) for H_R in H._right}\n right_3 = {selective(G_R, H_R) for G_R in G._right for H_R in H._right}\n return Game(left_1 | left_2 | left_3, right_1 | right_2 | right_3)"},"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 _move_in_one_more_block():\n with tik_inst.for_range(0, sub_h_align_block_size) as sub_h_idx:\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block * sub_h_idx],\n src[w_offset + w_size * sub_h_idx], 0, 1, sub_w_block, 0, 0)\n # in order to avoid dirty data when multiple core\n with tik_inst.for_range(0, data_cnt_one_block) as sub_h_idx_1:\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block *\n (sub_h_align_block_size + sub_h_idx_1)],\n src[w_offset +\n w_size * (sub_h_size - data_cnt_one_block + sub_h_idx_1)],\n 0, 1, sub_w_block, 0, 0)","def move(self, heaps: Tuple[int, ...], misere: bool) -> Tuple[int, int]:\r\n pass","def moveSpecialOb(self):\n\t\tfor obJ in self.special:\n\t\t\tobJ.moveStep()","def _ispinnedmove(self, from_, to_):\n return False","def move(self): # AH note. Swich move with extra_steps?\n if self.adjustment < 0:\n self.position += self.extra_steps\n super().move()\n self.no_moves += 1\n # Do the regular move","def memmove(self, grid):\n self.moveList.append((self.x, self.y))\n self.moveList2.append((self.x, self.y))\n waysList = []\n for f in range(4):\n if self.test(grid, f):\n if (self.x+SPEED_X[f], self.y+SPEED_Y[f]) not in self.moveList:\n waysList.append(f)\n if len(waysList) == 1:\n self.flag = waysList[0]\n self.move(grid)\n return\n elif len(waysList) == 4:\n self.flag = 0\n self.move(grid)\n return\n elif len(waysList) > 1:\n for f in waysList:\n self.mem.append((self.x, self.y, f))\n self.x, self.y, self.flag = self.mem[-1]\n elif len(waysList) == 0:\n self.x, self.y, self.flag = self.mem[-1]\n for i in range(len(self.moveList2)):\n if self.moveList2[i][0] == self.x and self.moveList2[i][1] == self.y:\n del self.moveList2[i+1:]\n break\n self.move(grid)\n self.mem.pop()","def move(self):\n pass","def _move_in_one_more_block():\n with tik_inst.for_range(0, sub_h_align_block_size) as sub_h_idx_0:\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block * sub_h_idx_0],\n src[in_offset + sub_h_idx_0 * w_size],\n 0, 1, sub_w_block, 0, 0)\n # move in one more block of h\n with tik_inst.for_range(0, data_cnt_one_block) as sub_h_idx_1:\n tik_inst.data_move(\n dst[sub_w_block * data_cnt_one_block * (sub_h_align_block_size + sub_h_idx_1)],\n src[in_offset + (sub_h_idx_1 + sub_h_size - data_cnt_one_block) * w_size],\n 0, 1, sub_w_block, 0, 0)","def no_more_move(self):\n if (self.p_no_move + self.c_no_move == 2):\n return True\n return False","def legalMove(turtles, poles, m, n, count):\n if len(poles[m]) != 0 and (len(poles[n]) == 0 or poles[m][-1] < poles[n][-1]): #one possible legal move btwn m and n\n moveTurt(turtles[poles[m][-1] - 1], n, count)\n poles[n].append(poles[m].pop())\n if len(poles[0]) == 0 and len(poles[1]) == 0:\n return\n elif len(poles[n]) != 0 and (len(poles[m]) == 0 or poles[n][-1] < poles[m][-1]): #other possible legal move btwn m and n\n moveTurt(turtles[poles[n][-1] - 1], m, count)\n poles[m].append(poles[n].pop())","def move(self):\n raise NotImplementedError","def move(a, i):\n x, d = a[i]\n if is_movable(a, i):\n if d == left:\n swap(a, i, i - 1)\n elif d == right:\n swap(a, i, i + 1)\n else:\n raise ValueError(\"unknown direction d = {}\".format(d))\n else:\n raise ValueError(\"not movable\")","def decide_next_move(self):\n pass","def move_forward():\n pass","def unmakeMove(self, move):","def moveNorth(self):\n north = (self.current[0], self.current[1] - 1)\n mv = self.lab.north()\n self.check_grue(mv)\n self.current = north\n self.visited.add(self.current)","def move(self, direction, cycles):\n\t\tpass","def move_to_position1(self):","def move(self) -> bool:\n pass","def get_next_moves3(self):\n \"\"\" These moves avoid completing the third side of a box, so that the player will not be able to score that box\"\"\"\n moves = []\n for i in range(len(self.board)):\n for j in range(len(self.board[i])):\n if self.board[i][j] == \"\" and self.move_second_inbox(i, j):\n next_board = copy.deepcopy(self.board)\n next_board[i][j] = colors[self.turn] + self.turn + \"\\u001b[0m\"\n next_turn = get_opponent(self.turn)\n moves.append(DotsAndBoxesState(next_board, next_turn))\n return moves","def move(x,y):\r\n pass","def move_buildings(self):","def single_move(triple):\r\n c = 0 # mark of a 1\r\n h = 0 # mark of a 2\r\n for i in triple:\r\n if i==1:\r\n c+=1\r\n elif i==2:\r\n h+=1\r\n if (c,h) == (2,0):\r\n return True\r\n elif (c,h) == (0,2):\r\n return True\r\n return False","def move(self, *args, **kw):\n return self.execute_action('move', *args, **kw)","def move(self, move):\n raise NotImplementedError()","def _move_item(self, src, dst):\n \"Does nothing\"","def check4move(st, selected_unit, direction):\n return 1","def move_silent(self, pos):\n self.move(pos, silent=True)","def bump_moving_obstacle(\n state: State, action: Action, next_state: State\n) -> bool:\n return overlap(state, action, next_state, object_type=MovingObstacle)","def move(name, other, newname=None):","def move_lift_up():\n return _move_lift(1)","def op_move_preconditions(self):\n\n if(self.next_move != self.FREE):\n return False\n\n return True","def moveOddPoles(poles, n, turtles, count):\n if done(poles):\n return\n\n legalMove(turtles, poles, 0, 2, count)\n\n if done(poles):\n return\n\n legalMove(turtles, poles, 0, 1, count)\n\n if done(poles):\n return\n\n legalMove(turtles, poles, 1, 2, count)\n\n moveOddPoles(poles, n, turtles, count)","def move(self):\n self._move_range_shuffle(3)\n self._move_satisfy_random_constraint()\n # self._move_range_shuffle(3)\n #if (curr_energy > 50):\n # self._move_satisfy_random_constraint()\n #else:\n # self._move_range_shuffle(3)","def move_step(self, direction):\n x = self.objects[0].x\n y = self.objects[0].y\n if direction == 0 and y >= 1:\n self.objects[0].y -= 1\n elif direction == 1 and y <= self.size_y - 2:\n self.objects[0].y += 1\n elif direction == 2 and x >= 1:\n self.objects[0].x -= 1\n elif direction == 3 and x <= self.size_x - 2:\n self.objects[0].x += 1","def move(*args, absolute: bool=True, componentOffset: bool=True, componentSpace: bool=True,\n constrainAlongNormal: bool=True, deletePriorHistory: bool=True, localSpace: bool=True,\n moveX: bool=True, moveXY: bool=True, moveXYZ: bool=True, moveXZ: bool=True, moveY:\n bool=True, moveYZ: bool=True, moveZ: bool=True, objectSpace: bool=True, orientJoint:\n AnyStr=\"\", parameter: bool=True, preserveChildPosition: bool=False,\n preserveGeometryPosition: bool=False, preserveUV: bool=False, reflection: bool=True,\n reflectionAboutBBox: bool=True, reflectionAboutOrigin: bool=True, reflectionAboutX:\n bool=True, reflectionAboutY: bool=True, reflectionAboutZ: bool=True,\n reflectionTolerance: float=0.0, relative: bool=True, rotatePivotRelative: bool=True,\n scalePivotRelative: bool=True, secondaryAxisOrient: AnyStr=\"\", symNegative: bool=True,\n worldSpace: bool=True, worldSpaceDistance: bool=True, xformConstraint: AnyStr=\"\",\n **kwargs)->None:\n pass","def move(t, length):\n pu(t)\n\t\n fd(t, length)\n pd(t)","def force_move():\n if ZERO_BASE_PLYR_POS in range(0, 10):\n # we cant go up, so go down\n move_player(\"south\")\n else:\n move_player(\"north\")","def getFirstMove(self):\n while True:\n try:\n move = tuple(int(str.strip()) for str in raw_input('Choose your first move: ').split(','))\n break\n except ValueError:\n print(\"Input is not a integer.\")\n\n while move not in [(1, 1), (self.grid.width/2, self.grid.height/2), \\\n (self.grid.width/2+1, self.grid.height/2+1), (self.grid.width, self.grid.height)]:\n print 'First move is not valid.'\n move = tuple(int(str.strip()) for str in raw_input('Choose your first move: ').split(','))\n return move","def move(self, _vec):\n\n\t\t_dest = self._grid[0] + _vec[0], self._grid[1] + _vec[1], self._grid[2] + _vec[2]\n\t\tif _vec[2]: # jeśli ruszamy się w z to znaczy że wchodzimy po schodach\n\t\t\tself._map.getLayer('Fields').get(self._pos).getLogic().occupy(None)\n\t\t\tself._grid = _dest\n\t\t\tself._pos = 32 * self._grid[0] + 16, 32 * self._grid[1] + 16\n\t\t\tself._dest = None\n\t\t\treturn\n\n\t\tif self._dest: # nie ma pola docelowego = brak ruchu\n\t\t\treturn\n\n\t\t_field = self._map.getLayer('Fields').get((_dest[0] * 32 + 16, _dest[1] * 32 + 16))\n\t\tif not _field: # brak pola = brak ruchu\n\t\t\treturn\n\t\t\n\t\t_field = _field.getLogic()\n\t\tif _field.getModifier() & field.MODIFIER_BLOCKED or not _field.getOccupied() in (None, self): # pole zablokowane, bądź zajęte przez kogoś innego\n\t\t\treturn\n\n\t\t_field.occupy(self)\n\t\tself._dest = _dest","def test_x_first_move(self):\n board = [[None, None, None],\n [None, None, None],\n [None, None, None]]\n \n self.assertEqual(char_move_order(board), (x_char, o_char))","def move_many(self,\r\n sourcerange=None,\r\n destinationrange=None,\r\n subordinate=False,\r\n makecompact=False,\r\n all_children=False,\r\n withchildren=True,\r\n copy=False):\r\n\r\n if sourcerange is None:\r\n sourcerange = []\r\n if destinationrange is None:\r\n destinationrange = []\r\n flatten = False\r\n\r\n\r\n\r\n if not withchildren:\r\n sourcerange = [a_temp for a_temp in sourcerange if a_temp.is_top()]\r\n\r\n if len(destinationrange)==1 and \\\r\n (subordinate and str(destinationrange[0]) in self.indexes()\r\n and str(destinationrange[0].child()) not in self.indexes()):\r\n\r\n for i_temp in sourcerange:\r\n\r\n self.move(i_temp,\r\n destinationrange[0].subordinate(i_temp),\r\n withchildren=False,\r\n copy=copy)\r\n\r\n elif len(destinationrange)==1 and (makecompact\r\n and str(destinationrange[0])\r\n in self.indexes()\r\n and str(destinationrange[0].child()) not in self.indexes()):\r\n\r\n j_temp = destinationrange[0].child()\r\n for i_temp in sourcerange:\r\n self.move(i_temp,\r\n j_temp,\r\n withchildren=False,\r\n copy=copy)\r\n j_temp = j_temp.next()\r\n\r\n elif len(destinationrange)==1 and all_children \\\r\n and str(destinationrange[0]) in self.indexes():\r\n\r\n childcount = 1\r\n for i_temp in sourcerange:\r\n j_temp = destinationrange[0]\r\n for a_temp in range(childcount):\r\n j_temp = j_temp.child()\r\n childcount += 1\r\n self.move(i_temp,\r\n j_temp,\r\n withchildren=withchildren,\r\n copy=copy)\r\n\r\n else:\r\n\r\n sourcecycle = cycle(sourcerange)\r\n destinationcycle = cycle(destinationrange)\r\n if withchildren: #not deleted\r\n flatten = True\r\n\r\n for a_temp in range(len(sourcerange)):\r\n\r\n i_temp = next(sourcecycle)\r\n j_temp = next(destinationcycle)\r\n\r\n self.move(i_temp,\r\n j_temp,\r\n withchildren=withchildren,\r\n flatten=flatten,\r\n copy=copy)","def move_valid(move):\n return True","def move(self, rel_pos):\n self.pos = (self.pos[0] + rel_pos[0] * GRID, self.pos[1] + rel_pos[1] * GRID)","def choose_move(self):\r\n \r\n return None","def move(self, t, s):\n raise NotImplementedError","def handleMove(self):\n pass","def position_at_least(self, a, b):\n return None","def choose_move(self):\n raise NotImplementedError()","def move_atoms(self):\n return self.abivars.ionmov != 0","def hanota(self, A: List[int], B: List[int], C: List[int]) -> None:\n n = len(A)\n self.move(n, A, B, C)","def step(self, move):","def move(self, origin_index, new_index):\n if len(self._stools[origin_index]) == 0:\n pass\n elif len(self._stools[new_index]) == 0:\n self.add(self.get_top_cheese(origin_index), new_index)\n self._stools[origin_index].pop()\n self._move_seq.add_move(origin_index, new_index)\n elif self._stools[origin_index][-1].size < \\\n self._stools[new_index][-1].size:\n self.add(self.get_top_cheese(origin_index), new_index)\n self._stools[origin_index].pop()\n self._move_seq.add_move(origin_index, new_index)\n else:\n raise IllegalMoveError","def move_to_position2(self):","def firstMove(self):\n return (10, 10)","def exactly_one_knights_move(variables):\n cnf = []\n\n for valid_move in variables[:-1]:\n # print(valid_move)\n cnf.append([-valid_move, -variables[-1]])\n\n return cnf","def move_multi_wire_gates(self, operator_grid):\n n = operator_grid.num_layers\n i = -1\n while i < n - 1:\n i += 1\n\n this_layer = operator_grid.layer(i)\n layer_ops = _remove_duplicates(this_layer)\n other_layer = [None] * operator_grid.num_wires\n\n for j in range(len(layer_ops)):\n op = layer_ops[j]\n\n if op is None:\n continue\n\n # translate wires to their indices on the device\n wire_indices = self.active_wires.indices(op.wires)\n\n if len(op.wires) > 1:\n\n sorted_wires = wire_indices.copy()\n sorted_wires.sort()\n\n blocked_wires = list(range(sorted_wires[0], sorted_wires[-1] + 1))\n\n for k in range(j + 1, len(layer_ops)):\n other_op = layer_ops[k]\n\n if other_op is None:\n continue\n\n # translate wires to their indices on the device\n other_wire_indices = self.active_wires.indices(other_op.wires)\n other_sorted_wire_indices = other_wire_indices.copy()\n other_sorted_wire_indices.sort()\n other_blocked_wires = list(\n range(other_sorted_wire_indices[0], other_sorted_wire_indices[-1] + 1)\n )\n\n if not set(other_blocked_wires).isdisjoint(set(blocked_wires)):\n op_indices = [\n idx for idx, layer_op in enumerate(this_layer) if layer_op == op\n ]\n\n for l in op_indices:\n other_layer[l] = op\n this_layer[l] = None\n\n break\n\n if not all([item is None for item in other_layer]):\n operator_grid.insert_layer(i + 1, other_layer)\n n += 1","def _move_comp_person(self):\n\n move_tuple = random.choice(self._board.possible())\n self._board[move_tuple] = 'x'","def test_first_move(self):\n\t\tdata = {'moves': [],\n\t\t\t\t'player_number': 1}\n\t\tfor AI in self.list_of_AIs:\n\t\t\tself.assertTrue(AI.move(data) in ['r', 'p', 's'])","def motion(self):\n priority = {\"north\": [-1, 0], \"south\": [1, 0],\n \"east\": [0, 1], \"west\": [0, -1]}\n\n priority_list = [\"north\", \"south\", \"east\", \"west\"]\n\n critical_point = False\n while critical_point is False:\n row = self.curr_cell.row\n column = self.curr_cell.col\n\n if self.allow_to_move(priority_list[0],\n row + priority[priority_list[0]][0],\n column + priority[priority_list[0]][1]):\n\n self.move(priority_list[0])\n\n elif self.allow_to_move(priority_list[1],\n row + priority[priority_list[1]][0],\n column + priority[priority_list[1]][1]):\n\n self.move(priority_list[1])\n\n elif self.allow_to_move(priority_list[2],\n row + priority[priority_list[2]][0],\n column + priority[priority_list[2]][1]):\n\n self.move(priority_list[2])\n\n elif self.allow_to_move(priority_list[3],\n row + priority[priority_list[3]][0],\n column + priority[priority_list[3]][1]):\n\n self.move(priority_list[3])\n\n else:\n # Robot isolated\n critical_point = True\n\n return self.curr_cell, self.path","def test_fourth_move(self):\n\t\tdata = {'moves': [('r','s'), ('r','p'), ('s','p')],\n\t\t\t\t'player_number': 2}\n\t\tfor AI in self.list_of_AIs:\n\t\t\tself.assertTrue(AI.move(data) in ['r', 'p', 's'])","def firstMove(board):\r\n x = board.size / 2\r\n return (x, x)","def move(self) -> None:\n\n if self.move_up:\n self.__moveUpIfPossible()\n if self.move_down:\n self.__moveDownIfPossible()","def test_valid_move():\n\n board = Board()\n\n # a col outside the width of the board should be false\n assert board.valid_move(board.get_grid_size()[1] + 1) is False\n\n # only positive cols should be considered for a move\n assert board.valid_move(-2) is False\n\n # since board is empty all cols should have moves\n for i in range(board.get_grid_size()[1]):\n assert board.valid_move(i) is True\n\n # if a col is full no move can be made\n for i in range(board.get_grid_size()[1]):\n if i % 2 == 0:\n board.move(board.P1, 0)\n else:\n board.move(board.P2, 0)\n\n \"\"\"\n board now looks like this...\n \n 0 1 2 3 4 5 6 \n +-+-+-+-+-+-+-+\n 0|O|-|-|-|-|-|-|0\n +-+-+-+-+-+-+-+\n 1|X|-|-|-|-|-|-|1\n +-+-+-+-+-+-+-+\n 2|O|-|-|-|-|-|-|2\n +-+-+-+-+-+-+-+\n 3|X|-|-|-|-|-|-|3\n +-+-+-+-+-+-+-+\n 4|O|-|-|-|-|-|-|4\n +-+-+-+-+-+-+-+\n 5|X|-|-|-|-|-|-|5\n +-+-+-+-+-+-+-+\n 0 1 2 3 4 5 6 \n\n \"\"\"\n assert board.valid_move(0) is False","def move_element(self,n_a,n_b):\n self.element_array.insert(n_b,self.element_array.pop(n_a))","def move_second_inbox(self, i, j):\n \"\"\"the function achieves the above statement by not filling in the third line of any possible sqaure \"\"\"\n if i == 0: #top\n return check_two_spots(self.board[i+1][j-1], self.board[i+1][j+1], self.board[i+2][j])\n\n if i == 6: #bottom\n return check_two_spots(self.board[i-1][j-1], self.board[i-1][j+1], self.board[i-2][j])\n\n if j == 0: #left\n return check_two_spots(self.board[i-1][j+1], self.board[i+1][j+1], self.board[i][j+2])\n\n\n if j == 6: #right\n return check_two_spots(self.board[i-1][j-1], self.board[i+1][j-1], self.board[i][j-2])\n\n\n if i == 2 or i == 4: # possible horizontal moves\n return check_two_spots(self.board[i-1][j-1], self.board[i-1][j+1], self.board[i-2][j]) and check_two_spots(self.board[i+1][j-1], self.board[i+1][j+1], self.board[i+2][j])\n\n if j == 2 or j == 4: # possible vertical moves\n return check_two_spots(self.board[i-1][j-1], self.board[i+1][j-1], self.board[i][j-2]) and check_two_spots(self.board[i-1][j+1], self.board[i+1][j+1], self.board[i][j+2])","def m_move1(state,b1,b2):\n if b2 != 'hand' and not state.holding['hand']:\n if b2 == 'table':\n return [('clear',b1,True), ('pos', b1, 'hand'), ('pos', b1, b2)]\n else:\n return [('clear',b2,True), ('clear',b1,True), \\\n ('pos', b1, 'hand'), ('pos', b1, b2)]","def _pull(self, action):\n change = CHANGE_COORDINATES[(action - 1) % 4]\n new_position = self.player_position + change\n current_position = self.player_position.copy()\n pull_content_position = self.player_position - change\n\n # Move player if the field in the moving direction is either\n # an empty field or an empty box target.\n if self.room_state[new_position[0], new_position[1]] in [1, 2]:\n self.player_position = new_position\n self.room_state[(new_position[0], new_position[1])] = 5\n self.room_state[current_position[0], current_position[1]] = \\\n self.room_fixed[current_position[0], current_position[1]]\n\n box_next_to_player = self.room_state[pull_content_position[0], pull_content_position[1]] in [3, 4]\n if box_next_to_player:\n # Move Box\n box_type = 4\n if self.room_fixed[current_position[0], current_position[1]] == 2:\n box_type = 3\n self.room_state[current_position[0], current_position[1]] = box_type\n self.room_state[pull_content_position[0], pull_content_position[1]] = \\\n self.room_fixed[pull_content_position[0], pull_content_position[1]]\n\n return True, box_next_to_player\n\n return False, False","def valid_move(x, y):\r\n if [x, y] in empty_cells(board):\r\n return True\r\n else:\r\n return False","def turn_around():\n for i in range(2):\n turn_left()","def choose_move(self):\n return 0","def _undo_naughty_movement(self, set_balls_that_moved :Set[Ball], set_bots_that_moved :Set[Robot]):\n ball :Ball\n bot :Robot\n bln_naughty = True\n lng_naughty_loop_count = 0\n lng_naughty_loop_limit = len(self.lstBalls) + len(self.lstRobots) # worst case scenario\n while bln_naughty:\n lng_naughty_loop_count += 1\n if lng_naughty_loop_count > lng_naughty_loop_limit:\n if const.GAME_MODE:\n print(\"WARNING: UNABLE TO RESOLVE ALL COLLISIONS FOR FRAME.\")\n else:\n raise Exception(\"UNABLE TO RESOLVE ALL COLLISIONS FOR FRAME\")\n set_naughty_bots = set()\n set_naughty_balls = set()\n\n \"\"\" Ball vs Ball \"\"\"\n for ball1, ball2 in TrashyPhysics.collision_pairs_self(\n self.grpBalls, fncCollided=TrashyPhysics.balls_collided):\n set_naughty_balls.add(ball1)\n set_naughty_balls.add(ball2)\n\n \"\"\" Ball vs Bot \"\"\"\n for ball, bot in TrashyPhysics.collision_pairs(\n self.grpBalls, self.grpRobots,\n fncCollided=TrashyPhysics.ball_robot_collided):\n set_naughty_balls.add(ball)\n set_naughty_bots.add(bot)\n\n \"\"\" Ball vs Wall \"\"\"\n for ball in filter(lambda x: TrashyPhysics.collided_wall(x), self.lstBalls):\n set_naughty_balls.add(ball)\n\n \"\"\" Ball vs Bumper \"\"\"\n # todo\n\n \"\"\" Undo movement. \"\"\"\n bln_naughty = len(set_naughty_bots) + len(set_naughty_balls) > 0\n for bot in set_bots_that_moved & set_naughty_bots:\n set_bots_that_moved.remove(bot)\n if not bot.undo_move():\n print(f\"UNABLE TO UNDO MOVE FOR BOT: {bot}\")\n for ball in set_balls_that_moved & set_naughty_balls:\n set_balls_that_moved.remove(ball)\n if not ball.undo_move():\n print(f\"UNABLE TO UNDO MOVE FOR BALL: {ball}\")","def decide_move(self, action):\n x1, y1 = action['xy1']\n x2, y2 = action['xy2']\n self.__state.push(action)","def move(x, y, direction, board):\n\n piece_at_xy = starter.get_piece(x, y, board); # Getting necessary pieces\n\n assert piece_at_xy != '*', \"Error in swipe logic\"; # Logical debug case\n valid_direction = (direction == \"left\" or\n direction == \"right\" or\n direction == \"up\" or\n direction == \"down\");\n assert valid_direction, \"Invalid direction passed in\"; # Logical debug case\n\n # The new x and y for the current piece (adjacent's current position) are stored alongside adjacent (fewer ifs + redundant code)\n if direction == \"left\":\n adjacent = (starter.get_piece(x - 1, y, board), x - 1, y);\n elif direction == \"right\":\n adjacent = (starter.get_piece(x + 1, y, board), x + 1, y);\n elif direction == \"up\":\n adjacent = (starter.get_piece(x, y - 1, board), x, y - 1);\n elif direction == \"down\":\n adjacent = (starter.get_piece(x, y + 1, board), x, y + 1);\n\n if adjacent[0] == None: # Edge of the board case (no action taken)\n return False;\n\n elif piece_at_xy != adjacent[0] and adjacent[0] != '*': # Can't combine two numbers case (no action taken)\n return False;\n\n elif adjacent[0] == '*': # Empty spot adjacent case (recursive movement in direction)\n starter.place_piece('*', x, y, board);\n starter.place_piece(piece_at_xy, adjacent[1], adjacent[2], board);\n move(adjacent[1], adjacent[2], direction, board);\n return True;\n\n elif piece_at_xy == adjacent[0]: # Adjacent same numbers case (combine them)\n starter.place_piece('*', x, y, board);\n starter.place_piece(str(int(adjacent[0]) * 2), adjacent[1], adjacent[2], board);\n move(adjacent[1], adjacent[2], direction, board);\n return True;\n\n else:\n # Logical debug case\n assert False, \"No way you should be in here. Error in move logic\";\n\n return False;","def mass_move(self,\r\n entrylist1,\r\n entrylist2):\r\n\r\n\r\n if len(entrylist1) > len(entrylist2):\r\n entrylist2 = entrylist2+list(range(entrylist2[-1]+1,\r\n (entrylist2[-1]\r\n +len(entrylist1)\r\n -len(entrylist2))))\r\n lastindexto = entrylist2[0]\r\n\r\n e1 = iter(entrylist1)\r\n e2 = iter(entrylist2)\r\n gofurther = True\r\n\r\n while gofurther:\r\n try:\r\n indexfrom = next(e1)\r\n except StopIteration:\r\n indexfrom = StopIteration\r\n try:\r\n indexto = self.find_space(next(e2), entrylist2)\r\n except StopIteration:\r\n indexto = StopIteration\r\n if indexto != StopIteration:\r\n lastindexto = indexto\r\n if indexto == StopIteration:\r\n indexto = self.find_space(lastindexto)\r\n\r\n if indexfrom != StopIteration:\r\n self.display_buffer.append(alerts.MOVING_FROM\r\n +index_reduce(str(indexfrom))\r\n +queries.TOTO+str(indexto))\r\n self.move(indexfrom, indexto)\r\n else:\r\n gofurther = False","def move(self, i, j):\n board_cpy = copy.deepcopy(self.board)\n piece = self.board[self.selected[0]][self.selected[1]]\n if piece == 0:\n return False\n elif piece.player != self.active_player:\n print(\"it's not your turn\", piece.player, self.active_player)\n return False\n elif self.board[i][j] != 0:\n if piece.player == self.board[i][j].player:\n print(\"can't capture your own pieces\")\n return False\n if i==self.selected[0] and piece.direction == 0:\n if piece.master == False:\n if (i + j - sum(self.selected))%2 == 0:\n print(\"must choose a different color\")\n return False\n if j < self.selected[1]:\n spaces_between = [self.board[i][y] for y in range(j+1, self.selected[1])]\n else:\n spaces_between = [self.board[i][y] for y in range(self.selected[1]+1, j)]\n print(spaces_between)\n for p in spaces_between:\n if p != 0:\n print(\"can't jump pieces\")\n return False\n piece.direction = 1\n self.board[i][j] = piece\n self.board[self.selected[0]][self.selected[1]] = 0\n elif j==self.selected[1] and piece.direction == 1:\n if piece.master == False:\n if (i + j - sum(self.selected))%2 == 0:\n print(\"must choose a different color\")\n return False\n if i < self.selected[0]:\n spaces_between = [self.board[x][j] for x in range(i+1, self.selected[0])]\n else:\n spaces_between = [self.board[x][j] for x in range(self.selected[0]+1, i)] \n print(spaces_between)\n for p in spaces_between:\n if p != 0:\n print(\"can't jump pieces\")\n return False\n piece.direction = 0\n self.board[i][j] = piece\n self.board[self.selected[0]][self.selected[1]] = 0\n else:\n print(\"Invalid movement\")\n return False\n if self.board[i][j] == 0:\n print(\"Something wrong happened\")\n return False\n elif (i==0 or i==self.board_size-1) and (j==0 or j==self.board_size-1):\n self.board[i][j].master = True\n self.active_player = (self.active_player+1)%2\n self.sequence += [board_cpy]\n return True","def move_circular(self, count):\n planned_move = self.cur_pos + count\n if count + planned_move < self.length:\n move_count = count\n self.cur_pos += move_count\n # print(\"Move less from {} to {}({})\".format(\n # self.cur_pos,\n # self.cur_pos + move_count,\n # planned_move\n # ))\n else:\n self.cur_node = self.start_node\n move_count = max(0, (planned_move % (self.length)))\n # print(\"Move circ from {} to {}({})\".format(self.cur_pos, move_count, planned_move))\n self.cur_pos = move_count\n for _ in range(move_count):\n self.cur_node = self.cur_node.next","def move_1_piece(context: GUI, old_coordinate, new_coordinate):\n\n old_tile = context.board.board_dict[old_coordinate]\n new_tile = context.board.board_dict[new_coordinate]\n\n new_tile.piece = old_tile.piece\n old_tile.piece = None\n\n context.update_move_printer(old_coordinate + \" \" + new_coordinate)","def qmove(az=None, el=None, ants=0) :\n move(az, el, ants, waiton=NONE)","def automove(self):\n if self.x < self.end_cinematic_x_pos:\n self.x += self.SHIP_SPEED\n if self.x > self.end_cinematic_x_pos:\n self.x -= self.SHIP_SPEED\n if self.y < self.end_cinematic_y_pos:\n self.y += self.SHIP_SPEED\n if self.y > self.end_cinematic_y_pos:\n self.y -= self.SHIP_SPEED","def move_wrapper(board, player, trials):\r\n move = mm_move(board, player)\r\n assert move[1] != (-1, -1), \"returned illegal move (-1, -1)\"\r\n return move[1]","def move_wrapper(board, player, trials):\r\n move = mm_move(board, player)\r\n assert move[1] != (-1, -1), \"returned illegal move (-1, -1)\"\r\n return move[1]","def pixelMove(*args, **kwargs)->None:\n pass","def move(self, start, distance, p1):\n if (p1):\n #move your piece\n self.p1vec[start] -= 1\n dest = start + distance\n if (dest == 25):\n self.bornoff = True\n else:\n self.p1vec[start+distance] += 1\n #capture your opponent, despite their number\n spot = 25 - start - distance\n self.p2vec[0] += self.p2vec[spot]\n self.p2vec[spot] = 0\n else:\n #move your piece\n self.p2vec[start] -= 1\n dest = start + distance\n if (dest == 25):\n pass\n else:\n self.p2vec[start+distance] += 1\n #capture your opponent\n spot = 25 - start - distance\n self.p2vec[0] += self.p2vec[spot]\n self.p2vec[spot] = 0","def _move_lift(self, cmd):\n self.move_lift(cmd.data)","def move_by(self, increment):\n return self.move_to(self.position + increment)","def test_move():\n human = Human()\n coordinates = [2, 1]\n dimensions = [3, 4]\n\n new_coordinates = human.move(coordinates, dimensions)\n\n possible_new_coordinates = [[2, 0], [3, 0], [3, 1], [3, 2], [2, 2], [1, 2], [1, 1], [1, 0]]\n\n assert new_coordinates in possible_new_coordinates","def _move(self, start: (int, int), dest: (int, int), extra_info=''):\n moving_piece = self.board[start[0]][start[1]]\n end_piece = self.board[dest[0]][dest[1]]\n\n # Check if the move is valid\n possible_moves = self.get_all_moves()\n if State.convert_to_EAN(start, dest, extra_info) not in possible_moves:\n return False\n\n # Invalidate castling\n self._invalidate_castles()\n\n # Update half turn counters since capture (updates 50 move draw)\n # reset on capture, which is when the destination piece is a different color\n self.half_moves += 1\n if not State._is_same_color(moving_piece, end_piece):\n self.half_moves = 0\n\n # Update full moves after black's turn\n if not self.white_to_move:\n self.full_moves += 1\n\n # Update the board to reflect the move\n self._update_board(start, dest, extra_info)\n\n # Update move history TODO\n # Detect three move repetition TODO\n\n # Update whose turn it is\n self.white_to_move = not self.white_to_move","def move(self):\n for agent in self.agents:\n if not agent.fidelity:\n options = agent.get_move_options(agent.hex, self.kernel_size, None, extend=True)\n target = random36.choices(population=options,weights=[x.quality**2 for x in options])\n agent.move(target[0])","def move(self, *step):\n self.x += step[0]\n self.y += step[1]","def manual_pivot_move(self, *args, **kwargs):\n pass","def _move_up(self, exclude=None):\n self._move(self._pos + _Vec3(0, 1, 0))\n self._place(self._pos + _Vec3(0, -1, 0), exclude)","def test_move():\n\n board = Board()\n\n # invalid moves: out of board boundaries\n assert board.move(board.P1, 100) is False\n assert board.move(board.P2, -2) is False\n\n print(board)\n\n # valid moves\n assert board.move(board.P1, 0) is True\n assert board.move(board.P2, 3) is True\n\n assert board.move(board.P1, 4) is True\n assert board.move(board.P2, 3) is True\n\n assert board.move(board.P1, 3) is True\n assert board.move(board.P2, 4) is True\n\n assert board.move(board.P1, 2) is True\n assert board.move(board.P2, 4) is True\n\n assert board.move(board.P1, 2) is True\n assert board.move(board.P2, 2) is True\n\n assert board.move(board.P1, 1) is True\n assert board.move(board.P2, 4) is True\n\n \"\"\"\n BEFORE:\n \n 0 1 2 3 4 5 6 \n +-+-+-+-+-+-+-+\n 0|-|-|-|-|-|-|-|0\n +-+-+-+-+-+-+-+\n 1|-|-|-|-|-|-|-|1\n +-+-+-+-+-+-+-+\n 2|-|-|-|-|-|-|-|2\n +-+-+-+-+-+-+-+\n 3|-|-|-|-|-|-|-|3\n +-+-+-+-+-+-+-+\n 4|-|-|-|-|-|-|-|4\n +-+-+-+-+-+-+-+\n 5|-|-|-|-|-|-|-|5\n +-+-+-+-+-+-+-+\n 0 1 2 3 4 5 6 \n \n AFTER:\n \n 0 1 2 3 4 5 6 \n +-+-+-+-+-+-+-+\n 0|-|-|-|-|-|-|-|0\n +-+-+-+-+-+-+-+\n 1|-|-|-|-|-|-|-|1\n +-+-+-+-+-+-+-+\n 2|-|-|-|-|O|-|-|2\n +-+-+-+-+-+-+-+\n 3|-|-|O|X|O|-|-|3\n +-+-+-+-+-+-+-+\n 4|-|-|X|O|O|-|-|4\n +-+-+-+-+-+-+-+\n 5|X|X|X|O|X|-|-|5\n +-+-+-+-+-+-+-+\n 0 1 2 3 4 5 6 \n \n \"\"\"","def move(self, initial_pos, final_pos):\n\n ops = [ self.op_move_north, self.op_move_nwest, self.op_move_neast,\n self.op_jump_north, self.op_jump_nwest, self.op_jump_neast,\n self.op_capture_north, self.op_capture_east, self.op_capture_west,\n self.op_capture_nwest, self.op_capture_neast, self.op_add_piece\n ]\n\n # Check if the final position is empty\n if final_pos and self.board.get_element(*final_pos) != self.EMPTY:\n return False\n\n # Check if the intial position is a valid start piece\n if initial_pos not in self.next_pieces:\n return False\n\n # Test for add piece operation\n if self.next_move == self.ADDPIECE_1 or self.next_move == self.ADDPIECE_2:\n res = self.op_add_piece(initial_pos)\n if type(res) != type(False):\n return res\n\n # Test for other operations\n for op in ops:\n res = op(initial_pos)\n\n if type(res) != type(False) and (res.last_piece == final_pos):\n return res\n\n return False","def _is_valid_move(self, vector, current_piece, other_piece):\n return True","def move(self):\n self.old_tail = self.body[-1][:] # save old position of last block\n self.head[0] += self.direction[0] # moves head\n self.head[1] += self.direction[1]\n \n self.head[0] = (self.head[0] + self.xMaxSize) % self.xMaxSize\n self.head[1] = (self.head[1] + self.yMaxSize) % self.yMaxSize\n \n if self.head in self.body[1:]: # if snakes hits himself\n self.alive = False\n self.body.insert(0, self.body.pop()) # each block is replace by predecessor\n self.body[0] = self.head[:] # first block is head","def can_move_wrap(self, index):\n # Define the indices that the '0' tile is allowed to be in for a wrapping move (all four corners)\n allowed_indices = [0, self.puzzle_width - 1, self.puzzle_length - self.puzzle_width, self.puzzle_length - 1]\n\n # If the index of the '0' tile is not in any of the allowed positions, then we cannot do the action\n if index not in allowed_indices:\n return False\n\n return True","def _move(self, direction, difference):\n future_tile_number = self.get_number() + difference\n if future_tile_number in range(1, Tile.total_tiles + 1):\n future_tile = Tile.get_tile(future_tile_number)\n if future_tile.walkable:\n self.set_target(future_tile)\n self.rotate(direction)","def move(self):\r\n segments = len(self.all_turtles) - 1\r\n for i in range(len(self.all_turtles)):\r\n if segments == 0:\r\n self.all_turtles[segments].forward(MOVE_DISTANCE)\r\n else:\r\n new_x = self.all_turtles[segments - 1].xcor()\r\n new_y = self.all_turtles[segments - 1].ycor()\r\n self.all_turtles[segments].goto(new_x, new_y)\r\n segments -= 1","def move(self, state):\n raise NotImplementedError(\"Need to implement this method\")","def move_forward(self):\n self.x, self.y = self.compute_positions()"],"string":"[\n \"def _move_in_one_more_block():\\n with tik_inst.for_range(0, sub_h_align_block_size) as sub_h_idx:\\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block * sub_h_idx],\\n src[w_offset + w_size * sub_h_idx], 0, 1, sub_w_block, 0, 0)\\n # in order to avoid dirty data when multiple core\\n with tik_inst.for_range(0, data_cnt_one_block) as sub_h_idx_1:\\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block *\\n (sub_h_align_block_size + sub_h_idx_1)],\\n src[w_offset +\\n w_size * (sub_h_size - data_cnt_one_block + sub_h_idx_1)],\\n 0, 1, sub_w_block, 0, 0)\",\n \"def move(self, heaps: Tuple[int, ...], misere: bool) -> Tuple[int, int]:\\r\\n pass\",\n \"def moveSpecialOb(self):\\n\\t\\tfor obJ in self.special:\\n\\t\\t\\tobJ.moveStep()\",\n \"def _ispinnedmove(self, from_, to_):\\n return False\",\n \"def move(self): # AH note. Swich move with extra_steps?\\n if self.adjustment < 0:\\n self.position += self.extra_steps\\n super().move()\\n self.no_moves += 1\\n # Do the regular move\",\n \"def memmove(self, grid):\\n self.moveList.append((self.x, self.y))\\n self.moveList2.append((self.x, self.y))\\n waysList = []\\n for f in range(4):\\n if self.test(grid, f):\\n if (self.x+SPEED_X[f], self.y+SPEED_Y[f]) not in self.moveList:\\n waysList.append(f)\\n if len(waysList) == 1:\\n self.flag = waysList[0]\\n self.move(grid)\\n return\\n elif len(waysList) == 4:\\n self.flag = 0\\n self.move(grid)\\n return\\n elif len(waysList) > 1:\\n for f in waysList:\\n self.mem.append((self.x, self.y, f))\\n self.x, self.y, self.flag = self.mem[-1]\\n elif len(waysList) == 0:\\n self.x, self.y, self.flag = self.mem[-1]\\n for i in range(len(self.moveList2)):\\n if self.moveList2[i][0] == self.x and self.moveList2[i][1] == self.y:\\n del self.moveList2[i+1:]\\n break\\n self.move(grid)\\n self.mem.pop()\",\n \"def move(self):\\n pass\",\n \"def _move_in_one_more_block():\\n with tik_inst.for_range(0, sub_h_align_block_size) as sub_h_idx_0:\\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block * sub_h_idx_0],\\n src[in_offset + sub_h_idx_0 * w_size],\\n 0, 1, sub_w_block, 0, 0)\\n # move in one more block of h\\n with tik_inst.for_range(0, data_cnt_one_block) as sub_h_idx_1:\\n tik_inst.data_move(\\n dst[sub_w_block * data_cnt_one_block * (sub_h_align_block_size + sub_h_idx_1)],\\n src[in_offset + (sub_h_idx_1 + sub_h_size - data_cnt_one_block) * w_size],\\n 0, 1, sub_w_block, 0, 0)\",\n \"def no_more_move(self):\\n if (self.p_no_move + self.c_no_move == 2):\\n return True\\n return False\",\n \"def legalMove(turtles, poles, m, n, count):\\n if len(poles[m]) != 0 and (len(poles[n]) == 0 or poles[m][-1] < poles[n][-1]): #one possible legal move btwn m and n\\n moveTurt(turtles[poles[m][-1] - 1], n, count)\\n poles[n].append(poles[m].pop())\\n if len(poles[0]) == 0 and len(poles[1]) == 0:\\n return\\n elif len(poles[n]) != 0 and (len(poles[m]) == 0 or poles[n][-1] < poles[m][-1]): #other possible legal move btwn m and n\\n moveTurt(turtles[poles[n][-1] - 1], m, count)\\n poles[m].append(poles[n].pop())\",\n \"def move(self):\\n raise NotImplementedError\",\n \"def move(a, i):\\n x, d = a[i]\\n if is_movable(a, i):\\n if d == left:\\n swap(a, i, i - 1)\\n elif d == right:\\n swap(a, i, i + 1)\\n else:\\n raise ValueError(\\\"unknown direction d = {}\\\".format(d))\\n else:\\n raise ValueError(\\\"not movable\\\")\",\n \"def decide_next_move(self):\\n pass\",\n \"def move_forward():\\n pass\",\n \"def unmakeMove(self, move):\",\n \"def moveNorth(self):\\n north = (self.current[0], self.current[1] - 1)\\n mv = self.lab.north()\\n self.check_grue(mv)\\n self.current = north\\n self.visited.add(self.current)\",\n \"def move(self, direction, cycles):\\n\\t\\tpass\",\n \"def move_to_position1(self):\",\n \"def move(self) -> bool:\\n pass\",\n \"def get_next_moves3(self):\\n \\\"\\\"\\\" These moves avoid completing the third side of a box, so that the player will not be able to score that box\\\"\\\"\\\"\\n moves = []\\n for i in range(len(self.board)):\\n for j in range(len(self.board[i])):\\n if self.board[i][j] == \\\"\\\" and self.move_second_inbox(i, j):\\n next_board = copy.deepcopy(self.board)\\n next_board[i][j] = colors[self.turn] + self.turn + \\\"\\\\u001b[0m\\\"\\n next_turn = get_opponent(self.turn)\\n moves.append(DotsAndBoxesState(next_board, next_turn))\\n return moves\",\n \"def move(x,y):\\r\\n pass\",\n \"def move_buildings(self):\",\n \"def single_move(triple):\\r\\n c = 0 # mark of a 1\\r\\n h = 0 # mark of a 2\\r\\n for i in triple:\\r\\n if i==1:\\r\\n c+=1\\r\\n elif i==2:\\r\\n h+=1\\r\\n if (c,h) == (2,0):\\r\\n return True\\r\\n elif (c,h) == (0,2):\\r\\n return True\\r\\n return False\",\n \"def move(self, *args, **kw):\\n return self.execute_action('move', *args, **kw)\",\n \"def move(self, move):\\n raise NotImplementedError()\",\n \"def _move_item(self, src, dst):\\n \\\"Does nothing\\\"\",\n \"def check4move(st, selected_unit, direction):\\n return 1\",\n \"def move_silent(self, pos):\\n self.move(pos, silent=True)\",\n \"def bump_moving_obstacle(\\n state: State, action: Action, next_state: State\\n) -> bool:\\n return overlap(state, action, next_state, object_type=MovingObstacle)\",\n \"def move(name, other, newname=None):\",\n \"def move_lift_up():\\n return _move_lift(1)\",\n \"def op_move_preconditions(self):\\n\\n if(self.next_move != self.FREE):\\n return False\\n\\n return True\",\n \"def moveOddPoles(poles, n, turtles, count):\\n if done(poles):\\n return\\n\\n legalMove(turtles, poles, 0, 2, count)\\n\\n if done(poles):\\n return\\n\\n legalMove(turtles, poles, 0, 1, count)\\n\\n if done(poles):\\n return\\n\\n legalMove(turtles, poles, 1, 2, count)\\n\\n moveOddPoles(poles, n, turtles, count)\",\n \"def move(self):\\n self._move_range_shuffle(3)\\n self._move_satisfy_random_constraint()\\n # self._move_range_shuffle(3)\\n #if (curr_energy > 50):\\n # self._move_satisfy_random_constraint()\\n #else:\\n # self._move_range_shuffle(3)\",\n \"def move_step(self, direction):\\n x = self.objects[0].x\\n y = self.objects[0].y\\n if direction == 0 and y >= 1:\\n self.objects[0].y -= 1\\n elif direction == 1 and y <= self.size_y - 2:\\n self.objects[0].y += 1\\n elif direction == 2 and x >= 1:\\n self.objects[0].x -= 1\\n elif direction == 3 and x <= self.size_x - 2:\\n self.objects[0].x += 1\",\n \"def move(*args, absolute: bool=True, componentOffset: bool=True, componentSpace: bool=True,\\n constrainAlongNormal: bool=True, deletePriorHistory: bool=True, localSpace: bool=True,\\n moveX: bool=True, moveXY: bool=True, moveXYZ: bool=True, moveXZ: bool=True, moveY:\\n bool=True, moveYZ: bool=True, moveZ: bool=True, objectSpace: bool=True, orientJoint:\\n AnyStr=\\\"\\\", parameter: bool=True, preserveChildPosition: bool=False,\\n preserveGeometryPosition: bool=False, preserveUV: bool=False, reflection: bool=True,\\n reflectionAboutBBox: bool=True, reflectionAboutOrigin: bool=True, reflectionAboutX:\\n bool=True, reflectionAboutY: bool=True, reflectionAboutZ: bool=True,\\n reflectionTolerance: float=0.0, relative: bool=True, rotatePivotRelative: bool=True,\\n scalePivotRelative: bool=True, secondaryAxisOrient: AnyStr=\\\"\\\", symNegative: bool=True,\\n worldSpace: bool=True, worldSpaceDistance: bool=True, xformConstraint: AnyStr=\\\"\\\",\\n **kwargs)->None:\\n pass\",\n \"def move(t, length):\\n pu(t)\\n\\t\\n fd(t, length)\\n pd(t)\",\n \"def force_move():\\n if ZERO_BASE_PLYR_POS in range(0, 10):\\n # we cant go up, so go down\\n move_player(\\\"south\\\")\\n else:\\n move_player(\\\"north\\\")\",\n \"def getFirstMove(self):\\n while True:\\n try:\\n move = tuple(int(str.strip()) for str in raw_input('Choose your first move: ').split(','))\\n break\\n except ValueError:\\n print(\\\"Input is not a integer.\\\")\\n\\n while move not in [(1, 1), (self.grid.width/2, self.grid.height/2), \\\\\\n (self.grid.width/2+1, self.grid.height/2+1), (self.grid.width, self.grid.height)]:\\n print 'First move is not valid.'\\n move = tuple(int(str.strip()) for str in raw_input('Choose your first move: ').split(','))\\n return move\",\n \"def move(self, _vec):\\n\\n\\t\\t_dest = self._grid[0] + _vec[0], self._grid[1] + _vec[1], self._grid[2] + _vec[2]\\n\\t\\tif _vec[2]: # jeśli ruszamy się w z to znaczy że wchodzimy po schodach\\n\\t\\t\\tself._map.getLayer('Fields').get(self._pos).getLogic().occupy(None)\\n\\t\\t\\tself._grid = _dest\\n\\t\\t\\tself._pos = 32 * self._grid[0] + 16, 32 * self._grid[1] + 16\\n\\t\\t\\tself._dest = None\\n\\t\\t\\treturn\\n\\n\\t\\tif self._dest: # nie ma pola docelowego = brak ruchu\\n\\t\\t\\treturn\\n\\n\\t\\t_field = self._map.getLayer('Fields').get((_dest[0] * 32 + 16, _dest[1] * 32 + 16))\\n\\t\\tif not _field: # brak pola = brak ruchu\\n\\t\\t\\treturn\\n\\t\\t\\n\\t\\t_field = _field.getLogic()\\n\\t\\tif _field.getModifier() & field.MODIFIER_BLOCKED or not _field.getOccupied() in (None, self): # pole zablokowane, bądź zajęte przez kogoś innego\\n\\t\\t\\treturn\\n\\n\\t\\t_field.occupy(self)\\n\\t\\tself._dest = _dest\",\n \"def test_x_first_move(self):\\n board = [[None, None, None],\\n [None, None, None],\\n [None, None, None]]\\n \\n self.assertEqual(char_move_order(board), (x_char, o_char))\",\n \"def move_many(self,\\r\\n sourcerange=None,\\r\\n destinationrange=None,\\r\\n subordinate=False,\\r\\n makecompact=False,\\r\\n all_children=False,\\r\\n withchildren=True,\\r\\n copy=False):\\r\\n\\r\\n if sourcerange is None:\\r\\n sourcerange = []\\r\\n if destinationrange is None:\\r\\n destinationrange = []\\r\\n flatten = False\\r\\n\\r\\n\\r\\n\\r\\n if not withchildren:\\r\\n sourcerange = [a_temp for a_temp in sourcerange if a_temp.is_top()]\\r\\n\\r\\n if len(destinationrange)==1 and \\\\\\r\\n (subordinate and str(destinationrange[0]) in self.indexes()\\r\\n and str(destinationrange[0].child()) not in self.indexes()):\\r\\n\\r\\n for i_temp in sourcerange:\\r\\n\\r\\n self.move(i_temp,\\r\\n destinationrange[0].subordinate(i_temp),\\r\\n withchildren=False,\\r\\n copy=copy)\\r\\n\\r\\n elif len(destinationrange)==1 and (makecompact\\r\\n and str(destinationrange[0])\\r\\n in self.indexes()\\r\\n and str(destinationrange[0].child()) not in self.indexes()):\\r\\n\\r\\n j_temp = destinationrange[0].child()\\r\\n for i_temp in sourcerange:\\r\\n self.move(i_temp,\\r\\n j_temp,\\r\\n withchildren=False,\\r\\n copy=copy)\\r\\n j_temp = j_temp.next()\\r\\n\\r\\n elif len(destinationrange)==1 and all_children \\\\\\r\\n and str(destinationrange[0]) in self.indexes():\\r\\n\\r\\n childcount = 1\\r\\n for i_temp in sourcerange:\\r\\n j_temp = destinationrange[0]\\r\\n for a_temp in range(childcount):\\r\\n j_temp = j_temp.child()\\r\\n childcount += 1\\r\\n self.move(i_temp,\\r\\n j_temp,\\r\\n withchildren=withchildren,\\r\\n copy=copy)\\r\\n\\r\\n else:\\r\\n\\r\\n sourcecycle = cycle(sourcerange)\\r\\n destinationcycle = cycle(destinationrange)\\r\\n if withchildren: #not deleted\\r\\n flatten = True\\r\\n\\r\\n for a_temp in range(len(sourcerange)):\\r\\n\\r\\n i_temp = next(sourcecycle)\\r\\n j_temp = next(destinationcycle)\\r\\n\\r\\n self.move(i_temp,\\r\\n j_temp,\\r\\n withchildren=withchildren,\\r\\n flatten=flatten,\\r\\n copy=copy)\",\n \"def move_valid(move):\\n return True\",\n \"def move(self, rel_pos):\\n self.pos = (self.pos[0] + rel_pos[0] * GRID, self.pos[1] + rel_pos[1] * GRID)\",\n \"def choose_move(self):\\r\\n \\r\\n return None\",\n \"def move(self, t, s):\\n raise NotImplementedError\",\n \"def handleMove(self):\\n pass\",\n \"def position_at_least(self, a, b):\\n return None\",\n \"def choose_move(self):\\n raise NotImplementedError()\",\n \"def move_atoms(self):\\n return self.abivars.ionmov != 0\",\n \"def hanota(self, A: List[int], B: List[int], C: List[int]) -> None:\\n n = len(A)\\n self.move(n, A, B, C)\",\n \"def step(self, move):\",\n \"def move(self, origin_index, new_index):\\n if len(self._stools[origin_index]) == 0:\\n pass\\n elif len(self._stools[new_index]) == 0:\\n self.add(self.get_top_cheese(origin_index), new_index)\\n self._stools[origin_index].pop()\\n self._move_seq.add_move(origin_index, new_index)\\n elif self._stools[origin_index][-1].size < \\\\\\n self._stools[new_index][-1].size:\\n self.add(self.get_top_cheese(origin_index), new_index)\\n self._stools[origin_index].pop()\\n self._move_seq.add_move(origin_index, new_index)\\n else:\\n raise IllegalMoveError\",\n \"def move_to_position2(self):\",\n \"def firstMove(self):\\n return (10, 10)\",\n \"def exactly_one_knights_move(variables):\\n cnf = []\\n\\n for valid_move in variables[:-1]:\\n # print(valid_move)\\n cnf.append([-valid_move, -variables[-1]])\\n\\n return cnf\",\n \"def move_multi_wire_gates(self, operator_grid):\\n n = operator_grid.num_layers\\n i = -1\\n while i < n - 1:\\n i += 1\\n\\n this_layer = operator_grid.layer(i)\\n layer_ops = _remove_duplicates(this_layer)\\n other_layer = [None] * operator_grid.num_wires\\n\\n for j in range(len(layer_ops)):\\n op = layer_ops[j]\\n\\n if op is None:\\n continue\\n\\n # translate wires to their indices on the device\\n wire_indices = self.active_wires.indices(op.wires)\\n\\n if len(op.wires) > 1:\\n\\n sorted_wires = wire_indices.copy()\\n sorted_wires.sort()\\n\\n blocked_wires = list(range(sorted_wires[0], sorted_wires[-1] + 1))\\n\\n for k in range(j + 1, len(layer_ops)):\\n other_op = layer_ops[k]\\n\\n if other_op is None:\\n continue\\n\\n # translate wires to their indices on the device\\n other_wire_indices = self.active_wires.indices(other_op.wires)\\n other_sorted_wire_indices = other_wire_indices.copy()\\n other_sorted_wire_indices.sort()\\n other_blocked_wires = list(\\n range(other_sorted_wire_indices[0], other_sorted_wire_indices[-1] + 1)\\n )\\n\\n if not set(other_blocked_wires).isdisjoint(set(blocked_wires)):\\n op_indices = [\\n idx for idx, layer_op in enumerate(this_layer) if layer_op == op\\n ]\\n\\n for l in op_indices:\\n other_layer[l] = op\\n this_layer[l] = None\\n\\n break\\n\\n if not all([item is None for item in other_layer]):\\n operator_grid.insert_layer(i + 1, other_layer)\\n n += 1\",\n \"def _move_comp_person(self):\\n\\n move_tuple = random.choice(self._board.possible())\\n self._board[move_tuple] = 'x'\",\n \"def test_first_move(self):\\n\\t\\tdata = {'moves': [],\\n\\t\\t\\t\\t'player_number': 1}\\n\\t\\tfor AI in self.list_of_AIs:\\n\\t\\t\\tself.assertTrue(AI.move(data) in ['r', 'p', 's'])\",\n \"def motion(self):\\n priority = {\\\"north\\\": [-1, 0], \\\"south\\\": [1, 0],\\n \\\"east\\\": [0, 1], \\\"west\\\": [0, -1]}\\n\\n priority_list = [\\\"north\\\", \\\"south\\\", \\\"east\\\", \\\"west\\\"]\\n\\n critical_point = False\\n while critical_point is False:\\n row = self.curr_cell.row\\n column = self.curr_cell.col\\n\\n if self.allow_to_move(priority_list[0],\\n row + priority[priority_list[0]][0],\\n column + priority[priority_list[0]][1]):\\n\\n self.move(priority_list[0])\\n\\n elif self.allow_to_move(priority_list[1],\\n row + priority[priority_list[1]][0],\\n column + priority[priority_list[1]][1]):\\n\\n self.move(priority_list[1])\\n\\n elif self.allow_to_move(priority_list[2],\\n row + priority[priority_list[2]][0],\\n column + priority[priority_list[2]][1]):\\n\\n self.move(priority_list[2])\\n\\n elif self.allow_to_move(priority_list[3],\\n row + priority[priority_list[3]][0],\\n column + priority[priority_list[3]][1]):\\n\\n self.move(priority_list[3])\\n\\n else:\\n # Robot isolated\\n critical_point = True\\n\\n return self.curr_cell, self.path\",\n \"def test_fourth_move(self):\\n\\t\\tdata = {'moves': [('r','s'), ('r','p'), ('s','p')],\\n\\t\\t\\t\\t'player_number': 2}\\n\\t\\tfor AI in self.list_of_AIs:\\n\\t\\t\\tself.assertTrue(AI.move(data) in ['r', 'p', 's'])\",\n \"def firstMove(board):\\r\\n x = board.size / 2\\r\\n return (x, x)\",\n \"def move(self) -> None:\\n\\n if self.move_up:\\n self.__moveUpIfPossible()\\n if self.move_down:\\n self.__moveDownIfPossible()\",\n \"def test_valid_move():\\n\\n board = Board()\\n\\n # a col outside the width of the board should be false\\n assert board.valid_move(board.get_grid_size()[1] + 1) is False\\n\\n # only positive cols should be considered for a move\\n assert board.valid_move(-2) is False\\n\\n # since board is empty all cols should have moves\\n for i in range(board.get_grid_size()[1]):\\n assert board.valid_move(i) is True\\n\\n # if a col is full no move can be made\\n for i in range(board.get_grid_size()[1]):\\n if i % 2 == 0:\\n board.move(board.P1, 0)\\n else:\\n board.move(board.P2, 0)\\n\\n \\\"\\\"\\\"\\n board now looks like this...\\n \\n 0 1 2 3 4 5 6 \\n +-+-+-+-+-+-+-+\\n 0|O|-|-|-|-|-|-|0\\n +-+-+-+-+-+-+-+\\n 1|X|-|-|-|-|-|-|1\\n +-+-+-+-+-+-+-+\\n 2|O|-|-|-|-|-|-|2\\n +-+-+-+-+-+-+-+\\n 3|X|-|-|-|-|-|-|3\\n +-+-+-+-+-+-+-+\\n 4|O|-|-|-|-|-|-|4\\n +-+-+-+-+-+-+-+\\n 5|X|-|-|-|-|-|-|5\\n +-+-+-+-+-+-+-+\\n 0 1 2 3 4 5 6 \\n\\n \\\"\\\"\\\"\\n assert board.valid_move(0) is False\",\n \"def move_element(self,n_a,n_b):\\n self.element_array.insert(n_b,self.element_array.pop(n_a))\",\n \"def move_second_inbox(self, i, j):\\n \\\"\\\"\\\"the function achieves the above statement by not filling in the third line of any possible sqaure \\\"\\\"\\\"\\n if i == 0: #top\\n return check_two_spots(self.board[i+1][j-1], self.board[i+1][j+1], self.board[i+2][j])\\n\\n if i == 6: #bottom\\n return check_two_spots(self.board[i-1][j-1], self.board[i-1][j+1], self.board[i-2][j])\\n\\n if j == 0: #left\\n return check_two_spots(self.board[i-1][j+1], self.board[i+1][j+1], self.board[i][j+2])\\n\\n\\n if j == 6: #right\\n return check_two_spots(self.board[i-1][j-1], self.board[i+1][j-1], self.board[i][j-2])\\n\\n\\n if i == 2 or i == 4: # possible horizontal moves\\n return check_two_spots(self.board[i-1][j-1], self.board[i-1][j+1], self.board[i-2][j]) and check_two_spots(self.board[i+1][j-1], self.board[i+1][j+1], self.board[i+2][j])\\n\\n if j == 2 or j == 4: # possible vertical moves\\n return check_two_spots(self.board[i-1][j-1], self.board[i+1][j-1], self.board[i][j-2]) and check_two_spots(self.board[i-1][j+1], self.board[i+1][j+1], self.board[i][j+2])\",\n \"def m_move1(state,b1,b2):\\n if b2 != 'hand' and not state.holding['hand']:\\n if b2 == 'table':\\n return [('clear',b1,True), ('pos', b1, 'hand'), ('pos', b1, b2)]\\n else:\\n return [('clear',b2,True), ('clear',b1,True), \\\\\\n ('pos', b1, 'hand'), ('pos', b1, b2)]\",\n \"def _pull(self, action):\\n change = CHANGE_COORDINATES[(action - 1) % 4]\\n new_position = self.player_position + change\\n current_position = self.player_position.copy()\\n pull_content_position = self.player_position - change\\n\\n # Move player if the field in the moving direction is either\\n # an empty field or an empty box target.\\n if self.room_state[new_position[0], new_position[1]] in [1, 2]:\\n self.player_position = new_position\\n self.room_state[(new_position[0], new_position[1])] = 5\\n self.room_state[current_position[0], current_position[1]] = \\\\\\n self.room_fixed[current_position[0], current_position[1]]\\n\\n box_next_to_player = self.room_state[pull_content_position[0], pull_content_position[1]] in [3, 4]\\n if box_next_to_player:\\n # Move Box\\n box_type = 4\\n if self.room_fixed[current_position[0], current_position[1]] == 2:\\n box_type = 3\\n self.room_state[current_position[0], current_position[1]] = box_type\\n self.room_state[pull_content_position[0], pull_content_position[1]] = \\\\\\n self.room_fixed[pull_content_position[0], pull_content_position[1]]\\n\\n return True, box_next_to_player\\n\\n return False, False\",\n \"def valid_move(x, y):\\r\\n if [x, y] in empty_cells(board):\\r\\n return True\\r\\n else:\\r\\n return False\",\n \"def turn_around():\\n for i in range(2):\\n turn_left()\",\n \"def choose_move(self):\\n return 0\",\n \"def _undo_naughty_movement(self, set_balls_that_moved :Set[Ball], set_bots_that_moved :Set[Robot]):\\n ball :Ball\\n bot :Robot\\n bln_naughty = True\\n lng_naughty_loop_count = 0\\n lng_naughty_loop_limit = len(self.lstBalls) + len(self.lstRobots) # worst case scenario\\n while bln_naughty:\\n lng_naughty_loop_count += 1\\n if lng_naughty_loop_count > lng_naughty_loop_limit:\\n if const.GAME_MODE:\\n print(\\\"WARNING: UNABLE TO RESOLVE ALL COLLISIONS FOR FRAME.\\\")\\n else:\\n raise Exception(\\\"UNABLE TO RESOLVE ALL COLLISIONS FOR FRAME\\\")\\n set_naughty_bots = set()\\n set_naughty_balls = set()\\n\\n \\\"\\\"\\\" Ball vs Ball \\\"\\\"\\\"\\n for ball1, ball2 in TrashyPhysics.collision_pairs_self(\\n self.grpBalls, fncCollided=TrashyPhysics.balls_collided):\\n set_naughty_balls.add(ball1)\\n set_naughty_balls.add(ball2)\\n\\n \\\"\\\"\\\" Ball vs Bot \\\"\\\"\\\"\\n for ball, bot in TrashyPhysics.collision_pairs(\\n self.grpBalls, self.grpRobots,\\n fncCollided=TrashyPhysics.ball_robot_collided):\\n set_naughty_balls.add(ball)\\n set_naughty_bots.add(bot)\\n\\n \\\"\\\"\\\" Ball vs Wall \\\"\\\"\\\"\\n for ball in filter(lambda x: TrashyPhysics.collided_wall(x), self.lstBalls):\\n set_naughty_balls.add(ball)\\n\\n \\\"\\\"\\\" Ball vs Bumper \\\"\\\"\\\"\\n # todo\\n\\n \\\"\\\"\\\" Undo movement. \\\"\\\"\\\"\\n bln_naughty = len(set_naughty_bots) + len(set_naughty_balls) > 0\\n for bot in set_bots_that_moved & set_naughty_bots:\\n set_bots_that_moved.remove(bot)\\n if not bot.undo_move():\\n print(f\\\"UNABLE TO UNDO MOVE FOR BOT: {bot}\\\")\\n for ball in set_balls_that_moved & set_naughty_balls:\\n set_balls_that_moved.remove(ball)\\n if not ball.undo_move():\\n print(f\\\"UNABLE TO UNDO MOVE FOR BALL: {ball}\\\")\",\n \"def decide_move(self, action):\\n x1, y1 = action['xy1']\\n x2, y2 = action['xy2']\\n self.__state.push(action)\",\n \"def move(x, y, direction, board):\\n\\n piece_at_xy = starter.get_piece(x, y, board); # Getting necessary pieces\\n\\n assert piece_at_xy != '*', \\\"Error in swipe logic\\\"; # Logical debug case\\n valid_direction = (direction == \\\"left\\\" or\\n direction == \\\"right\\\" or\\n direction == \\\"up\\\" or\\n direction == \\\"down\\\");\\n assert valid_direction, \\\"Invalid direction passed in\\\"; # Logical debug case\\n\\n # The new x and y for the current piece (adjacent's current position) are stored alongside adjacent (fewer ifs + redundant code)\\n if direction == \\\"left\\\":\\n adjacent = (starter.get_piece(x - 1, y, board), x - 1, y);\\n elif direction == \\\"right\\\":\\n adjacent = (starter.get_piece(x + 1, y, board), x + 1, y);\\n elif direction == \\\"up\\\":\\n adjacent = (starter.get_piece(x, y - 1, board), x, y - 1);\\n elif direction == \\\"down\\\":\\n adjacent = (starter.get_piece(x, y + 1, board), x, y + 1);\\n\\n if adjacent[0] == None: # Edge of the board case (no action taken)\\n return False;\\n\\n elif piece_at_xy != adjacent[0] and adjacent[0] != '*': # Can't combine two numbers case (no action taken)\\n return False;\\n\\n elif adjacent[0] == '*': # Empty spot adjacent case (recursive movement in direction)\\n starter.place_piece('*', x, y, board);\\n starter.place_piece(piece_at_xy, adjacent[1], adjacent[2], board);\\n move(adjacent[1], adjacent[2], direction, board);\\n return True;\\n\\n elif piece_at_xy == adjacent[0]: # Adjacent same numbers case (combine them)\\n starter.place_piece('*', x, y, board);\\n starter.place_piece(str(int(adjacent[0]) * 2), adjacent[1], adjacent[2], board);\\n move(adjacent[1], adjacent[2], direction, board);\\n return True;\\n\\n else:\\n # Logical debug case\\n assert False, \\\"No way you should be in here. Error in move logic\\\";\\n\\n return False;\",\n \"def mass_move(self,\\r\\n entrylist1,\\r\\n entrylist2):\\r\\n\\r\\n\\r\\n if len(entrylist1) > len(entrylist2):\\r\\n entrylist2 = entrylist2+list(range(entrylist2[-1]+1,\\r\\n (entrylist2[-1]\\r\\n +len(entrylist1)\\r\\n -len(entrylist2))))\\r\\n lastindexto = entrylist2[0]\\r\\n\\r\\n e1 = iter(entrylist1)\\r\\n e2 = iter(entrylist2)\\r\\n gofurther = True\\r\\n\\r\\n while gofurther:\\r\\n try:\\r\\n indexfrom = next(e1)\\r\\n except StopIteration:\\r\\n indexfrom = StopIteration\\r\\n try:\\r\\n indexto = self.find_space(next(e2), entrylist2)\\r\\n except StopIteration:\\r\\n indexto = StopIteration\\r\\n if indexto != StopIteration:\\r\\n lastindexto = indexto\\r\\n if indexto == StopIteration:\\r\\n indexto = self.find_space(lastindexto)\\r\\n\\r\\n if indexfrom != StopIteration:\\r\\n self.display_buffer.append(alerts.MOVING_FROM\\r\\n +index_reduce(str(indexfrom))\\r\\n +queries.TOTO+str(indexto))\\r\\n self.move(indexfrom, indexto)\\r\\n else:\\r\\n gofurther = False\",\n \"def move(self, i, j):\\n board_cpy = copy.deepcopy(self.board)\\n piece = self.board[self.selected[0]][self.selected[1]]\\n if piece == 0:\\n return False\\n elif piece.player != self.active_player:\\n print(\\\"it's not your turn\\\", piece.player, self.active_player)\\n return False\\n elif self.board[i][j] != 0:\\n if piece.player == self.board[i][j].player:\\n print(\\\"can't capture your own pieces\\\")\\n return False\\n if i==self.selected[0] and piece.direction == 0:\\n if piece.master == False:\\n if (i + j - sum(self.selected))%2 == 0:\\n print(\\\"must choose a different color\\\")\\n return False\\n if j < self.selected[1]:\\n spaces_between = [self.board[i][y] for y in range(j+1, self.selected[1])]\\n else:\\n spaces_between = [self.board[i][y] for y in range(self.selected[1]+1, j)]\\n print(spaces_between)\\n for p in spaces_between:\\n if p != 0:\\n print(\\\"can't jump pieces\\\")\\n return False\\n piece.direction = 1\\n self.board[i][j] = piece\\n self.board[self.selected[0]][self.selected[1]] = 0\\n elif j==self.selected[1] and piece.direction == 1:\\n if piece.master == False:\\n if (i + j - sum(self.selected))%2 == 0:\\n print(\\\"must choose a different color\\\")\\n return False\\n if i < self.selected[0]:\\n spaces_between = [self.board[x][j] for x in range(i+1, self.selected[0])]\\n else:\\n spaces_between = [self.board[x][j] for x in range(self.selected[0]+1, i)] \\n print(spaces_between)\\n for p in spaces_between:\\n if p != 0:\\n print(\\\"can't jump pieces\\\")\\n return False\\n piece.direction = 0\\n self.board[i][j] = piece\\n self.board[self.selected[0]][self.selected[1]] = 0\\n else:\\n print(\\\"Invalid movement\\\")\\n return False\\n if self.board[i][j] == 0:\\n print(\\\"Something wrong happened\\\")\\n return False\\n elif (i==0 or i==self.board_size-1) and (j==0 or j==self.board_size-1):\\n self.board[i][j].master = True\\n self.active_player = (self.active_player+1)%2\\n self.sequence += [board_cpy]\\n return True\",\n \"def move_circular(self, count):\\n planned_move = self.cur_pos + count\\n if count + planned_move < self.length:\\n move_count = count\\n self.cur_pos += move_count\\n # print(\\\"Move less from {} to {}({})\\\".format(\\n # self.cur_pos,\\n # self.cur_pos + move_count,\\n # planned_move\\n # ))\\n else:\\n self.cur_node = self.start_node\\n move_count = max(0, (planned_move % (self.length)))\\n # print(\\\"Move circ from {} to {}({})\\\".format(self.cur_pos, move_count, planned_move))\\n self.cur_pos = move_count\\n for _ in range(move_count):\\n self.cur_node = self.cur_node.next\",\n \"def move_1_piece(context: GUI, old_coordinate, new_coordinate):\\n\\n old_tile = context.board.board_dict[old_coordinate]\\n new_tile = context.board.board_dict[new_coordinate]\\n\\n new_tile.piece = old_tile.piece\\n old_tile.piece = None\\n\\n context.update_move_printer(old_coordinate + \\\" \\\" + new_coordinate)\",\n \"def qmove(az=None, el=None, ants=0) :\\n move(az, el, ants, waiton=NONE)\",\n \"def automove(self):\\n if self.x < self.end_cinematic_x_pos:\\n self.x += self.SHIP_SPEED\\n if self.x > self.end_cinematic_x_pos:\\n self.x -= self.SHIP_SPEED\\n if self.y < self.end_cinematic_y_pos:\\n self.y += self.SHIP_SPEED\\n if self.y > self.end_cinematic_y_pos:\\n self.y -= self.SHIP_SPEED\",\n \"def move_wrapper(board, player, trials):\\r\\n move = mm_move(board, player)\\r\\n assert move[1] != (-1, -1), \\\"returned illegal move (-1, -1)\\\"\\r\\n return move[1]\",\n \"def move_wrapper(board, player, trials):\\r\\n move = mm_move(board, player)\\r\\n assert move[1] != (-1, -1), \\\"returned illegal move (-1, -1)\\\"\\r\\n return move[1]\",\n \"def pixelMove(*args, **kwargs)->None:\\n pass\",\n \"def move(self, start, distance, p1):\\n if (p1):\\n #move your piece\\n self.p1vec[start] -= 1\\n dest = start + distance\\n if (dest == 25):\\n self.bornoff = True\\n else:\\n self.p1vec[start+distance] += 1\\n #capture your opponent, despite their number\\n spot = 25 - start - distance\\n self.p2vec[0] += self.p2vec[spot]\\n self.p2vec[spot] = 0\\n else:\\n #move your piece\\n self.p2vec[start] -= 1\\n dest = start + distance\\n if (dest == 25):\\n pass\\n else:\\n self.p2vec[start+distance] += 1\\n #capture your opponent\\n spot = 25 - start - distance\\n self.p2vec[0] += self.p2vec[spot]\\n self.p2vec[spot] = 0\",\n \"def _move_lift(self, cmd):\\n self.move_lift(cmd.data)\",\n \"def move_by(self, increment):\\n return self.move_to(self.position + increment)\",\n \"def test_move():\\n human = Human()\\n coordinates = [2, 1]\\n dimensions = [3, 4]\\n\\n new_coordinates = human.move(coordinates, dimensions)\\n\\n possible_new_coordinates = [[2, 0], [3, 0], [3, 1], [3, 2], [2, 2], [1, 2], [1, 1], [1, 0]]\\n\\n assert new_coordinates in possible_new_coordinates\",\n \"def _move(self, start: (int, int), dest: (int, int), extra_info=''):\\n moving_piece = self.board[start[0]][start[1]]\\n end_piece = self.board[dest[0]][dest[1]]\\n\\n # Check if the move is valid\\n possible_moves = self.get_all_moves()\\n if State.convert_to_EAN(start, dest, extra_info) not in possible_moves:\\n return False\\n\\n # Invalidate castling\\n self._invalidate_castles()\\n\\n # Update half turn counters since capture (updates 50 move draw)\\n # reset on capture, which is when the destination piece is a different color\\n self.half_moves += 1\\n if not State._is_same_color(moving_piece, end_piece):\\n self.half_moves = 0\\n\\n # Update full moves after black's turn\\n if not self.white_to_move:\\n self.full_moves += 1\\n\\n # Update the board to reflect the move\\n self._update_board(start, dest, extra_info)\\n\\n # Update move history TODO\\n # Detect three move repetition TODO\\n\\n # Update whose turn it is\\n self.white_to_move = not self.white_to_move\",\n \"def move(self):\\n for agent in self.agents:\\n if not agent.fidelity:\\n options = agent.get_move_options(agent.hex, self.kernel_size, None, extend=True)\\n target = random36.choices(population=options,weights=[x.quality**2 for x in options])\\n agent.move(target[0])\",\n \"def move(self, *step):\\n self.x += step[0]\\n self.y += step[1]\",\n \"def manual_pivot_move(self, *args, **kwargs):\\n pass\",\n \"def _move_up(self, exclude=None):\\n self._move(self._pos + _Vec3(0, 1, 0))\\n self._place(self._pos + _Vec3(0, -1, 0), exclude)\",\n \"def test_move():\\n\\n board = Board()\\n\\n # invalid moves: out of board boundaries\\n assert board.move(board.P1, 100) is False\\n assert board.move(board.P2, -2) is False\\n\\n print(board)\\n\\n # valid moves\\n assert board.move(board.P1, 0) is True\\n assert board.move(board.P2, 3) is True\\n\\n assert board.move(board.P1, 4) is True\\n assert board.move(board.P2, 3) is True\\n\\n assert board.move(board.P1, 3) is True\\n assert board.move(board.P2, 4) is True\\n\\n assert board.move(board.P1, 2) is True\\n assert board.move(board.P2, 4) is True\\n\\n assert board.move(board.P1, 2) is True\\n assert board.move(board.P2, 2) is True\\n\\n assert board.move(board.P1, 1) is True\\n assert board.move(board.P2, 4) is True\\n\\n \\\"\\\"\\\"\\n BEFORE:\\n \\n 0 1 2 3 4 5 6 \\n +-+-+-+-+-+-+-+\\n 0|-|-|-|-|-|-|-|0\\n +-+-+-+-+-+-+-+\\n 1|-|-|-|-|-|-|-|1\\n +-+-+-+-+-+-+-+\\n 2|-|-|-|-|-|-|-|2\\n +-+-+-+-+-+-+-+\\n 3|-|-|-|-|-|-|-|3\\n +-+-+-+-+-+-+-+\\n 4|-|-|-|-|-|-|-|4\\n +-+-+-+-+-+-+-+\\n 5|-|-|-|-|-|-|-|5\\n +-+-+-+-+-+-+-+\\n 0 1 2 3 4 5 6 \\n \\n AFTER:\\n \\n 0 1 2 3 4 5 6 \\n +-+-+-+-+-+-+-+\\n 0|-|-|-|-|-|-|-|0\\n +-+-+-+-+-+-+-+\\n 1|-|-|-|-|-|-|-|1\\n +-+-+-+-+-+-+-+\\n 2|-|-|-|-|O|-|-|2\\n +-+-+-+-+-+-+-+\\n 3|-|-|O|X|O|-|-|3\\n +-+-+-+-+-+-+-+\\n 4|-|-|X|O|O|-|-|4\\n +-+-+-+-+-+-+-+\\n 5|X|X|X|O|X|-|-|5\\n +-+-+-+-+-+-+-+\\n 0 1 2 3 4 5 6 \\n \\n \\\"\\\"\\\"\",\n \"def move(self, initial_pos, final_pos):\\n\\n ops = [ self.op_move_north, self.op_move_nwest, self.op_move_neast,\\n self.op_jump_north, self.op_jump_nwest, self.op_jump_neast,\\n self.op_capture_north, self.op_capture_east, self.op_capture_west,\\n self.op_capture_nwest, self.op_capture_neast, self.op_add_piece\\n ]\\n\\n # Check if the final position is empty\\n if final_pos and self.board.get_element(*final_pos) != self.EMPTY:\\n return False\\n\\n # Check if the intial position is a valid start piece\\n if initial_pos not in self.next_pieces:\\n return False\\n\\n # Test for add piece operation\\n if self.next_move == self.ADDPIECE_1 or self.next_move == self.ADDPIECE_2:\\n res = self.op_add_piece(initial_pos)\\n if type(res) != type(False):\\n return res\\n\\n # Test for other operations\\n for op in ops:\\n res = op(initial_pos)\\n\\n if type(res) != type(False) and (res.last_piece == final_pos):\\n return res\\n\\n return False\",\n \"def _is_valid_move(self, vector, current_piece, other_piece):\\n return True\",\n \"def move(self):\\n self.old_tail = self.body[-1][:] # save old position of last block\\n self.head[0] += self.direction[0] # moves head\\n self.head[1] += self.direction[1]\\n \\n self.head[0] = (self.head[0] + self.xMaxSize) % self.xMaxSize\\n self.head[1] = (self.head[1] + self.yMaxSize) % self.yMaxSize\\n \\n if self.head in self.body[1:]: # if snakes hits himself\\n self.alive = False\\n self.body.insert(0, self.body.pop()) # each block is replace by predecessor\\n self.body[0] = self.head[:] # first block is head\",\n \"def can_move_wrap(self, index):\\n # Define the indices that the '0' tile is allowed to be in for a wrapping move (all four corners)\\n allowed_indices = [0, self.puzzle_width - 1, self.puzzle_length - self.puzzle_width, self.puzzle_length - 1]\\n\\n # If the index of the '0' tile is not in any of the allowed positions, then we cannot do the action\\n if index not in allowed_indices:\\n return False\\n\\n return True\",\n \"def _move(self, direction, difference):\\n future_tile_number = self.get_number() + difference\\n if future_tile_number in range(1, Tile.total_tiles + 1):\\n future_tile = Tile.get_tile(future_tile_number)\\n if future_tile.walkable:\\n self.set_target(future_tile)\\n self.rotate(direction)\",\n \"def move(self):\\r\\n segments = len(self.all_turtles) - 1\\r\\n for i in range(len(self.all_turtles)):\\r\\n if segments == 0:\\r\\n self.all_turtles[segments].forward(MOVE_DISTANCE)\\r\\n else:\\r\\n new_x = self.all_turtles[segments - 1].xcor()\\r\\n new_y = self.all_turtles[segments - 1].ycor()\\r\\n self.all_turtles[segments].goto(new_x, new_y)\\r\\n segments -= 1\",\n \"def move(self, state):\\n raise NotImplementedError(\\\"Need to implement this method\\\")\",\n \"def move_forward(self):\\n self.x, self.y = self.compute_positions()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6018227","0.59535146","0.59033984","0.5829751","0.5825883","0.57707506","0.5694387","0.56823575","0.5666963","0.5642597","0.5641661","0.5638052","0.55918825","0.5589538","0.55241865","0.55067444","0.54987234","0.54837316","0.5470003","0.5466049","0.54639524","0.5436921","0.54332066","0.5429503","0.5421685","0.54012895","0.53845364","0.5376513","0.5343169","0.53367156","0.5335585","0.532601","0.5322198","0.53211164","0.53141385","0.52997655","0.52988815","0.5278647","0.5268204","0.52669924","0.52541417","0.5253849","0.5248369","0.5239481","0.5239373","0.52299315","0.5229912","0.52244925","0.52234674","0.52233094","0.5216992","0.5213005","0.52086353","0.520032","0.51989955","0.519769","0.51959485","0.51824564","0.5177828","0.51682353","0.51656115","0.5164444","0.5150138","0.51498264","0.5146714","0.5145187","0.51431924","0.51272905","0.51247495","0.5122496","0.51156354","0.511262","0.5111973","0.51118624","0.5110664","0.5102406","0.51019275","0.5096738","0.50874585","0.50846195","0.5083178","0.5083178","0.5079833","0.5079606","0.50774825","0.5077406","0.5074569","0.50735724","0.50715727","0.5065565","0.50649464","0.5062437","0.50617814","0.5054907","0.5054703","0.5054053","0.505377","0.5049802","0.5048237","0.50477594","0.5043108"],"string":"[\n \"0.6018227\",\n \"0.59535146\",\n \"0.59033984\",\n \"0.5829751\",\n \"0.5825883\",\n \"0.57707506\",\n \"0.5694387\",\n \"0.56823575\",\n \"0.5666963\",\n \"0.5642597\",\n \"0.5641661\",\n \"0.5638052\",\n \"0.55918825\",\n \"0.5589538\",\n \"0.55241865\",\n \"0.55067444\",\n \"0.54987234\",\n \"0.54837316\",\n \"0.5470003\",\n \"0.5466049\",\n \"0.54639524\",\n \"0.5436921\",\n \"0.54332066\",\n \"0.5429503\",\n \"0.5421685\",\n \"0.54012895\",\n \"0.53845364\",\n \"0.5376513\",\n \"0.5343169\",\n \"0.53367156\",\n \"0.5335585\",\n \"0.532601\",\n \"0.5322198\",\n \"0.53211164\",\n \"0.53141385\",\n \"0.52997655\",\n \"0.52988815\",\n \"0.5278647\",\n \"0.5268204\",\n \"0.52669924\",\n \"0.52541417\",\n \"0.5253849\",\n \"0.5248369\",\n \"0.5239481\",\n \"0.5239373\",\n \"0.52299315\",\n \"0.5229912\",\n \"0.52244925\",\n \"0.52234674\",\n \"0.52233094\",\n \"0.5216992\",\n \"0.5213005\",\n \"0.52086353\",\n \"0.520032\",\n \"0.51989955\",\n \"0.519769\",\n \"0.51959485\",\n \"0.51824564\",\n \"0.5177828\",\n \"0.51682353\",\n \"0.51656115\",\n \"0.5164444\",\n \"0.5150138\",\n \"0.51498264\",\n \"0.5146714\",\n \"0.5145187\",\n \"0.51431924\",\n \"0.51272905\",\n \"0.51247495\",\n \"0.5122496\",\n \"0.51156354\",\n \"0.511262\",\n \"0.5111973\",\n \"0.51118624\",\n \"0.5110664\",\n \"0.5102406\",\n \"0.51019275\",\n \"0.5096738\",\n \"0.50874585\",\n \"0.50846195\",\n \"0.5083178\",\n \"0.5083178\",\n \"0.5079833\",\n \"0.5079606\",\n \"0.50774825\",\n \"0.5077406\",\n \"0.5074569\",\n \"0.50735724\",\n \"0.50715727\",\n \"0.5065565\",\n \"0.50649464\",\n \"0.5062437\",\n \"0.50617814\",\n \"0.5054907\",\n \"0.5054703\",\n \"0.5054053\",\n \"0.505377\",\n \"0.5049802\",\n \"0.5048237\",\n \"0.50477594\",\n \"0.5043108\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":22898,"cells":{"query":{"kind":"string","value":"Move in exactly one component. Play ends immediately when any one of them terminates."},"document":{"kind":"string","value":"def diminished_disjunctive(G, H):\n if G == 0 or H == 0:\n return Game(0)\n else:\n left_1 = {diminished_disjunctive(G_L, H) for G_L in G._left}\n left_2 = {diminished_disjunctive(G, H_L) for H_L in H._left}\n right_1 = {diminished_disjunctive(G_R, H) for G_R in G._right}\n right_2 = {diminished_disjunctive(G, H_R) for H_R in H._right}\n return Game(left_1 | left_2, right_1 | right_2)"},"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 play_one_move(self):\n self.print(\"top of move\")\n # 1) grab three cups\n c1 = self.take_cup_after(self.current_cup_idx())\n c2 = self.take_cup_after(self.current_cup_idx())\n c3 = self.take_cup_after(self.current_cup_idx())\n print(f\"pick up: {c1}, {c2}, {c3}\")\n self.print(\"after pickup\")\n\n # 2) find a destination cup\n destination_idx = self.find_next_destination(self.current_cup)\n print(\n f\"destination index is {destination_idx}, cup is {self.cups[destination_idx]}\"\n )\n\n # 3) insert cups back into the circle\n self.add_cups(destination_idx, [c1, c2, c3])\n self.print(\"after adding cups..\")\n\n # 4) select the next cup\n self.select_next_cup()\n\n self.print(\"post move\")","def decide(self):\n self.maybe_shoot()\n next(self.move_cycle)\n\n pass","def move(self):\n pass","def step(self, move):","def decide_next_move(self):\n pass","def move(self, direction, cycles):\n\t\tpass","def handleMove(self):\n pass","def play_step(self, action):\n self.players[0].moving_left = False\n self.players[0].moving_right = False\n if action == MOVE_LEFT:\n self.players[0].moving_left = True\n for i in range(LOOP_AT_EACH_MOVE_UPDATE):\n self.update(is_a_star=True)\n if self.dead_player or not self.players[0].is_alive:\n break\n self.players[0].moving_left = False\n if self.dead_player or not self.players[0].is_alive:\n return\n elif action == MOVE_RIGHT:\n self.players[0].moving_right = True\n for i in range(LOOP_AT_EACH_MOVE_UPDATE):\n self.update(is_a_star=True)\n if self.dead_player or not self.players[0].is_alive:\n break\n self.players[0].moving_right = False\n if self.dead_player or not self.players[0].is_alive:\n return\n elif action == SHOOT:\n if self.dead_player or not self.players[0].is_alive:\n self.update(is_a_star=True)\n return\n if not self.players[0].weapon.is_active:\n self.players[0].shoot()\n for i in range(LOOP_AT_EACH_MOVE_UPDATE):\n self.update(is_a_star=True)\n if self.dead_player or not self.players[0].is_alive:\n break\n if self.dead_player or not self.players[0].is_alive:\n return","def run(self):\n while not self.turn_over:\n self.go()","def second_move(self):\n self.play_sound(self.second_key)\n self.end_move()","def move(self):\n raise NotImplementedError","def play_one_move(self, verbose=False):\n if verbose:\n self.print(\"top of move\")\n\n # 1) grab three cups\n c1 = self.cups.remove_next_node()\n c2 = self.cups.remove_next_node()\n c3 = self.cups.remove_next_node()\n if verbose:\n print(f\"pick up: {c1}, {c2}, {c3}\")\n self.print(\"after pickup\")\n\n # 2) find a destination cup\n destination_node = self.find_next_destination(\n self.cups.get_current_node().value\n )\n if verbose:\n print(f\"destination node is {destination_node}\")\n\n # 3) insert cups back into the circle\n self.cups.add_after(destination_node, c3.value)\n self.cups.add_after(destination_node, c2.value)\n self.cups.add_after(destination_node, c1.value)\n if verbose:\n self.print(\"after adding cups..\")\n\n # 4) select the next cup\n target_cup = self.cups.get_current_node().next()\n self.cups.set_current_node(target_cup)\n\n if verbose:\n self.print(\"post move\")","def move(self) -> bool:\n pass","def play(self):\n\n while self.board.board[self.board.target_location()[0]]\\\n [self.board.target_location()[1]] == \"E\": # the car didn't\n # arrive the exit\n self.__single_turn()\n print(\"you won!\")","def play_simulation(self):\n self._play(self._move_comp_person)","def move(self) -> None:\n\n if self.move_up:\n self.__moveUpIfPossible()\n if self.move_down:\n self.__moveDownIfPossible()","def move_forward():\n pass","def main():\r\n turn_left()\r\n while front_is_clear():\r\n move()\r\n turn_right()\r\n while front_is_clear():\r\n move()\r\n turn_right()\r\n while front_is_clear():\r\n move()\r\n turn_left()","def bqm_move_queue(self):\n self.bqm.turn_once()","def interaction_void(self) -> None:\n self.grid.obj_list.swap_obj(self.moving_character, self.target)","def main():\n move()\n move()\n pick_beeper()\n move()\n turn_left()\n for i in range(2):\n move()\n put_beeper()\n turn_around()\n move_to_wall()\n turn_right()\n move_to_wall()\n turn_around()","def process_IN_MOVE_SELF(self, event):","def move_cycle(self, actions, players):\n\n for i in range(len(players)):\n player = players[i]\n action = actions[i]\n player.move(action)\n for other in players:\n if Circle.collide(player, other) and player != other:\n player.revert_move()\n if Circle.collide(player, self.ball):\n self.possession = player.team\n self.ball.move(player)\n\n self.ball.move()\n scored = self.__ball_scored()\n if scored:\n self.ball.replace()\n if scored == TEAM_RED:\n self.score[1] += 1\n return (1, TEAM_RED)\n else:\n self.score[0] += 1\n return (1, TEAM_BLUE)\n elif self.__ball_out_bounds():\n if self.possession == TEAM_BLUE:\n self.ball.restart(Point(WIDTH / 4, HEIGHT / 2))\n else:\n self.ball.restart(Point(WIDTH * 3/4, HEIGHT / 2))\n return (2, self.possession)\n else:\n return (0, None)","def run(self):\n for _ in range(self.num_iteration):\n self.move()\n time.sleep(self.speed)\n if not self.is_running:\n break","def move(self):\r\n segments = len(self.all_turtles) - 1\r\n for i in range(len(self.all_turtles)):\r\n if segments == 0:\r\n self.all_turtles[segments].forward(MOVE_DISTANCE)\r\n else:\r\n new_x = self.all_turtles[segments - 1].xcor()\r\n new_y = self.all_turtles[segments - 1].ycor()\r\n self.all_turtles[segments].goto(new_x, new_y)\r\n segments -= 1","def play_move(self, move):\n color, move_tuple = convert_from_GTP(move, self.size)\n result = self.game.move_stone(move_tuple[0], move_tuple[1], color)\n if result.status != gogame.VALID:\n raise PlayError, result.status\n self.board.PlaceMove(move_tuple, color)\n self.board.ErasePieces(result.prisoners)\n self.board.SwitchCurColor()\n\n self.curWatcher.play(move)\n\n #if there are consecutive passes, end the game, else reset pass count\n if move == \"pass\":\n self.isPass += 1\n if self.isPass == 2:\n self.end_game()\n else:\n self.isPass = 0\n\n #switch the players\n temp = self.curPlayer\n self.curPlayer = self.curWatcher\n self.curWatcher = temp\n \n if self.isPass < 2:\n self.call_for_move()\n else:\n self.end_game()","def MULTIPLAYER_LOOP():\n pass","def cb_move(self, event):\n if not self.move_timer.IsRunning():\n self.move_timer.StartOnce(2000)","def step(self, action):\n # print(\"############################\")\n # print(\"action: {}\".format(action))\n\n self.movement_complete.data = False\n\n # 1) Read last joint positions by getting the observation before acting\n old_observation = self.get_obs()\n\n # 2) Get the new joint positions according to chosen action (actions here are the joint increments)\n if self._joint_increment is None:\n next_action_position = action\n else:\n next_action_position = self.get_action_to_position(action, old_observation[1:7])\n\n # 3) Move to position and wait for moveit to complete the execution\n self.publisher_to_moveit_object.pub_joints_to_moveit(next_action_position)\n # rospy.wait_for_message(\"/pickbot/movement_complete\", Bool)\n while not self.movement_complete.data:\n pass\n\n start_ros_time = rospy.Time.now()\n while True:\n # Check collision:\n # invalid_collision = self.get_collisions()\n # if invalid_collision:\n # print(\">>>>>>>>>> Collision: RESET <<<<<<<<<<<<<<<\")\n # observation = self.get_obs()\n # reward = UMath.compute_reward(observation, -200, True)\n # observation = self.get_obs()\n # print(\"Test Joint: {}\".format(np.around(observation[1:7], decimals=3)))\n # return U.get_state(observation), reward, True, {}\n\n elapsed_time = rospy.Time.now() - start_ros_time\n if np.isclose(next_action_position, self.joints_state.position, rtol=0.0, atol=0.01).all():\n break\n elif elapsed_time > rospy.Duration(2): # time out\n break\n # time.sleep(s\n\n \"\"\"\n #execute action as long as the current position is close to the target position and there is no invalid collision and time spend in the while loop is below 1.2 seconds to avoid beeing stuck touching the object and not beeing able to go to the desired position \n time1=time.time()\n while np.linalg.norm(np.asarray(self.joints_state.position)-np.asarray(next_action_position))>0.1 and self.get_collisions()==False and time.time()-time1<0.1: \n rospy.loginfo(\"Not yet reached target position and no collision\")\n \"\"\"\n # 4) Get new observation and update min_distance after performing the action\n new_observation = self.get_obs()\n if new_observation[0] < self.min_distace:\n self.min_distace = new_observation[0]\n # print(\"observ: {}\".format( np.around(new_observation[1:7], decimals=3)))\n\n # 5) Convert Observations into state\n state = U.get_state(new_observation)\n\n # 6) Check if its done, calculate done_reward\n done, done_reward, invalid_contact = self.is_done(new_observation)\n\n # 7) Calculate reward based on Observatin and done_reward and update the accumulated Episode Reward\n reward = UMath.compute_reward(new_observation, done_reward, invalid_contact)\n\n ### TEST ###\n if done:\n joint_pos = self.joints_state.position\n print(\"Joint in step (done): {}\".format(np.around(joint_pos, decimals=3)))\n ### END of TEST ###\n\n self.accumulated_episode_reward += reward\n\n self.episode_steps += 1\n\n return state, reward, done, {}","def first_move(self):\n self.play_sound(self.first_key)\n self.make_blink()\n self.wait_second_move()","def algo_mover(self):\n self.tick_count = 0 ## reset to start clock on delayed state change\n\n ### Move 1 ring ###\n de, aux, vers = self.instructions.pop(0)\n\n de = self.rods[de]\n aux = self.rods[aux]\n vers = self.rods[vers]\n\n ring = de.pop_ring()\n vers.add_ring(ring)\n\n ### Update the states after -- moved this to main update\n #self.state_updater()","def move(self, absolutePosition):\n if self.connection is not None:\n c = self.connection.getChannel(self.chanNamePrefix % 'start_one')\n\n c.write(absolutePosition)\n\n w = SpecWaitObject.SpecWaitObject(self.connection)\n w.waitChannelUpdate(self.chanNamePrefix % 'move_done', waitValue = 0) #move_done is set to 0 when move has finished","def moveSpecialOb(self):\n\t\tfor obJ in self.special:\n\t\t\tobJ.moveStep()","def moveCirc(self):\n\t\tfor circle in self.circles:\n\t\t\tcircle.moveStep()","def play_move(self,state):\n #Keep asking for the next move until a valid move.\n while(True):\n childList = state.get_successors()\n print(\"Your possible moves:\")\n i = 0\n for c in childList:\n if i > 0 and i%4 == 0:\n print()\n print(c.get_action().ljust(10),end=\"\\t\");\n i += 1\n print()\n nextMove = input(\"What is your next move? \\ne.g.'F2-E3' or 'Quit'\\n\")\n #Check if the move is valid\n if nextMove.lower() == 'Quit'.lower():\n return None\n for c in childList:\n if c.get_action().upper() == nextMove.upper():\n return c\n # Move not possible \n print(\"Invalid move!! Please try again...\\n\")","def test_eos_next(self):\n source1 = procedural.Sine(0.5)\n source2 = procedural.Sine(0.5)\n player = media.Player()\n player.queue(source1)\n player.queue(source2)\n player.play()","def play(self):\n self._play(self._move_person)","def twist(self):\n self.right()\n time.sleep(1)\n self.stop()\n self.left()\n time.sleep(1)\n self.stop()","def main():\r\n turn_left()\r\n move_three_times()\r\n turn_right()\r\n move_three_times()\r\n turn_right()\r\n move_three_times()\r\n turn_left()","def automove(self):\n if self.x < self.end_cinematic_x_pos:\n self.x += self.SHIP_SPEED\n if self.x > self.end_cinematic_x_pos:\n self.x -= self.SHIP_SPEED\n if self.y < self.end_cinematic_y_pos:\n self.y += self.SHIP_SPEED\n if self.y > self.end_cinematic_y_pos:\n self.y -= self.SHIP_SPEED","def move_repeatedly():\n check = check50.run(run_command)\n check.stdin(\"WEST\").stdout(room_2_description)\n check.stdin(\"EAST\").stdout(room_1_name)\n check.stdin(\"WEST\").stdout(room_2_name)","def stop(self):\n self.move(None)","def move_to_position1(self):","def move_once():\n try:\n check50.run(run_command).stdout(room_1_description)\n except check50.Failure as error:\n raise check50.Failure(f\"Expected the description of initial room when Adventure starts.\\n {error}\")\n check50.run(run_command).stdin(\"WEST\").stdout(room_2_description)","def move(self):\n\n choices = []\n if self.game.green_apples > 0:\n choices.append(self.game.move_green)\n if self.game.red_apples > 0:\n choices.append(self.game.move_red)\n if self.game.blue_plums > 0:\n choices.append(self.game.move_blue)\n if self.game.yellow_pears > 0:\n choices.append(self.game.move_yellow)\n\n random_index = random.randint(0, len(choices) - 1)\n f = choices[random_index]\n f(True)","def run(self):\n while self.direction != \"\":\n if self.direction == \"decrease\":\n if self.position > 200:\n self.position -= 15\n elif self.direction == \"increase\":\n if self.position < 800:\n self.position += 15\n if self.direction != \"neutral\":\n self.move_joint(self.position, 900)\n time.sleep(0.1)","async def move(self, movement):\n next_position = self.position\n self.position = (next_position + movement) % self.game.positions\n self.game.player_moved(self)\n\n box = None\n for mov in range(movement):\n next_position += 1\n if next_position == self.game.positions:\n next_position = 0\n\n box = self.game.board.get_box(next_position)\n await self.move_position(box)\n\n box.goes_in(self)","def move(self, *args, **kw):\n return self.execute_action('move', *args, **kw)","def movement(self):","def _ispinnedmove(self, from_, to_):\n return False","def _move_forward(self):\n\t\tself.x,self.y = Mario._get_coordinates(Board.prev_i,Board.prev_j,Board.prev_k)\n\t\tif(self.y<=798):\n\t\t\tself.y = self.y+1\n\t\t\tif Board.board[self.x][self.y]=='0':\n\t\t\t\tMario.score += 1\n\t\t\t\tMario._pass(self.x,self.y-1)\n\t\t\t\tBoard.board[self.x][self.y]='M'\n\n\t\t\telif Board.board[self.x][self.y]=='P':\n\t\t\t\tMario.lives+=1\n\t\t\t\tMario._pass(self.x,self.y-1)\n\t\t\t\tBoard.board[self.x][self.y]='M'\n\t\t\t\tcall([\"aplay\",\"-q\",\"smb_1-up.wav\"])\n\n\t\t\telif Board.board[self.x][self.y]=='A':\n\t\t\t\tMario._pass(self.x,self.y-1)\n\t\t\t\tBoard.board[self.x][self.y]='M'\n\t\t\t\tMario.attack = 1\n\t\t\t\tcall([\"aplay\",\"-q\",\"smb_powerup.wav\"])\n\n\t\t\telif Board.board[self.x][self.y]=='@':\n\t\t\t\tMario._pass(self.x,self.y-1)\n\t\t\t\tMario.lives-=1\n\t\t\t\tcall([\"aplay\",\"-q\",\"smb_mariodie.wav\"])\n\t\t\t\tif Mario.lives<=0:\n\t\t\t\t\tcall([\"aplay\",\"-q\",\"smb_gameover.wav\"])\n\t\t\t\t\treturn \"exit\"\n\t\t\t\tos.system('clear')\n\t\t\t\tprint(\"\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\t\\t\\t\\t\\t\\tNumber of Mario left\",Mario.lives)\n\t\t\t\tMario.respawn(self.x,self.y)\n\t\t\t\ttime.sleep(2)\n\t\t\t\tinit_board(Board.prev_i,Board.prev_j,Board.prev_k)\n\n\t\t\telif(Board.board[self.x][self.y]=='/'):\n\t\t\t\tMario._pass(self.x,self.y-1)\n\t\t\t\tBoard.board[self.x-1][self.y]='M'\n\n\t\t\telif Board.board[self.x][self.y]=='I':\n\t\t\t\tMario._pass(self.x,self.y-1)\n\t\t\t\tcall([\"aplay\",\"-q\",\"smb_stage_clear.wav\"])\n\t\t\t\tBoard.bonus_round()\n\n\t\t\telif Board.board[self.x][self.y]=='K':\n\t\t\t\tMario._pass(self.x,self.y-1)\n\t\t\t\tcall([\"aplay\",\"-q\",\"smb_stage_clear.wav\"])\n\t\t\t\tenemy.boss_round()\n\n\t\t\telif(Board.board[self.x][self.y] in obstacles):\n\t\t\t\tMario._pass(self.x,self.y-1)\n\t\t\t\tBoard.board[self.x][self.y-1]='M'\n\n\t\t\telif((Board.board[self.x+1][self.y-1]=='/' or Board.board[self.x+1][self.y-1]=='T') and Board.board[self.x+1][self.y]==' '):\n\t\t\t\tMario._pass(self.x,self.y-1)\n\t\t\t\tBoard.board[self.x][self.y+1]='M'\n\t\t\t\tMario.go_down(self)\n\t\t\telse:\n\t\t\t\tMario._pass(self.x,self.y-1)\n\t\t\t\tBoard.board[self.x][self.y]='M'\n\n\t\tif( self.y-1 >= ((Board.prev_j+Board.prev_k)/2) ):\n\t\t\tos.system('clear')\n\t\t\tBoard.prev_j += 1 \n\t\t\tBoard.prev_k += 1\n\t\t\tinit_board(Board.prev_i,Board.prev_j,Board.prev_k)\n\t\telse:\n\t\t\tos.system('clear')\n\t\t\tinit_board(Board.prev_i,Board.prev_j,Board.prev_k)","def move(self):\n # This block is used to move into the living room.\n if self.room_name == \"living\" or self.room_name == \"Living\":\n self.living_room()\n # This block is used to open the door.\n elif self.room_name == \"Door\" or self.room_name == \"door\":\n self.door()\n # This block is used to move into the kitchen.\n elif self.room_name == \"Kitchen\" or self.room_name == \"kitchen\":\n self.kitchen()\n # This block is used to move into the hallway.\n elif self.room_name == \"Hallway\" or self.room_name == \"hallway\":\n self.hallway()\n # This block is used to move into the bathroom.\n elif self.room_name == \"Bathroom\" or self.room_name == \"bathroom\":\n self.bathroom()\n # This block is used to move into the basement.\n elif self.room_name == \"Basement\" or self.room_name == \"basement\":\n self.basement()\n # This block is used to move into the bedroom.\n elif self.room_name == \"Bedroom\" or self.room_name == \"bedroom\":\n self.bedroom()\n # This block is used to move into the attic.\n elif self.room_name == \"Attic\" or \"attic\":\n self.attic()","def moveStep(self):\n\t\tif self.pos[0] <= self.boundsX[0] or \\\n\t\t(self.pos[0]+ 2*(self.radius)) >= self.boundsX[1]:\n\t\t\tself.dir[0] *= -1\n\t\t\t\n\t\tself.pos[0] += self.dir[0]*self.speed\n\t\tself.pos[1] += self.dir[1]*self.speed","def move(): #py:move\n RUR._move_()","def move(self):\n # moving each of the obstacles\n time = rospy.get_rostime()\n self.vel_msg1.linear.x = math.sin(time.to_sec())\n self.pub1.publish(self.vel_msg1)\n self.vel_msg2.linear.x = math.cos(1.2 * time.to_sec())\n self.pub2.publish(self.vel_msg2)\n self.vel_msg3.linear.x = math.cos(2 * time.to_sec())\n self.pub3.publish(self.vel_msg3)\n self.vel_msg4.linear.x = math.sin(0.85 * time.to_sec())\n self.pub4.publish(self.vel_msg4)","def turn_around():\n for i in range(2):\n turn_left()","def startMovementAll(self):\n self.startMovementX()\n self.startMovementY()\n self.startMovementZ()","def _move(self, d, event):\n\n actor = None\n if event.source in self._crates:\n actor = self._crates[event.source]\n else:\n actor = self._clones[event.source][0]\n\n if d == Direction.NO_ACT or not event.success:\n actor.animation = actor.do_nothing_animation()\n return\n pos = actor.pos\n target = pos.dir_pos(d)\n actor.direction = d\n actor.animation = actor.walk_animation()\n self.repaint()","def run_logic(self):\n if not self.game_over:\n # Move all the sprites\n self.all_sprites_list.update()","def move(self, x, y):\n if self.computer_first:\n self.app.config(cursor='watch')\n self.board = self.board.move(x, y)\n self.update()\n self.computer_first = 0\n self.app.config(cursor='')\n else:\n self.board = self.board.move(x, y)\n self.update()\n self.app.config(cursor='watch')\n move = self.board.best()\n if move:\n self.board = self.board.move(*move)\n self.update()\n self.app.config(cursor='')","def move_step(self, direction):\n x = self.objects[0].x\n y = self.objects[0].y\n if direction == 0 and y >= 1:\n self.objects[0].y -= 1\n elif direction == 1 and y <= self.size_y - 2:\n self.objects[0].y += 1\n elif direction == 2 and x >= 1:\n self.objects[0].x -= 1\n elif direction == 3 and x <= self.size_x - 2:\n self.objects[0].x += 1","def move(self, start, distance, p1):\n if (p1):\n #move your piece\n self.p1vec[start] -= 1\n dest = start + distance\n if (dest == 25):\n self.bornoff = True\n else:\n self.p1vec[start+distance] += 1\n #capture your opponent, despite their number\n spot = 25 - start - distance\n self.p2vec[0] += self.p2vec[spot]\n self.p2vec[spot] = 0\n else:\n #move your piece\n self.p2vec[start] -= 1\n dest = start + distance\n if (dest == 25):\n pass\n else:\n self.p2vec[start+distance] += 1\n #capture your opponent\n spot = 25 - start - distance\n self.p2vec[0] += self.p2vec[spot]\n self.p2vec[spot] = 0","def start_game(self):\n p1_move = True\n is_all_moves_over = False\n while not is_all_moves_over:\n\n while p1_move and not is_all_moves_over:\n p1 = int(input(\"Player 1 pos:\"))\n is_all_moves_over, p1_move = self.play('p1', p1, p1_move)\n\n while not p1_move and not is_all_moves_over:\n p2 = int(input(\"Player 2 pos:\"))\n is_all_moves_over, p1_move = self.play('p2', p2, p1_move)\n\n print(\"Game Ended in Draw\")","def _move(self, move: Tile):\n if not self.game_state:\n raise RuntimeError(\"Cannot call move when the game has not started!\")\n # Adversaries are supposed to be notified of new info right before they move.\n if issubclass(type(self.current_turn), Enemy):\n current_enemy = next(enemy for enemy in self.enemy_list if enemy.entity.name == self.current_turn.entity.name)\n self._notify_adversary(current_enemy)\n # Players that are alive before this move\n pre_players = self.game_state.get_current_characters()\n completed_before_turn = self.game_state.get_completed_characters()\n if move != None:\n self._move_and_update(move)\n else:\n self.current_turn.notify(self._format_move_result_notification(None, Moveresult.OK))\n # Notify players and adversaries of changes to the gamestate, including players who were killed\n # on this turn. Note that this usually results in one rendering per move to all entities.\n self._update_players()\n self._update_adversaries()\n self._handle_completed_characters(completed_before_turn)\n self._handle_killed_players(pre_players)\n self.current_turn = self.turn_order.next()","def move(self, direction):\n pass","def move(self, move):\n raise NotImplementedError()","def __move_ball(self):\n while not self.__game_is_over():\n self.__ball.move(self.__dx, self.__dy)\n self.__handle_wall_collision()\n if self.__num_lives == 0:\n self.__game_over_picture()\n break\n elif self.__bricks_total == 0:\n self.__game_over_picture('You Win!!')\n break\n pause(FRAME_RATE)","def move(x,y):\r\n pass","def _move_in_one_more_block():\n with tik_inst.for_range(0, sub_h_align_block_size) as sub_h_idx:\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block * sub_h_idx],\n src[w_offset + w_size * sub_h_idx], 0, 1, sub_w_block, 0, 0)\n # in order to avoid dirty data when multiple core\n with tik_inst.for_range(0, data_cnt_one_block) as sub_h_idx_1:\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block *\n (sub_h_align_block_size + sub_h_idx_1)],\n src[w_offset +\n w_size * (sub_h_size - data_cnt_one_block + sub_h_idx_1)],\n 0, 1, sub_w_block, 0, 0)","async def move_channel_loop(self):\n try:\n while self.state == CHANNEL_MOVE_STATE_NONE:\n message = await self.poll_message()\n if message is None:\n break\n \n try:\n await self.move_message(message)\n except DiscordException as err:\n if err.code == ERROR_CODES.unknown_webhook:\n self.set_status_update_waiter_webhook_deleted()\n return\n \n raise\n \n self.last_message_id = message.id\n self.total_moved_messages += 1\n \n except GeneratorExit:\n raise\n \n except CancelledError:\n raise\n \n except BaseException as err:\n self.set_status_update_waiter_error()\n await self.client.events.error(self.client, repr(self), err)\n return\n \n finally:\n self.discard()\n \n self.set_status_update_waiter_finished()","def computer_move(board,move,player):\r\n com_execution(board, move, player)","def move_piece(self, direction=None):\n if self.will_collide(direction=direction):\n return\n self.active_piece.move(direction=direction)\n self.display_piece()","def move_to_position2(self):","def step(self):\n if not self._is_game_over:\n self._move_snake()\n self._is_game_over = self.is_snake_collides()","def play(self):\n for player in cycle((self.player_x, self.player_o)):\n if self._turn(player):\n return","def choose_move(self):\r\n \r\n return None","def run(self):\n # type: () -> None\n self.move_to(self.location)","def play_move(self,state):\n raise AIError(\"Must be implemented for child class!\")","def _move_comp_person(self):\n\n move_tuple = random.choice(self._board.possible())\n self._board[move_tuple] = 'x'","def step(self, actions):\n if len(actions) != len(self._seats):\n raise error.Error('actions must be same shape as number of seats.')\n\n if self._current_player is None:\n raise error.Error('Round cannot be played without 2 or more players.')\n\n if self._round == 4:\n raise error.Error('Rounds already finished, needs to be reset.')\n\n players = [p for p in self._seats if p.playing_hand]\n if len(players) == 1:\n raise error.Error('Round cannot be played with one player.')\n\n self._last_player = self._current_player\n self._last_actions = actions\n\n if not self._current_player.playedthisround and len([p for p in players if not p.isallin]) >= 1:\n if self._current_player.isallin:\n self._current_player = self._next(players, self._current_player)\n return self._get_current_step_returns(False)\n\n move = self._current_player.player_move(\n self._output_state(self._current_player), actions[self._current_player.player_id])\n\n if move[0] == 'call':\n self._player_bet(self._current_player, self._tocall)\n if self._debug:\n print('Player', self._current_player.player_id, move)\n self._current_player = self._next(players, self._current_player)\n elif move[0] == 'check':\n self._player_bet(self._current_player, self._current_player.currentbet)\n if self._debug:\n print('Player', self._current_player.player_id, move)\n self._current_player = self._next(players, self._current_player)\n elif move[0] == 'raise':\n self._player_bet(self._current_player, move[1]+self._current_player.currentbet)\n if self._debug:\n print('Player', self._current_player.player_id, move)\n for p in players:\n if p != self._current_player:\n p.playedthisround = False\n self._current_player = self._next(players, self._current_player)\n elif move[0] == 'fold':\n self._current_player.playing_hand = False\n folded_player = self._current_player\n if self._debug:\n print('Player', self._current_player.player_id, move)\n self._current_player = self._next(players, self._current_player)\n players.remove(folded_player)\n self._folded_players.append(folded_player)\n # break if a single player left\n if len(players) == 1:\n self._resolve(players)\n if all([player.playedthisround for player in players]):\n self._resolve(players)\n\n terminal = False\n if all([player.isallin for player in players]):\n while self._round < 4:\n self._deal_next_round()\n self._round += 1\n if self._round == 4 or len(players) == 1:\n terminal = True\n self._resolve_round(players)\n return self._get_current_step_returns(terminal)","def evolve(self):\n # Start with first player\n self.phase.set(1)\n\n #self.first_player\n \n # Autopass turn if no cards left for player\n \n \n pass","def player(board):\n #X ALWAYS gets first move, alternates with each additional move\n curr_moves = actions(board)\n if (board == initial_state()):\n return X\n if(len(curr_moves) % 2 == 0):\n return O\n else:\n return X","def _play(self, func):\n\n func()\n print('\\nhuman movement:\\n')\n print(self._board)\n\n while self._board.possible() != []:\n self._board.move_computer()\n print('\\ncomputer movement:\\n')\n print(self._board)\n if self._board.check_win():\n print('\\nwinner is computer')\n return\n\n func()\n print('\\nhuman movement:\\n')\n print(self._board)\n if self._board.check_win():\n print('\\nwinner is human')\n return\n print('\\nwinner is friendship :)')","def move(self):\n self.old_tail = self.body[-1][:] # save old position of last block\n self.head[0] += self.direction[0] # moves head\n self.head[1] += self.direction[1]\n \n self.head[0] = (self.head[0] + self.xMaxSize) % self.xMaxSize\n self.head[1] = (self.head[1] + self.yMaxSize) % self.yMaxSize\n \n if self.head in self.body[1:]: # if snakes hits himself\n self.alive = False\n self.body.insert(0, self.body.pop()) # each block is replace by predecessor\n self.body[0] = self.head[:] # first block is head","def cancel_move(self):\n self.should_move = False","def moveStep(self):\n\t\tif self.pos[0] < self.boundsX[0] or \\\n\t\t\tself.pos[0] > (self.boundsX[1] - self.width):\n\t\t\t\tself.dir[0] *= -1\n\t\tif self.pos[1] < self.boundsY[0] or \\\n\t\t self.pos[1] > (self.boundsY[1] - self.height):\n\t\t\t\tself.dir[1] *= -1\n\t\t\t\n\t\tself.pos[0] += self.dir[0]*self.speed\n\t\tself.pos[1] += self.dir[1]*self.speed","def move(self, direction, step):\n for i in range(1, step + 1):\n y, x = self.robot_position\n if direction == \"N\" and y > 0:\n if self.carte[y - 1][x] in [\" \", \".\", \"U\"]:\n self.robot_position = (y - 1, x)\n elif direction == \"S\" and y <= self.height:\n if self.carte[y + 1][x] in [\" \", \".\", \"U\"]:\n self.robot_position = (y + 1, x)\n elif direction == \"E\" and x <= self.width+1:\n if self.carte[y][x + 1] in [\" \", \".\", \"U\"]:\n self.robot_position = (y, x + 1)\n elif direction == \"O\" and x > 0:\n if self.carte[y][x - 1] in [\" \", \".\", \"U\"]:\n self.robot_position = (y, x - 1)\n\n if self.robot_position == self.out_position:\n print(\"Bravo vous avez fini\")\n return True\n\n return False","def move(self):\n self.tick()\n self.pressed = pygame.key.get_pressed()\n\n \"\"\"Do deleting platforms/do losing\"\"\"\n self.player.update(self)\n self.main_platform.update(self)\n\n for i in self.platformsx:\n self.platformsx[i].update(self)\n \n for i in self.platforms:\n self.platforms[i].update(self)\n\n for i in self.to_remove:\n self.platforms.pop(i)\n self.to_remove.clear()\n\n for i in self.platformsx:\n self.platformsx[i].update(self)","def nextMovie(self):\n if (len(self.movie_queue) > 0):\n\n # Figure out where to take the movie.\n elt = self.movie_queue[0]\n if isinstance(elt, list):\n [dx, dy] = elt\n [im_x_um, im_y_um] = self.last_image.getSizeUm()\n \n next_x_um = self.current_center.x_um + (1.0 - self.fractional_overlap)*im_x_um*dx\n next_y_um = self.current_center.y_um + (1.0 - self.fractional_overlap)*im_y_um*dy\n movie_pos = coord.Point(next_x_um, next_y_um, \"um\")\n\n else:\n self.current_center = elt\n movie_pos = elt\n\n # Remove from the queue.\n self.movie_queue = self.movie_queue[1:]\n \n # Take the movie, checking for failure to communicate with HAL.\n if not self.takeSingleMovie(movie_pos):\n self.movie_queue = []\n self.smc = None\n self.sequenceComplete.emit()\n\n else: \n self.comm.stopCommunication()\n self.smc = None\n\n self.sequenceComplete.emit()","def moveToNextFrame(self):\n\t\tall_ts = [s for t in self.stamps_by_stream.values() for s in t]\n\t\tall_ts.sort()\n\t\tfirst_frame = all_ts[0]\n\n\t\tselected_index = bisect.bisect_right(all_ts, self._timeline.current_pos)-1\n\t\tif len(all_ts)-1 == selected_index:\n\t\t\t# We are already at the last frame\n\t\t\treturn\n\n\t\t# Move forward enough to be sure to reach the first frame\n\t\tincrease = 1\n\t\twhile all_ts[selected_index+increase] < first_frame:\n\t\t\tincrease += 1\n\n\t\tself._timeline.current_pos = all_ts[selected_index+increase]\n\t\tself.objectSelected.emit(\n\t\t self.getFileAtStamp(self._timeline.current_pos)\n\t\t)","def make_move(self):\r\n if self.running and self.run:\r\n if self.board is None:\r\n SlTrace.lg(\"sp.board is None\")\r\n return False\r\n \r\n SlTrace.lg(\"running_loop self.running and self.run\", \"running_loop\")\r\n SlTrace.lg(\"running_loop self.start_move\", \"running_loop\")\r\n if self.start_move():\r\n SlTrace.lg(\"running_loop successful start_move\", \"running_loop\")\r\n self.next_move_no()\r\n SlTrace.lg(\"running_loop after start_move\", \"running_loop\")\r\n if self.to_pause:\r\n self.pause_cmd()\r\n self.to_pause = False\r\n return True","def motion(self):\n priority = {\"north\": [-1, 0], \"south\": [1, 0],\n \"east\": [0, 1], \"west\": [0, -1]}\n\n priority_list = [\"north\", \"south\", \"east\", \"west\"]\n\n critical_point = False\n while critical_point is False:\n row = self.curr_cell.row\n column = self.curr_cell.col\n\n if self.allow_to_move(priority_list[0],\n row + priority[priority_list[0]][0],\n column + priority[priority_list[0]][1]):\n\n self.move(priority_list[0])\n\n elif self.allow_to_move(priority_list[1],\n row + priority[priority_list[1]][0],\n column + priority[priority_list[1]][1]):\n\n self.move(priority_list[1])\n\n elif self.allow_to_move(priority_list[2],\n row + priority[priority_list[2]][0],\n column + priority[priority_list[2]][1]):\n\n self.move(priority_list[2])\n\n elif self.allow_to_move(priority_list[3],\n row + priority[priority_list[3]][0],\n column + priority[priority_list[3]][1]):\n\n self.move(priority_list[3])\n\n else:\n # Robot isolated\n critical_point = True\n\n return self.curr_cell, self.path","def chacha(self):\n self.right()\n time.sleep(2)\n self.stop()\n self.back()\n time.sleep(1)\n self.servo(1000)\n time.sleep(1)\n self.stop()\n self.fwd()\n time.sleep(1)\n self.stop()\n self.servo(2000)\n time.sleep(1)\n self.stop()\n self.left()\n time.sleep(2)\n self.stop()","def move(self, t, s):\n raise NotImplementedError","def stop(self):\n self.move(0, 0)","def _onmove(self, event):","def update(self):\n if not self._move:\n self.get_next_move()\n if self._move:\n self._move.update()","def move(self, direction):\n # replace with your code\n pass","def move(self, direction):\n # replace with your code\n pass","def move(self):\n self._move_range_shuffle(3)\n self._move_satisfy_random_constraint()\n # self._move_range_shuffle(3)\n #if (curr_energy > 50):\n # self._move_satisfy_random_constraint()\n #else:\n # self._move_range_shuffle(3)","def stopMovementAll(self):\n self.stopMovementX()\n self.stopMovementY()\n self.stopMovementZ()"],"string":"[\n \"def play_one_move(self):\\n self.print(\\\"top of move\\\")\\n # 1) grab three cups\\n c1 = self.take_cup_after(self.current_cup_idx())\\n c2 = self.take_cup_after(self.current_cup_idx())\\n c3 = self.take_cup_after(self.current_cup_idx())\\n print(f\\\"pick up: {c1}, {c2}, {c3}\\\")\\n self.print(\\\"after pickup\\\")\\n\\n # 2) find a destination cup\\n destination_idx = self.find_next_destination(self.current_cup)\\n print(\\n f\\\"destination index is {destination_idx}, cup is {self.cups[destination_idx]}\\\"\\n )\\n\\n # 3) insert cups back into the circle\\n self.add_cups(destination_idx, [c1, c2, c3])\\n self.print(\\\"after adding cups..\\\")\\n\\n # 4) select the next cup\\n self.select_next_cup()\\n\\n self.print(\\\"post move\\\")\",\n \"def decide(self):\\n self.maybe_shoot()\\n next(self.move_cycle)\\n\\n pass\",\n \"def move(self):\\n pass\",\n \"def step(self, move):\",\n \"def decide_next_move(self):\\n pass\",\n \"def move(self, direction, cycles):\\n\\t\\tpass\",\n \"def handleMove(self):\\n pass\",\n \"def play_step(self, action):\\n self.players[0].moving_left = False\\n self.players[0].moving_right = False\\n if action == MOVE_LEFT:\\n self.players[0].moving_left = True\\n for i in range(LOOP_AT_EACH_MOVE_UPDATE):\\n self.update(is_a_star=True)\\n if self.dead_player or not self.players[0].is_alive:\\n break\\n self.players[0].moving_left = False\\n if self.dead_player or not self.players[0].is_alive:\\n return\\n elif action == MOVE_RIGHT:\\n self.players[0].moving_right = True\\n for i in range(LOOP_AT_EACH_MOVE_UPDATE):\\n self.update(is_a_star=True)\\n if self.dead_player or not self.players[0].is_alive:\\n break\\n self.players[0].moving_right = False\\n if self.dead_player or not self.players[0].is_alive:\\n return\\n elif action == SHOOT:\\n if self.dead_player or not self.players[0].is_alive:\\n self.update(is_a_star=True)\\n return\\n if not self.players[0].weapon.is_active:\\n self.players[0].shoot()\\n for i in range(LOOP_AT_EACH_MOVE_UPDATE):\\n self.update(is_a_star=True)\\n if self.dead_player or not self.players[0].is_alive:\\n break\\n if self.dead_player or not self.players[0].is_alive:\\n return\",\n \"def run(self):\\n while not self.turn_over:\\n self.go()\",\n \"def second_move(self):\\n self.play_sound(self.second_key)\\n self.end_move()\",\n \"def move(self):\\n raise NotImplementedError\",\n \"def play_one_move(self, verbose=False):\\n if verbose:\\n self.print(\\\"top of move\\\")\\n\\n # 1) grab three cups\\n c1 = self.cups.remove_next_node()\\n c2 = self.cups.remove_next_node()\\n c3 = self.cups.remove_next_node()\\n if verbose:\\n print(f\\\"pick up: {c1}, {c2}, {c3}\\\")\\n self.print(\\\"after pickup\\\")\\n\\n # 2) find a destination cup\\n destination_node = self.find_next_destination(\\n self.cups.get_current_node().value\\n )\\n if verbose:\\n print(f\\\"destination node is {destination_node}\\\")\\n\\n # 3) insert cups back into the circle\\n self.cups.add_after(destination_node, c3.value)\\n self.cups.add_after(destination_node, c2.value)\\n self.cups.add_after(destination_node, c1.value)\\n if verbose:\\n self.print(\\\"after adding cups..\\\")\\n\\n # 4) select the next cup\\n target_cup = self.cups.get_current_node().next()\\n self.cups.set_current_node(target_cup)\\n\\n if verbose:\\n self.print(\\\"post move\\\")\",\n \"def move(self) -> bool:\\n pass\",\n \"def play(self):\\n\\n while self.board.board[self.board.target_location()[0]]\\\\\\n [self.board.target_location()[1]] == \\\"E\\\": # the car didn't\\n # arrive the exit\\n self.__single_turn()\\n print(\\\"you won!\\\")\",\n \"def play_simulation(self):\\n self._play(self._move_comp_person)\",\n \"def move(self) -> None:\\n\\n if self.move_up:\\n self.__moveUpIfPossible()\\n if self.move_down:\\n self.__moveDownIfPossible()\",\n \"def move_forward():\\n pass\",\n \"def main():\\r\\n turn_left()\\r\\n while front_is_clear():\\r\\n move()\\r\\n turn_right()\\r\\n while front_is_clear():\\r\\n move()\\r\\n turn_right()\\r\\n while front_is_clear():\\r\\n move()\\r\\n turn_left()\",\n \"def bqm_move_queue(self):\\n self.bqm.turn_once()\",\n \"def interaction_void(self) -> None:\\n self.grid.obj_list.swap_obj(self.moving_character, self.target)\",\n \"def main():\\n move()\\n move()\\n pick_beeper()\\n move()\\n turn_left()\\n for i in range(2):\\n move()\\n put_beeper()\\n turn_around()\\n move_to_wall()\\n turn_right()\\n move_to_wall()\\n turn_around()\",\n \"def process_IN_MOVE_SELF(self, event):\",\n \"def move_cycle(self, actions, players):\\n\\n for i in range(len(players)):\\n player = players[i]\\n action = actions[i]\\n player.move(action)\\n for other in players:\\n if Circle.collide(player, other) and player != other:\\n player.revert_move()\\n if Circle.collide(player, self.ball):\\n self.possession = player.team\\n self.ball.move(player)\\n\\n self.ball.move()\\n scored = self.__ball_scored()\\n if scored:\\n self.ball.replace()\\n if scored == TEAM_RED:\\n self.score[1] += 1\\n return (1, TEAM_RED)\\n else:\\n self.score[0] += 1\\n return (1, TEAM_BLUE)\\n elif self.__ball_out_bounds():\\n if self.possession == TEAM_BLUE:\\n self.ball.restart(Point(WIDTH / 4, HEIGHT / 2))\\n else:\\n self.ball.restart(Point(WIDTH * 3/4, HEIGHT / 2))\\n return (2, self.possession)\\n else:\\n return (0, None)\",\n \"def run(self):\\n for _ in range(self.num_iteration):\\n self.move()\\n time.sleep(self.speed)\\n if not self.is_running:\\n break\",\n \"def move(self):\\r\\n segments = len(self.all_turtles) - 1\\r\\n for i in range(len(self.all_turtles)):\\r\\n if segments == 0:\\r\\n self.all_turtles[segments].forward(MOVE_DISTANCE)\\r\\n else:\\r\\n new_x = self.all_turtles[segments - 1].xcor()\\r\\n new_y = self.all_turtles[segments - 1].ycor()\\r\\n self.all_turtles[segments].goto(new_x, new_y)\\r\\n segments -= 1\",\n \"def play_move(self, move):\\n color, move_tuple = convert_from_GTP(move, self.size)\\n result = self.game.move_stone(move_tuple[0], move_tuple[1], color)\\n if result.status != gogame.VALID:\\n raise PlayError, result.status\\n self.board.PlaceMove(move_tuple, color)\\n self.board.ErasePieces(result.prisoners)\\n self.board.SwitchCurColor()\\n\\n self.curWatcher.play(move)\\n\\n #if there are consecutive passes, end the game, else reset pass count\\n if move == \\\"pass\\\":\\n self.isPass += 1\\n if self.isPass == 2:\\n self.end_game()\\n else:\\n self.isPass = 0\\n\\n #switch the players\\n temp = self.curPlayer\\n self.curPlayer = self.curWatcher\\n self.curWatcher = temp\\n \\n if self.isPass < 2:\\n self.call_for_move()\\n else:\\n self.end_game()\",\n \"def MULTIPLAYER_LOOP():\\n pass\",\n \"def cb_move(self, event):\\n if not self.move_timer.IsRunning():\\n self.move_timer.StartOnce(2000)\",\n \"def step(self, action):\\n # print(\\\"############################\\\")\\n # print(\\\"action: {}\\\".format(action))\\n\\n self.movement_complete.data = False\\n\\n # 1) Read last joint positions by getting the observation before acting\\n old_observation = self.get_obs()\\n\\n # 2) Get the new joint positions according to chosen action (actions here are the joint increments)\\n if self._joint_increment is None:\\n next_action_position = action\\n else:\\n next_action_position = self.get_action_to_position(action, old_observation[1:7])\\n\\n # 3) Move to position and wait for moveit to complete the execution\\n self.publisher_to_moveit_object.pub_joints_to_moveit(next_action_position)\\n # rospy.wait_for_message(\\\"/pickbot/movement_complete\\\", Bool)\\n while not self.movement_complete.data:\\n pass\\n\\n start_ros_time = rospy.Time.now()\\n while True:\\n # Check collision:\\n # invalid_collision = self.get_collisions()\\n # if invalid_collision:\\n # print(\\\">>>>>>>>>> Collision: RESET <<<<<<<<<<<<<<<\\\")\\n # observation = self.get_obs()\\n # reward = UMath.compute_reward(observation, -200, True)\\n # observation = self.get_obs()\\n # print(\\\"Test Joint: {}\\\".format(np.around(observation[1:7], decimals=3)))\\n # return U.get_state(observation), reward, True, {}\\n\\n elapsed_time = rospy.Time.now() - start_ros_time\\n if np.isclose(next_action_position, self.joints_state.position, rtol=0.0, atol=0.01).all():\\n break\\n elif elapsed_time > rospy.Duration(2): # time out\\n break\\n # time.sleep(s\\n\\n \\\"\\\"\\\"\\n #execute action as long as the current position is close to the target position and there is no invalid collision and time spend in the while loop is below 1.2 seconds to avoid beeing stuck touching the object and not beeing able to go to the desired position \\n time1=time.time()\\n while np.linalg.norm(np.asarray(self.joints_state.position)-np.asarray(next_action_position))>0.1 and self.get_collisions()==False and time.time()-time1<0.1: \\n rospy.loginfo(\\\"Not yet reached target position and no collision\\\")\\n \\\"\\\"\\\"\\n # 4) Get new observation and update min_distance after performing the action\\n new_observation = self.get_obs()\\n if new_observation[0] < self.min_distace:\\n self.min_distace = new_observation[0]\\n # print(\\\"observ: {}\\\".format( np.around(new_observation[1:7], decimals=3)))\\n\\n # 5) Convert Observations into state\\n state = U.get_state(new_observation)\\n\\n # 6) Check if its done, calculate done_reward\\n done, done_reward, invalid_contact = self.is_done(new_observation)\\n\\n # 7) Calculate reward based on Observatin and done_reward and update the accumulated Episode Reward\\n reward = UMath.compute_reward(new_observation, done_reward, invalid_contact)\\n\\n ### TEST ###\\n if done:\\n joint_pos = self.joints_state.position\\n print(\\\"Joint in step (done): {}\\\".format(np.around(joint_pos, decimals=3)))\\n ### END of TEST ###\\n\\n self.accumulated_episode_reward += reward\\n\\n self.episode_steps += 1\\n\\n return state, reward, done, {}\",\n \"def first_move(self):\\n self.play_sound(self.first_key)\\n self.make_blink()\\n self.wait_second_move()\",\n \"def algo_mover(self):\\n self.tick_count = 0 ## reset to start clock on delayed state change\\n\\n ### Move 1 ring ###\\n de, aux, vers = self.instructions.pop(0)\\n\\n de = self.rods[de]\\n aux = self.rods[aux]\\n vers = self.rods[vers]\\n\\n ring = de.pop_ring()\\n vers.add_ring(ring)\\n\\n ### Update the states after -- moved this to main update\\n #self.state_updater()\",\n \"def move(self, absolutePosition):\\n if self.connection is not None:\\n c = self.connection.getChannel(self.chanNamePrefix % 'start_one')\\n\\n c.write(absolutePosition)\\n\\n w = SpecWaitObject.SpecWaitObject(self.connection)\\n w.waitChannelUpdate(self.chanNamePrefix % 'move_done', waitValue = 0) #move_done is set to 0 when move has finished\",\n \"def moveSpecialOb(self):\\n\\t\\tfor obJ in self.special:\\n\\t\\t\\tobJ.moveStep()\",\n \"def moveCirc(self):\\n\\t\\tfor circle in self.circles:\\n\\t\\t\\tcircle.moveStep()\",\n \"def play_move(self,state):\\n #Keep asking for the next move until a valid move.\\n while(True):\\n childList = state.get_successors()\\n print(\\\"Your possible moves:\\\")\\n i = 0\\n for c in childList:\\n if i > 0 and i%4 == 0:\\n print()\\n print(c.get_action().ljust(10),end=\\\"\\\\t\\\");\\n i += 1\\n print()\\n nextMove = input(\\\"What is your next move? \\\\ne.g.'F2-E3' or 'Quit'\\\\n\\\")\\n #Check if the move is valid\\n if nextMove.lower() == 'Quit'.lower():\\n return None\\n for c in childList:\\n if c.get_action().upper() == nextMove.upper():\\n return c\\n # Move not possible \\n print(\\\"Invalid move!! Please try again...\\\\n\\\")\",\n \"def test_eos_next(self):\\n source1 = procedural.Sine(0.5)\\n source2 = procedural.Sine(0.5)\\n player = media.Player()\\n player.queue(source1)\\n player.queue(source2)\\n player.play()\",\n \"def play(self):\\n self._play(self._move_person)\",\n \"def twist(self):\\n self.right()\\n time.sleep(1)\\n self.stop()\\n self.left()\\n time.sleep(1)\\n self.stop()\",\n \"def main():\\r\\n turn_left()\\r\\n move_three_times()\\r\\n turn_right()\\r\\n move_three_times()\\r\\n turn_right()\\r\\n move_three_times()\\r\\n turn_left()\",\n \"def automove(self):\\n if self.x < self.end_cinematic_x_pos:\\n self.x += self.SHIP_SPEED\\n if self.x > self.end_cinematic_x_pos:\\n self.x -= self.SHIP_SPEED\\n if self.y < self.end_cinematic_y_pos:\\n self.y += self.SHIP_SPEED\\n if self.y > self.end_cinematic_y_pos:\\n self.y -= self.SHIP_SPEED\",\n \"def move_repeatedly():\\n check = check50.run(run_command)\\n check.stdin(\\\"WEST\\\").stdout(room_2_description)\\n check.stdin(\\\"EAST\\\").stdout(room_1_name)\\n check.stdin(\\\"WEST\\\").stdout(room_2_name)\",\n \"def stop(self):\\n self.move(None)\",\n \"def move_to_position1(self):\",\n \"def move_once():\\n try:\\n check50.run(run_command).stdout(room_1_description)\\n except check50.Failure as error:\\n raise check50.Failure(f\\\"Expected the description of initial room when Adventure starts.\\\\n {error}\\\")\\n check50.run(run_command).stdin(\\\"WEST\\\").stdout(room_2_description)\",\n \"def move(self):\\n\\n choices = []\\n if self.game.green_apples > 0:\\n choices.append(self.game.move_green)\\n if self.game.red_apples > 0:\\n choices.append(self.game.move_red)\\n if self.game.blue_plums > 0:\\n choices.append(self.game.move_blue)\\n if self.game.yellow_pears > 0:\\n choices.append(self.game.move_yellow)\\n\\n random_index = random.randint(0, len(choices) - 1)\\n f = choices[random_index]\\n f(True)\",\n \"def run(self):\\n while self.direction != \\\"\\\":\\n if self.direction == \\\"decrease\\\":\\n if self.position > 200:\\n self.position -= 15\\n elif self.direction == \\\"increase\\\":\\n if self.position < 800:\\n self.position += 15\\n if self.direction != \\\"neutral\\\":\\n self.move_joint(self.position, 900)\\n time.sleep(0.1)\",\n \"async def move(self, movement):\\n next_position = self.position\\n self.position = (next_position + movement) % self.game.positions\\n self.game.player_moved(self)\\n\\n box = None\\n for mov in range(movement):\\n next_position += 1\\n if next_position == self.game.positions:\\n next_position = 0\\n\\n box = self.game.board.get_box(next_position)\\n await self.move_position(box)\\n\\n box.goes_in(self)\",\n \"def move(self, *args, **kw):\\n return self.execute_action('move', *args, **kw)\",\n \"def movement(self):\",\n \"def _ispinnedmove(self, from_, to_):\\n return False\",\n \"def _move_forward(self):\\n\\t\\tself.x,self.y = Mario._get_coordinates(Board.prev_i,Board.prev_j,Board.prev_k)\\n\\t\\tif(self.y<=798):\\n\\t\\t\\tself.y = self.y+1\\n\\t\\t\\tif Board.board[self.x][self.y]=='0':\\n\\t\\t\\t\\tMario.score += 1\\n\\t\\t\\t\\tMario._pass(self.x,self.y-1)\\n\\t\\t\\t\\tBoard.board[self.x][self.y]='M'\\n\\n\\t\\t\\telif Board.board[self.x][self.y]=='P':\\n\\t\\t\\t\\tMario.lives+=1\\n\\t\\t\\t\\tMario._pass(self.x,self.y-1)\\n\\t\\t\\t\\tBoard.board[self.x][self.y]='M'\\n\\t\\t\\t\\tcall([\\\"aplay\\\",\\\"-q\\\",\\\"smb_1-up.wav\\\"])\\n\\n\\t\\t\\telif Board.board[self.x][self.y]=='A':\\n\\t\\t\\t\\tMario._pass(self.x,self.y-1)\\n\\t\\t\\t\\tBoard.board[self.x][self.y]='M'\\n\\t\\t\\t\\tMario.attack = 1\\n\\t\\t\\t\\tcall([\\\"aplay\\\",\\\"-q\\\",\\\"smb_powerup.wav\\\"])\\n\\n\\t\\t\\telif Board.board[self.x][self.y]=='@':\\n\\t\\t\\t\\tMario._pass(self.x,self.y-1)\\n\\t\\t\\t\\tMario.lives-=1\\n\\t\\t\\t\\tcall([\\\"aplay\\\",\\\"-q\\\",\\\"smb_mariodie.wav\\\"])\\n\\t\\t\\t\\tif Mario.lives<=0:\\n\\t\\t\\t\\t\\tcall([\\\"aplay\\\",\\\"-q\\\",\\\"smb_gameover.wav\\\"])\\n\\t\\t\\t\\t\\treturn \\\"exit\\\"\\n\\t\\t\\t\\tos.system('clear')\\n\\t\\t\\t\\tprint(\\\"\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\t\\\\t\\\\t\\\\t\\\\t\\\\tNumber of Mario left\\\",Mario.lives)\\n\\t\\t\\t\\tMario.respawn(self.x,self.y)\\n\\t\\t\\t\\ttime.sleep(2)\\n\\t\\t\\t\\tinit_board(Board.prev_i,Board.prev_j,Board.prev_k)\\n\\n\\t\\t\\telif(Board.board[self.x][self.y]=='/'):\\n\\t\\t\\t\\tMario._pass(self.x,self.y-1)\\n\\t\\t\\t\\tBoard.board[self.x-1][self.y]='M'\\n\\n\\t\\t\\telif Board.board[self.x][self.y]=='I':\\n\\t\\t\\t\\tMario._pass(self.x,self.y-1)\\n\\t\\t\\t\\tcall([\\\"aplay\\\",\\\"-q\\\",\\\"smb_stage_clear.wav\\\"])\\n\\t\\t\\t\\tBoard.bonus_round()\\n\\n\\t\\t\\telif Board.board[self.x][self.y]=='K':\\n\\t\\t\\t\\tMario._pass(self.x,self.y-1)\\n\\t\\t\\t\\tcall([\\\"aplay\\\",\\\"-q\\\",\\\"smb_stage_clear.wav\\\"])\\n\\t\\t\\t\\tenemy.boss_round()\\n\\n\\t\\t\\telif(Board.board[self.x][self.y] in obstacles):\\n\\t\\t\\t\\tMario._pass(self.x,self.y-1)\\n\\t\\t\\t\\tBoard.board[self.x][self.y-1]='M'\\n\\n\\t\\t\\telif((Board.board[self.x+1][self.y-1]=='/' or Board.board[self.x+1][self.y-1]=='T') and Board.board[self.x+1][self.y]==' '):\\n\\t\\t\\t\\tMario._pass(self.x,self.y-1)\\n\\t\\t\\t\\tBoard.board[self.x][self.y+1]='M'\\n\\t\\t\\t\\tMario.go_down(self)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tMario._pass(self.x,self.y-1)\\n\\t\\t\\t\\tBoard.board[self.x][self.y]='M'\\n\\n\\t\\tif( self.y-1 >= ((Board.prev_j+Board.prev_k)/2) ):\\n\\t\\t\\tos.system('clear')\\n\\t\\t\\tBoard.prev_j += 1 \\n\\t\\t\\tBoard.prev_k += 1\\n\\t\\t\\tinit_board(Board.prev_i,Board.prev_j,Board.prev_k)\\n\\t\\telse:\\n\\t\\t\\tos.system('clear')\\n\\t\\t\\tinit_board(Board.prev_i,Board.prev_j,Board.prev_k)\",\n \"def move(self):\\n # This block is used to move into the living room.\\n if self.room_name == \\\"living\\\" or self.room_name == \\\"Living\\\":\\n self.living_room()\\n # This block is used to open the door.\\n elif self.room_name == \\\"Door\\\" or self.room_name == \\\"door\\\":\\n self.door()\\n # This block is used to move into the kitchen.\\n elif self.room_name == \\\"Kitchen\\\" or self.room_name == \\\"kitchen\\\":\\n self.kitchen()\\n # This block is used to move into the hallway.\\n elif self.room_name == \\\"Hallway\\\" or self.room_name == \\\"hallway\\\":\\n self.hallway()\\n # This block is used to move into the bathroom.\\n elif self.room_name == \\\"Bathroom\\\" or self.room_name == \\\"bathroom\\\":\\n self.bathroom()\\n # This block is used to move into the basement.\\n elif self.room_name == \\\"Basement\\\" or self.room_name == \\\"basement\\\":\\n self.basement()\\n # This block is used to move into the bedroom.\\n elif self.room_name == \\\"Bedroom\\\" or self.room_name == \\\"bedroom\\\":\\n self.bedroom()\\n # This block is used to move into the attic.\\n elif self.room_name == \\\"Attic\\\" or \\\"attic\\\":\\n self.attic()\",\n \"def moveStep(self):\\n\\t\\tif self.pos[0] <= self.boundsX[0] or \\\\\\n\\t\\t(self.pos[0]+ 2*(self.radius)) >= self.boundsX[1]:\\n\\t\\t\\tself.dir[0] *= -1\\n\\t\\t\\t\\n\\t\\tself.pos[0] += self.dir[0]*self.speed\\n\\t\\tself.pos[1] += self.dir[1]*self.speed\",\n \"def move(): #py:move\\n RUR._move_()\",\n \"def move(self):\\n # moving each of the obstacles\\n time = rospy.get_rostime()\\n self.vel_msg1.linear.x = math.sin(time.to_sec())\\n self.pub1.publish(self.vel_msg1)\\n self.vel_msg2.linear.x = math.cos(1.2 * time.to_sec())\\n self.pub2.publish(self.vel_msg2)\\n self.vel_msg3.linear.x = math.cos(2 * time.to_sec())\\n self.pub3.publish(self.vel_msg3)\\n self.vel_msg4.linear.x = math.sin(0.85 * time.to_sec())\\n self.pub4.publish(self.vel_msg4)\",\n \"def turn_around():\\n for i in range(2):\\n turn_left()\",\n \"def startMovementAll(self):\\n self.startMovementX()\\n self.startMovementY()\\n self.startMovementZ()\",\n \"def _move(self, d, event):\\n\\n actor = None\\n if event.source in self._crates:\\n actor = self._crates[event.source]\\n else:\\n actor = self._clones[event.source][0]\\n\\n if d == Direction.NO_ACT or not event.success:\\n actor.animation = actor.do_nothing_animation()\\n return\\n pos = actor.pos\\n target = pos.dir_pos(d)\\n actor.direction = d\\n actor.animation = actor.walk_animation()\\n self.repaint()\",\n \"def run_logic(self):\\n if not self.game_over:\\n # Move all the sprites\\n self.all_sprites_list.update()\",\n \"def move(self, x, y):\\n if self.computer_first:\\n self.app.config(cursor='watch')\\n self.board = self.board.move(x, y)\\n self.update()\\n self.computer_first = 0\\n self.app.config(cursor='')\\n else:\\n self.board = self.board.move(x, y)\\n self.update()\\n self.app.config(cursor='watch')\\n move = self.board.best()\\n if move:\\n self.board = self.board.move(*move)\\n self.update()\\n self.app.config(cursor='')\",\n \"def move_step(self, direction):\\n x = self.objects[0].x\\n y = self.objects[0].y\\n if direction == 0 and y >= 1:\\n self.objects[0].y -= 1\\n elif direction == 1 and y <= self.size_y - 2:\\n self.objects[0].y += 1\\n elif direction == 2 and x >= 1:\\n self.objects[0].x -= 1\\n elif direction == 3 and x <= self.size_x - 2:\\n self.objects[0].x += 1\",\n \"def move(self, start, distance, p1):\\n if (p1):\\n #move your piece\\n self.p1vec[start] -= 1\\n dest = start + distance\\n if (dest == 25):\\n self.bornoff = True\\n else:\\n self.p1vec[start+distance] += 1\\n #capture your opponent, despite their number\\n spot = 25 - start - distance\\n self.p2vec[0] += self.p2vec[spot]\\n self.p2vec[spot] = 0\\n else:\\n #move your piece\\n self.p2vec[start] -= 1\\n dest = start + distance\\n if (dest == 25):\\n pass\\n else:\\n self.p2vec[start+distance] += 1\\n #capture your opponent\\n spot = 25 - start - distance\\n self.p2vec[0] += self.p2vec[spot]\\n self.p2vec[spot] = 0\",\n \"def start_game(self):\\n p1_move = True\\n is_all_moves_over = False\\n while not is_all_moves_over:\\n\\n while p1_move and not is_all_moves_over:\\n p1 = int(input(\\\"Player 1 pos:\\\"))\\n is_all_moves_over, p1_move = self.play('p1', p1, p1_move)\\n\\n while not p1_move and not is_all_moves_over:\\n p2 = int(input(\\\"Player 2 pos:\\\"))\\n is_all_moves_over, p1_move = self.play('p2', p2, p1_move)\\n\\n print(\\\"Game Ended in Draw\\\")\",\n \"def _move(self, move: Tile):\\n if not self.game_state:\\n raise RuntimeError(\\\"Cannot call move when the game has not started!\\\")\\n # Adversaries are supposed to be notified of new info right before they move.\\n if issubclass(type(self.current_turn), Enemy):\\n current_enemy = next(enemy for enemy in self.enemy_list if enemy.entity.name == self.current_turn.entity.name)\\n self._notify_adversary(current_enemy)\\n # Players that are alive before this move\\n pre_players = self.game_state.get_current_characters()\\n completed_before_turn = self.game_state.get_completed_characters()\\n if move != None:\\n self._move_and_update(move)\\n else:\\n self.current_turn.notify(self._format_move_result_notification(None, Moveresult.OK))\\n # Notify players and adversaries of changes to the gamestate, including players who were killed\\n # on this turn. Note that this usually results in one rendering per move to all entities.\\n self._update_players()\\n self._update_adversaries()\\n self._handle_completed_characters(completed_before_turn)\\n self._handle_killed_players(pre_players)\\n self.current_turn = self.turn_order.next()\",\n \"def move(self, direction):\\n pass\",\n \"def move(self, move):\\n raise NotImplementedError()\",\n \"def __move_ball(self):\\n while not self.__game_is_over():\\n self.__ball.move(self.__dx, self.__dy)\\n self.__handle_wall_collision()\\n if self.__num_lives == 0:\\n self.__game_over_picture()\\n break\\n elif self.__bricks_total == 0:\\n self.__game_over_picture('You Win!!')\\n break\\n pause(FRAME_RATE)\",\n \"def move(x,y):\\r\\n pass\",\n \"def _move_in_one_more_block():\\n with tik_inst.for_range(0, sub_h_align_block_size) as sub_h_idx:\\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block * sub_h_idx],\\n src[w_offset + w_size * sub_h_idx], 0, 1, sub_w_block, 0, 0)\\n # in order to avoid dirty data when multiple core\\n with tik_inst.for_range(0, data_cnt_one_block) as sub_h_idx_1:\\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block *\\n (sub_h_align_block_size + sub_h_idx_1)],\\n src[w_offset +\\n w_size * (sub_h_size - data_cnt_one_block + sub_h_idx_1)],\\n 0, 1, sub_w_block, 0, 0)\",\n \"async def move_channel_loop(self):\\n try:\\n while self.state == CHANNEL_MOVE_STATE_NONE:\\n message = await self.poll_message()\\n if message is None:\\n break\\n \\n try:\\n await self.move_message(message)\\n except DiscordException as err:\\n if err.code == ERROR_CODES.unknown_webhook:\\n self.set_status_update_waiter_webhook_deleted()\\n return\\n \\n raise\\n \\n self.last_message_id = message.id\\n self.total_moved_messages += 1\\n \\n except GeneratorExit:\\n raise\\n \\n except CancelledError:\\n raise\\n \\n except BaseException as err:\\n self.set_status_update_waiter_error()\\n await self.client.events.error(self.client, repr(self), err)\\n return\\n \\n finally:\\n self.discard()\\n \\n self.set_status_update_waiter_finished()\",\n \"def computer_move(board,move,player):\\r\\n com_execution(board, move, player)\",\n \"def move_piece(self, direction=None):\\n if self.will_collide(direction=direction):\\n return\\n self.active_piece.move(direction=direction)\\n self.display_piece()\",\n \"def move_to_position2(self):\",\n \"def step(self):\\n if not self._is_game_over:\\n self._move_snake()\\n self._is_game_over = self.is_snake_collides()\",\n \"def play(self):\\n for player in cycle((self.player_x, self.player_o)):\\n if self._turn(player):\\n return\",\n \"def choose_move(self):\\r\\n \\r\\n return None\",\n \"def run(self):\\n # type: () -> None\\n self.move_to(self.location)\",\n \"def play_move(self,state):\\n raise AIError(\\\"Must be implemented for child class!\\\")\",\n \"def _move_comp_person(self):\\n\\n move_tuple = random.choice(self._board.possible())\\n self._board[move_tuple] = 'x'\",\n \"def step(self, actions):\\n if len(actions) != len(self._seats):\\n raise error.Error('actions must be same shape as number of seats.')\\n\\n if self._current_player is None:\\n raise error.Error('Round cannot be played without 2 or more players.')\\n\\n if self._round == 4:\\n raise error.Error('Rounds already finished, needs to be reset.')\\n\\n players = [p for p in self._seats if p.playing_hand]\\n if len(players) == 1:\\n raise error.Error('Round cannot be played with one player.')\\n\\n self._last_player = self._current_player\\n self._last_actions = actions\\n\\n if not self._current_player.playedthisround and len([p for p in players if not p.isallin]) >= 1:\\n if self._current_player.isallin:\\n self._current_player = self._next(players, self._current_player)\\n return self._get_current_step_returns(False)\\n\\n move = self._current_player.player_move(\\n self._output_state(self._current_player), actions[self._current_player.player_id])\\n\\n if move[0] == 'call':\\n self._player_bet(self._current_player, self._tocall)\\n if self._debug:\\n print('Player', self._current_player.player_id, move)\\n self._current_player = self._next(players, self._current_player)\\n elif move[0] == 'check':\\n self._player_bet(self._current_player, self._current_player.currentbet)\\n if self._debug:\\n print('Player', self._current_player.player_id, move)\\n self._current_player = self._next(players, self._current_player)\\n elif move[0] == 'raise':\\n self._player_bet(self._current_player, move[1]+self._current_player.currentbet)\\n if self._debug:\\n print('Player', self._current_player.player_id, move)\\n for p in players:\\n if p != self._current_player:\\n p.playedthisround = False\\n self._current_player = self._next(players, self._current_player)\\n elif move[0] == 'fold':\\n self._current_player.playing_hand = False\\n folded_player = self._current_player\\n if self._debug:\\n print('Player', self._current_player.player_id, move)\\n self._current_player = self._next(players, self._current_player)\\n players.remove(folded_player)\\n self._folded_players.append(folded_player)\\n # break if a single player left\\n if len(players) == 1:\\n self._resolve(players)\\n if all([player.playedthisround for player in players]):\\n self._resolve(players)\\n\\n terminal = False\\n if all([player.isallin for player in players]):\\n while self._round < 4:\\n self._deal_next_round()\\n self._round += 1\\n if self._round == 4 or len(players) == 1:\\n terminal = True\\n self._resolve_round(players)\\n return self._get_current_step_returns(terminal)\",\n \"def evolve(self):\\n # Start with first player\\n self.phase.set(1)\\n\\n #self.first_player\\n \\n # Autopass turn if no cards left for player\\n \\n \\n pass\",\n \"def player(board):\\n #X ALWAYS gets first move, alternates with each additional move\\n curr_moves = actions(board)\\n if (board == initial_state()):\\n return X\\n if(len(curr_moves) % 2 == 0):\\n return O\\n else:\\n return X\",\n \"def _play(self, func):\\n\\n func()\\n print('\\\\nhuman movement:\\\\n')\\n print(self._board)\\n\\n while self._board.possible() != []:\\n self._board.move_computer()\\n print('\\\\ncomputer movement:\\\\n')\\n print(self._board)\\n if self._board.check_win():\\n print('\\\\nwinner is computer')\\n return\\n\\n func()\\n print('\\\\nhuman movement:\\\\n')\\n print(self._board)\\n if self._board.check_win():\\n print('\\\\nwinner is human')\\n return\\n print('\\\\nwinner is friendship :)')\",\n \"def move(self):\\n self.old_tail = self.body[-1][:] # save old position of last block\\n self.head[0] += self.direction[0] # moves head\\n self.head[1] += self.direction[1]\\n \\n self.head[0] = (self.head[0] + self.xMaxSize) % self.xMaxSize\\n self.head[1] = (self.head[1] + self.yMaxSize) % self.yMaxSize\\n \\n if self.head in self.body[1:]: # if snakes hits himself\\n self.alive = False\\n self.body.insert(0, self.body.pop()) # each block is replace by predecessor\\n self.body[0] = self.head[:] # first block is head\",\n \"def cancel_move(self):\\n self.should_move = False\",\n \"def moveStep(self):\\n\\t\\tif self.pos[0] < self.boundsX[0] or \\\\\\n\\t\\t\\tself.pos[0] > (self.boundsX[1] - self.width):\\n\\t\\t\\t\\tself.dir[0] *= -1\\n\\t\\tif self.pos[1] < self.boundsY[0] or \\\\\\n\\t\\t self.pos[1] > (self.boundsY[1] - self.height):\\n\\t\\t\\t\\tself.dir[1] *= -1\\n\\t\\t\\t\\n\\t\\tself.pos[0] += self.dir[0]*self.speed\\n\\t\\tself.pos[1] += self.dir[1]*self.speed\",\n \"def move(self, direction, step):\\n for i in range(1, step + 1):\\n y, x = self.robot_position\\n if direction == \\\"N\\\" and y > 0:\\n if self.carte[y - 1][x] in [\\\" \\\", \\\".\\\", \\\"U\\\"]:\\n self.robot_position = (y - 1, x)\\n elif direction == \\\"S\\\" and y <= self.height:\\n if self.carte[y + 1][x] in [\\\" \\\", \\\".\\\", \\\"U\\\"]:\\n self.robot_position = (y + 1, x)\\n elif direction == \\\"E\\\" and x <= self.width+1:\\n if self.carte[y][x + 1] in [\\\" \\\", \\\".\\\", \\\"U\\\"]:\\n self.robot_position = (y, x + 1)\\n elif direction == \\\"O\\\" and x > 0:\\n if self.carte[y][x - 1] in [\\\" \\\", \\\".\\\", \\\"U\\\"]:\\n self.robot_position = (y, x - 1)\\n\\n if self.robot_position == self.out_position:\\n print(\\\"Bravo vous avez fini\\\")\\n return True\\n\\n return False\",\n \"def move(self):\\n self.tick()\\n self.pressed = pygame.key.get_pressed()\\n\\n \\\"\\\"\\\"Do deleting platforms/do losing\\\"\\\"\\\"\\n self.player.update(self)\\n self.main_platform.update(self)\\n\\n for i in self.platformsx:\\n self.platformsx[i].update(self)\\n \\n for i in self.platforms:\\n self.platforms[i].update(self)\\n\\n for i in self.to_remove:\\n self.platforms.pop(i)\\n self.to_remove.clear()\\n\\n for i in self.platformsx:\\n self.platformsx[i].update(self)\",\n \"def nextMovie(self):\\n if (len(self.movie_queue) > 0):\\n\\n # Figure out where to take the movie.\\n elt = self.movie_queue[0]\\n if isinstance(elt, list):\\n [dx, dy] = elt\\n [im_x_um, im_y_um] = self.last_image.getSizeUm()\\n \\n next_x_um = self.current_center.x_um + (1.0 - self.fractional_overlap)*im_x_um*dx\\n next_y_um = self.current_center.y_um + (1.0 - self.fractional_overlap)*im_y_um*dy\\n movie_pos = coord.Point(next_x_um, next_y_um, \\\"um\\\")\\n\\n else:\\n self.current_center = elt\\n movie_pos = elt\\n\\n # Remove from the queue.\\n self.movie_queue = self.movie_queue[1:]\\n \\n # Take the movie, checking for failure to communicate with HAL.\\n if not self.takeSingleMovie(movie_pos):\\n self.movie_queue = []\\n self.smc = None\\n self.sequenceComplete.emit()\\n\\n else: \\n self.comm.stopCommunication()\\n self.smc = None\\n\\n self.sequenceComplete.emit()\",\n \"def moveToNextFrame(self):\\n\\t\\tall_ts = [s for t in self.stamps_by_stream.values() for s in t]\\n\\t\\tall_ts.sort()\\n\\t\\tfirst_frame = all_ts[0]\\n\\n\\t\\tselected_index = bisect.bisect_right(all_ts, self._timeline.current_pos)-1\\n\\t\\tif len(all_ts)-1 == selected_index:\\n\\t\\t\\t# We are already at the last frame\\n\\t\\t\\treturn\\n\\n\\t\\t# Move forward enough to be sure to reach the first frame\\n\\t\\tincrease = 1\\n\\t\\twhile all_ts[selected_index+increase] < first_frame:\\n\\t\\t\\tincrease += 1\\n\\n\\t\\tself._timeline.current_pos = all_ts[selected_index+increase]\\n\\t\\tself.objectSelected.emit(\\n\\t\\t self.getFileAtStamp(self._timeline.current_pos)\\n\\t\\t)\",\n \"def make_move(self):\\r\\n if self.running and self.run:\\r\\n if self.board is None:\\r\\n SlTrace.lg(\\\"sp.board is None\\\")\\r\\n return False\\r\\n \\r\\n SlTrace.lg(\\\"running_loop self.running and self.run\\\", \\\"running_loop\\\")\\r\\n SlTrace.lg(\\\"running_loop self.start_move\\\", \\\"running_loop\\\")\\r\\n if self.start_move():\\r\\n SlTrace.lg(\\\"running_loop successful start_move\\\", \\\"running_loop\\\")\\r\\n self.next_move_no()\\r\\n SlTrace.lg(\\\"running_loop after start_move\\\", \\\"running_loop\\\")\\r\\n if self.to_pause:\\r\\n self.pause_cmd()\\r\\n self.to_pause = False\\r\\n return True\",\n \"def motion(self):\\n priority = {\\\"north\\\": [-1, 0], \\\"south\\\": [1, 0],\\n \\\"east\\\": [0, 1], \\\"west\\\": [0, -1]}\\n\\n priority_list = [\\\"north\\\", \\\"south\\\", \\\"east\\\", \\\"west\\\"]\\n\\n critical_point = False\\n while critical_point is False:\\n row = self.curr_cell.row\\n column = self.curr_cell.col\\n\\n if self.allow_to_move(priority_list[0],\\n row + priority[priority_list[0]][0],\\n column + priority[priority_list[0]][1]):\\n\\n self.move(priority_list[0])\\n\\n elif self.allow_to_move(priority_list[1],\\n row + priority[priority_list[1]][0],\\n column + priority[priority_list[1]][1]):\\n\\n self.move(priority_list[1])\\n\\n elif self.allow_to_move(priority_list[2],\\n row + priority[priority_list[2]][0],\\n column + priority[priority_list[2]][1]):\\n\\n self.move(priority_list[2])\\n\\n elif self.allow_to_move(priority_list[3],\\n row + priority[priority_list[3]][0],\\n column + priority[priority_list[3]][1]):\\n\\n self.move(priority_list[3])\\n\\n else:\\n # Robot isolated\\n critical_point = True\\n\\n return self.curr_cell, self.path\",\n \"def chacha(self):\\n self.right()\\n time.sleep(2)\\n self.stop()\\n self.back()\\n time.sleep(1)\\n self.servo(1000)\\n time.sleep(1)\\n self.stop()\\n self.fwd()\\n time.sleep(1)\\n self.stop()\\n self.servo(2000)\\n time.sleep(1)\\n self.stop()\\n self.left()\\n time.sleep(2)\\n self.stop()\",\n \"def move(self, t, s):\\n raise NotImplementedError\",\n \"def stop(self):\\n self.move(0, 0)\",\n \"def _onmove(self, event):\",\n \"def update(self):\\n if not self._move:\\n self.get_next_move()\\n if self._move:\\n self._move.update()\",\n \"def move(self, direction):\\n # replace with your code\\n pass\",\n \"def move(self, direction):\\n # replace with your code\\n pass\",\n \"def move(self):\\n self._move_range_shuffle(3)\\n self._move_satisfy_random_constraint()\\n # self._move_range_shuffle(3)\\n #if (curr_energy > 50):\\n # self._move_satisfy_random_constraint()\\n #else:\\n # self._move_range_shuffle(3)\",\n \"def stopMovementAll(self):\\n self.stopMovementX()\\n self.stopMovementY()\\n self.stopMovementZ()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.647995","0.6420473","0.64017844","0.6215315","0.61987627","0.6173288","0.6152753","0.6094539","0.60649693","0.6058507","0.602774","0.6017141","0.5978515","0.5970727","0.594726","0.5940435","0.5864352","0.58516985","0.5839466","0.58298063","0.58190876","0.5803321","0.579727","0.57787025","0.5778429","0.5769887","0.57680017","0.57511294","0.5749395","0.5744106","0.5741391","0.5728194","0.5726664","0.5725459","0.5723438","0.5716526","0.570416","0.56944615","0.56882507","0.56761354","0.5673672","0.5669594","0.56673443","0.5664904","0.566238","0.5639882","0.5633062","0.56106627","0.56025213","0.5602417","0.55988723","0.55961806","0.5595728","0.5593145","0.55931026","0.55921793","0.55870724","0.558505","0.5577098","0.5576012","0.5558716","0.5549718","0.55448866","0.55393565","0.55369776","0.55315715","0.55314845","0.55313194","0.5523715","0.5520851","0.55161065","0.55150324","0.55121785","0.55116117","0.55044436","0.5498152","0.549609","0.54884124","0.5484271","0.5480661","0.5477763","0.5472827","0.54694986","0.54672694","0.5467034","0.54644734","0.54631877","0.54578745","0.5456654","0.5451209","0.5448969","0.54471624","0.54453814","0.5443329","0.5442417","0.5439851","0.5439641","0.54394287","0.54394287","0.5439239","0.5436526"],"string":"[\n \"0.647995\",\n \"0.6420473\",\n \"0.64017844\",\n \"0.6215315\",\n \"0.61987627\",\n \"0.6173288\",\n \"0.6152753\",\n \"0.6094539\",\n \"0.60649693\",\n \"0.6058507\",\n \"0.602774\",\n \"0.6017141\",\n \"0.5978515\",\n \"0.5970727\",\n \"0.594726\",\n \"0.5940435\",\n \"0.5864352\",\n \"0.58516985\",\n \"0.5839466\",\n \"0.58298063\",\n \"0.58190876\",\n \"0.5803321\",\n \"0.579727\",\n \"0.57787025\",\n \"0.5778429\",\n \"0.5769887\",\n \"0.57680017\",\n \"0.57511294\",\n \"0.5749395\",\n \"0.5744106\",\n \"0.5741391\",\n \"0.5728194\",\n \"0.5726664\",\n \"0.5725459\",\n \"0.5723438\",\n \"0.5716526\",\n \"0.570416\",\n \"0.56944615\",\n \"0.56882507\",\n \"0.56761354\",\n \"0.5673672\",\n \"0.5669594\",\n \"0.56673443\",\n \"0.5664904\",\n \"0.566238\",\n \"0.5639882\",\n \"0.5633062\",\n \"0.56106627\",\n \"0.56025213\",\n \"0.5602417\",\n \"0.55988723\",\n \"0.55961806\",\n \"0.5595728\",\n \"0.5593145\",\n \"0.55931026\",\n \"0.55921793\",\n \"0.55870724\",\n \"0.558505\",\n \"0.5577098\",\n \"0.5576012\",\n \"0.5558716\",\n \"0.5549718\",\n \"0.55448866\",\n \"0.55393565\",\n \"0.55369776\",\n \"0.55315715\",\n \"0.55314845\",\n \"0.55313194\",\n \"0.5523715\",\n \"0.5520851\",\n \"0.55161065\",\n \"0.55150324\",\n \"0.55121785\",\n \"0.55116117\",\n \"0.55044436\",\n \"0.5498152\",\n \"0.549609\",\n \"0.54884124\",\n \"0.5484271\",\n \"0.5480661\",\n \"0.5477763\",\n \"0.5472827\",\n \"0.54694986\",\n \"0.54672694\",\n \"0.5467034\",\n \"0.54644734\",\n \"0.54631877\",\n \"0.54578745\",\n \"0.5456654\",\n \"0.5451209\",\n \"0.5448969\",\n \"0.54471624\",\n \"0.54453814\",\n \"0.5443329\",\n \"0.5442417\",\n \"0.5439851\",\n \"0.5439641\",\n \"0.54394287\",\n \"0.54394287\",\n \"0.5439239\",\n \"0.5436526\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":22899,"cells":{"query":{"kind":"string","value":"Move in all nonterminal components. Play ends only after all components terminate."},"document":{"kind":"string","value":"def continued_conjunctive(G, H):\n if G == 0 or H == 0:\n return disjunctive(G, H)\n else:\n left = {continued_conjunctive(G_L, H_L) for G_L in G._left for H_L in H._left}\n right = {continued_conjunctive(G_R, H_R) for G_R in G._right for H_R in H._right}\n return Game(left, right)"},"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 move(self):\r\n segments = len(self.all_turtles) - 1\r\n for i in range(len(self.all_turtles)):\r\n if segments == 0:\r\n self.all_turtles[segments].forward(MOVE_DISTANCE)\r\n else:\r\n new_x = self.all_turtles[segments - 1].xcor()\r\n new_y = self.all_turtles[segments - 1].ycor()\r\n self.all_turtles[segments].goto(new_x, new_y)\r\n segments -= 1","def moveSpecialOb(self):\n\t\tfor obJ in self.special:\n\t\t\tobJ.moveStep()","def play_move(self,state):\n #Keep asking for the next move until a valid move.\n while(True):\n childList = state.get_successors()\n print(\"Your possible moves:\")\n i = 0\n for c in childList:\n if i > 0 and i%4 == 0:\n print()\n print(c.get_action().ljust(10),end=\"\\t\");\n i += 1\n print()\n nextMove = input(\"What is your next move? \\ne.g.'F2-E3' or 'Quit'\\n\")\n #Check if the move is valid\n if nextMove.lower() == 'Quit'.lower():\n return None\n for c in childList:\n if c.get_action().upper() == nextMove.upper():\n return c\n # Move not possible \n print(\"Invalid move!! Please try again...\\n\")","def algo_mover(self):\n self.tick_count = 0 ## reset to start clock on delayed state change\n\n ### Move 1 ring ###\n de, aux, vers = self.instructions.pop(0)\n\n de = self.rods[de]\n aux = self.rods[aux]\n vers = self.rods[vers]\n\n ring = de.pop_ring()\n vers.add_ring(ring)\n\n ### Update the states after -- moved this to main update\n #self.state_updater()","def successor(self, state):\n for action in self.actions:\n nexts = state.move(action)\n if nexts is not None:\n yield (action,nexts)","def _iter_tokens(self):\n reobj, actions, nextstates = self._rules[self.states[-1]]\n mobj = reobj.match(self.string, self.pos)\n while mobj is not None:\n text = mobj.group(0)\n idx = mobj.lastindex - 1\n nextstate = nextstates[idx]\n\n # Take action\n actions[idx](self, text)\n while self.tokens:\n yield self.pop_token()\n if nextstate and nextstate != self.states[-1]:\n self.states[-1] = nextstate\n\n # Update position variables\n self.pos = mobj.end()\n lines = text.split(\"\\n\")\n nlines = len(lines) - 1\n if nlines == 0:\n self.offset = self.offset + len(lines[0])\n else:\n self.lineno = self.lineno + nlines\n self.offset = 1 + len(lines[-1])\n\n reobj, actions, nextstates = self._rules[self.states[-1]]\n mobj = reobj.match(self.string, self.pos)\n\n if self.pos != len(self.string):\n msg = \"unexpected character\"\n text = self.string[self.pos]\n raise RunError(msg, self.lineno, self.offset, text)\n\n yield EndToken(\"\", self.lineno, self.offset)","def move(self):\n # This block is used to move into the living room.\n if self.room_name == \"living\" or self.room_name == \"Living\":\n self.living_room()\n # This block is used to open the door.\n elif self.room_name == \"Door\" or self.room_name == \"door\":\n self.door()\n # This block is used to move into the kitchen.\n elif self.room_name == \"Kitchen\" or self.room_name == \"kitchen\":\n self.kitchen()\n # This block is used to move into the hallway.\n elif self.room_name == \"Hallway\" or self.room_name == \"hallway\":\n self.hallway()\n # This block is used to move into the bathroom.\n elif self.room_name == \"Bathroom\" or self.room_name == \"bathroom\":\n self.bathroom()\n # This block is used to move into the basement.\n elif self.room_name == \"Basement\" or self.room_name == \"basement\":\n self.basement()\n # This block is used to move into the bedroom.\n elif self.room_name == \"Bedroom\" or self.room_name == \"bedroom\":\n self.bedroom()\n # This block is used to move into the attic.\n elif self.room_name == \"Attic\" or \"attic\":\n self.attic()","def next_move(self):\n self.branchize()\n try:\n _, new_branch = self.score_scheme.pop(0)\n except IndexError:\n return False\n\n move_list = [new_branch[\"move\"]]\n parent = new_branch[\"parent\"]\n\n while True:\n try:\n move_list.append(parent[\"move\"]) \n parent = parent[\"parent\"]\n\n except KeyError:\n break\n\n self.__originate__()\n for i in move_list[::-1]:\n self.change(i)\n\n self.current_branch = new_branch\n self.output += str(self)\n return True","def move(self, direction, cycles):\n\t\tpass","def state_parsing_toplevel_text(self):\n chars = []\n while self.more():\n if self.peek() in CHAR_COMMENT:\n self.emit(TokenWhitespace, chars)\n return self.state_parsing_comment\n if self.peek() in CHAR_NUMBER:\n self.emit(TokenWhitespace, chars)\n return self.state_parsing_transaction\n if self.confirm_next(\"P\"):\n self.emit(TokenWhitespace, chars)\n return self.state_parsing_price\n if self.confirm_next(\"C\"):\n self.emit(TokenWhitespace, chars)\n return self.state_parsing_conversion\n if self.confirm_next(\"python\"):\n self.emit(TokenWhitespace, chars)\n return self.state_parsing_embedded_python\n if self.confirm_next(\"tag\"):\n self.emit(TokenWhitespace, chars)\n return self.state_parsing_embedded_tag\n if self.peek() not in CHAR_WHITESPACE + CHAR_ENTER:\n _, _, l2, c2 = self._coords()\n raise LexingError(\n \"unparsable data at line %d, char %d\" % (l2, c2)\n )\n chars += [next(self)]\n self.emit(TokenWhitespace, chars)\n return","def act(state: Tree) -> None:\n cur_state = state.value\n state.children = [Tree(cur_state.make_move(m)) for m in\n cur_state.get_possible_moves()]","def move(self):\n pass","def player_loop(self):\n\n # Generate game tree object\n first_msg = self.receiver()\n # Initialize your minimax model\n model = self.initialize_model(initial_data=first_msg)\n\n while True:\n msg = self.receiver()\n\n # Create the root node of the game tree\n node = Node(message=msg, player=0)\n\n # Possible next moves: \"stay\", \"left\", \"right\", \"up\", \"down\"\n best_move = self.search_best_next_move(\n model=model, initial_tree_node=node)\n\n # Execute next action\n self.sender({\"action\": best_move, \"search_time\": None})","def step(self):\n while self.state != STATE_TERMINAL:\n self.step_strategies[self.state]()","def makeMove(self, node):\n if self.idx in node.finished:\n print ('Congratulations, you\\'re out of cards and were number {} '\n 'to finish!'.format(node.finished.index(self.idx)+1))\n return (0, -1)\n\n print 'Cards left for each player: {}'.format(node.numRemaining)\n print 'Your hand: {}'.format(\n map(lambda c: cards.cardRepr[c], cards.cardDictToList(self.hand))\n )\n if node.topCard:\n topN, topC = node.topCard\n topStr = '{} {}'.format(topN, cards.cardRepr[topC])\n else:\n topStr = 'Empty'\n print 'Top card: {}'.format(topStr)\n legalActions = self.getAllActions(node)\n print 'Valid actions: {}'.format(\n ['{} {}'.format(n, cards.cardRepr[c]) for n, c in legalActions]\n )\n mnAgent = maxN.MaxNAgent(self.idx, self.hand)\n mnN, mnC = mnAgent.makeMove(node)\n print 'The Max^n agent recommends playing {} {}'.format(\n mnN, cards.cardRepr[mnC])\n action = None\n while action not in legalActions:\n actStr = raw_input(\n 'Your move. Input as a space-separated tuple of numCards and '\n 'whichCard representing the action (that is, '\n '\"numCards whichCard\" without the quotes). To pass, enter '\n '\"0 P\", \"P\", or \"pass\". So, what\\'s your move? '\n )\n if actStr.lower() in ('pass', 'p', '0p'):\n action = (0, -1)\n else:\n try:\n numStr, cardStr = actStr.split()\n numCards = int(numStr)\n encodedNum = cards.cardRepr.index(cardStr.upper())\n except Exception:\n continue\n # if number not valid, continue the loop again\n if encodedNum == -1:\n continue\n whichCard = int(encodedNum)\n action = (numCards, whichCard)\n return action","def move_replay(self) -> Generator[List[List[str]], None, None]:\n current_moves = OrderedDict()\n for move in self.moves:\n current_moves[move] = self.moves[move]\n yield self.compile_board(current_moves)","def play_one_move(self, verbose=False):\n if verbose:\n self.print(\"top of move\")\n\n # 1) grab three cups\n c1 = self.cups.remove_next_node()\n c2 = self.cups.remove_next_node()\n c3 = self.cups.remove_next_node()\n if verbose:\n print(f\"pick up: {c1}, {c2}, {c3}\")\n self.print(\"after pickup\")\n\n # 2) find a destination cup\n destination_node = self.find_next_destination(\n self.cups.get_current_node().value\n )\n if verbose:\n print(f\"destination node is {destination_node}\")\n\n # 3) insert cups back into the circle\n self.cups.add_after(destination_node, c3.value)\n self.cups.add_after(destination_node, c2.value)\n self.cups.add_after(destination_node, c1.value)\n if verbose:\n self.print(\"after adding cups..\")\n\n # 4) select the next cup\n target_cup = self.cups.get_current_node().next()\n self.cups.set_current_node(target_cup)\n\n if verbose:\n self.print(\"post move\")","def makeMove(self, movable_statement):\n ### Student code goes here\n tile = movable_statement.terms[0].term.element\n initialX = movable_statement.terms[1].term.element\n initialY = movable_statement.terms[2].term.element\n goalX = movable_statement.terms[3].term.element\n goalY = movable_statement.terms[4].term.element\n r1 = parse_input(\"fact: (on \" + tile + \" \" + initialX + \" \" + initialY + \")\")\n self.kb.kb_retract(r1)\n r2 = parse_input(\"fact: (on empty \" + goalX + \" \" + goalY + \")\")\n self.kb.kb_retract(r2)\n stat1 = parse_input(\"fact: (on \" + tile + \" \" + goalX + \" \" + goalY + \")\")\n self.kb.kb_assert(stat1)\n stat2 = parse_input(\"fact: (on empty \" + initialX + \" \" + initialY + \")\")\n self.kb.kb_assert(stat2)\n\n\n #for facts in self.kb.facts:\n # print(facts.statement)\n\n #print(\"\\n\\n\")\n ##Need to handle adjacentTo\n '''ask = parse_input(\"fact: (adjacentTo empty ?tile)\")\n answer = self.kb.kb_ask(ask)\n empty_adj = []\n if answer:\n for ans in answer.list_of_bindings:\n adjTile = ans[0].bindings[0].constant.element\n if adjTile != tile:\n rt = parse_input(\"fact: (adjacentTo empty \" + adjTile + \")\")\n self.kb.kb_retract(rt)\n #print(\"RMOVINGGGG\")\n #print(rt)\n rt1 = parse_input(\"fact: (adjacentTo \" + adjTile + \" empty)\")\n self.kb.kb_retract(rt1)\n empty_adj.append(adjTile) #All of empty's adjacent tiles'''\n\n #for facts in self.kb.facts:\n # print(facts.statement)\n\n #print(\"::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::\")\n '''ask1 = parse_input(\"fact: (adjacentTo \" + tile + \" ?tile)\")\n answer1 = self.kb.kb_ask(ask1)\n if answer1:\n for ans in answer1.list_of_bindings:\n adjTile = ans[0].bindings[0].constant.element\n if adjTile != \"empty\":\n stat = parse_input(\"fact: (adjacentTo empty \" + adjTile + \")\")\n self.kb.kb_assert(stat)\n radj1 = parse_input(\"fact: (adjacentTo \" + tile + \" \" + adjTile + \")\")\n self.kb.kb_retract(radj1)\n radj2 = parse_input(\"fact: (adjacentTo \" + adjTile + \" \" + tile + \")\")\n self.kb.kb_retract(radj2)\n for tiles in empty_adj:\n stat = parse_input(\"fact: (adjacentTo \" + tile + \" \" + tiles + \")\")\n self.kb.kb_assert(stat)'''","def successor(self, state):\n for direct in self.direction :\n newState = state.move(direct)\n if newState :\n yield (None, newState)","def moveCirc(self):\n\t\tfor circle in self.circles:\n\t\t\tcircle.moveStep()","def parse(self):\r\n readnext = False\r\n error = False\r\n errorInfo = (-100, -100)\r\n token = self.tokens.nextToken()\r\n accepted = False\r\n while len(self.stack) > 0:\r\n (type, value) = self.stack.pop()\r\n self.runtime_transitions.append((type, value))\r\n\r\n if(readnext):\r\n token = self.tokens.nextToken()\r\n\r\n if (type == TERMINAL):\r\n if (value == token.category_num or value == EPSILON):\r\n if(value != EPSILON):\r\n print(token)\r\n\r\n if (not self.tokens.hasToken() and len(self.stack) == 0):\r\n print(\"Input Accepted!\")\r\n error = False\r\n accepted = True\r\n\r\n if(value != EPSILON):\r\n readnext = True\r\n\r\n else:\r\n error = True\r\n errorInfo = (value, token.category_num)\r\n\r\n\r\n\r\n elif (type == RULE):\r\n if(token.category_num > -1):\r\n rule = self.table[value][token.category_num]\r\n\r\n self.print_production(rule, value)\r\n self.last_transition = rule\r\n\r\n if(rule == -1):\r\n print(toRuleString[value], self.terminal_to_str(token.category_num))\r\n break\r\n for r in reversed(self.rules[rule]):\r\n self.stack.append(r)\r\n\r\n readnext = False\r\n\r\n if(error):\r\n break;\r\n\r\n if(error):\r\n print(\"Syntax error on position (%d, %d): [%s] expected. Got [%s]\" % (token.line, token.column, self.terminal_to_str(errorInfo[0]), self.terminal_to_str(errorInfo[1])))\r\n print(token)\r\n self.printStack()","def play_simulation(self):\n self._play(self._move_comp_person)","def move(self, move):\n out = ''\n for val in self.moves[move]:\n out += self.state[val]\n self.state = out","def interaction_void(self) -> None:\n self.grid.obj_list.swap_obj(self.moving_character, self.target)","def step(self, move):","def moveNorth(self):\n north = (self.current[0], self.current[1] - 1)\n mv = self.lab.north()\n self.check_grue(mv)\n self.current = north\n self.visited.add(self.current)","def move(self):\n self.build_graph()\n while 1:\n if self.current in self.visited:\n self.build_graph()\n if (self.current[0], self.current[1] + 1) in self.unvisited:\n self.moveSouth()\n elif (self.current[0], self.current[1] - 1) in self.unvisited:\n self.moveNorth()\n elif (self.current[0] - 1, self.current[1]) in self.unvisited:\n self.moveWest()\n elif (self.current[0] + 1, self.current[1]) in self.unvisited:\n self.moveEast()\n elif self.intersection:\n self.backtrack()\n \n #Using Tremaux's algorithm as backup\n elif (self.current[0] + 1, self.current[1]) in self.visited.difference(self.visitedtwice):\n self.visitedtwice.add(self.current)\n self.moveEast()\n elif (self.current[0] - 1, self.current[1]) in self.visited.difference(self.visitedtwice):\n self.visitedtwice.add(self.current)\n self.moveWest()\n elif (self.current[0], self.current[1] - 1) in self.visited.difference(self.visitedtwice):\n self.visitedtwice.add(self.current)\n self.moveNorth()\n elif (self.current[0], self.current[1] + 1) in self.visited.difference(self.visitedtwice):\n self.visitedtwice.add(self.current)\n self.moveSouth()\n \n if self._find_intersection() and self.current in self.unvisited:\n self.intersection.append(self.current)\n \n self.lab.cleanup()","def move(self, state):\n \n self.depth_limit=1\n self.best_utility=-2\n action=None\n while not self.is_time_up():\n self.terminal=True\n self.cache={}\n action=self.alpha_beta_search(state,0)\n if self.terminal==True:\n break\n self.depth_limit=self.depth_limit+1\n \n return action","def __exit__(self, *_) -> None:\n for component in self.__traverse_backward():\n component.__exit__(*_)","def move(self, move: tuple) -> None:\n if move in self.root.children:\n child = self.root.children[move]\n child.parent = None\n self.root = child\n self.root_state.play(child.move)\n return\n\n # if for whatever reason the move is not in the children of\n # the root just throw out the tree and start over\n self.root_state.play(move)\n self.root = Node()","def run_each_move(root: State, state: GameState) -> State:\n for m, base_move in enumerate(root.moves):\n for _ in range(50):\n base_move = expand(base_move)\n outcome, _ = MCTS(base_move, state, False, 0)\n if outcome == state.player:\n base_move.winner()\n else:\n base_move.loser()\n root.attempts += 1\n root.moves[m] = base_move\n print(\"Move: \", base_move.idx)\n print(\" Wins: \", base_move.wins)\n update_ucbs(root)\n return root","def _finish_all_moves(self, current_time):\n\t\tfor piece_id in self.all_piece_ids:\n\t\t\tstate = getattr(self, piece_id)\n\t\t\tif len(state) == 0:\n\t\t\t\tcontinue\n\t\t\tpiece = Piece(state)\n\t\t\tif piece.moving:\n\t\t\t\tif piece.end_time <= current_time:\n\t\t\t\t\tself._finish_move(piece_id, piece, current_time)","def startMovementAll(self):\n self.startMovementX()\n self.startMovementY()\n self.startMovementZ()","def makeMove(self, movable_statement):\n ### Student code goes here\n\n # make statement of (on disk firstpeg) and (on disk secondpeg) from movable_statement\n # retract (on disk firstpeg)\n # add (on disk secondpeg)\n # that should be it...\n\n if type(movable_statement) != Statement or not self.kb.kb_ask(Fact(movable_statement, [])):\n # print(\"current gamestate: \", self.getGameState())\n # print(\"~~~~~~~Error: \", movable_statement, \"is not a valid movable statement~~~~~~~\")\n return None\n\n # print(\"current gamestate: \", self.getGameState())\n # if self.kb.kb_ask(parse_input(\"fact: (movable ?X ?A ?B)\")):\n # for binding in self.kb.kb_ask(parse_input(\"fact: (movable ?X ?A ?B)\")):\n # print(\"movable: \", binding.bindings[0].constant.element)\n # if self.kb.kb_ask(parse_input(\"fact: (empty ?X)\")):\n # for binding in self.kb.kb_ask(parse_input(\"fact: (empty ?X)\")):\n # print(\"empty: \", binding.bindings[0].constant.element)\n # if self.kb.kb_ask(parse_input(\"fact: (top ?X ?A)\")):\n # for binding in self.kb.kb_ask(parse_input(\"fact: (top ?X ?A)\")):\n # print(\"top fact: \", binding.bindings[0].constant.element)\n # print(\"moving: \", movable_statement)\n\n\n\n # remove old \"on\", add new \"on\"\n statement1_list = [\"on\"]\n statement2_list = [\"on\"]\n\n statement1_list.append(movable_statement.terms[0])\n statement1_list.append(movable_statement.terms[1])\n\n statement2_list.append(movable_statement.terms[0])\n statement2_list.append(movable_statement.terms[2])\n\n curr_fact = Fact(Statement(statement1_list), [])\n new_fact = Fact(Statement(statement2_list), [])\n\n\n # print(\"retracted: fact: (top \" + movable_statement.terms[0].term.element + \" \" + movable_statement.terms[1].term.element + \")\")\n\n\n # (movable disk1 peg1 peg2)\n # retract (fact: on disk1 peg1)\n\n # DISK We're moving from:\n # Retract previous on statement\n # Retract previous top statement\n # If empty, say empty.\n # If not empty, make the new top statement using ontopof\n\n # STEP 1\n self.kb.kb_retract(curr_fact)\n moved_disk= movable_statement.terms[0].term.element\n prev_peg= movable_statement.terms[1].term.element\n new_peg=movable_statement.terms[2].term.element\n\n # STEP 2\n top_ask = parse_input(\"fact: (top \" + moved_disk + \" \" + prev_peg + \")\")\n if self.kb.kb_ask(top_ask):\n self.kb.kb_retract(top_ask)\n else:\n print(\"something went wrong with top...\")\n\n # STEP 3\n prev_top_ask = parse_input(\"fact: (onTopOf \" + moved_disk + \" ?X)\")\n if self.kb.kb_ask(prev_top_ask):\n # then it's not empty, make this one the top.\n for binding in self.kb.kb_ask(prev_top_ask):\n # there should only be one binding...\n disk_on_bottom = binding.bindings[0].constant.element\n # make the disk on bottom the new top of the previous peg\n # then remove the \"ontopof\" fact because it's no longer true.\n self.kb.kb_assert(parse_input(\"fact: (top \" + disk_on_bottom + \" \" + prev_peg + \")\"))\n self.kb.kb_remove(parse_input(\"fact: (onTopOf \" + moved_disk + \" \" + disk_on_bottom + \")\"))\n else:\n self.kb.kb_assert(parse_input(\"fact: (empty \" + prev_peg + \")\"))\n\n\n\n # DISK WE'RE MOVING TO: DEALING WITH TOP, EMPTY, and ONTOPOF.\n # Add new on statement\n # if empty, then remove empty statement. if not, add new ontopof statement and remove old top statement.\n # Add new top statement\n\n # STEP 1\n self.kb.kb_assert(new_fact)\n\n # STEP 2\n empty_ask = parse_input(\"fact: (empty \" + new_peg + \")\")\n top_ask = parse_input(\"fact: (top ?X \" + new_peg + \")\")\n if self.kb.kb_ask(empty_ask):\n self.kb.kb_retract(empty_ask)\n else:\n top_disk = self.kb.kb_ask(top_ask).list_of_bindings[0][0].bindings[0].constant.element\n oldTopFact = parse_input(\"fact: (top \" + top_disk + \" \" + new_peg + \")\")\n ontopof_fact = parse_input(\"fact: (onTopOf \" + moved_disk + \" \" + top_disk + \")\")\n\n self.kb.kb_retract(oldTopFact)\n self.kb.kb_add(ontopof_fact)\n\n newTopFact = parse_input(\"fact: (top \" + moved_disk + \" \" + new_peg + \")\")\n self.kb.kb_add(newTopFact)\n\n # if self.kb.kb_ask(top_ask):\n # self.kb.kb_retract(parse_input(\n # \"fact: (top \" + self.kb.kb_ask(top_ask)[0].bindings[0].constant.element + \" \" + movable_statement.terms[\n # 1].term.element + \")\"))\n\n\n\n\n\n\n # if self.kb.kb_ask(empty_ask):\n # for binding in self.kb.kb_ask(empty_ask):\n # empty_peg = binding.bindings[0].constant.element\n # remove_empty = parse_input(\"fact: (empty \" + empty_peg + \")\")\n # if self.kb.kb_ask(parse_input(\"fact: (on ?X \" + empty_peg + \")\")):\n # print(\"removing: \", remove_empty)\n # self.kb.kb_retract(remove_empty)\n # # print(\"retracting: (empty \" + empty_peg + \")\")\n\n\n\n # DISK WE'RE MOVING FROM: DEALING WITH TOP AND EMPTY.\n # First, we retract the previous top statement.\n # then, we must check: if the disk is now empty, we must say it's empty.\n # if it's not, we must now add the new top statement.\n\n\n\n\n # empty check\n\n #\n # for top_statement in self.kb.kb_ask(parse_input(\"fact: (top ?X ?A)\")):\n # print(top_statement)","def move(self):\n if VERBOSE:\n print('-- move', self.move_number, '--')\n self.display_cups()\n\n picked_up = self.pick_up_cups(3)\n self.update_destination_cup()\n\n if VERBOSE:\n print('pick up: ', end='')\n for pick in picked_up:\n print(pick, end=' ')\n print()\n print('destination:', self.destination)\n print()\n\n self.insert_cups(inserts=picked_up, insert_after=self.destination)\n self.select_new_current_cup()\n\n self.move_number += 1","def move_turtle(self):\n self.forward(self.move_speed)","def step(self, actions):\n if len(actions) != len(self._seats):\n raise error.Error('actions must be same shape as number of seats.')\n\n if self._current_player is None:\n raise error.Error('Round cannot be played without 2 or more players.')\n\n if self._round == 4:\n raise error.Error('Rounds already finished, needs to be reset.')\n\n players = [p for p in self._seats if p.playing_hand]\n if len(players) == 1:\n raise error.Error('Round cannot be played with one player.')\n\n self._last_player = self._current_player\n self._last_actions = actions\n\n if not self._current_player.playedthisround and len([p for p in players if not p.isallin]) >= 1:\n if self._current_player.isallin:\n self._current_player = self._next(players, self._current_player)\n return self._get_current_step_returns(False)\n\n move = self._current_player.player_move(\n self._output_state(self._current_player), actions[self._current_player.player_id])\n\n if move[0] == 'call':\n self._player_bet(self._current_player, self._tocall)\n if self._debug:\n print('Player', self._current_player.player_id, move)\n self._current_player = self._next(players, self._current_player)\n elif move[0] == 'check':\n self._player_bet(self._current_player, self._current_player.currentbet)\n if self._debug:\n print('Player', self._current_player.player_id, move)\n self._current_player = self._next(players, self._current_player)\n elif move[0] == 'raise':\n self._player_bet(self._current_player, move[1]+self._current_player.currentbet)\n if self._debug:\n print('Player', self._current_player.player_id, move)\n for p in players:\n if p != self._current_player:\n p.playedthisround = False\n self._current_player = self._next(players, self._current_player)\n elif move[0] == 'fold':\n self._current_player.playing_hand = False\n folded_player = self._current_player\n if self._debug:\n print('Player', self._current_player.player_id, move)\n self._current_player = self._next(players, self._current_player)\n players.remove(folded_player)\n self._folded_players.append(folded_player)\n # break if a single player left\n if len(players) == 1:\n self._resolve(players)\n if all([player.playedthisround for player in players]):\n self._resolve(players)\n\n terminal = False\n if all([player.isallin for player in players]):\n while self._round < 4:\n self._deal_next_round()\n self._round += 1\n if self._round == 4 or len(players) == 1:\n terminal = True\n self._resolve_round(players)\n return self._get_current_step_returns(terminal)","def iterate():\n # States are of the form (coordinates, word so far, used spots)\n # Load the initial states into the stack\n global theStack\n for r,layer in enumerate(honeycomb):\n for e,el in enumerate(layer):\n theStack.append( ((e,r), [el],set([(e,r)])) )\n \n while (len(theStack) != 0):\n #pop the next run\n (e,r),soFar,used=theStack[-1]\n theStack=theStack[:-1]\n #run it!\n step((e,r),soFar,used)","def stopMovementAll(self):\n self.stopMovementX()\n self.stopMovementY()\n self.stopMovementZ()","def play_one_move(self):\n self.print(\"top of move\")\n # 1) grab three cups\n c1 = self.take_cup_after(self.current_cup_idx())\n c2 = self.take_cup_after(self.current_cup_idx())\n c3 = self.take_cup_after(self.current_cup_idx())\n print(f\"pick up: {c1}, {c2}, {c3}\")\n self.print(\"after pickup\")\n\n # 2) find a destination cup\n destination_idx = self.find_next_destination(self.current_cup)\n print(\n f\"destination index is {destination_idx}, cup is {self.cups[destination_idx]}\"\n )\n\n # 3) insert cups back into the circle\n self.add_cups(destination_idx, [c1, c2, c3])\n self.print(\"after adding cups..\")\n\n # 4) select the next cup\n self.select_next_cup()\n\n self.print(\"post move\")","def makeMove(self, movable_statement):\n ### Student code goes here\n # ToGO:\n # if not(self.isMovableLegal(movable_statement)):\n # pass\n currDisk = movable_statement.terms[0]\n prevPeg = movable_statement.terms[1]\n newPeg = movable_statement.terms[2]\n\n # On next peg\n newOnStatement = Statement()\n newOnStatement.predicate = 'on'\n newOnStatement.terms = [currDisk, newPeg]\n newOnFact = Fact(newOnStatement)\n self.kb.kb_assert(newOnFact) #1\n\n #Not on previous peg\n removeOnStatement = Statement()\n removeOnStatement.predicate = 'on'\n removeOnStatement.terms = [currDisk, prevPeg]\n removeOnFact = Fact(removeOnStatement)\n self.kb.kb_retract(removeOnFact) #2\n\n\n #If Prev Empty Logic\n ONStatement = Statement()\n ONTerm1 = Term('?x')\n ONTerm2 = Term(prevPeg)\n ONStatement.terms = (ONTerm1, ONTerm2)\n ONStatement.predicate = 'on'\n ONFact = Fact(ONStatement)\n if not(self.kb.kb_ask(ONFact)):\n prevEmptyStatement = Statement()\n prevEmptyStatement.terms = [prevPeg]\n prevEmptyStatement.predicate = 'empty'\n prevEmptyFact = Fact(prevEmptyStatement)\n self.kb.kb_assert(prevEmptyFact) #3\n else:\n # previous disk now on top\n # AND\n # Not above previous disk\n abovePrevStatement = Statement()\n aboveTerm = Term('?x')\n abovePrevStatement.terms = [currDisk, aboveTerm]\n abovePrevStatement.predicate = 'Above'\n for fact in self.kb.facts:\n if match(fact.statement, abovePrevStatement):\n prevDisk = fact.statement.terms[1]\n self.kb.kb_retract(fact) #7\n break\n prevonTopStatement = Statement()\n prevonTopStatement.predicate = 'onTop'\n prevonTopStatement.terms = [prevDisk, prevPeg]\n prevonTopFact = Fact(prevonTopStatement)\n self.kb.kb_assert(prevonTopFact) #8\n\n # Above next disk\n # If next not empty\n nextEmptyBool = False\n nextEmptyStatement = Statement()\n nextEmptyStatement.terms = [newPeg]\n nextEmptyStatement.predicate = 'empty'\n for fact in self.kb.facts:\n if match(fact.statement, nextEmptyStatement):\n nextEmptyBool = True\n self.kb.kb_retract(fact) #9\n break\n\n if nextEmptyBool == False:\n nextOnTopStatement = Statement()\n nextOnTopStatement.predicate = 'onTop'\n onTopTerm1 = Term('?x')\n nextOnTopStatement.terms = [onTopTerm1, newPeg]\n nextOnTopFact = Fact(nextOnTopStatement)\n for fact in self.kb.facts:\n if match(fact.statement, nextOnTopStatement):\n nextOnTop = fact.statement.terms[0]\n aboveNextStatement = Statement()\n aboveNextStatement.predicate = 'Above'\n aboveNextStatement.terms = [currDisk, nextOnTop]\n aboveNextFact = Fact(aboveNextStatement)\n self.kb.kb_assert(aboveNextFact) #6\n self.kb.kb_retract(nextOnTopFact)\n break\n\n\n\n #On top of new peg\n newonTopStatement = Statement()\n newonTopStatement.predicate = 'onTop'\n newonTopStatement.terms = [currDisk, newPeg]\n newonTopFact = Fact(newonTopStatement)\n self.kb.kb_assert(newonTopFact) #4\n\n #Not on top of previous peg\n removeonTopStatement = Statement()\n removeonTopStatement.predicate = 'onTop'\n removeonTopStatement.terms = [currDisk, prevPeg]\n removeonTopFact = Fact(removeonTopStatement)\n self.kb.kb_retract(removeonTopFact) #5\n\n\n\n\n\n #Destination not empty","def solveOneStep(self):\n ### Student code goes here\n # Mark this move as explored\n self.visited[self.currentState] = True\n\n # Get move to make\n movables = self.gm.getMovables()\n # print(\"EXPLORING GAME STATE \" + str(self.gm.getGameState()) + \"---------------------------------------------------------\")\n to_move = self.currentState.nextChildToVisit # movables index\n # print(\"depth \", self.currentState.depth)\n\n # Return if done\n if self.currentState.state == self.victoryCondition:\n # print(\"DONE\")\n return True\n\n while to_move < len(movables):\n # Make the move\n movable_statement = movables[to_move]\n # print(\"implementing move \", movable_statement)\n self.gm.makeMove(movable_statement)\n\n # Create a new state with this move made\n new_state = self.gm.getGameState()\n\n # Find out if this state has already been explored\n visited = False\n for visited_state in self.visited.keys():\n if visited_state.state == new_state:\n visited = True\n\n # If the new state hasn't been visited then add it as a child then move down to this child\n if not visited:\n new_gs = GameState(new_state, self.currentState.depth + 1, movable_statement)\n new_gs.parent = self.currentState\n self.currentState.children.append(new_gs)\n self.currentState.nextChildToVisit = to_move + 1\n self.currentState = new_gs\n break\n\n # Else skip this state and try going to the next movable statement\n else:\n # print(\"SKIP THIS STATE\")\n self.gm.reverseMove(movable_statement)\n to_move += 1\n\n # Went all the way down to a leaf, backtrack\n if (to_move >= len(movables)):\n self.gm.reverseMove(self.currentState.requiredMovable)\n self.currentState = self.currentState.parent\n\n return False","def step(self):\n self.emit_symbol()\n self.change_state()","def __iter__(self):\n for node in self.grammar.walk():\n yield node","def behavior_loop(self, goal, rc_cb, terminate_cb):\n rc_out = rc_cb(self, goal)\n is_term = terminate_cb(self, goal)\n\n while not is_term:\n # timeout termination behvior\n if self._as.is_preempt_requested():\n self.rc_off()\n rospy.loginfo('Timeout preempted')\n self._as.set_preempted()\n break\n\n controlout = OverrideRCIn(channels=rc_out)\n self.contolp.publish(controlout)\n\n # send command feedback\n self.send_feedback(goal)\n self.rate.sleep()\n\n # set up next loop\n is_term = terminate_cb(self, goal)\n rc_out = rc_cb(self, goal)\n\n # publish a result message when finished\n if is_term:\n self.rc_off()\n result = MoveRobotResult(actionID=goal.actionID,\n end_heading=self.curr_heading,\n end_depth=self.curr_depth)\n self._as.set_succeeded(result=result)","def loop2(self, move, new_state, i):\n if move == i[0]:\n # analyze the other 2 cells\n if (new_state.get_current_player_name()[1]\n == new_state.letters[i[1]]\n or new_state.get_current_player_name()[1]\n == new_state.letters[i[2]]) \\\n and new_state.claim[i[3]] == \"@\":\n new_state.claim[i[3]] \\\n = new_state.get_current_player_name()[1]\n\n # analyze the other 4 cells\n count = 0\n for x in [new_state.letters[i[4]],\n new_state.letters[i[5]],\n new_state.letters[i[6]],\n new_state.letters[i[7]]]:\n if new_state.get_current_player_name()[1] == x:\n count += 1\n if count == 2 and new_state.claim[i[8]] == \"@\":\n new_state.claim[i[8]] = \\\n new_state.get_current_player_name()[1]\n\n # analyze the other 4 cells\n count = 0\n for x in [new_state.letters[i[9]],\n new_state.letters[i[10]],\n new_state.letters[i[11]],\n new_state.letters[i[12]]]:\n if new_state.get_current_player_name()[1] == x:\n count += 1\n if count == 2 and new_state.claim[i[13]] == \"@\":\n new_state.claim[i[13]] = \\\n new_state.get_current_player_name()[1]\n new_state.letters = [self.get_current_player_name()[1]\n if i == move else i for i in self.letters]\n return new_state","def main():\n move()\n move()\n pick_beeper()\n move()\n turn_left()\n for i in range(2):\n move()\n put_beeper()\n turn_around()\n move_to_wall()\n turn_right()\n move_to_wall()\n turn_around()","def unmakeMove(self, move):","def move(self, direction, step):\n for i in range(1, step + 1):\n y, x = self.robot_position\n if direction == \"N\" and y > 0:\n if self.carte[y - 1][x] in [\" \", \".\", \"U\"]:\n self.robot_position = (y - 1, x)\n elif direction == \"S\" and y <= self.height:\n if self.carte[y + 1][x] in [\" \", \".\", \"U\"]:\n self.robot_position = (y + 1, x)\n elif direction == \"E\" and x <= self.width+1:\n if self.carte[y][x + 1] in [\" \", \".\", \"U\"]:\n self.robot_position = (y, x + 1)\n elif direction == \"O\" and x > 0:\n if self.carte[y][x - 1] in [\" \", \".\", \"U\"]:\n self.robot_position = (y, x - 1)\n\n if self.robot_position == self.out_position:\n print(\"Bravo vous avez fini\")\n return True\n\n return False","def handle_unmake(self, move):\n# print \"board:handle_make pgn = \" + move.pgn\n if not move: return\n # remove en passant capture\n if move.is_en_passant():\n self.put(move.dst + (8 if move.is_white() else -8), \\\n 'p' if move.is_white() else 'P')\n\n # move rook when castling\n if move.is_castling_short():\n if move.is_white():\n self.move((61,63))\n else:\n self.move((5,7))\n if move.is_castling_long():\n if move.is_white():\n self.move((59, 56))\n else:\n self.move((3, 0))\n\n # now move itself\n self.move((move.dst, move.src))\n \n # recover capture\n if move.is_capture():\n p = move.get_captured_piece()\n if move.is_white(): p = p.lower()\n self.put(move.dst, p)\n\n # Recover promoted piece\n if move.is_promotion():\n self.remove(move.src)\n self.put(move.src, 'P' if move.is_white() else 'p')\n self.update_vars_list()","def step(self):\n self.time_alive += 1\n self.fsm.update(self)\n\n for state in self.states:\n if not self.pos:\n continue\n\n state.on_update(self)","def handleMove(self):\n pass","def get_nonterminals(self):\n for node in self.hosttree.traverse():\n if not node.is_leaf():\n yield node","def move(self):\n raise NotImplementedError","def loop52(self, move, new_state, i):\n if move == i[0]:\n # analyze the other 2 cells\n if (new_state.get_current_player_name()[1]\n == new_state.letters[i[1]]\n or new_state.get_current_player_name()[1]\n == new_state.letters[i[2]]) \\\n and new_state.claim[i[3]] == \"@\":\n new_state.claim[i[3]] \\\n = new_state.get_current_player_name()[1]\n\n # analyze the other 4 cells\n count = 0\n for x in [new_state.letters[i[4]],\n new_state.letters[i[5]],\n new_state.letters[i[6]],\n new_state.letters[i[7]]]:\n if new_state.get_current_player_name()[1] == x:\n count += 1\n if count == 2 and new_state.claim[i[8]] == \"@\":\n new_state.claim[i[8]] = \\\n new_state.get_current_player_name()[1]\n\n # analyze the other 4 cells\n count = 0\n for x in [new_state.letters[i[9]],\n new_state.letters[i[10]],\n new_state.letters[i[11]],\n new_state.letters[i[12]]]:\n if new_state.get_current_player_name()[1] == x:\n count += 1\n if count == 2 and new_state.claim[i[13]] == \"@\":\n new_state.claim[i[13]] = \\\n new_state.get_current_player_name()[1]\n new_state.letters = [self.get_current_player_name()[1]\n if i == move else i for i in self.letters]\n return new_state","def solveOneStep(self):\n ### Student code goes here\n # Mark this move as explored\n self.visited[self.currentState] = True\n self.visited_states.append(self.currentState.state)\n\n # Get move to make\n movables = self.gm.getMovables()\n # print(\"EXPLORING GAME STATE \" + str(self.gm.getGameState()) + \"---------------------------------------------------------\")\n to_move = self.currentState.nextChildToVisit # movables index\n # print(\"depth \", self.currentState.depth)\n\n # Return if done\n if self.currentState.state == self.victoryCondition:\n # print(\"DONE\")\n return True\n\n # If current state has no children, make children\n if not self.currentState.children:\n for movable_statement in movables:\n # Make the move\n # print(\"implementing move \", movable_statement)\n self.gm.makeMove(movable_statement)\n\n # Create a new state with this move made\n new_state = self.gm.getGameState()\n # print (\"new state \", new_state)\n\n # If the new state hasn't been visited and isn't in the queue then add it as a child and to the queue\n if (new_state not in self.visited_states):\n new_gs = GameState(new_state, self.currentState.depth + 1, movable_statement)\n new_gs.parent = self.currentState\n self.currentState.children.append(new_gs)\n self.currentState.nextChildToVisit = to_move + 1\n self.visited[new_gs] = True\n self.visited_states.append(new_state)\n self.gs_queue.append(new_gs)\n\n self.gm.reverseMove(movable_statement)\n\n # Return false if no more to explore\n if not self.gs_queue:\n return False\n\n # Revert to state at when current and next start to change\n root_curr = self.currentState\n self.currentState = self.gs_queue.popleft()\n root_new = self.currentState\n\n # Backtrack to when current node and new node start to diverge\n if root_new.depth == root_curr.depth:\n while root_curr.state != root_new.state:\n self.gm.reverseMove(root_curr.requiredMovable)\n root_curr = root_curr.parent\n root_new = root_new.parent\n else:\n while root_curr.requiredMovable:\n self.gm.reverseMove(root_curr.requiredMovable)\n root_curr = root_curr.parent\n\n # Return game master to state that we are exploring\n # Find path between root and current state\n path = []\n currNode = self.currentState\n while currNode != root_curr:\n path.append(currNode.requiredMovable)\n currNode = currNode.parent\n\n # Created backwards path, now make moves from root to current state\n path.reverse()\n for movable_statement in path:\n self.gm.makeMove(movable_statement)\n\n return False","def makeMove(self, movable_statement):\n ### Student code goes here\n disk = movable_statement.terms[0].term.element\n initial = movable_statement.terms[1].term.element\n goal = movable_statement.terms[2].term.element\n #### Add the disk to the new stack and remove the facts of it being on the old one\n r1 = parse_input(\"fact: (on \" + disk + \" \" + initial + \")\")\n self.kb.kb_retract(r1)\n r2 = parse_input(\"fact: (isTopofStack \" + disk + \" \" + initial + \")\")\n self.kb.kb_retract(r2)\n stat1 = parse_input(\"fact: (on \" + disk + \" \" + goal + \")\")\n self.kb.kb_assert(stat1)\n stat2 = parse_input(\"fact: (isTopofStack \" + disk + \" \" + goal + \")\")\n self.kb.kb_assert(stat2)\n\n ## Determine if any disks are on the initial peg\n ask1 = parse_input(\"fact: (on ?X \" + initial + \")\")\n answer = self.kb.kb_ask(ask1)\n if answer == False: #If no disks are on the initial peg\n empty_stat = parse_input(\"fact: (isempty \" + initial + \")\")\n self.kb.kb_assert(empty_stat)\n else:\n disks_on_initial = []\n for ans in answer.list_of_bindings:\n disks_on_initial.append(int(ans[0].bindings[0].constant.element.split('disk',1)[1]))\n ask_top = parse_input(\"fact: (isTopofStack ?X \" + initial + \")\")\n top_ans = self.kb.kb_ask(ask_top)\n disks_on_initial.sort()\n if top_ans:\n for ans in top_ans.list_of_bindings:\n if int(ans[0].bindings[0].constant.element.split('disk',1)[1]) != disks_on_initial[0]:\n retract = parse_input(\"fact: (isTopofStack \" + ans[0].bindings[0].constant.element + \" \" + initial + \")\")\n self.kb.kb_retract(retract)\n assert1 = parse_input(\"fact: (isTopofStack disk\" + str(disks_on_initial[0]) + \" \" + initial + \")\")\n self.kb.kb_assert(assert1)\n\n goal_ask = parse_input(\"fact: (on ?X \" + goal + \")\")\n goal_answer = self.kb.kb_ask(goal_ask)\n disks_on_goal = []\n for ans in goal_answer.list_of_bindings:\n disks_on_goal.append(int(ans[0].bindings[0].constant.element.split('disk',1)[1]))\n ask_topg = parse_input(\"fact: (isTopofStack ?X \" + goal + \")\")\n top_ansg = self.kb.kb_ask(ask_topg)\n disks_on_goal.sort()\n if top_ansg:\n for ans in top_ansg.list_of_bindings:\n if int(ans[0].bindings[0].constant.element.split('disk',1)[1]) != disks_on_goal[0]:\n retract = parse_input(\"fact: (isTopofStack \" + ans[0].bindings[0].constant.element + \" \" + goal + \")\")\n self.kb.kb_retract(retract)\n\n ask2 = parse_input(\"fact: (isempty \" + goal + \")\")\n answer2 = self.kb.kb_ask(ask2)\n if answer2:\n self.kb.kb_retract(ask2)","def onStopMovingNorthCommand(self, *args):\n if self.going_north:\n self.going_north = 0\n self.moveEntity()","def exec_all_moves(self,level=0):\n\n capts = [self.op_capture_north, self.op_capture_nwest, self.op_capture_neast, self.op_capture_east, self.op_capture_west]\n jmps = [self.op_jump_north, self.op_jump_nwest, self.op_jump_neast]\n moves = [self.op_move_north,self.op_move_nwest, self.op_move_neast]\n result = []\n ops = []\n\n # Pre-select all operations that may be executed\n if self.next_move == self.FREE:\n capturingStarts, otherStarts = self.possible_capture()\n\n # Check for pieces that may capture\n if len(capturingStarts) > 0:\n self.next_move = self.CAPT\n self.next_pieces = capturingStarts\n else:\n self.next_move = self.FREE\n jmps.extend(moves)\n ops = jmps\n self.next_pieces = otherStarts\n\n elif self.next_move == self.CAPT:\n ops = capts\n elif self.next_move == self.JUMP:\n ops = jmps\n elif self.next_move == self.FREE:\n jmps.extend(moves)\n ops = jmps\n elif self.next_move == self.ADDPIECE_2:\n return self.op_add_piece_bot(self.next_pieces)\n\n # Execute possible operations for all viable pieces\n for pos in self.next_pieces:\n for op in ops:\n newState = op(pos)\n\n # Check if op succeeded\n if newState:\n\n # If the next player is the current player than the function is called recursevely, this is done so that outcomes account for successive plays by the same\n # player ( successive jumps and captures or piece addition)\n if newState.curr_player != self.curr_player:\n result.append(newState)\n else:\n result.extend(newState.exec_all_moves(level+1))\n\n\n return result","def makeMove(self, movable_statement):\n ### Student code goes here\n\n if type(movable_statement) != Statement or not self.kb.kb_ask(Fact(movable_statement, [])):\n return None\n\n statement1_list = [\"located\"]\n statement2_list = [\"located\"]\n\n statement1_list.append(movable_statement.terms[0])\n statement1_list.append(movable_statement.terms[1])\n statement1_list.append(movable_statement.terms[2])\n\n statement2_list.append(movable_statement.terms[0])\n statement2_list.append(movable_statement.terms[3])\n statement2_list.append(movable_statement.terms[4])\n\n curr_fact1 = Fact(Statement(statement1_list), [])\n new_fact1 = Fact(Statement(statement2_list), [])\n\n curr_empty = parse_input(\"fact: (located empty \" + statement2_list[2].term.element + \" \" + statement2_list[3].term.element + \")\")\n statement3_list = statement1_list\n statement3_list[1] = \"empty\"\n new_empty = Fact(Statement(statement3_list), [])\n\n self.kb.kb_retract(curr_fact1)\n self.kb.kb_assert(new_fact1)\n self.kb.kb_retract(curr_empty)\n self.kb.kb_assert(new_empty)","def play_move(self,state):\n raise AIError(\"Must be implemented for child class!\")","def loop(self):\r\n\r\n self._next_state = self._current_state","def tick(self):\n if self._solution == \"\":\n self._root.after(300, self.tick)\n return\n direction = self._solution[0]\n self._solution = self._solution[1:]\n try:\n self._puzzle.update_puzzle(direction)\n except:\n print \"invalid move:\", direction\n self.draw()\n self._root.after(300, self.tick)","def loop3(self, move, new_state, i):\n if move == i[0]:\n # analyze the other 3 cells\n if (new_state.get_current_player_name()[1]\n == new_state.letters[i[1]]\n or new_state.get_current_player_name()[1]\n == new_state.letters[i[2]]\n or new_state.get_current_player_name()[1]\n == new_state.letters[i[3]]) \\\n and new_state.claim[i[4]] == \"@\":\n new_state.claim[i[4]] \\\n = new_state.get_current_player_name()[1]\n\n # analyze the other 3 cells\n if (new_state.get_current_player_name()[1]\n == new_state.letters[i[5]]\n or new_state.get_current_player_name()[1]\n == new_state.letters[i[6]]\n or new_state.get_current_player_name()[1]\n == new_state.letters[i[7]]) \\\n and new_state.claim[i[8]] == \"@\":\n new_state.claim[i[8]] \\\n = new_state.get_current_player_name()[1]\n\n # analyze the other 4 cells\n count = 0\n for x in [new_state.letters[i[9]],\n new_state.letters[i[10]],\n new_state.letters[i[11]],\n new_state.letters[i[12]]]:\n if new_state.get_current_player_name()[1] == x:\n count += 1\n if count == 2 and new_state.claim[i[13]] == \"@\":\n new_state.claim[i[13]] = \\\n new_state.get_current_player_name()[1]\n\n new_state.letters = [self.get_current_player_name()[1]\n if i == move else i for i in self.letters]\n return new_state","def remove(self, *nonterminals):\n # type: (Iterable[Type[Nonterminal]]) -> None\n for nonterm in set(nonterminals):\n _NonterminalSet._control_nonterminal(nonterm)\n if nonterm not in self:\n raise KeyError('Nonterminal ' + nonterm.__name__ + ' is not inside')\n self._grammar.rules.remove(*self._assign_map[nonterm], _validate=False)\n del self._assign_map[nonterm]\n if self._grammar.start is nonterm:\n del self._grammar.start\n super().remove(nonterm)","def loop1(self, move, new_state, i):\n if move == i[0]:\n # analyze another cell\n if new_state.letters[i[1]].isalpha():\n new_state.claim[i[2]] \\\n = new_state.get_current_player_name()[1]\n # analyze the other 3 cells\n if (new_state.get_current_player_name()[1]\n == new_state.letters[i[3]]\n or new_state.get_current_player_name()[1]\n == new_state.letters[i[4]]\n or new_state.get_current_player_name()[1]\n == new_state.letters[i[5]]) \\\n and new_state.claim[i[6]] == \"@\":\n new_state.claim[i[6]] \\\n = new_state.get_current_player_name()[1]\n # analyze the other 4 cells\n count = 0\n for x in [new_state.letters[i[7]],\n new_state.letters[i[8]],\n new_state.letters[i[9]],\n new_state.letters[i[10]]]:\n if new_state.get_current_player_name()[1] == x:\n count += 1\n if count == 2 and new_state.claim[i[11]] == \"@\":\n new_state.claim[i[11]] = \\\n new_state.get_current_player_name()[1]\n new_state.letters = [self.get_current_player_name()[1]\n if i == move else i for i in self.letters]\n return new_state","def move(self):\n\n # get the location we WOULD go to\n newX = self.xcor() + self.dx\n newY = self.ycor() + self.dy\n while (abs (newX) > self.BOX_RANGE) or (abs(newY) > self.BOX_RANGE):\n # print(\"choosing new direction... \",end=\"\")\n self.chooseNewDirection()\n # print(self.dx, self.dy)\n newX = self.xcor() + self.dx\n newY = self.ycor() + self.dy\n\n # now move our monster\n super().move()","def stop(self):\n self.move(None)","def enumerate_moves(self):\n add_ew = lambda x: [x+'e', x+'w']\n allowed_catches = add_ew(self._directions[0])\n moves = []\n # First add the one/two step forward moves\n new_slot = self._board.get_dir(self._current_space, self._directions[0])\n if new_slot and new_slot.is_free():\n moves.append(ChessMove(self._current_space, new_slot))\n if (self._side == BLACK and new_slot.row == self._board.size - 1) or \\\n (self._side == WHITE and new_slot.row == 0):\n moves[-1].add_promotion()\n if (self._side == BLACK and self._current_space.row == 1) or \\\n (self._side == WHITE and self._current_space.row == self._board.size -2):\n new_slot = self._board.get_dir(new_slot, self._directions[0])\n if new_slot and new_slot.is_free():\n moves.append(ChessMove(self._current_space, new_slot))\n\n # Now add all the captures.\n for direction in allowed_catches:\n new_slot = self._board.get_dir(self._current_space, direction)\n if new_slot and new_slot.has_opponent(self._side):\n moves.append(ChessMove(self._current_space, new_slot, [new_slot]))\n if (self._side == BLACK and new_slot.row == self._board.size - 1) or \\\n (self._side == WHITE and new_slot.row == 0):\n moves[-1].add_promotion()\n return moves","def loop54(self, move, new_state, i):\n if move == i[0]:\n # analyze the other 2 cells\n if (new_state.get_current_player_name()[1]\n == new_state.letters[i[1]]\n or new_state.get_current_player_name()[1]\n == new_state.letters[i[2]]) \\\n and new_state.claim[i[3]] == \"@\":\n new_state.claim[i[3]] \\\n = new_state.get_current_player_name()[1]\n\n # analyze the other 5 cells\n count = 0\n for x in [new_state.letters[i[4]],\n new_state.letters[i[5]],\n new_state.letters[i[6]],\n new_state.letters[i[7]],\n new_state.letters[i[8]]]:\n if new_state.get_current_player_name()[1] == x:\n count += 1\n if count == 2 and new_state.claim[i[9]] == \"@\":\n new_state.claim[i[9]] = \\\n new_state.get_current_player_name()[1]\n\n # analyze the other 5 cells\n count = 0\n for x in [new_state.letters[i[10]],\n new_state.letters[i[11]],\n new_state.letters[i[12]],\n new_state.letters[i[13]],\n new_state.letters[i[14]]]:\n if new_state.get_current_player_name()[1] == x:\n count += 1\n if count == 2 and new_state.claim[i[15]] == \"@\":\n new_state.claim[i[15]] = \\\n new_state.get_current_player_name()[1]\n new_state.letters = [self.get_current_player_name()[1]\n if i == move else i for i in self.letters]\n return new_state","def move(): #py:move\n RUR._move_()","def goto_end(self):\n\n self.__do_action(self.motor.moveto_edge(MotorDriver.RIGHT))","def loops_back_to_screen(self):\r\n for segment in self.all_turtles:\r\n if segment.xcor() < -300 or segment.xcor() > 300:\r\n segment.goto(-segment.xcor(), segment.ycor())\r\n\r\n elif segment.ycor() < -300 or segment.ycor() > 300:\r\n segment.goto(segment.xcor(), -segment.ycor())","def loop53(self, move, new_state, i):\n if move == i[0]:\n # analyze the other 3 cells\n if (new_state.get_current_player_name()[1]\n == new_state.letters[i[1]]\n or new_state.get_current_player_name()[1]\n == new_state.letters[i[2]]\n or new_state.get_current_player_name()[1]\n == new_state.letters[i[3]]) \\\n and new_state.claim[i[4]] == \"@\":\n new_state.claim[i[4]] \\\n = new_state.get_current_player_name()[1]\n\n # analyze the other 3 cells\n if (new_state.get_current_player_name()[1]\n == new_state.letters[i[5]]\n or new_state.get_current_player_name()[1]\n == new_state.letters[i[6]]\n or new_state.get_current_player_name()[1]\n == new_state.letters[i[7]]) \\\n and new_state.claim[i[8]] == \"@\":\n new_state.claim[i[8]] \\\n = new_state.get_current_player_name()[1]\n\n # analyze the other 4 cells\n count = 0\n for x in [new_state.letters[i[9]],\n new_state.letters[i[10]],\n new_state.letters[i[11]],\n new_state.letters[i[12]]]:\n if new_state.get_current_player_name()[1] == x:\n count += 1\n if count == 2 and new_state.claim[i[13]] == \"@\":\n new_state.claim[i[13]] = \\\n new_state.get_current_player_name()[1]\n new_state.letters = [self.get_current_player_name()[1]\n if i == move else i for i in self.letters]\n return new_state","def move_cycle_gen(self):\n while True:\n self.update_grid_pos()\n path = self.find_shortest_path(\"without_metalbox\")\n if not path:\n path = self.find_shortest_path(\"metalbox\")\n yield\n if not path:\n continue\n next_coord = path.pop()\n next_coord += Vec2d(0.5, 0.5)\n yield\n target_angle = \\\n angle_between_vectors(Vec2d(self.tank.body.position), next_coord)\n angle_tank = self.tank.body.angle\n self.turn(angle_tank, target_angle)\n while not self.correct_angle(angle_tank, target_angle):\n angle_tank = self.tank.body.angle\n target_angle = \\\n angle_between_vectors(Vec2d(self.tank.body.position),\n next_coord)\n yield\n self.tank.accelerate()\n while not self.correct_pos(next_coord, self.last_distance):\n yield\n yield","def _parser_fsm(self):\n basic = self.basic\n listener = self.listener\n draw = listener.draw\n debug = listener.debug\n\n ESC, CSI_C1 = ctrl.ESC, ctrl.CSI_C1\n OSC_C1 = ctrl.OSC_C1\n SP_OR_GT = ctrl.SP + \">\"\n NUL_OR_DEL = ctrl.NUL + ctrl.DEL\n CAN_OR_SUB = ctrl.CAN + ctrl.SUB\n ALLOWED_IN_CSI = \"\".join([ctrl.BEL, ctrl.BS, ctrl.HT, ctrl.LF,\n ctrl.VT, ctrl.FF, ctrl.CR])\n OSC_TERMINATORS = set([ctrl.ST_C0, ctrl.ST_C1, ctrl.BEL, ctrl.CR])\n\n def create_dispatcher(mapping):\n return defaultdict(lambda: debug, dict(\n (event, getattr(listener, attr))\n for event, attr in mapping.items()))\n\n basic_dispatch = create_dispatcher(basic)\n sharp_dispatch = create_dispatcher(self.sharp)\n escape_dispatch = create_dispatcher(self.escape)\n csi_dispatch = create_dispatcher(self.csi)\n osc_dispatch = create_dispatcher(self.osc)\n\n while True:\n # it is allowed to send\n # chunks of plain text directly to the listener, instead\n # of this generator.\n char = yield PLAIN_TEXT\n\n if char == ESC:\n # Most non-VT52 commands start with a left-bracket after the\n # escape and then a stream of parameters and a command; with\n # a single notable exception -- :data:`escape.DECOM` sequence,\n # which starts with a sharp.\n #\n # .. versionchanged:: 0.4.10\n #\n # For compatibility with Linux terminal stream also\n # recognizes ``ESC % C`` sequences for selecting control\n # character set. However, in the current version these\n # are noop.\n char = yield\n if char == \"[\":\n char = CSI_C1 # Go to CSI.\n elif char == \"]\":\n char = OSC_C1 # Go to OSC.\n else:\n if char == \"#\":\n sharp_dispatch[(yield)]()\n if char == \"%\":\n self.select_other_charset((yield))\n elif char in \"()\":\n code = yield\n if self.use_utf8:\n continue\n\n # See http://www.cl.cam.ac.uk/~mgk25/unicode.html#term\n # for the why on the UTF-8 restriction.\n listener.define_charset(code, mode=char)\n else:\n escape_dispatch[char]()\n continue # Don't go to CSI.\n\n if char in basic:\n # Ignore shifts in UTF-8 mode. See\n # http://www.cl.cam.ac.uk/~mgk25/unicode.html#term for\n # the why on UTF-8 restriction.\n if (char == ctrl.SI or char == ctrl.SO) and self.use_utf8:\n continue\n\n basic_dispatch[char]()\n elif char == CSI_C1:\n # All parameters are unsigned, positive decimal integers, with\n # the most significant digit sent first. Any parameter greater\n # than 9999 is set to 9999. If you do not specify a value, a 0\n # value is assumed.\n #\n # .. seealso::\n #\n # `VT102 User Guide <http://vt100.net/docs/vt102-ug/>`_\n # For details on the formatting of escape arguments.\n #\n # `VT220 Programmer Ref. <http://vt100.net/docs/vt220-rm/>`_\n # For details on the characters valid for use as\n # arguments.\n params = []\n current = \"\"\n private = False\n while True:\n char = yield\n if char == \"?\":\n private = True\n elif char in ALLOWED_IN_CSI:\n basic_dispatch[char]()\n elif char in SP_OR_GT:\n pass # Secondary DA is not supported atm.\n elif char in CAN_OR_SUB:\n # If CAN or SUB is received during a sequence, the\n # current sequence is aborted; terminal displays\n # the substitute character, followed by characters\n # in the sequence received after CAN or SUB.\n draw(char)\n break\n elif char.isdigit():\n current += char\n else:\n params.append(min(int(current or 0), 9999))\n\n if char == \";\":\n current = \"\"\n else:\n if private:\n csi_dispatch[char](*params, private=True)\n else:\n csi_dispatch[char](*params)\n break # CSI is finished.\n elif char == OSC_C1:\n code = \"\"\n while True:\n char = yield\n if char in OSC_TERMINATORS or char == \";\":\n break\n code += char\n\n if code == \"R\":\n continue # Reset palette. Not implemented.\n elif code == \"P\":\n continue # Set palette. Not implemented.\n\n param = \"\"\n if char == \";\":\n while True:\n block = yield OSC_PARAM\n if block in OSC_TERMINATORS:\n break\n param += block\n\n osc_dispatch[code](param)\n\n elif char not in NUL_OR_DEL:\n draw(char)","def play_move(self, move_data, all_english_words):\r\n \r\n #first, make copy of board and try to apply move there.\r\n board_cpy = copy.deepcopy(self.myboard)\r\n \r\n rack_cpy = copy.deepcopy(self.rack) #***need to remove appropriate words from rack after we've made a move. \r\n\r\n i = 0 \r\n for cur_char in move_data[0]:\r\n new_tile = Tile(cur_char, self.game_bag.letter_freq_and_val[cur_char][1]) #create a new tile.\r\n if move_data[3] == \"horizontal\":\r\n print(\"adding cur_char {} at {} {}\".format(cur_char, move_data[1], move_data[2]+i))\r\n board_cpy.place_tile(move_data[1], move_data[2]+ i, new_tile)\r\n elif move_data[3] == \"vertical\":\r\n board_cpy.place_tile(move_data[1] + i, move_data[2], new_tile)\r\n\r\n i = i + 1\r\n #print(\"New i value is {}\".format(i))\r\n board_cpy.print_board()\r\n \r\n\r\n #once we're done placing the tiles, check for validity of entire board.\r\n cur_board_words = board_cpy.find_words_on_board()\r\n move_valid = True #assume move is valid, until proven otherwise.\r\n\r\n for word_data in cur_board_words:\r\n word = word_data[0]\r\n print(word)\r\n if word not in all_english_words:\r\n return False #do nothing else\r\n \r\n #print(\"Getting here; all words valid\")\r\n \r\n #getting here means that the move is actually valid, with no conflicts.\r\n main_board = self.myboard\r\n #In this case, add to the real board. \r\n i = 0 \r\n for cur_char in move_data[0]:\r\n new_tile = Tile(cur_char, self.game_bag.letter_freq_and_val[cur_char][1]) #create a new tile.\r\n if move_data[3] == \"horizontal\":\r\n main_board.place_tile(move_data[1], move_data[2]+ i, new_tile)\r\n elif move_data[3] == \"vertical\":\r\n main_board.place_tile(move_data[1] + i, move_data[2], new_tile)\r\n\r\n i = i + 1\r\n return True","def step(self):\n try:\n self.agents.sort(key=lambda x: x.dist)\n except Exception as e:\n print(e)\n\n for agent in self.agents:\n try:\n agent.step()\n except Exception as e:\n print(e)\n\n\n # Removes agents if they reach exit\n for exit in self.model.exits:\n x, y = exit.pos[0] * 6 + 1, exit.pos[1] * 6 + 1\n if agent.node == (x, y):\n try:\n agent.saved()\n except Exception as e:\n print(e)","def demo():\n\n from nltk import parse, CFG\n\n grammar = CFG.fromstring(\"\"\"\n S -> NP VP\n NP -> Det N | Det N PP\n VP -> V NP | V NP PP\n PP -> P NP\n NP -> 'I'\n N -> 'man' | 'park' | 'telescope' | 'dog'\n Det -> 'the' | 'a'\n P -> 'in' | 'with'\n V -> 'saw'\n \"\"\")\n\n sent = 'I saw a man in the park'.split()\n\n parser = parse.ShiftReduceParser(grammar, trace=2)\n for p in parser.parse(sent):\n print(p)","def decide_next_move(self):\n pass","async def move_channel_loop(self):\n try:\n while self.state == CHANNEL_MOVE_STATE_NONE:\n message = await self.poll_message()\n if message is None:\n break\n \n try:\n await self.move_message(message)\n except DiscordException as err:\n if err.code == ERROR_CODES.unknown_webhook:\n self.set_status_update_waiter_webhook_deleted()\n return\n \n raise\n \n self.last_message_id = message.id\n self.total_moved_messages += 1\n \n except GeneratorExit:\n raise\n \n except CancelledError:\n raise\n \n except BaseException as err:\n self.set_status_update_waiter_error()\n await self.client.events.error(self.client, repr(self), err)\n return\n \n finally:\n self.discard()\n \n self.set_status_update_waiter_finished()","def solve(self):\n\n self.queue.add(*self.moved.items)\n self.solving = True\n self.moved.items = []","def loop55(self, move, new_state, i):\n if move == i[0]:\n\n # analyze the other 3 cells\n if (new_state.get_current_player_name()[1]\n == new_state.letters[i[1]]\n or new_state.get_current_player_name()[1]\n == new_state.letters[i[2]]\n or new_state.get_current_player_name()[1]\n == new_state.letters[i[3]]) \\\n and new_state.claim[i[4]] == \"@\":\n new_state.claim[i[4]] \\\n = new_state.get_current_player_name()[1]\n\n # analyze the other 4 cells\n count = 0\n for x in [new_state.letters[i[5]],\n new_state.letters[i[6]],\n new_state.letters[i[7]],\n new_state.letters[i[8]]]:\n if new_state.get_current_player_name()[1] == x:\n count += 1\n if count == 2 and new_state.claim[i[9]] == \"@\":\n new_state.claim[i[9]] = \\\n new_state.get_current_player_name()[1]\n\n # analyze the other 5 cells\n count = 0\n for x in [new_state.letters[i[10]],\n new_state.letters[i[11]],\n new_state.letters[i[12]],\n new_state.letters[i[13]],\n new_state.letters[i[14]]]:\n if new_state.get_current_player_name()[1] == x:\n count += 1\n if count == 2 and new_state.claim[i[15]] == \"@\":\n new_state.claim[i[15]] = \\\n new_state.get_current_player_name()[1]\n new_state.letters = [self.get_current_player_name()[1]\n if i == move else i for i in self.letters]\n return new_state","def move(self, direction):\n try:\n\n if self.in_thing:\n print(\"You have to get out of the \" + str(*self.in_thing[-1]) +\n \" first\")\n return self\n if direction == 'north':\n if self.finished_places == 12:\n self.finished_places += 1\n return North(self.items, self.finished_places)\n if direction == 'up':\n if self.finished_places == 4:\n self.finished_places += 1\n return Up(self.items, self.finished_places)\n if direction == 'east':\n if self.finished_places == 2:\n self.finished_places += 1\n return East(self.items, self.finished_places)\n except AttributeError:\n self.items = []\n return self.move(direction)\n print(' you didn\\'t listen to my very subtle hints, i know it was hard'\n ' your lost now. if you remember the commands i told you you can'\n ' go back to where you left off and continue, just type \"QUIT\"')\n return Place(self.items, self.finished_places)\n\n # implement\n # return new instance on class","def move(self, state):\n raise NotImplementedError(\"Need to implement this method\")","def play_step(self, action):\n self.players[0].moving_left = False\n self.players[0].moving_right = False\n if action == MOVE_LEFT:\n self.players[0].moving_left = True\n for i in range(LOOP_AT_EACH_MOVE_UPDATE):\n self.update(is_a_star=True)\n if self.dead_player or not self.players[0].is_alive:\n break\n self.players[0].moving_left = False\n if self.dead_player or not self.players[0].is_alive:\n return\n elif action == MOVE_RIGHT:\n self.players[0].moving_right = True\n for i in range(LOOP_AT_EACH_MOVE_UPDATE):\n self.update(is_a_star=True)\n if self.dead_player or not self.players[0].is_alive:\n break\n self.players[0].moving_right = False\n if self.dead_player or not self.players[0].is_alive:\n return\n elif action == SHOOT:\n if self.dead_player or not self.players[0].is_alive:\n self.update(is_a_star=True)\n return\n if not self.players[0].weapon.is_active:\n self.players[0].shoot()\n for i in range(LOOP_AT_EACH_MOVE_UPDATE):\n self.update(is_a_star=True)\n if self.dead_player or not self.players[0].is_alive:\n break\n if self.dead_player or not self.players[0].is_alive:\n return","def execute_move(self, game_state):\n game_state.pacs_pos[self.pac_id] = self.next_move","def move(self): # AH note. Swich move with extra_steps?\n if self.adjustment < 0:\n self.position += self.extra_steps\n super().move()\n self.no_moves += 1\n # Do the regular move","def loop56(self, move, new_state, i):\n if move == i[0]:\n\n # analyze the other 4 cells\n count = 0\n for x in [new_state.letters[i[1]],\n new_state.letters[i[2]],\n new_state.letters[i[3]],\n new_state.letters[i[4]]]:\n if new_state.get_current_player_name()[1] == x:\n count += 1\n if count == 2 and new_state.claim[i[5]] == \"@\":\n new_state.claim[i[5]] = \\\n new_state.get_current_player_name()[1]\n\n # analyze the other 4 cells\n count = 0\n for x in [new_state.letters[i[6]],\n new_state.letters[i[7]],\n new_state.letters[i[8]],\n new_state.letters[i[9]]]:\n if new_state.get_current_player_name()[1] == x:\n count += 1\n if count == 2 and new_state.claim[i[10]] == \"@\":\n new_state.claim[i[10]] = \\\n new_state.get_current_player_name()[1]\n\n # analyze the other 4 cells\n count = 0\n for x in [new_state.letters[i[11]],\n new_state.letters[i[12]],\n new_state.letters[i[13]],\n new_state.letters[i[14]]]:\n if new_state.get_current_player_name()[1] == x:\n count += 1\n if count == 2 and new_state.claim[i[15]] == \"@\":\n new_state.claim[i[15]] = \\\n new_state.get_current_player_name()[1]\n\n new_state.letters = [self.get_current_player_name()[1]\n if i == move else i for i in self.letters]\n return new_state","def handle_make(self, move):\n# print \"handle make-\"+str(move.src)+\":\"+str(move.dst)\n if not move: return\n # remove en passant capture\n if move.is_en_passant():\n self.remove(move.dst + (8 if move.is_white() else -8))\n if move.is_capture():\n self.remove(move.dst)\n\n # move rook when castling\n if move.is_castling_short():\n if move.is_white():\n self.move((63,61))\n else:\n self.move((7,5))\n if move.is_castling_long():\n if move.is_white():\n self.move((56, 59))\n else:\n self.move((0, 3))\n # Actual move itself.\n self.move((move.src, move.dst))\n\n # Replace promoted piece.\n if move.is_promotion():\n self.remove(move.dst)\n p_piece = move.get_promotion_piece()\n if not move.is_white(): p_piece = p_piece.lower()\n# print \"promoting to \"+p_piece+\" at \"+move.dst\n self.put(move.dst, p_piece)\n self.update_vars_list()","def play_game(game, *players):\n state = game.initial\n while True:\n for player in players:\n print \"now move for player \", player\n move = player(game, state) # update move\n state = game.make_move(move, state) # update game state\n print '---'\n game.display(state) # display board\n print '---'\n \n if move == None or game.terminal_test(state): #check game end\n if game.utility(state,'X')==1:\n print 'X has won!'\n elif game.utility(state,'O')==1:\n print 'O has won!'\n else:\n print 'Its A Draw!'\n return #exit","def successor(self, state):\n pass # abstract","def act_after_input(self, current_dir, subdirs, car):\n new_dir = current_dir\n if car == 'q':\n new_dir = None\n elif car in {str(i+1) for i in range(len(subdirs))}:\n print ('----> Moving to directory', subdirs[int(car)-1])\n new_dir = subdirs[int(car)-1]\n elif car=='.':\n pass\n elif car == 'l':\n self.list_files(current_dir)\n elif car == '!':\n self.pass1(self.verb)\n elif car in {'u','0','..'}:\n print ('----> Moving one step up')\n new_dir = self.move_to_parent(current_dir)\n elif car == '+':\n new_dir = subdirs[len(subdirs)-1]\n elif car == 'v':\n self.verb = not self.verb\n elif car[0] == 'c': \n if len(car)>1:\n num = car[1:]\n if num in {str(i+1) for i in range(len(subdirs))}:\n self.list_for_clean(subdirs[int(num)-1])\n else:\n self.list_for_clean(current_dir)\n else:\n print (help_pass2)\n return new_dir","def step(self, action):\n # print(\"############################\")\n # print(\"action: {}\".format(action))\n\n self.movement_complete.data = False\n\n # 1) Read last joint positions by getting the observation before acting\n old_observation = self.get_obs()\n\n # 2) Get the new joint positions according to chosen action (actions here are the joint increments)\n if self._joint_increment is None:\n next_action_position = action\n else:\n next_action_position = self.get_action_to_position(action, old_observation[1:7])\n\n # 3) Move to position and wait for moveit to complete the execution\n self.publisher_to_moveit_object.pub_joints_to_moveit(next_action_position)\n # rospy.wait_for_message(\"/pickbot/movement_complete\", Bool)\n while not self.movement_complete.data:\n pass\n\n start_ros_time = rospy.Time.now()\n while True:\n # Check collision:\n # invalid_collision = self.get_collisions()\n # if invalid_collision:\n # print(\">>>>>>>>>> Collision: RESET <<<<<<<<<<<<<<<\")\n # observation = self.get_obs()\n # reward = UMath.compute_reward(observation, -200, True)\n # observation = self.get_obs()\n # print(\"Test Joint: {}\".format(np.around(observation[1:7], decimals=3)))\n # return U.get_state(observation), reward, True, {}\n\n elapsed_time = rospy.Time.now() - start_ros_time\n if np.isclose(next_action_position, self.joints_state.position, rtol=0.0, atol=0.01).all():\n break\n elif elapsed_time > rospy.Duration(2): # time out\n break\n # time.sleep(s\n\n \"\"\"\n #execute action as long as the current position is close to the target position and there is no invalid collision and time spend in the while loop is below 1.2 seconds to avoid beeing stuck touching the object and not beeing able to go to the desired position \n time1=time.time()\n while np.linalg.norm(np.asarray(self.joints_state.position)-np.asarray(next_action_position))>0.1 and self.get_collisions()==False and time.time()-time1<0.1: \n rospy.loginfo(\"Not yet reached target position and no collision\")\n \"\"\"\n # 4) Get new observation and update min_distance after performing the action\n new_observation = self.get_obs()\n if new_observation[0] < self.min_distace:\n self.min_distace = new_observation[0]\n # print(\"observ: {}\".format( np.around(new_observation[1:7], decimals=3)))\n\n # 5) Convert Observations into state\n state = U.get_state(new_observation)\n\n # 6) Check if its done, calculate done_reward\n done, done_reward, invalid_contact = self.is_done(new_observation)\n\n # 7) Calculate reward based on Observatin and done_reward and update the accumulated Episode Reward\n reward = UMath.compute_reward(new_observation, done_reward, invalid_contact)\n\n ### TEST ###\n if done:\n joint_pos = self.joints_state.position\n print(\"Joint in step (done): {}\".format(np.around(joint_pos, decimals=3)))\n ### END of TEST ###\n\n self.accumulated_episode_reward += reward\n\n self.episode_steps += 1\n\n return state, reward, done, {}","def shutdown_allcomponents(self):\n for key,obj in reversed(self.components.get_tuplelist()):\n obj.shutdown()","def solveOneStep(self):\n ### Student code goes here\n state = self.currentState\n #print (type(state))\n self.visited[state] = True\n #print (type(self.gm.getGameState()))\n moves = self.gm.getMovables()\n print (\"CURRENTSTATE\" + str(self.currentState.state))\n print (\"MOVABLES:\")\n if moves:\n for m in moves:\n print (str(m))\n print (\"CHILDINDEX:\")\n print (state.nextChildToVisit)\n print (\"*********\")\n if state.state == self.victoryCondition:\n return True\n #if no child to expand then go back\n if not moves or state.nextChildToVisit >= len(moves):\n self.currentState = state.parent\n if state.requiredMovable is not None:\n self.gm.reverseMove(state.requiredMovable)\n # expand\n else:\n\n next_move = moves[state.nextChildToVisit]\n self.gm.makeMove(next_move)\n state.nextChildToVisit += 1\n\n #if to parent or if visited then skip\n while (((state.parent is not None) and (self.gm.getGameState() == state.parent.state))) or GameState(self.gm.getGameState(), 0, None) in self.visited:\n print (\"PARENT FOUND!\")\n self.gm.reverseMove(next_move)\n if state.nextChildToVisit >= len(moves):\n self.currentState = state.parent\n return False\n else:\n next_move = moves[state.nextChildToVisit]\n self.gm.makeMove(next_move)\n state.nextChildToVisit += 1\n\n next_state = GameState(self.gm.getGameState(), state.depth + 1, next_move)\n next_state.parent = state\n #next_state.requiredMovable = next_move\n state.children.append(next_state)\n self.currentState = next_state\n print (state.nextChildToVisit)\n return False","def action(self):\r\n\r\n\r\n #have we just started?\r\n if self.player_information[\"us\"][\"nTokens\"] == 0:\r\n move = generate_starting_move(self.player_information[\"us\"][\"player_side\"], self.board_array)\r\n return move\r\n\r\n #otherwise do minimax \r\n \r\n #start off with some shallow depth:\r\n if self.turn_no < 5:\r\n depth = 3\r\n else:\r\n depth = 2\r\n \r\n #set a constraint for search depth\r\n if self.total_tokens_on_board < 6:\r\n depth = 3\r\n elif self.total_tokens_on_board < 10:\r\n depth = 2\r\n else:\r\n depth = 1\r\n \r\n #have a time reference\r\n print(f'nthrows: {self.player_information[\"us\"][\"nThrowsRemaining\"]}')\r\n starting_time = int(round(time.time(), 0))\r\n #salvage result from minimax\r\n result = minimax(self.board_dict.copy(), self.player_tokens.copy(), self.co_existance_dict.copy(),\r\n None, None, None, depth, True, -math.inf, math.inf,\r\n (-5, -5), self.player_information.copy(), self.board_array, self.board_edge, \r\n starting_time, True, self.turn_no)\r\n\r\n #clean it up a bit \r\n print(self.board_dict)\r\n #tidy it up\r\n result = result[0]\r\n print(f'pre: {result}')\r\n #in case we get a bad move redo but make it very shallow\r\n if len(result) == 1 or result == (-5, -5):\r\n #force it to return a usable move\r\n counter = 0\r\n while (len(result) == 1) or (result == (-5, -5)):\r\n result = minimax(self.board_dict.copy(), self.player_tokens.copy(), self.co_existance_dict.copy(),\r\n None, None, None, 1, True, -math.inf, math.inf,\r\n (-5, -5), self.player_information.copy(), self.board_array, self.board_edge, \r\n starting_time, False, self.turn_no)\r\n result = result[0]\r\n counter += 1\r\n \r\n #if its taking too long\r\n if counter > 2: \r\n #generate one random possible move to use \r\n allied_tokens = [token for token in self.player_tokens if self.player_tokens[token] == \"us\"]\r\n move_list = generate_moves(self.board_dict, self.player_tokens, self.co_existance_dict, allied_tokens,\r\n self.player_information, self.board_array, True, \"all\")\r\n \r\n \r\n #if there are no moves\r\n if len(move_list) == 0:\r\n if self.player_information['us']['nThrowsRemaining'] > 0:\r\n throws = generate_possible_throws(self.board_dict, self.player_tokens, self.co_existance_dict, self.player_information, \"us\",\r\n self.player_information[\"us\"][\"player_side\"], self.board_array, \"all\" )\r\n result = random.choice(throws)\r\n \r\n else:\r\n result = random.choice(move_list)\r\n print(f'random: {result}')\r\n break\r\n\r\n print(f' inside: {result}')\r\n\r\n print(result)\r\n #otherwise clean it up\r\n if result[0] == 'throw':\r\n final_result = (result[0].upper(), result[1], result[2])\r\n else:\r\n final_result = (result[0].upper(), result[2], result[3])\r\n # return final result \r\n return final_result","def play(self):\n for step_i in range(self.max_step):\n player_id = step_i & 1\n player = self.players[player_id]\n action = player.nxt_move()\n if isinstance(player, mcts.MCTSPlayer) and player.value_net.loggable:\n print(f'Player{player_id}: Action: {action}')\n if not self.is_valid_action(action):\n # because now just consider 2 players\n print(f\"Player: {player_id}, Action: {action} Did Not choose a valid action!\")\n self.board[action // self.w][action % self.w] = player_id\n self.winner = 1 - player_id\n else:\n self.board[action // self.w][action % self.w] = player_id\n self.winner = self.k0()\n self.players[1 - player_id].other_nxt_move(action)\n if self.winner != -1:\n break\n print(f'Winner: {self.winner}')\n for player_id in range(len(self.players)):\n self.players[player_id].game_ended()","def move(self, direction, no_of_exits):\n if direction in NS:\n self.y = shift[direction](self.y)\n else:\n self.x = shift[direction](self.x)\n\n # Store new movement\n self.path.append([self.x, self.y])\n\n # Stores new tested junction direction after reset\n if self.moved() is False:\n self._dead_end_direction[-1].append(direction)\n\n # Stores the direction and location when testing a new junction.\n if no_of_exits > 1 and self.moved() is True:\n self._dead_end_direction.append([direction])\n self._junction_index.append(len(self.fullpath()) - 1)\n\n self._moved = True","def move(self, agent, action):\n\t\tpass","async def move(self, board, valid_actions):\n self._move = None\n output_move_row = Value('d', -1)\n output_move_column = Value('d', 0)\n try:\n # await self.search(board, valid_actions) \n p = Process(\n target=self.search, \n args=(\n self._color, board, valid_actions, \n output_move_row, output_move_column))\n p.start()\n while p.is_alive():\n await asyncio.sleep(0.1)\n self._move = np.array([output_move_row.value,output_move_column.value],dtype=np.int32)\n except asyncio.CancelledError as e:\n print('The previous player is interrupted by a user or a timer.')\n except Exception as e:\n print(type(e).__name__)\n print('move() Traceback (most recent call last): ')\n traceback.print_tb(e.__traceback__)\n finally:\n p.kill()\n self._move = np.array(\n [output_move_row.value, output_move_column.value],\n dtype=np.int32)\n return self.best_move"],"string":"[\n \"def move(self):\\r\\n segments = len(self.all_turtles) - 1\\r\\n for i in range(len(self.all_turtles)):\\r\\n if segments == 0:\\r\\n self.all_turtles[segments].forward(MOVE_DISTANCE)\\r\\n else:\\r\\n new_x = self.all_turtles[segments - 1].xcor()\\r\\n new_y = self.all_turtles[segments - 1].ycor()\\r\\n self.all_turtles[segments].goto(new_x, new_y)\\r\\n segments -= 1\",\n \"def moveSpecialOb(self):\\n\\t\\tfor obJ in self.special:\\n\\t\\t\\tobJ.moveStep()\",\n \"def play_move(self,state):\\n #Keep asking for the next move until a valid move.\\n while(True):\\n childList = state.get_successors()\\n print(\\\"Your possible moves:\\\")\\n i = 0\\n for c in childList:\\n if i > 0 and i%4 == 0:\\n print()\\n print(c.get_action().ljust(10),end=\\\"\\\\t\\\");\\n i += 1\\n print()\\n nextMove = input(\\\"What is your next move? \\\\ne.g.'F2-E3' or 'Quit'\\\\n\\\")\\n #Check if the move is valid\\n if nextMove.lower() == 'Quit'.lower():\\n return None\\n for c in childList:\\n if c.get_action().upper() == nextMove.upper():\\n return c\\n # Move not possible \\n print(\\\"Invalid move!! Please try again...\\\\n\\\")\",\n \"def algo_mover(self):\\n self.tick_count = 0 ## reset to start clock on delayed state change\\n\\n ### Move 1 ring ###\\n de, aux, vers = self.instructions.pop(0)\\n\\n de = self.rods[de]\\n aux = self.rods[aux]\\n vers = self.rods[vers]\\n\\n ring = de.pop_ring()\\n vers.add_ring(ring)\\n\\n ### Update the states after -- moved this to main update\\n #self.state_updater()\",\n \"def successor(self, state):\\n for action in self.actions:\\n nexts = state.move(action)\\n if nexts is not None:\\n yield (action,nexts)\",\n \"def _iter_tokens(self):\\n reobj, actions, nextstates = self._rules[self.states[-1]]\\n mobj = reobj.match(self.string, self.pos)\\n while mobj is not None:\\n text = mobj.group(0)\\n idx = mobj.lastindex - 1\\n nextstate = nextstates[idx]\\n\\n # Take action\\n actions[idx](self, text)\\n while self.tokens:\\n yield self.pop_token()\\n if nextstate and nextstate != self.states[-1]:\\n self.states[-1] = nextstate\\n\\n # Update position variables\\n self.pos = mobj.end()\\n lines = text.split(\\\"\\\\n\\\")\\n nlines = len(lines) - 1\\n if nlines == 0:\\n self.offset = self.offset + len(lines[0])\\n else:\\n self.lineno = self.lineno + nlines\\n self.offset = 1 + len(lines[-1])\\n\\n reobj, actions, nextstates = self._rules[self.states[-1]]\\n mobj = reobj.match(self.string, self.pos)\\n\\n if self.pos != len(self.string):\\n msg = \\\"unexpected character\\\"\\n text = self.string[self.pos]\\n raise RunError(msg, self.lineno, self.offset, text)\\n\\n yield EndToken(\\\"\\\", self.lineno, self.offset)\",\n \"def move(self):\\n # This block is used to move into the living room.\\n if self.room_name == \\\"living\\\" or self.room_name == \\\"Living\\\":\\n self.living_room()\\n # This block is used to open the door.\\n elif self.room_name == \\\"Door\\\" or self.room_name == \\\"door\\\":\\n self.door()\\n # This block is used to move into the kitchen.\\n elif self.room_name == \\\"Kitchen\\\" or self.room_name == \\\"kitchen\\\":\\n self.kitchen()\\n # This block is used to move into the hallway.\\n elif self.room_name == \\\"Hallway\\\" or self.room_name == \\\"hallway\\\":\\n self.hallway()\\n # This block is used to move into the bathroom.\\n elif self.room_name == \\\"Bathroom\\\" or self.room_name == \\\"bathroom\\\":\\n self.bathroom()\\n # This block is used to move into the basement.\\n elif self.room_name == \\\"Basement\\\" or self.room_name == \\\"basement\\\":\\n self.basement()\\n # This block is used to move into the bedroom.\\n elif self.room_name == \\\"Bedroom\\\" or self.room_name == \\\"bedroom\\\":\\n self.bedroom()\\n # This block is used to move into the attic.\\n elif self.room_name == \\\"Attic\\\" or \\\"attic\\\":\\n self.attic()\",\n \"def next_move(self):\\n self.branchize()\\n try:\\n _, new_branch = self.score_scheme.pop(0)\\n except IndexError:\\n return False\\n\\n move_list = [new_branch[\\\"move\\\"]]\\n parent = new_branch[\\\"parent\\\"]\\n\\n while True:\\n try:\\n move_list.append(parent[\\\"move\\\"]) \\n parent = parent[\\\"parent\\\"]\\n\\n except KeyError:\\n break\\n\\n self.__originate__()\\n for i in move_list[::-1]:\\n self.change(i)\\n\\n self.current_branch = new_branch\\n self.output += str(self)\\n return True\",\n \"def move(self, direction, cycles):\\n\\t\\tpass\",\n \"def state_parsing_toplevel_text(self):\\n chars = []\\n while self.more():\\n if self.peek() in CHAR_COMMENT:\\n self.emit(TokenWhitespace, chars)\\n return self.state_parsing_comment\\n if self.peek() in CHAR_NUMBER:\\n self.emit(TokenWhitespace, chars)\\n return self.state_parsing_transaction\\n if self.confirm_next(\\\"P\\\"):\\n self.emit(TokenWhitespace, chars)\\n return self.state_parsing_price\\n if self.confirm_next(\\\"C\\\"):\\n self.emit(TokenWhitespace, chars)\\n return self.state_parsing_conversion\\n if self.confirm_next(\\\"python\\\"):\\n self.emit(TokenWhitespace, chars)\\n return self.state_parsing_embedded_python\\n if self.confirm_next(\\\"tag\\\"):\\n self.emit(TokenWhitespace, chars)\\n return self.state_parsing_embedded_tag\\n if self.peek() not in CHAR_WHITESPACE + CHAR_ENTER:\\n _, _, l2, c2 = self._coords()\\n raise LexingError(\\n \\\"unparsable data at line %d, char %d\\\" % (l2, c2)\\n )\\n chars += [next(self)]\\n self.emit(TokenWhitespace, chars)\\n return\",\n \"def act(state: Tree) -> None:\\n cur_state = state.value\\n state.children = [Tree(cur_state.make_move(m)) for m in\\n cur_state.get_possible_moves()]\",\n \"def move(self):\\n pass\",\n \"def player_loop(self):\\n\\n # Generate game tree object\\n first_msg = self.receiver()\\n # Initialize your minimax model\\n model = self.initialize_model(initial_data=first_msg)\\n\\n while True:\\n msg = self.receiver()\\n\\n # Create the root node of the game tree\\n node = Node(message=msg, player=0)\\n\\n # Possible next moves: \\\"stay\\\", \\\"left\\\", \\\"right\\\", \\\"up\\\", \\\"down\\\"\\n best_move = self.search_best_next_move(\\n model=model, initial_tree_node=node)\\n\\n # Execute next action\\n self.sender({\\\"action\\\": best_move, \\\"search_time\\\": None})\",\n \"def step(self):\\n while self.state != STATE_TERMINAL:\\n self.step_strategies[self.state]()\",\n \"def makeMove(self, node):\\n if self.idx in node.finished:\\n print ('Congratulations, you\\\\'re out of cards and were number {} '\\n 'to finish!'.format(node.finished.index(self.idx)+1))\\n return (0, -1)\\n\\n print 'Cards left for each player: {}'.format(node.numRemaining)\\n print 'Your hand: {}'.format(\\n map(lambda c: cards.cardRepr[c], cards.cardDictToList(self.hand))\\n )\\n if node.topCard:\\n topN, topC = node.topCard\\n topStr = '{} {}'.format(topN, cards.cardRepr[topC])\\n else:\\n topStr = 'Empty'\\n print 'Top card: {}'.format(topStr)\\n legalActions = self.getAllActions(node)\\n print 'Valid actions: {}'.format(\\n ['{} {}'.format(n, cards.cardRepr[c]) for n, c in legalActions]\\n )\\n mnAgent = maxN.MaxNAgent(self.idx, self.hand)\\n mnN, mnC = mnAgent.makeMove(node)\\n print 'The Max^n agent recommends playing {} {}'.format(\\n mnN, cards.cardRepr[mnC])\\n action = None\\n while action not in legalActions:\\n actStr = raw_input(\\n 'Your move. Input as a space-separated tuple of numCards and '\\n 'whichCard representing the action (that is, '\\n '\\\"numCards whichCard\\\" without the quotes). To pass, enter '\\n '\\\"0 P\\\", \\\"P\\\", or \\\"pass\\\". So, what\\\\'s your move? '\\n )\\n if actStr.lower() in ('pass', 'p', '0p'):\\n action = (0, -1)\\n else:\\n try:\\n numStr, cardStr = actStr.split()\\n numCards = int(numStr)\\n encodedNum = cards.cardRepr.index(cardStr.upper())\\n except Exception:\\n continue\\n # if number not valid, continue the loop again\\n if encodedNum == -1:\\n continue\\n whichCard = int(encodedNum)\\n action = (numCards, whichCard)\\n return action\",\n \"def move_replay(self) -> Generator[List[List[str]], None, None]:\\n current_moves = OrderedDict()\\n for move in self.moves:\\n current_moves[move] = self.moves[move]\\n yield self.compile_board(current_moves)\",\n \"def play_one_move(self, verbose=False):\\n if verbose:\\n self.print(\\\"top of move\\\")\\n\\n # 1) grab three cups\\n c1 = self.cups.remove_next_node()\\n c2 = self.cups.remove_next_node()\\n c3 = self.cups.remove_next_node()\\n if verbose:\\n print(f\\\"pick up: {c1}, {c2}, {c3}\\\")\\n self.print(\\\"after pickup\\\")\\n\\n # 2) find a destination cup\\n destination_node = self.find_next_destination(\\n self.cups.get_current_node().value\\n )\\n if verbose:\\n print(f\\\"destination node is {destination_node}\\\")\\n\\n # 3) insert cups back into the circle\\n self.cups.add_after(destination_node, c3.value)\\n self.cups.add_after(destination_node, c2.value)\\n self.cups.add_after(destination_node, c1.value)\\n if verbose:\\n self.print(\\\"after adding cups..\\\")\\n\\n # 4) select the next cup\\n target_cup = self.cups.get_current_node().next()\\n self.cups.set_current_node(target_cup)\\n\\n if verbose:\\n self.print(\\\"post move\\\")\",\n \"def makeMove(self, movable_statement):\\n ### Student code goes here\\n tile = movable_statement.terms[0].term.element\\n initialX = movable_statement.terms[1].term.element\\n initialY = movable_statement.terms[2].term.element\\n goalX = movable_statement.terms[3].term.element\\n goalY = movable_statement.terms[4].term.element\\n r1 = parse_input(\\\"fact: (on \\\" + tile + \\\" \\\" + initialX + \\\" \\\" + initialY + \\\")\\\")\\n self.kb.kb_retract(r1)\\n r2 = parse_input(\\\"fact: (on empty \\\" + goalX + \\\" \\\" + goalY + \\\")\\\")\\n self.kb.kb_retract(r2)\\n stat1 = parse_input(\\\"fact: (on \\\" + tile + \\\" \\\" + goalX + \\\" \\\" + goalY + \\\")\\\")\\n self.kb.kb_assert(stat1)\\n stat2 = parse_input(\\\"fact: (on empty \\\" + initialX + \\\" \\\" + initialY + \\\")\\\")\\n self.kb.kb_assert(stat2)\\n\\n\\n #for facts in self.kb.facts:\\n # print(facts.statement)\\n\\n #print(\\\"\\\\n\\\\n\\\")\\n ##Need to handle adjacentTo\\n '''ask = parse_input(\\\"fact: (adjacentTo empty ?tile)\\\")\\n answer = self.kb.kb_ask(ask)\\n empty_adj = []\\n if answer:\\n for ans in answer.list_of_bindings:\\n adjTile = ans[0].bindings[0].constant.element\\n if adjTile != tile:\\n rt = parse_input(\\\"fact: (adjacentTo empty \\\" + adjTile + \\\")\\\")\\n self.kb.kb_retract(rt)\\n #print(\\\"RMOVINGGGG\\\")\\n #print(rt)\\n rt1 = parse_input(\\\"fact: (adjacentTo \\\" + adjTile + \\\" empty)\\\")\\n self.kb.kb_retract(rt1)\\n empty_adj.append(adjTile) #All of empty's adjacent tiles'''\\n\\n #for facts in self.kb.facts:\\n # print(facts.statement)\\n\\n #print(\\\"::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::\\\")\\n '''ask1 = parse_input(\\\"fact: (adjacentTo \\\" + tile + \\\" ?tile)\\\")\\n answer1 = self.kb.kb_ask(ask1)\\n if answer1:\\n for ans in answer1.list_of_bindings:\\n adjTile = ans[0].bindings[0].constant.element\\n if adjTile != \\\"empty\\\":\\n stat = parse_input(\\\"fact: (adjacentTo empty \\\" + adjTile + \\\")\\\")\\n self.kb.kb_assert(stat)\\n radj1 = parse_input(\\\"fact: (adjacentTo \\\" + tile + \\\" \\\" + adjTile + \\\")\\\")\\n self.kb.kb_retract(radj1)\\n radj2 = parse_input(\\\"fact: (adjacentTo \\\" + adjTile + \\\" \\\" + tile + \\\")\\\")\\n self.kb.kb_retract(radj2)\\n for tiles in empty_adj:\\n stat = parse_input(\\\"fact: (adjacentTo \\\" + tile + \\\" \\\" + tiles + \\\")\\\")\\n self.kb.kb_assert(stat)'''\",\n \"def successor(self, state):\\n for direct in self.direction :\\n newState = state.move(direct)\\n if newState :\\n yield (None, newState)\",\n \"def moveCirc(self):\\n\\t\\tfor circle in self.circles:\\n\\t\\t\\tcircle.moveStep()\",\n \"def parse(self):\\r\\n readnext = False\\r\\n error = False\\r\\n errorInfo = (-100, -100)\\r\\n token = self.tokens.nextToken()\\r\\n accepted = False\\r\\n while len(self.stack) > 0:\\r\\n (type, value) = self.stack.pop()\\r\\n self.runtime_transitions.append((type, value))\\r\\n\\r\\n if(readnext):\\r\\n token = self.tokens.nextToken()\\r\\n\\r\\n if (type == TERMINAL):\\r\\n if (value == token.category_num or value == EPSILON):\\r\\n if(value != EPSILON):\\r\\n print(token)\\r\\n\\r\\n if (not self.tokens.hasToken() and len(self.stack) == 0):\\r\\n print(\\\"Input Accepted!\\\")\\r\\n error = False\\r\\n accepted = True\\r\\n\\r\\n if(value != EPSILON):\\r\\n readnext = True\\r\\n\\r\\n else:\\r\\n error = True\\r\\n errorInfo = (value, token.category_num)\\r\\n\\r\\n\\r\\n\\r\\n elif (type == RULE):\\r\\n if(token.category_num > -1):\\r\\n rule = self.table[value][token.category_num]\\r\\n\\r\\n self.print_production(rule, value)\\r\\n self.last_transition = rule\\r\\n\\r\\n if(rule == -1):\\r\\n print(toRuleString[value], self.terminal_to_str(token.category_num))\\r\\n break\\r\\n for r in reversed(self.rules[rule]):\\r\\n self.stack.append(r)\\r\\n\\r\\n readnext = False\\r\\n\\r\\n if(error):\\r\\n break;\\r\\n\\r\\n if(error):\\r\\n print(\\\"Syntax error on position (%d, %d): [%s] expected. Got [%s]\\\" % (token.line, token.column, self.terminal_to_str(errorInfo[0]), self.terminal_to_str(errorInfo[1])))\\r\\n print(token)\\r\\n self.printStack()\",\n \"def play_simulation(self):\\n self._play(self._move_comp_person)\",\n \"def move(self, move):\\n out = ''\\n for val in self.moves[move]:\\n out += self.state[val]\\n self.state = out\",\n \"def interaction_void(self) -> None:\\n self.grid.obj_list.swap_obj(self.moving_character, self.target)\",\n \"def step(self, move):\",\n \"def moveNorth(self):\\n north = (self.current[0], self.current[1] - 1)\\n mv = self.lab.north()\\n self.check_grue(mv)\\n self.current = north\\n self.visited.add(self.current)\",\n \"def move(self):\\n self.build_graph()\\n while 1:\\n if self.current in self.visited:\\n self.build_graph()\\n if (self.current[0], self.current[1] + 1) in self.unvisited:\\n self.moveSouth()\\n elif (self.current[0], self.current[1] - 1) in self.unvisited:\\n self.moveNorth()\\n elif (self.current[0] - 1, self.current[1]) in self.unvisited:\\n self.moveWest()\\n elif (self.current[0] + 1, self.current[1]) in self.unvisited:\\n self.moveEast()\\n elif self.intersection:\\n self.backtrack()\\n \\n #Using Tremaux's algorithm as backup\\n elif (self.current[0] + 1, self.current[1]) in self.visited.difference(self.visitedtwice):\\n self.visitedtwice.add(self.current)\\n self.moveEast()\\n elif (self.current[0] - 1, self.current[1]) in self.visited.difference(self.visitedtwice):\\n self.visitedtwice.add(self.current)\\n self.moveWest()\\n elif (self.current[0], self.current[1] - 1) in self.visited.difference(self.visitedtwice):\\n self.visitedtwice.add(self.current)\\n self.moveNorth()\\n elif (self.current[0], self.current[1] + 1) in self.visited.difference(self.visitedtwice):\\n self.visitedtwice.add(self.current)\\n self.moveSouth()\\n \\n if self._find_intersection() and self.current in self.unvisited:\\n self.intersection.append(self.current)\\n \\n self.lab.cleanup()\",\n \"def move(self, state):\\n \\n self.depth_limit=1\\n self.best_utility=-2\\n action=None\\n while not self.is_time_up():\\n self.terminal=True\\n self.cache={}\\n action=self.alpha_beta_search(state,0)\\n if self.terminal==True:\\n break\\n self.depth_limit=self.depth_limit+1\\n \\n return action\",\n \"def __exit__(self, *_) -> None:\\n for component in self.__traverse_backward():\\n component.__exit__(*_)\",\n \"def move(self, move: tuple) -> None:\\n if move in self.root.children:\\n child = self.root.children[move]\\n child.parent = None\\n self.root = child\\n self.root_state.play(child.move)\\n return\\n\\n # if for whatever reason the move is not in the children of\\n # the root just throw out the tree and start over\\n self.root_state.play(move)\\n self.root = Node()\",\n \"def run_each_move(root: State, state: GameState) -> State:\\n for m, base_move in enumerate(root.moves):\\n for _ in range(50):\\n base_move = expand(base_move)\\n outcome, _ = MCTS(base_move, state, False, 0)\\n if outcome == state.player:\\n base_move.winner()\\n else:\\n base_move.loser()\\n root.attempts += 1\\n root.moves[m] = base_move\\n print(\\\"Move: \\\", base_move.idx)\\n print(\\\" Wins: \\\", base_move.wins)\\n update_ucbs(root)\\n return root\",\n \"def _finish_all_moves(self, current_time):\\n\\t\\tfor piece_id in self.all_piece_ids:\\n\\t\\t\\tstate = getattr(self, piece_id)\\n\\t\\t\\tif len(state) == 0:\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\tpiece = Piece(state)\\n\\t\\t\\tif piece.moving:\\n\\t\\t\\t\\tif piece.end_time <= current_time:\\n\\t\\t\\t\\t\\tself._finish_move(piece_id, piece, current_time)\",\n \"def startMovementAll(self):\\n self.startMovementX()\\n self.startMovementY()\\n self.startMovementZ()\",\n \"def makeMove(self, movable_statement):\\n ### Student code goes here\\n\\n # make statement of (on disk firstpeg) and (on disk secondpeg) from movable_statement\\n # retract (on disk firstpeg)\\n # add (on disk secondpeg)\\n # that should be it...\\n\\n if type(movable_statement) != Statement or not self.kb.kb_ask(Fact(movable_statement, [])):\\n # print(\\\"current gamestate: \\\", self.getGameState())\\n # print(\\\"~~~~~~~Error: \\\", movable_statement, \\\"is not a valid movable statement~~~~~~~\\\")\\n return None\\n\\n # print(\\\"current gamestate: \\\", self.getGameState())\\n # if self.kb.kb_ask(parse_input(\\\"fact: (movable ?X ?A ?B)\\\")):\\n # for binding in self.kb.kb_ask(parse_input(\\\"fact: (movable ?X ?A ?B)\\\")):\\n # print(\\\"movable: \\\", binding.bindings[0].constant.element)\\n # if self.kb.kb_ask(parse_input(\\\"fact: (empty ?X)\\\")):\\n # for binding in self.kb.kb_ask(parse_input(\\\"fact: (empty ?X)\\\")):\\n # print(\\\"empty: \\\", binding.bindings[0].constant.element)\\n # if self.kb.kb_ask(parse_input(\\\"fact: (top ?X ?A)\\\")):\\n # for binding in self.kb.kb_ask(parse_input(\\\"fact: (top ?X ?A)\\\")):\\n # print(\\\"top fact: \\\", binding.bindings[0].constant.element)\\n # print(\\\"moving: \\\", movable_statement)\\n\\n\\n\\n # remove old \\\"on\\\", add new \\\"on\\\"\\n statement1_list = [\\\"on\\\"]\\n statement2_list = [\\\"on\\\"]\\n\\n statement1_list.append(movable_statement.terms[0])\\n statement1_list.append(movable_statement.terms[1])\\n\\n statement2_list.append(movable_statement.terms[0])\\n statement2_list.append(movable_statement.terms[2])\\n\\n curr_fact = Fact(Statement(statement1_list), [])\\n new_fact = Fact(Statement(statement2_list), [])\\n\\n\\n # print(\\\"retracted: fact: (top \\\" + movable_statement.terms[0].term.element + \\\" \\\" + movable_statement.terms[1].term.element + \\\")\\\")\\n\\n\\n # (movable disk1 peg1 peg2)\\n # retract (fact: on disk1 peg1)\\n\\n # DISK We're moving from:\\n # Retract previous on statement\\n # Retract previous top statement\\n # If empty, say empty.\\n # If not empty, make the new top statement using ontopof\\n\\n # STEP 1\\n self.kb.kb_retract(curr_fact)\\n moved_disk= movable_statement.terms[0].term.element\\n prev_peg= movable_statement.terms[1].term.element\\n new_peg=movable_statement.terms[2].term.element\\n\\n # STEP 2\\n top_ask = parse_input(\\\"fact: (top \\\" + moved_disk + \\\" \\\" + prev_peg + \\\")\\\")\\n if self.kb.kb_ask(top_ask):\\n self.kb.kb_retract(top_ask)\\n else:\\n print(\\\"something went wrong with top...\\\")\\n\\n # STEP 3\\n prev_top_ask = parse_input(\\\"fact: (onTopOf \\\" + moved_disk + \\\" ?X)\\\")\\n if self.kb.kb_ask(prev_top_ask):\\n # then it's not empty, make this one the top.\\n for binding in self.kb.kb_ask(prev_top_ask):\\n # there should only be one binding...\\n disk_on_bottom = binding.bindings[0].constant.element\\n # make the disk on bottom the new top of the previous peg\\n # then remove the \\\"ontopof\\\" fact because it's no longer true.\\n self.kb.kb_assert(parse_input(\\\"fact: (top \\\" + disk_on_bottom + \\\" \\\" + prev_peg + \\\")\\\"))\\n self.kb.kb_remove(parse_input(\\\"fact: (onTopOf \\\" + moved_disk + \\\" \\\" + disk_on_bottom + \\\")\\\"))\\n else:\\n self.kb.kb_assert(parse_input(\\\"fact: (empty \\\" + prev_peg + \\\")\\\"))\\n\\n\\n\\n # DISK WE'RE MOVING TO: DEALING WITH TOP, EMPTY, and ONTOPOF.\\n # Add new on statement\\n # if empty, then remove empty statement. if not, add new ontopof statement and remove old top statement.\\n # Add new top statement\\n\\n # STEP 1\\n self.kb.kb_assert(new_fact)\\n\\n # STEP 2\\n empty_ask = parse_input(\\\"fact: (empty \\\" + new_peg + \\\")\\\")\\n top_ask = parse_input(\\\"fact: (top ?X \\\" + new_peg + \\\")\\\")\\n if self.kb.kb_ask(empty_ask):\\n self.kb.kb_retract(empty_ask)\\n else:\\n top_disk = self.kb.kb_ask(top_ask).list_of_bindings[0][0].bindings[0].constant.element\\n oldTopFact = parse_input(\\\"fact: (top \\\" + top_disk + \\\" \\\" + new_peg + \\\")\\\")\\n ontopof_fact = parse_input(\\\"fact: (onTopOf \\\" + moved_disk + \\\" \\\" + top_disk + \\\")\\\")\\n\\n self.kb.kb_retract(oldTopFact)\\n self.kb.kb_add(ontopof_fact)\\n\\n newTopFact = parse_input(\\\"fact: (top \\\" + moved_disk + \\\" \\\" + new_peg + \\\")\\\")\\n self.kb.kb_add(newTopFact)\\n\\n # if self.kb.kb_ask(top_ask):\\n # self.kb.kb_retract(parse_input(\\n # \\\"fact: (top \\\" + self.kb.kb_ask(top_ask)[0].bindings[0].constant.element + \\\" \\\" + movable_statement.terms[\\n # 1].term.element + \\\")\\\"))\\n\\n\\n\\n\\n\\n\\n # if self.kb.kb_ask(empty_ask):\\n # for binding in self.kb.kb_ask(empty_ask):\\n # empty_peg = binding.bindings[0].constant.element\\n # remove_empty = parse_input(\\\"fact: (empty \\\" + empty_peg + \\\")\\\")\\n # if self.kb.kb_ask(parse_input(\\\"fact: (on ?X \\\" + empty_peg + \\\")\\\")):\\n # print(\\\"removing: \\\", remove_empty)\\n # self.kb.kb_retract(remove_empty)\\n # # print(\\\"retracting: (empty \\\" + empty_peg + \\\")\\\")\\n\\n\\n\\n # DISK WE'RE MOVING FROM: DEALING WITH TOP AND EMPTY.\\n # First, we retract the previous top statement.\\n # then, we must check: if the disk is now empty, we must say it's empty.\\n # if it's not, we must now add the new top statement.\\n\\n\\n\\n\\n # empty check\\n\\n #\\n # for top_statement in self.kb.kb_ask(parse_input(\\\"fact: (top ?X ?A)\\\")):\\n # print(top_statement)\",\n \"def move(self):\\n if VERBOSE:\\n print('-- move', self.move_number, '--')\\n self.display_cups()\\n\\n picked_up = self.pick_up_cups(3)\\n self.update_destination_cup()\\n\\n if VERBOSE:\\n print('pick up: ', end='')\\n for pick in picked_up:\\n print(pick, end=' ')\\n print()\\n print('destination:', self.destination)\\n print()\\n\\n self.insert_cups(inserts=picked_up, insert_after=self.destination)\\n self.select_new_current_cup()\\n\\n self.move_number += 1\",\n \"def move_turtle(self):\\n self.forward(self.move_speed)\",\n \"def step(self, actions):\\n if len(actions) != len(self._seats):\\n raise error.Error('actions must be same shape as number of seats.')\\n\\n if self._current_player is None:\\n raise error.Error('Round cannot be played without 2 or more players.')\\n\\n if self._round == 4:\\n raise error.Error('Rounds already finished, needs to be reset.')\\n\\n players = [p for p in self._seats if p.playing_hand]\\n if len(players) == 1:\\n raise error.Error('Round cannot be played with one player.')\\n\\n self._last_player = self._current_player\\n self._last_actions = actions\\n\\n if not self._current_player.playedthisround and len([p for p in players if not p.isallin]) >= 1:\\n if self._current_player.isallin:\\n self._current_player = self._next(players, self._current_player)\\n return self._get_current_step_returns(False)\\n\\n move = self._current_player.player_move(\\n self._output_state(self._current_player), actions[self._current_player.player_id])\\n\\n if move[0] == 'call':\\n self._player_bet(self._current_player, self._tocall)\\n if self._debug:\\n print('Player', self._current_player.player_id, move)\\n self._current_player = self._next(players, self._current_player)\\n elif move[0] == 'check':\\n self._player_bet(self._current_player, self._current_player.currentbet)\\n if self._debug:\\n print('Player', self._current_player.player_id, move)\\n self._current_player = self._next(players, self._current_player)\\n elif move[0] == 'raise':\\n self._player_bet(self._current_player, move[1]+self._current_player.currentbet)\\n if self._debug:\\n print('Player', self._current_player.player_id, move)\\n for p in players:\\n if p != self._current_player:\\n p.playedthisround = False\\n self._current_player = self._next(players, self._current_player)\\n elif move[0] == 'fold':\\n self._current_player.playing_hand = False\\n folded_player = self._current_player\\n if self._debug:\\n print('Player', self._current_player.player_id, move)\\n self._current_player = self._next(players, self._current_player)\\n players.remove(folded_player)\\n self._folded_players.append(folded_player)\\n # break if a single player left\\n if len(players) == 1:\\n self._resolve(players)\\n if all([player.playedthisround for player in players]):\\n self._resolve(players)\\n\\n terminal = False\\n if all([player.isallin for player in players]):\\n while self._round < 4:\\n self._deal_next_round()\\n self._round += 1\\n if self._round == 4 or len(players) == 1:\\n terminal = True\\n self._resolve_round(players)\\n return self._get_current_step_returns(terminal)\",\n \"def iterate():\\n # States are of the form (coordinates, word so far, used spots)\\n # Load the initial states into the stack\\n global theStack\\n for r,layer in enumerate(honeycomb):\\n for e,el in enumerate(layer):\\n theStack.append( ((e,r), [el],set([(e,r)])) )\\n \\n while (len(theStack) != 0):\\n #pop the next run\\n (e,r),soFar,used=theStack[-1]\\n theStack=theStack[:-1]\\n #run it!\\n step((e,r),soFar,used)\",\n \"def stopMovementAll(self):\\n self.stopMovementX()\\n self.stopMovementY()\\n self.stopMovementZ()\",\n \"def play_one_move(self):\\n self.print(\\\"top of move\\\")\\n # 1) grab three cups\\n c1 = self.take_cup_after(self.current_cup_idx())\\n c2 = self.take_cup_after(self.current_cup_idx())\\n c3 = self.take_cup_after(self.current_cup_idx())\\n print(f\\\"pick up: {c1}, {c2}, {c3}\\\")\\n self.print(\\\"after pickup\\\")\\n\\n # 2) find a destination cup\\n destination_idx = self.find_next_destination(self.current_cup)\\n print(\\n f\\\"destination index is {destination_idx}, cup is {self.cups[destination_idx]}\\\"\\n )\\n\\n # 3) insert cups back into the circle\\n self.add_cups(destination_idx, [c1, c2, c3])\\n self.print(\\\"after adding cups..\\\")\\n\\n # 4) select the next cup\\n self.select_next_cup()\\n\\n self.print(\\\"post move\\\")\",\n \"def makeMove(self, movable_statement):\\n ### Student code goes here\\n # ToGO:\\n # if not(self.isMovableLegal(movable_statement)):\\n # pass\\n currDisk = movable_statement.terms[0]\\n prevPeg = movable_statement.terms[1]\\n newPeg = movable_statement.terms[2]\\n\\n # On next peg\\n newOnStatement = Statement()\\n newOnStatement.predicate = 'on'\\n newOnStatement.terms = [currDisk, newPeg]\\n newOnFact = Fact(newOnStatement)\\n self.kb.kb_assert(newOnFact) #1\\n\\n #Not on previous peg\\n removeOnStatement = Statement()\\n removeOnStatement.predicate = 'on'\\n removeOnStatement.terms = [currDisk, prevPeg]\\n removeOnFact = Fact(removeOnStatement)\\n self.kb.kb_retract(removeOnFact) #2\\n\\n\\n #If Prev Empty Logic\\n ONStatement = Statement()\\n ONTerm1 = Term('?x')\\n ONTerm2 = Term(prevPeg)\\n ONStatement.terms = (ONTerm1, ONTerm2)\\n ONStatement.predicate = 'on'\\n ONFact = Fact(ONStatement)\\n if not(self.kb.kb_ask(ONFact)):\\n prevEmptyStatement = Statement()\\n prevEmptyStatement.terms = [prevPeg]\\n prevEmptyStatement.predicate = 'empty'\\n prevEmptyFact = Fact(prevEmptyStatement)\\n self.kb.kb_assert(prevEmptyFact) #3\\n else:\\n # previous disk now on top\\n # AND\\n # Not above previous disk\\n abovePrevStatement = Statement()\\n aboveTerm = Term('?x')\\n abovePrevStatement.terms = [currDisk, aboveTerm]\\n abovePrevStatement.predicate = 'Above'\\n for fact in self.kb.facts:\\n if match(fact.statement, abovePrevStatement):\\n prevDisk = fact.statement.terms[1]\\n self.kb.kb_retract(fact) #7\\n break\\n prevonTopStatement = Statement()\\n prevonTopStatement.predicate = 'onTop'\\n prevonTopStatement.terms = [prevDisk, prevPeg]\\n prevonTopFact = Fact(prevonTopStatement)\\n self.kb.kb_assert(prevonTopFact) #8\\n\\n # Above next disk\\n # If next not empty\\n nextEmptyBool = False\\n nextEmptyStatement = Statement()\\n nextEmptyStatement.terms = [newPeg]\\n nextEmptyStatement.predicate = 'empty'\\n for fact in self.kb.facts:\\n if match(fact.statement, nextEmptyStatement):\\n nextEmptyBool = True\\n self.kb.kb_retract(fact) #9\\n break\\n\\n if nextEmptyBool == False:\\n nextOnTopStatement = Statement()\\n nextOnTopStatement.predicate = 'onTop'\\n onTopTerm1 = Term('?x')\\n nextOnTopStatement.terms = [onTopTerm1, newPeg]\\n nextOnTopFact = Fact(nextOnTopStatement)\\n for fact in self.kb.facts:\\n if match(fact.statement, nextOnTopStatement):\\n nextOnTop = fact.statement.terms[0]\\n aboveNextStatement = Statement()\\n aboveNextStatement.predicate = 'Above'\\n aboveNextStatement.terms = [currDisk, nextOnTop]\\n aboveNextFact = Fact(aboveNextStatement)\\n self.kb.kb_assert(aboveNextFact) #6\\n self.kb.kb_retract(nextOnTopFact)\\n break\\n\\n\\n\\n #On top of new peg\\n newonTopStatement = Statement()\\n newonTopStatement.predicate = 'onTop'\\n newonTopStatement.terms = [currDisk, newPeg]\\n newonTopFact = Fact(newonTopStatement)\\n self.kb.kb_assert(newonTopFact) #4\\n\\n #Not on top of previous peg\\n removeonTopStatement = Statement()\\n removeonTopStatement.predicate = 'onTop'\\n removeonTopStatement.terms = [currDisk, prevPeg]\\n removeonTopFact = Fact(removeonTopStatement)\\n self.kb.kb_retract(removeonTopFact) #5\\n\\n\\n\\n\\n\\n #Destination not empty\",\n \"def solveOneStep(self):\\n ### Student code goes here\\n # Mark this move as explored\\n self.visited[self.currentState] = True\\n\\n # Get move to make\\n movables = self.gm.getMovables()\\n # print(\\\"EXPLORING GAME STATE \\\" + str(self.gm.getGameState()) + \\\"---------------------------------------------------------\\\")\\n to_move = self.currentState.nextChildToVisit # movables index\\n # print(\\\"depth \\\", self.currentState.depth)\\n\\n # Return if done\\n if self.currentState.state == self.victoryCondition:\\n # print(\\\"DONE\\\")\\n return True\\n\\n while to_move < len(movables):\\n # Make the move\\n movable_statement = movables[to_move]\\n # print(\\\"implementing move \\\", movable_statement)\\n self.gm.makeMove(movable_statement)\\n\\n # Create a new state with this move made\\n new_state = self.gm.getGameState()\\n\\n # Find out if this state has already been explored\\n visited = False\\n for visited_state in self.visited.keys():\\n if visited_state.state == new_state:\\n visited = True\\n\\n # If the new state hasn't been visited then add it as a child then move down to this child\\n if not visited:\\n new_gs = GameState(new_state, self.currentState.depth + 1, movable_statement)\\n new_gs.parent = self.currentState\\n self.currentState.children.append(new_gs)\\n self.currentState.nextChildToVisit = to_move + 1\\n self.currentState = new_gs\\n break\\n\\n # Else skip this state and try going to the next movable statement\\n else:\\n # print(\\\"SKIP THIS STATE\\\")\\n self.gm.reverseMove(movable_statement)\\n to_move += 1\\n\\n # Went all the way down to a leaf, backtrack\\n if (to_move >= len(movables)):\\n self.gm.reverseMove(self.currentState.requiredMovable)\\n self.currentState = self.currentState.parent\\n\\n return False\",\n \"def step(self):\\n self.emit_symbol()\\n self.change_state()\",\n \"def __iter__(self):\\n for node in self.grammar.walk():\\n yield node\",\n \"def behavior_loop(self, goal, rc_cb, terminate_cb):\\n rc_out = rc_cb(self, goal)\\n is_term = terminate_cb(self, goal)\\n\\n while not is_term:\\n # timeout termination behvior\\n if self._as.is_preempt_requested():\\n self.rc_off()\\n rospy.loginfo('Timeout preempted')\\n self._as.set_preempted()\\n break\\n\\n controlout = OverrideRCIn(channels=rc_out)\\n self.contolp.publish(controlout)\\n\\n # send command feedback\\n self.send_feedback(goal)\\n self.rate.sleep()\\n\\n # set up next loop\\n is_term = terminate_cb(self, goal)\\n rc_out = rc_cb(self, goal)\\n\\n # publish a result message when finished\\n if is_term:\\n self.rc_off()\\n result = MoveRobotResult(actionID=goal.actionID,\\n end_heading=self.curr_heading,\\n end_depth=self.curr_depth)\\n self._as.set_succeeded(result=result)\",\n \"def loop2(self, move, new_state, i):\\n if move == i[0]:\\n # analyze the other 2 cells\\n if (new_state.get_current_player_name()[1]\\n == new_state.letters[i[1]]\\n or new_state.get_current_player_name()[1]\\n == new_state.letters[i[2]]) \\\\\\n and new_state.claim[i[3]] == \\\"@\\\":\\n new_state.claim[i[3]] \\\\\\n = new_state.get_current_player_name()[1]\\n\\n # analyze the other 4 cells\\n count = 0\\n for x in [new_state.letters[i[4]],\\n new_state.letters[i[5]],\\n new_state.letters[i[6]],\\n new_state.letters[i[7]]]:\\n if new_state.get_current_player_name()[1] == x:\\n count += 1\\n if count == 2 and new_state.claim[i[8]] == \\\"@\\\":\\n new_state.claim[i[8]] = \\\\\\n new_state.get_current_player_name()[1]\\n\\n # analyze the other 4 cells\\n count = 0\\n for x in [new_state.letters[i[9]],\\n new_state.letters[i[10]],\\n new_state.letters[i[11]],\\n new_state.letters[i[12]]]:\\n if new_state.get_current_player_name()[1] == x:\\n count += 1\\n if count == 2 and new_state.claim[i[13]] == \\\"@\\\":\\n new_state.claim[i[13]] = \\\\\\n new_state.get_current_player_name()[1]\\n new_state.letters = [self.get_current_player_name()[1]\\n if i == move else i for i in self.letters]\\n return new_state\",\n \"def main():\\n move()\\n move()\\n pick_beeper()\\n move()\\n turn_left()\\n for i in range(2):\\n move()\\n put_beeper()\\n turn_around()\\n move_to_wall()\\n turn_right()\\n move_to_wall()\\n turn_around()\",\n \"def unmakeMove(self, move):\",\n \"def move(self, direction, step):\\n for i in range(1, step + 1):\\n y, x = self.robot_position\\n if direction == \\\"N\\\" and y > 0:\\n if self.carte[y - 1][x] in [\\\" \\\", \\\".\\\", \\\"U\\\"]:\\n self.robot_position = (y - 1, x)\\n elif direction == \\\"S\\\" and y <= self.height:\\n if self.carte[y + 1][x] in [\\\" \\\", \\\".\\\", \\\"U\\\"]:\\n self.robot_position = (y + 1, x)\\n elif direction == \\\"E\\\" and x <= self.width+1:\\n if self.carte[y][x + 1] in [\\\" \\\", \\\".\\\", \\\"U\\\"]:\\n self.robot_position = (y, x + 1)\\n elif direction == \\\"O\\\" and x > 0:\\n if self.carte[y][x - 1] in [\\\" \\\", \\\".\\\", \\\"U\\\"]:\\n self.robot_position = (y, x - 1)\\n\\n if self.robot_position == self.out_position:\\n print(\\\"Bravo vous avez fini\\\")\\n return True\\n\\n return False\",\n \"def handle_unmake(self, move):\\n# print \\\"board:handle_make pgn = \\\" + move.pgn\\n if not move: return\\n # remove en passant capture\\n if move.is_en_passant():\\n self.put(move.dst + (8 if move.is_white() else -8), \\\\\\n 'p' if move.is_white() else 'P')\\n\\n # move rook when castling\\n if move.is_castling_short():\\n if move.is_white():\\n self.move((61,63))\\n else:\\n self.move((5,7))\\n if move.is_castling_long():\\n if move.is_white():\\n self.move((59, 56))\\n else:\\n self.move((3, 0))\\n\\n # now move itself\\n self.move((move.dst, move.src))\\n \\n # recover capture\\n if move.is_capture():\\n p = move.get_captured_piece()\\n if move.is_white(): p = p.lower()\\n self.put(move.dst, p)\\n\\n # Recover promoted piece\\n if move.is_promotion():\\n self.remove(move.src)\\n self.put(move.src, 'P' if move.is_white() else 'p')\\n self.update_vars_list()\",\n \"def step(self):\\n self.time_alive += 1\\n self.fsm.update(self)\\n\\n for state in self.states:\\n if not self.pos:\\n continue\\n\\n state.on_update(self)\",\n \"def handleMove(self):\\n pass\",\n \"def get_nonterminals(self):\\n for node in self.hosttree.traverse():\\n if not node.is_leaf():\\n yield node\",\n \"def move(self):\\n raise NotImplementedError\",\n \"def loop52(self, move, new_state, i):\\n if move == i[0]:\\n # analyze the other 2 cells\\n if (new_state.get_current_player_name()[1]\\n == new_state.letters[i[1]]\\n or new_state.get_current_player_name()[1]\\n == new_state.letters[i[2]]) \\\\\\n and new_state.claim[i[3]] == \\\"@\\\":\\n new_state.claim[i[3]] \\\\\\n = new_state.get_current_player_name()[1]\\n\\n # analyze the other 4 cells\\n count = 0\\n for x in [new_state.letters[i[4]],\\n new_state.letters[i[5]],\\n new_state.letters[i[6]],\\n new_state.letters[i[7]]]:\\n if new_state.get_current_player_name()[1] == x:\\n count += 1\\n if count == 2 and new_state.claim[i[8]] == \\\"@\\\":\\n new_state.claim[i[8]] = \\\\\\n new_state.get_current_player_name()[1]\\n\\n # analyze the other 4 cells\\n count = 0\\n for x in [new_state.letters[i[9]],\\n new_state.letters[i[10]],\\n new_state.letters[i[11]],\\n new_state.letters[i[12]]]:\\n if new_state.get_current_player_name()[1] == x:\\n count += 1\\n if count == 2 and new_state.claim[i[13]] == \\\"@\\\":\\n new_state.claim[i[13]] = \\\\\\n new_state.get_current_player_name()[1]\\n new_state.letters = [self.get_current_player_name()[1]\\n if i == move else i for i in self.letters]\\n return new_state\",\n \"def solveOneStep(self):\\n ### Student code goes here\\n # Mark this move as explored\\n self.visited[self.currentState] = True\\n self.visited_states.append(self.currentState.state)\\n\\n # Get move to make\\n movables = self.gm.getMovables()\\n # print(\\\"EXPLORING GAME STATE \\\" + str(self.gm.getGameState()) + \\\"---------------------------------------------------------\\\")\\n to_move = self.currentState.nextChildToVisit # movables index\\n # print(\\\"depth \\\", self.currentState.depth)\\n\\n # Return if done\\n if self.currentState.state == self.victoryCondition:\\n # print(\\\"DONE\\\")\\n return True\\n\\n # If current state has no children, make children\\n if not self.currentState.children:\\n for movable_statement in movables:\\n # Make the move\\n # print(\\\"implementing move \\\", movable_statement)\\n self.gm.makeMove(movable_statement)\\n\\n # Create a new state with this move made\\n new_state = self.gm.getGameState()\\n # print (\\\"new state \\\", new_state)\\n\\n # If the new state hasn't been visited and isn't in the queue then add it as a child and to the queue\\n if (new_state not in self.visited_states):\\n new_gs = GameState(new_state, self.currentState.depth + 1, movable_statement)\\n new_gs.parent = self.currentState\\n self.currentState.children.append(new_gs)\\n self.currentState.nextChildToVisit = to_move + 1\\n self.visited[new_gs] = True\\n self.visited_states.append(new_state)\\n self.gs_queue.append(new_gs)\\n\\n self.gm.reverseMove(movable_statement)\\n\\n # Return false if no more to explore\\n if not self.gs_queue:\\n return False\\n\\n # Revert to state at when current and next start to change\\n root_curr = self.currentState\\n self.currentState = self.gs_queue.popleft()\\n root_new = self.currentState\\n\\n # Backtrack to when current node and new node start to diverge\\n if root_new.depth == root_curr.depth:\\n while root_curr.state != root_new.state:\\n self.gm.reverseMove(root_curr.requiredMovable)\\n root_curr = root_curr.parent\\n root_new = root_new.parent\\n else:\\n while root_curr.requiredMovable:\\n self.gm.reverseMove(root_curr.requiredMovable)\\n root_curr = root_curr.parent\\n\\n # Return game master to state that we are exploring\\n # Find path between root and current state\\n path = []\\n currNode = self.currentState\\n while currNode != root_curr:\\n path.append(currNode.requiredMovable)\\n currNode = currNode.parent\\n\\n # Created backwards path, now make moves from root to current state\\n path.reverse()\\n for movable_statement in path:\\n self.gm.makeMove(movable_statement)\\n\\n return False\",\n \"def makeMove(self, movable_statement):\\n ### Student code goes here\\n disk = movable_statement.terms[0].term.element\\n initial = movable_statement.terms[1].term.element\\n goal = movable_statement.terms[2].term.element\\n #### Add the disk to the new stack and remove the facts of it being on the old one\\n r1 = parse_input(\\\"fact: (on \\\" + disk + \\\" \\\" + initial + \\\")\\\")\\n self.kb.kb_retract(r1)\\n r2 = parse_input(\\\"fact: (isTopofStack \\\" + disk + \\\" \\\" + initial + \\\")\\\")\\n self.kb.kb_retract(r2)\\n stat1 = parse_input(\\\"fact: (on \\\" + disk + \\\" \\\" + goal + \\\")\\\")\\n self.kb.kb_assert(stat1)\\n stat2 = parse_input(\\\"fact: (isTopofStack \\\" + disk + \\\" \\\" + goal + \\\")\\\")\\n self.kb.kb_assert(stat2)\\n\\n ## Determine if any disks are on the initial peg\\n ask1 = parse_input(\\\"fact: (on ?X \\\" + initial + \\\")\\\")\\n answer = self.kb.kb_ask(ask1)\\n if answer == False: #If no disks are on the initial peg\\n empty_stat = parse_input(\\\"fact: (isempty \\\" + initial + \\\")\\\")\\n self.kb.kb_assert(empty_stat)\\n else:\\n disks_on_initial = []\\n for ans in answer.list_of_bindings:\\n disks_on_initial.append(int(ans[0].bindings[0].constant.element.split('disk',1)[1]))\\n ask_top = parse_input(\\\"fact: (isTopofStack ?X \\\" + initial + \\\")\\\")\\n top_ans = self.kb.kb_ask(ask_top)\\n disks_on_initial.sort()\\n if top_ans:\\n for ans in top_ans.list_of_bindings:\\n if int(ans[0].bindings[0].constant.element.split('disk',1)[1]) != disks_on_initial[0]:\\n retract = parse_input(\\\"fact: (isTopofStack \\\" + ans[0].bindings[0].constant.element + \\\" \\\" + initial + \\\")\\\")\\n self.kb.kb_retract(retract)\\n assert1 = parse_input(\\\"fact: (isTopofStack disk\\\" + str(disks_on_initial[0]) + \\\" \\\" + initial + \\\")\\\")\\n self.kb.kb_assert(assert1)\\n\\n goal_ask = parse_input(\\\"fact: (on ?X \\\" + goal + \\\")\\\")\\n goal_answer = self.kb.kb_ask(goal_ask)\\n disks_on_goal = []\\n for ans in goal_answer.list_of_bindings:\\n disks_on_goal.append(int(ans[0].bindings[0].constant.element.split('disk',1)[1]))\\n ask_topg = parse_input(\\\"fact: (isTopofStack ?X \\\" + goal + \\\")\\\")\\n top_ansg = self.kb.kb_ask(ask_topg)\\n disks_on_goal.sort()\\n if top_ansg:\\n for ans in top_ansg.list_of_bindings:\\n if int(ans[0].bindings[0].constant.element.split('disk',1)[1]) != disks_on_goal[0]:\\n retract = parse_input(\\\"fact: (isTopofStack \\\" + ans[0].bindings[0].constant.element + \\\" \\\" + goal + \\\")\\\")\\n self.kb.kb_retract(retract)\\n\\n ask2 = parse_input(\\\"fact: (isempty \\\" + goal + \\\")\\\")\\n answer2 = self.kb.kb_ask(ask2)\\n if answer2:\\n self.kb.kb_retract(ask2)\",\n \"def onStopMovingNorthCommand(self, *args):\\n if self.going_north:\\n self.going_north = 0\\n self.moveEntity()\",\n \"def exec_all_moves(self,level=0):\\n\\n capts = [self.op_capture_north, self.op_capture_nwest, self.op_capture_neast, self.op_capture_east, self.op_capture_west]\\n jmps = [self.op_jump_north, self.op_jump_nwest, self.op_jump_neast]\\n moves = [self.op_move_north,self.op_move_nwest, self.op_move_neast]\\n result = []\\n ops = []\\n\\n # Pre-select all operations that may be executed\\n if self.next_move == self.FREE:\\n capturingStarts, otherStarts = self.possible_capture()\\n\\n # Check for pieces that may capture\\n if len(capturingStarts) > 0:\\n self.next_move = self.CAPT\\n self.next_pieces = capturingStarts\\n else:\\n self.next_move = self.FREE\\n jmps.extend(moves)\\n ops = jmps\\n self.next_pieces = otherStarts\\n\\n elif self.next_move == self.CAPT:\\n ops = capts\\n elif self.next_move == self.JUMP:\\n ops = jmps\\n elif self.next_move == self.FREE:\\n jmps.extend(moves)\\n ops = jmps\\n elif self.next_move == self.ADDPIECE_2:\\n return self.op_add_piece_bot(self.next_pieces)\\n\\n # Execute possible operations for all viable pieces\\n for pos in self.next_pieces:\\n for op in ops:\\n newState = op(pos)\\n\\n # Check if op succeeded\\n if newState:\\n\\n # If the next player is the current player than the function is called recursevely, this is done so that outcomes account for successive plays by the same\\n # player ( successive jumps and captures or piece addition)\\n if newState.curr_player != self.curr_player:\\n result.append(newState)\\n else:\\n result.extend(newState.exec_all_moves(level+1))\\n\\n\\n return result\",\n \"def makeMove(self, movable_statement):\\n ### Student code goes here\\n\\n if type(movable_statement) != Statement or not self.kb.kb_ask(Fact(movable_statement, [])):\\n return None\\n\\n statement1_list = [\\\"located\\\"]\\n statement2_list = [\\\"located\\\"]\\n\\n statement1_list.append(movable_statement.terms[0])\\n statement1_list.append(movable_statement.terms[1])\\n statement1_list.append(movable_statement.terms[2])\\n\\n statement2_list.append(movable_statement.terms[0])\\n statement2_list.append(movable_statement.terms[3])\\n statement2_list.append(movable_statement.terms[4])\\n\\n curr_fact1 = Fact(Statement(statement1_list), [])\\n new_fact1 = Fact(Statement(statement2_list), [])\\n\\n curr_empty = parse_input(\\\"fact: (located empty \\\" + statement2_list[2].term.element + \\\" \\\" + statement2_list[3].term.element + \\\")\\\")\\n statement3_list = statement1_list\\n statement3_list[1] = \\\"empty\\\"\\n new_empty = Fact(Statement(statement3_list), [])\\n\\n self.kb.kb_retract(curr_fact1)\\n self.kb.kb_assert(new_fact1)\\n self.kb.kb_retract(curr_empty)\\n self.kb.kb_assert(new_empty)\",\n \"def play_move(self,state):\\n raise AIError(\\\"Must be implemented for child class!\\\")\",\n \"def loop(self):\\r\\n\\r\\n self._next_state = self._current_state\",\n \"def tick(self):\\n if self._solution == \\\"\\\":\\n self._root.after(300, self.tick)\\n return\\n direction = self._solution[0]\\n self._solution = self._solution[1:]\\n try:\\n self._puzzle.update_puzzle(direction)\\n except:\\n print \\\"invalid move:\\\", direction\\n self.draw()\\n self._root.after(300, self.tick)\",\n \"def loop3(self, move, new_state, i):\\n if move == i[0]:\\n # analyze the other 3 cells\\n if (new_state.get_current_player_name()[1]\\n == new_state.letters[i[1]]\\n or new_state.get_current_player_name()[1]\\n == new_state.letters[i[2]]\\n or new_state.get_current_player_name()[1]\\n == new_state.letters[i[3]]) \\\\\\n and new_state.claim[i[4]] == \\\"@\\\":\\n new_state.claim[i[4]] \\\\\\n = new_state.get_current_player_name()[1]\\n\\n # analyze the other 3 cells\\n if (new_state.get_current_player_name()[1]\\n == new_state.letters[i[5]]\\n or new_state.get_current_player_name()[1]\\n == new_state.letters[i[6]]\\n or new_state.get_current_player_name()[1]\\n == new_state.letters[i[7]]) \\\\\\n and new_state.claim[i[8]] == \\\"@\\\":\\n new_state.claim[i[8]] \\\\\\n = new_state.get_current_player_name()[1]\\n\\n # analyze the other 4 cells\\n count = 0\\n for x in [new_state.letters[i[9]],\\n new_state.letters[i[10]],\\n new_state.letters[i[11]],\\n new_state.letters[i[12]]]:\\n if new_state.get_current_player_name()[1] == x:\\n count += 1\\n if count == 2 and new_state.claim[i[13]] == \\\"@\\\":\\n new_state.claim[i[13]] = \\\\\\n new_state.get_current_player_name()[1]\\n\\n new_state.letters = [self.get_current_player_name()[1]\\n if i == move else i for i in self.letters]\\n return new_state\",\n \"def remove(self, *nonterminals):\\n # type: (Iterable[Type[Nonterminal]]) -> None\\n for nonterm in set(nonterminals):\\n _NonterminalSet._control_nonterminal(nonterm)\\n if nonterm not in self:\\n raise KeyError('Nonterminal ' + nonterm.__name__ + ' is not inside')\\n self._grammar.rules.remove(*self._assign_map[nonterm], _validate=False)\\n del self._assign_map[nonterm]\\n if self._grammar.start is nonterm:\\n del self._grammar.start\\n super().remove(nonterm)\",\n \"def loop1(self, move, new_state, i):\\n if move == i[0]:\\n # analyze another cell\\n if new_state.letters[i[1]].isalpha():\\n new_state.claim[i[2]] \\\\\\n = new_state.get_current_player_name()[1]\\n # analyze the other 3 cells\\n if (new_state.get_current_player_name()[1]\\n == new_state.letters[i[3]]\\n or new_state.get_current_player_name()[1]\\n == new_state.letters[i[4]]\\n or new_state.get_current_player_name()[1]\\n == new_state.letters[i[5]]) \\\\\\n and new_state.claim[i[6]] == \\\"@\\\":\\n new_state.claim[i[6]] \\\\\\n = new_state.get_current_player_name()[1]\\n # analyze the other 4 cells\\n count = 0\\n for x in [new_state.letters[i[7]],\\n new_state.letters[i[8]],\\n new_state.letters[i[9]],\\n new_state.letters[i[10]]]:\\n if new_state.get_current_player_name()[1] == x:\\n count += 1\\n if count == 2 and new_state.claim[i[11]] == \\\"@\\\":\\n new_state.claim[i[11]] = \\\\\\n new_state.get_current_player_name()[1]\\n new_state.letters = [self.get_current_player_name()[1]\\n if i == move else i for i in self.letters]\\n return new_state\",\n \"def move(self):\\n\\n # get the location we WOULD go to\\n newX = self.xcor() + self.dx\\n newY = self.ycor() + self.dy\\n while (abs (newX) > self.BOX_RANGE) or (abs(newY) > self.BOX_RANGE):\\n # print(\\\"choosing new direction... \\\",end=\\\"\\\")\\n self.chooseNewDirection()\\n # print(self.dx, self.dy)\\n newX = self.xcor() + self.dx\\n newY = self.ycor() + self.dy\\n\\n # now move our monster\\n super().move()\",\n \"def stop(self):\\n self.move(None)\",\n \"def enumerate_moves(self):\\n add_ew = lambda x: [x+'e', x+'w']\\n allowed_catches = add_ew(self._directions[0])\\n moves = []\\n # First add the one/two step forward moves\\n new_slot = self._board.get_dir(self._current_space, self._directions[0])\\n if new_slot and new_slot.is_free():\\n moves.append(ChessMove(self._current_space, new_slot))\\n if (self._side == BLACK and new_slot.row == self._board.size - 1) or \\\\\\n (self._side == WHITE and new_slot.row == 0):\\n moves[-1].add_promotion()\\n if (self._side == BLACK and self._current_space.row == 1) or \\\\\\n (self._side == WHITE and self._current_space.row == self._board.size -2):\\n new_slot = self._board.get_dir(new_slot, self._directions[0])\\n if new_slot and new_slot.is_free():\\n moves.append(ChessMove(self._current_space, new_slot))\\n\\n # Now add all the captures.\\n for direction in allowed_catches:\\n new_slot = self._board.get_dir(self._current_space, direction)\\n if new_slot and new_slot.has_opponent(self._side):\\n moves.append(ChessMove(self._current_space, new_slot, [new_slot]))\\n if (self._side == BLACK and new_slot.row == self._board.size - 1) or \\\\\\n (self._side == WHITE and new_slot.row == 0):\\n moves[-1].add_promotion()\\n return moves\",\n \"def loop54(self, move, new_state, i):\\n if move == i[0]:\\n # analyze the other 2 cells\\n if (new_state.get_current_player_name()[1]\\n == new_state.letters[i[1]]\\n or new_state.get_current_player_name()[1]\\n == new_state.letters[i[2]]) \\\\\\n and new_state.claim[i[3]] == \\\"@\\\":\\n new_state.claim[i[3]] \\\\\\n = new_state.get_current_player_name()[1]\\n\\n # analyze the other 5 cells\\n count = 0\\n for x in [new_state.letters[i[4]],\\n new_state.letters[i[5]],\\n new_state.letters[i[6]],\\n new_state.letters[i[7]],\\n new_state.letters[i[8]]]:\\n if new_state.get_current_player_name()[1] == x:\\n count += 1\\n if count == 2 and new_state.claim[i[9]] == \\\"@\\\":\\n new_state.claim[i[9]] = \\\\\\n new_state.get_current_player_name()[1]\\n\\n # analyze the other 5 cells\\n count = 0\\n for x in [new_state.letters[i[10]],\\n new_state.letters[i[11]],\\n new_state.letters[i[12]],\\n new_state.letters[i[13]],\\n new_state.letters[i[14]]]:\\n if new_state.get_current_player_name()[1] == x:\\n count += 1\\n if count == 2 and new_state.claim[i[15]] == \\\"@\\\":\\n new_state.claim[i[15]] = \\\\\\n new_state.get_current_player_name()[1]\\n new_state.letters = [self.get_current_player_name()[1]\\n if i == move else i for i in self.letters]\\n return new_state\",\n \"def move(): #py:move\\n RUR._move_()\",\n \"def goto_end(self):\\n\\n self.__do_action(self.motor.moveto_edge(MotorDriver.RIGHT))\",\n \"def loops_back_to_screen(self):\\r\\n for segment in self.all_turtles:\\r\\n if segment.xcor() < -300 or segment.xcor() > 300:\\r\\n segment.goto(-segment.xcor(), segment.ycor())\\r\\n\\r\\n elif segment.ycor() < -300 or segment.ycor() > 300:\\r\\n segment.goto(segment.xcor(), -segment.ycor())\",\n \"def loop53(self, move, new_state, i):\\n if move == i[0]:\\n # analyze the other 3 cells\\n if (new_state.get_current_player_name()[1]\\n == new_state.letters[i[1]]\\n or new_state.get_current_player_name()[1]\\n == new_state.letters[i[2]]\\n or new_state.get_current_player_name()[1]\\n == new_state.letters[i[3]]) \\\\\\n and new_state.claim[i[4]] == \\\"@\\\":\\n new_state.claim[i[4]] \\\\\\n = new_state.get_current_player_name()[1]\\n\\n # analyze the other 3 cells\\n if (new_state.get_current_player_name()[1]\\n == new_state.letters[i[5]]\\n or new_state.get_current_player_name()[1]\\n == new_state.letters[i[6]]\\n or new_state.get_current_player_name()[1]\\n == new_state.letters[i[7]]) \\\\\\n and new_state.claim[i[8]] == \\\"@\\\":\\n new_state.claim[i[8]] \\\\\\n = new_state.get_current_player_name()[1]\\n\\n # analyze the other 4 cells\\n count = 0\\n for x in [new_state.letters[i[9]],\\n new_state.letters[i[10]],\\n new_state.letters[i[11]],\\n new_state.letters[i[12]]]:\\n if new_state.get_current_player_name()[1] == x:\\n count += 1\\n if count == 2 and new_state.claim[i[13]] == \\\"@\\\":\\n new_state.claim[i[13]] = \\\\\\n new_state.get_current_player_name()[1]\\n new_state.letters = [self.get_current_player_name()[1]\\n if i == move else i for i in self.letters]\\n return new_state\",\n \"def move_cycle_gen(self):\\n while True:\\n self.update_grid_pos()\\n path = self.find_shortest_path(\\\"without_metalbox\\\")\\n if not path:\\n path = self.find_shortest_path(\\\"metalbox\\\")\\n yield\\n if not path:\\n continue\\n next_coord = path.pop()\\n next_coord += Vec2d(0.5, 0.5)\\n yield\\n target_angle = \\\\\\n angle_between_vectors(Vec2d(self.tank.body.position), next_coord)\\n angle_tank = self.tank.body.angle\\n self.turn(angle_tank, target_angle)\\n while not self.correct_angle(angle_tank, target_angle):\\n angle_tank = self.tank.body.angle\\n target_angle = \\\\\\n angle_between_vectors(Vec2d(self.tank.body.position),\\n next_coord)\\n yield\\n self.tank.accelerate()\\n while not self.correct_pos(next_coord, self.last_distance):\\n yield\\n yield\",\n \"def _parser_fsm(self):\\n basic = self.basic\\n listener = self.listener\\n draw = listener.draw\\n debug = listener.debug\\n\\n ESC, CSI_C1 = ctrl.ESC, ctrl.CSI_C1\\n OSC_C1 = ctrl.OSC_C1\\n SP_OR_GT = ctrl.SP + \\\">\\\"\\n NUL_OR_DEL = ctrl.NUL + ctrl.DEL\\n CAN_OR_SUB = ctrl.CAN + ctrl.SUB\\n ALLOWED_IN_CSI = \\\"\\\".join([ctrl.BEL, ctrl.BS, ctrl.HT, ctrl.LF,\\n ctrl.VT, ctrl.FF, ctrl.CR])\\n OSC_TERMINATORS = set([ctrl.ST_C0, ctrl.ST_C1, ctrl.BEL, ctrl.CR])\\n\\n def create_dispatcher(mapping):\\n return defaultdict(lambda: debug, dict(\\n (event, getattr(listener, attr))\\n for event, attr in mapping.items()))\\n\\n basic_dispatch = create_dispatcher(basic)\\n sharp_dispatch = create_dispatcher(self.sharp)\\n escape_dispatch = create_dispatcher(self.escape)\\n csi_dispatch = create_dispatcher(self.csi)\\n osc_dispatch = create_dispatcher(self.osc)\\n\\n while True:\\n # it is allowed to send\\n # chunks of plain text directly to the listener, instead\\n # of this generator.\\n char = yield PLAIN_TEXT\\n\\n if char == ESC:\\n # Most non-VT52 commands start with a left-bracket after the\\n # escape and then a stream of parameters and a command; with\\n # a single notable exception -- :data:`escape.DECOM` sequence,\\n # which starts with a sharp.\\n #\\n # .. versionchanged:: 0.4.10\\n #\\n # For compatibility with Linux terminal stream also\\n # recognizes ``ESC % C`` sequences for selecting control\\n # character set. However, in the current version these\\n # are noop.\\n char = yield\\n if char == \\\"[\\\":\\n char = CSI_C1 # Go to CSI.\\n elif char == \\\"]\\\":\\n char = OSC_C1 # Go to OSC.\\n else:\\n if char == \\\"#\\\":\\n sharp_dispatch[(yield)]()\\n if char == \\\"%\\\":\\n self.select_other_charset((yield))\\n elif char in \\\"()\\\":\\n code = yield\\n if self.use_utf8:\\n continue\\n\\n # See http://www.cl.cam.ac.uk/~mgk25/unicode.html#term\\n # for the why on the UTF-8 restriction.\\n listener.define_charset(code, mode=char)\\n else:\\n escape_dispatch[char]()\\n continue # Don't go to CSI.\\n\\n if char in basic:\\n # Ignore shifts in UTF-8 mode. See\\n # http://www.cl.cam.ac.uk/~mgk25/unicode.html#term for\\n # the why on UTF-8 restriction.\\n if (char == ctrl.SI or char == ctrl.SO) and self.use_utf8:\\n continue\\n\\n basic_dispatch[char]()\\n elif char == CSI_C1:\\n # All parameters are unsigned, positive decimal integers, with\\n # the most significant digit sent first. Any parameter greater\\n # than 9999 is set to 9999. If you do not specify a value, a 0\\n # value is assumed.\\n #\\n # .. seealso::\\n #\\n # `VT102 User Guide <http://vt100.net/docs/vt102-ug/>`_\\n # For details on the formatting of escape arguments.\\n #\\n # `VT220 Programmer Ref. <http://vt100.net/docs/vt220-rm/>`_\\n # For details on the characters valid for use as\\n # arguments.\\n params = []\\n current = \\\"\\\"\\n private = False\\n while True:\\n char = yield\\n if char == \\\"?\\\":\\n private = True\\n elif char in ALLOWED_IN_CSI:\\n basic_dispatch[char]()\\n elif char in SP_OR_GT:\\n pass # Secondary DA is not supported atm.\\n elif char in CAN_OR_SUB:\\n # If CAN or SUB is received during a sequence, the\\n # current sequence is aborted; terminal displays\\n # the substitute character, followed by characters\\n # in the sequence received after CAN or SUB.\\n draw(char)\\n break\\n elif char.isdigit():\\n current += char\\n else:\\n params.append(min(int(current or 0), 9999))\\n\\n if char == \\\";\\\":\\n current = \\\"\\\"\\n else:\\n if private:\\n csi_dispatch[char](*params, private=True)\\n else:\\n csi_dispatch[char](*params)\\n break # CSI is finished.\\n elif char == OSC_C1:\\n code = \\\"\\\"\\n while True:\\n char = yield\\n if char in OSC_TERMINATORS or char == \\\";\\\":\\n break\\n code += char\\n\\n if code == \\\"R\\\":\\n continue # Reset palette. Not implemented.\\n elif code == \\\"P\\\":\\n continue # Set palette. Not implemented.\\n\\n param = \\\"\\\"\\n if char == \\\";\\\":\\n while True:\\n block = yield OSC_PARAM\\n if block in OSC_TERMINATORS:\\n break\\n param += block\\n\\n osc_dispatch[code](param)\\n\\n elif char not in NUL_OR_DEL:\\n draw(char)\",\n \"def play_move(self, move_data, all_english_words):\\r\\n \\r\\n #first, make copy of board and try to apply move there.\\r\\n board_cpy = copy.deepcopy(self.myboard)\\r\\n \\r\\n rack_cpy = copy.deepcopy(self.rack) #***need to remove appropriate words from rack after we've made a move. \\r\\n\\r\\n i = 0 \\r\\n for cur_char in move_data[0]:\\r\\n new_tile = Tile(cur_char, self.game_bag.letter_freq_and_val[cur_char][1]) #create a new tile.\\r\\n if move_data[3] == \\\"horizontal\\\":\\r\\n print(\\\"adding cur_char {} at {} {}\\\".format(cur_char, move_data[1], move_data[2]+i))\\r\\n board_cpy.place_tile(move_data[1], move_data[2]+ i, new_tile)\\r\\n elif move_data[3] == \\\"vertical\\\":\\r\\n board_cpy.place_tile(move_data[1] + i, move_data[2], new_tile)\\r\\n\\r\\n i = i + 1\\r\\n #print(\\\"New i value is {}\\\".format(i))\\r\\n board_cpy.print_board()\\r\\n \\r\\n\\r\\n #once we're done placing the tiles, check for validity of entire board.\\r\\n cur_board_words = board_cpy.find_words_on_board()\\r\\n move_valid = True #assume move is valid, until proven otherwise.\\r\\n\\r\\n for word_data in cur_board_words:\\r\\n word = word_data[0]\\r\\n print(word)\\r\\n if word not in all_english_words:\\r\\n return False #do nothing else\\r\\n \\r\\n #print(\\\"Getting here; all words valid\\\")\\r\\n \\r\\n #getting here means that the move is actually valid, with no conflicts.\\r\\n main_board = self.myboard\\r\\n #In this case, add to the real board. \\r\\n i = 0 \\r\\n for cur_char in move_data[0]:\\r\\n new_tile = Tile(cur_char, self.game_bag.letter_freq_and_val[cur_char][1]) #create a new tile.\\r\\n if move_data[3] == \\\"horizontal\\\":\\r\\n main_board.place_tile(move_data[1], move_data[2]+ i, new_tile)\\r\\n elif move_data[3] == \\\"vertical\\\":\\r\\n main_board.place_tile(move_data[1] + i, move_data[2], new_tile)\\r\\n\\r\\n i = i + 1\\r\\n return True\",\n \"def step(self):\\n try:\\n self.agents.sort(key=lambda x: x.dist)\\n except Exception as e:\\n print(e)\\n\\n for agent in self.agents:\\n try:\\n agent.step()\\n except Exception as e:\\n print(e)\\n\\n\\n # Removes agents if they reach exit\\n for exit in self.model.exits:\\n x, y = exit.pos[0] * 6 + 1, exit.pos[1] * 6 + 1\\n if agent.node == (x, y):\\n try:\\n agent.saved()\\n except Exception as e:\\n print(e)\",\n \"def demo():\\n\\n from nltk import parse, CFG\\n\\n grammar = CFG.fromstring(\\\"\\\"\\\"\\n S -> NP VP\\n NP -> Det N | Det N PP\\n VP -> V NP | V NP PP\\n PP -> P NP\\n NP -> 'I'\\n N -> 'man' | 'park' | 'telescope' | 'dog'\\n Det -> 'the' | 'a'\\n P -> 'in' | 'with'\\n V -> 'saw'\\n \\\"\\\"\\\")\\n\\n sent = 'I saw a man in the park'.split()\\n\\n parser = parse.ShiftReduceParser(grammar, trace=2)\\n for p in parser.parse(sent):\\n print(p)\",\n \"def decide_next_move(self):\\n pass\",\n \"async def move_channel_loop(self):\\n try:\\n while self.state == CHANNEL_MOVE_STATE_NONE:\\n message = await self.poll_message()\\n if message is None:\\n break\\n \\n try:\\n await self.move_message(message)\\n except DiscordException as err:\\n if err.code == ERROR_CODES.unknown_webhook:\\n self.set_status_update_waiter_webhook_deleted()\\n return\\n \\n raise\\n \\n self.last_message_id = message.id\\n self.total_moved_messages += 1\\n \\n except GeneratorExit:\\n raise\\n \\n except CancelledError:\\n raise\\n \\n except BaseException as err:\\n self.set_status_update_waiter_error()\\n await self.client.events.error(self.client, repr(self), err)\\n return\\n \\n finally:\\n self.discard()\\n \\n self.set_status_update_waiter_finished()\",\n \"def solve(self):\\n\\n self.queue.add(*self.moved.items)\\n self.solving = True\\n self.moved.items = []\",\n \"def loop55(self, move, new_state, i):\\n if move == i[0]:\\n\\n # analyze the other 3 cells\\n if (new_state.get_current_player_name()[1]\\n == new_state.letters[i[1]]\\n or new_state.get_current_player_name()[1]\\n == new_state.letters[i[2]]\\n or new_state.get_current_player_name()[1]\\n == new_state.letters[i[3]]) \\\\\\n and new_state.claim[i[4]] == \\\"@\\\":\\n new_state.claim[i[4]] \\\\\\n = new_state.get_current_player_name()[1]\\n\\n # analyze the other 4 cells\\n count = 0\\n for x in [new_state.letters[i[5]],\\n new_state.letters[i[6]],\\n new_state.letters[i[7]],\\n new_state.letters[i[8]]]:\\n if new_state.get_current_player_name()[1] == x:\\n count += 1\\n if count == 2 and new_state.claim[i[9]] == \\\"@\\\":\\n new_state.claim[i[9]] = \\\\\\n new_state.get_current_player_name()[1]\\n\\n # analyze the other 5 cells\\n count = 0\\n for x in [new_state.letters[i[10]],\\n new_state.letters[i[11]],\\n new_state.letters[i[12]],\\n new_state.letters[i[13]],\\n new_state.letters[i[14]]]:\\n if new_state.get_current_player_name()[1] == x:\\n count += 1\\n if count == 2 and new_state.claim[i[15]] == \\\"@\\\":\\n new_state.claim[i[15]] = \\\\\\n new_state.get_current_player_name()[1]\\n new_state.letters = [self.get_current_player_name()[1]\\n if i == move else i for i in self.letters]\\n return new_state\",\n \"def move(self, direction):\\n try:\\n\\n if self.in_thing:\\n print(\\\"You have to get out of the \\\" + str(*self.in_thing[-1]) +\\n \\\" first\\\")\\n return self\\n if direction == 'north':\\n if self.finished_places == 12:\\n self.finished_places += 1\\n return North(self.items, self.finished_places)\\n if direction == 'up':\\n if self.finished_places == 4:\\n self.finished_places += 1\\n return Up(self.items, self.finished_places)\\n if direction == 'east':\\n if self.finished_places == 2:\\n self.finished_places += 1\\n return East(self.items, self.finished_places)\\n except AttributeError:\\n self.items = []\\n return self.move(direction)\\n print(' you didn\\\\'t listen to my very subtle hints, i know it was hard'\\n ' your lost now. if you remember the commands i told you you can'\\n ' go back to where you left off and continue, just type \\\"QUIT\\\"')\\n return Place(self.items, self.finished_places)\\n\\n # implement\\n # return new instance on class\",\n \"def move(self, state):\\n raise NotImplementedError(\\\"Need to implement this method\\\")\",\n \"def play_step(self, action):\\n self.players[0].moving_left = False\\n self.players[0].moving_right = False\\n if action == MOVE_LEFT:\\n self.players[0].moving_left = True\\n for i in range(LOOP_AT_EACH_MOVE_UPDATE):\\n self.update(is_a_star=True)\\n if self.dead_player or not self.players[0].is_alive:\\n break\\n self.players[0].moving_left = False\\n if self.dead_player or not self.players[0].is_alive:\\n return\\n elif action == MOVE_RIGHT:\\n self.players[0].moving_right = True\\n for i in range(LOOP_AT_EACH_MOVE_UPDATE):\\n self.update(is_a_star=True)\\n if self.dead_player or not self.players[0].is_alive:\\n break\\n self.players[0].moving_right = False\\n if self.dead_player or not self.players[0].is_alive:\\n return\\n elif action == SHOOT:\\n if self.dead_player or not self.players[0].is_alive:\\n self.update(is_a_star=True)\\n return\\n if not self.players[0].weapon.is_active:\\n self.players[0].shoot()\\n for i in range(LOOP_AT_EACH_MOVE_UPDATE):\\n self.update(is_a_star=True)\\n if self.dead_player or not self.players[0].is_alive:\\n break\\n if self.dead_player or not self.players[0].is_alive:\\n return\",\n \"def execute_move(self, game_state):\\n game_state.pacs_pos[self.pac_id] = self.next_move\",\n \"def move(self): # AH note. Swich move with extra_steps?\\n if self.adjustment < 0:\\n self.position += self.extra_steps\\n super().move()\\n self.no_moves += 1\\n # Do the regular move\",\n \"def loop56(self, move, new_state, i):\\n if move == i[0]:\\n\\n # analyze the other 4 cells\\n count = 0\\n for x in [new_state.letters[i[1]],\\n new_state.letters[i[2]],\\n new_state.letters[i[3]],\\n new_state.letters[i[4]]]:\\n if new_state.get_current_player_name()[1] == x:\\n count += 1\\n if count == 2 and new_state.claim[i[5]] == \\\"@\\\":\\n new_state.claim[i[5]] = \\\\\\n new_state.get_current_player_name()[1]\\n\\n # analyze the other 4 cells\\n count = 0\\n for x in [new_state.letters[i[6]],\\n new_state.letters[i[7]],\\n new_state.letters[i[8]],\\n new_state.letters[i[9]]]:\\n if new_state.get_current_player_name()[1] == x:\\n count += 1\\n if count == 2 and new_state.claim[i[10]] == \\\"@\\\":\\n new_state.claim[i[10]] = \\\\\\n new_state.get_current_player_name()[1]\\n\\n # analyze the other 4 cells\\n count = 0\\n for x in [new_state.letters[i[11]],\\n new_state.letters[i[12]],\\n new_state.letters[i[13]],\\n new_state.letters[i[14]]]:\\n if new_state.get_current_player_name()[1] == x:\\n count += 1\\n if count == 2 and new_state.claim[i[15]] == \\\"@\\\":\\n new_state.claim[i[15]] = \\\\\\n new_state.get_current_player_name()[1]\\n\\n new_state.letters = [self.get_current_player_name()[1]\\n if i == move else i for i in self.letters]\\n return new_state\",\n \"def handle_make(self, move):\\n# print \\\"handle make-\\\"+str(move.src)+\\\":\\\"+str(move.dst)\\n if not move: return\\n # remove en passant capture\\n if move.is_en_passant():\\n self.remove(move.dst + (8 if move.is_white() else -8))\\n if move.is_capture():\\n self.remove(move.dst)\\n\\n # move rook when castling\\n if move.is_castling_short():\\n if move.is_white():\\n self.move((63,61))\\n else:\\n self.move((7,5))\\n if move.is_castling_long():\\n if move.is_white():\\n self.move((56, 59))\\n else:\\n self.move((0, 3))\\n # Actual move itself.\\n self.move((move.src, move.dst))\\n\\n # Replace promoted piece.\\n if move.is_promotion():\\n self.remove(move.dst)\\n p_piece = move.get_promotion_piece()\\n if not move.is_white(): p_piece = p_piece.lower()\\n# print \\\"promoting to \\\"+p_piece+\\\" at \\\"+move.dst\\n self.put(move.dst, p_piece)\\n self.update_vars_list()\",\n \"def play_game(game, *players):\\n state = game.initial\\n while True:\\n for player in players:\\n print \\\"now move for player \\\", player\\n move = player(game, state) # update move\\n state = game.make_move(move, state) # update game state\\n print '---'\\n game.display(state) # display board\\n print '---'\\n \\n if move == None or game.terminal_test(state): #check game end\\n if game.utility(state,'X')==1:\\n print 'X has won!'\\n elif game.utility(state,'O')==1:\\n print 'O has won!'\\n else:\\n print 'Its A Draw!'\\n return #exit\",\n \"def successor(self, state):\\n pass # abstract\",\n \"def act_after_input(self, current_dir, subdirs, car):\\n new_dir = current_dir\\n if car == 'q':\\n new_dir = None\\n elif car in {str(i+1) for i in range(len(subdirs))}:\\n print ('----> Moving to directory', subdirs[int(car)-1])\\n new_dir = subdirs[int(car)-1]\\n elif car=='.':\\n pass\\n elif car == 'l':\\n self.list_files(current_dir)\\n elif car == '!':\\n self.pass1(self.verb)\\n elif car in {'u','0','..'}:\\n print ('----> Moving one step up')\\n new_dir = self.move_to_parent(current_dir)\\n elif car == '+':\\n new_dir = subdirs[len(subdirs)-1]\\n elif car == 'v':\\n self.verb = not self.verb\\n elif car[0] == 'c': \\n if len(car)>1:\\n num = car[1:]\\n if num in {str(i+1) for i in range(len(subdirs))}:\\n self.list_for_clean(subdirs[int(num)-1])\\n else:\\n self.list_for_clean(current_dir)\\n else:\\n print (help_pass2)\\n return new_dir\",\n \"def step(self, action):\\n # print(\\\"############################\\\")\\n # print(\\\"action: {}\\\".format(action))\\n\\n self.movement_complete.data = False\\n\\n # 1) Read last joint positions by getting the observation before acting\\n old_observation = self.get_obs()\\n\\n # 2) Get the new joint positions according to chosen action (actions here are the joint increments)\\n if self._joint_increment is None:\\n next_action_position = action\\n else:\\n next_action_position = self.get_action_to_position(action, old_observation[1:7])\\n\\n # 3) Move to position and wait for moveit to complete the execution\\n self.publisher_to_moveit_object.pub_joints_to_moveit(next_action_position)\\n # rospy.wait_for_message(\\\"/pickbot/movement_complete\\\", Bool)\\n while not self.movement_complete.data:\\n pass\\n\\n start_ros_time = rospy.Time.now()\\n while True:\\n # Check collision:\\n # invalid_collision = self.get_collisions()\\n # if invalid_collision:\\n # print(\\\">>>>>>>>>> Collision: RESET <<<<<<<<<<<<<<<\\\")\\n # observation = self.get_obs()\\n # reward = UMath.compute_reward(observation, -200, True)\\n # observation = self.get_obs()\\n # print(\\\"Test Joint: {}\\\".format(np.around(observation[1:7], decimals=3)))\\n # return U.get_state(observation), reward, True, {}\\n\\n elapsed_time = rospy.Time.now() - start_ros_time\\n if np.isclose(next_action_position, self.joints_state.position, rtol=0.0, atol=0.01).all():\\n break\\n elif elapsed_time > rospy.Duration(2): # time out\\n break\\n # time.sleep(s\\n\\n \\\"\\\"\\\"\\n #execute action as long as the current position is close to the target position and there is no invalid collision and time spend in the while loop is below 1.2 seconds to avoid beeing stuck touching the object and not beeing able to go to the desired position \\n time1=time.time()\\n while np.linalg.norm(np.asarray(self.joints_state.position)-np.asarray(next_action_position))>0.1 and self.get_collisions()==False and time.time()-time1<0.1: \\n rospy.loginfo(\\\"Not yet reached target position and no collision\\\")\\n \\\"\\\"\\\"\\n # 4) Get new observation and update min_distance after performing the action\\n new_observation = self.get_obs()\\n if new_observation[0] < self.min_distace:\\n self.min_distace = new_observation[0]\\n # print(\\\"observ: {}\\\".format( np.around(new_observation[1:7], decimals=3)))\\n\\n # 5) Convert Observations into state\\n state = U.get_state(new_observation)\\n\\n # 6) Check if its done, calculate done_reward\\n done, done_reward, invalid_contact = self.is_done(new_observation)\\n\\n # 7) Calculate reward based on Observatin and done_reward and update the accumulated Episode Reward\\n reward = UMath.compute_reward(new_observation, done_reward, invalid_contact)\\n\\n ### TEST ###\\n if done:\\n joint_pos = self.joints_state.position\\n print(\\\"Joint in step (done): {}\\\".format(np.around(joint_pos, decimals=3)))\\n ### END of TEST ###\\n\\n self.accumulated_episode_reward += reward\\n\\n self.episode_steps += 1\\n\\n return state, reward, done, {}\",\n \"def shutdown_allcomponents(self):\\n for key,obj in reversed(self.components.get_tuplelist()):\\n obj.shutdown()\",\n \"def solveOneStep(self):\\n ### Student code goes here\\n state = self.currentState\\n #print (type(state))\\n self.visited[state] = True\\n #print (type(self.gm.getGameState()))\\n moves = self.gm.getMovables()\\n print (\\\"CURRENTSTATE\\\" + str(self.currentState.state))\\n print (\\\"MOVABLES:\\\")\\n if moves:\\n for m in moves:\\n print (str(m))\\n print (\\\"CHILDINDEX:\\\")\\n print (state.nextChildToVisit)\\n print (\\\"*********\\\")\\n if state.state == self.victoryCondition:\\n return True\\n #if no child to expand then go back\\n if not moves or state.nextChildToVisit >= len(moves):\\n self.currentState = state.parent\\n if state.requiredMovable is not None:\\n self.gm.reverseMove(state.requiredMovable)\\n # expand\\n else:\\n\\n next_move = moves[state.nextChildToVisit]\\n self.gm.makeMove(next_move)\\n state.nextChildToVisit += 1\\n\\n #if to parent or if visited then skip\\n while (((state.parent is not None) and (self.gm.getGameState() == state.parent.state))) or GameState(self.gm.getGameState(), 0, None) in self.visited:\\n print (\\\"PARENT FOUND!\\\")\\n self.gm.reverseMove(next_move)\\n if state.nextChildToVisit >= len(moves):\\n self.currentState = state.parent\\n return False\\n else:\\n next_move = moves[state.nextChildToVisit]\\n self.gm.makeMove(next_move)\\n state.nextChildToVisit += 1\\n\\n next_state = GameState(self.gm.getGameState(), state.depth + 1, next_move)\\n next_state.parent = state\\n #next_state.requiredMovable = next_move\\n state.children.append(next_state)\\n self.currentState = next_state\\n print (state.nextChildToVisit)\\n return False\",\n \"def action(self):\\r\\n\\r\\n\\r\\n #have we just started?\\r\\n if self.player_information[\\\"us\\\"][\\\"nTokens\\\"] == 0:\\r\\n move = generate_starting_move(self.player_information[\\\"us\\\"][\\\"player_side\\\"], self.board_array)\\r\\n return move\\r\\n\\r\\n #otherwise do minimax \\r\\n \\r\\n #start off with some shallow depth:\\r\\n if self.turn_no < 5:\\r\\n depth = 3\\r\\n else:\\r\\n depth = 2\\r\\n \\r\\n #set a constraint for search depth\\r\\n if self.total_tokens_on_board < 6:\\r\\n depth = 3\\r\\n elif self.total_tokens_on_board < 10:\\r\\n depth = 2\\r\\n else:\\r\\n depth = 1\\r\\n \\r\\n #have a time reference\\r\\n print(f'nthrows: {self.player_information[\\\"us\\\"][\\\"nThrowsRemaining\\\"]}')\\r\\n starting_time = int(round(time.time(), 0))\\r\\n #salvage result from minimax\\r\\n result = minimax(self.board_dict.copy(), self.player_tokens.copy(), self.co_existance_dict.copy(),\\r\\n None, None, None, depth, True, -math.inf, math.inf,\\r\\n (-5, -5), self.player_information.copy(), self.board_array, self.board_edge, \\r\\n starting_time, True, self.turn_no)\\r\\n\\r\\n #clean it up a bit \\r\\n print(self.board_dict)\\r\\n #tidy it up\\r\\n result = result[0]\\r\\n print(f'pre: {result}')\\r\\n #in case we get a bad move redo but make it very shallow\\r\\n if len(result) == 1 or result == (-5, -5):\\r\\n #force it to return a usable move\\r\\n counter = 0\\r\\n while (len(result) == 1) or (result == (-5, -5)):\\r\\n result = minimax(self.board_dict.copy(), self.player_tokens.copy(), self.co_existance_dict.copy(),\\r\\n None, None, None, 1, True, -math.inf, math.inf,\\r\\n (-5, -5), self.player_information.copy(), self.board_array, self.board_edge, \\r\\n starting_time, False, self.turn_no)\\r\\n result = result[0]\\r\\n counter += 1\\r\\n \\r\\n #if its taking too long\\r\\n if counter > 2: \\r\\n #generate one random possible move to use \\r\\n allied_tokens = [token for token in self.player_tokens if self.player_tokens[token] == \\\"us\\\"]\\r\\n move_list = generate_moves(self.board_dict, self.player_tokens, self.co_existance_dict, allied_tokens,\\r\\n self.player_information, self.board_array, True, \\\"all\\\")\\r\\n \\r\\n \\r\\n #if there are no moves\\r\\n if len(move_list) == 0:\\r\\n if self.player_information['us']['nThrowsRemaining'] > 0:\\r\\n throws = generate_possible_throws(self.board_dict, self.player_tokens, self.co_existance_dict, self.player_information, \\\"us\\\",\\r\\n self.player_information[\\\"us\\\"][\\\"player_side\\\"], self.board_array, \\\"all\\\" )\\r\\n result = random.choice(throws)\\r\\n \\r\\n else:\\r\\n result = random.choice(move_list)\\r\\n print(f'random: {result}')\\r\\n break\\r\\n\\r\\n print(f' inside: {result}')\\r\\n\\r\\n print(result)\\r\\n #otherwise clean it up\\r\\n if result[0] == 'throw':\\r\\n final_result = (result[0].upper(), result[1], result[2])\\r\\n else:\\r\\n final_result = (result[0].upper(), result[2], result[3])\\r\\n # return final result \\r\\n return final_result\",\n \"def play(self):\\n for step_i in range(self.max_step):\\n player_id = step_i & 1\\n player = self.players[player_id]\\n action = player.nxt_move()\\n if isinstance(player, mcts.MCTSPlayer) and player.value_net.loggable:\\n print(f'Player{player_id}: Action: {action}')\\n if not self.is_valid_action(action):\\n # because now just consider 2 players\\n print(f\\\"Player: {player_id}, Action: {action} Did Not choose a valid action!\\\")\\n self.board[action // self.w][action % self.w] = player_id\\n self.winner = 1 - player_id\\n else:\\n self.board[action // self.w][action % self.w] = player_id\\n self.winner = self.k0()\\n self.players[1 - player_id].other_nxt_move(action)\\n if self.winner != -1:\\n break\\n print(f'Winner: {self.winner}')\\n for player_id in range(len(self.players)):\\n self.players[player_id].game_ended()\",\n \"def move(self, direction, no_of_exits):\\n if direction in NS:\\n self.y = shift[direction](self.y)\\n else:\\n self.x = shift[direction](self.x)\\n\\n # Store new movement\\n self.path.append([self.x, self.y])\\n\\n # Stores new tested junction direction after reset\\n if self.moved() is False:\\n self._dead_end_direction[-1].append(direction)\\n\\n # Stores the direction and location when testing a new junction.\\n if no_of_exits > 1 and self.moved() is True:\\n self._dead_end_direction.append([direction])\\n self._junction_index.append(len(self.fullpath()) - 1)\\n\\n self._moved = True\",\n \"def move(self, agent, action):\\n\\t\\tpass\",\n \"async def move(self, board, valid_actions):\\n self._move = None\\n output_move_row = Value('d', -1)\\n output_move_column = Value('d', 0)\\n try:\\n # await self.search(board, valid_actions) \\n p = Process(\\n target=self.search, \\n args=(\\n self._color, board, valid_actions, \\n output_move_row, output_move_column))\\n p.start()\\n while p.is_alive():\\n await asyncio.sleep(0.1)\\n self._move = np.array([output_move_row.value,output_move_column.value],dtype=np.int32)\\n except asyncio.CancelledError as e:\\n print('The previous player is interrupted by a user or a timer.')\\n except Exception as e:\\n print(type(e).__name__)\\n print('move() Traceback (most recent call last): ')\\n traceback.print_tb(e.__traceback__)\\n finally:\\n p.kill()\\n self._move = np.array(\\n [output_move_row.value, output_move_column.value],\\n dtype=np.int32)\\n return self.best_move\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.58747476","0.5517833","0.5281134","0.521895","0.5170323","0.5140568","0.50613856","0.50562793","0.5037675","0.49982315","0.49946517","0.49908346","0.49866736","0.49725467","0.4972026","0.49627477","0.49455985","0.494381","0.49339187","0.49254557","0.48986652","0.48953882","0.48944858","0.48873904","0.487353","0.48638928","0.4862374","0.48582488","0.4853171","0.48482946","0.4821698","0.48139933","0.4813266","0.4813147","0.48094863","0.47999772","0.47912017","0.4785221","0.47816128","0.4777925","0.47689262","0.47603095","0.47424453","0.47405684","0.47393247","0.47251698","0.47231323","0.47149992","0.47137517","0.47135267","0.4712643","0.47105512","0.47086182","0.47074437","0.4701523","0.47004974","0.46852964","0.468433","0.46821404","0.4674161","0.46724218","0.4670526","0.46687353","0.4664457","0.46617666","0.46520832","0.46509528","0.46488714","0.4646461","0.46414647","0.4638216","0.4628284","0.4614609","0.46106306","0.46102706","0.4610234","0.46059433","0.460509","0.46035022","0.46033466","0.45995682","0.45831963","0.45829993","0.45809388","0.45746848","0.4571079","0.45705158","0.4568609","0.45666903","0.4565555","0.45641777","0.45631903","0.45613208","0.45513272","0.4548814","0.45480672","0.45476145","0.4546041","0.4545571","0.45414534","0.45412874"],"string":"[\n \"0.58747476\",\n \"0.5517833\",\n \"0.5281134\",\n \"0.521895\",\n \"0.5170323\",\n \"0.5140568\",\n \"0.50613856\",\n \"0.50562793\",\n \"0.5037675\",\n \"0.49982315\",\n \"0.49946517\",\n \"0.49908346\",\n \"0.49866736\",\n \"0.49725467\",\n \"0.4972026\",\n \"0.49627477\",\n \"0.49455985\",\n \"0.494381\",\n \"0.49339187\",\n \"0.49254557\",\n \"0.48986652\",\n \"0.48953882\",\n \"0.48944858\",\n \"0.48873904\",\n \"0.487353\",\n \"0.48638928\",\n \"0.4862374\",\n \"0.48582488\",\n \"0.4853171\",\n \"0.48482946\",\n \"0.4821698\",\n \"0.48139933\",\n \"0.4813266\",\n \"0.4813147\",\n \"0.48094863\",\n \"0.47999772\",\n \"0.47912017\",\n \"0.4785221\",\n \"0.47816128\",\n \"0.4777925\",\n \"0.47689262\",\n \"0.47603095\",\n \"0.47424453\",\n \"0.47405684\",\n \"0.47393247\",\n \"0.47251698\",\n \"0.47231323\",\n \"0.47149992\",\n \"0.47137517\",\n \"0.47135267\",\n \"0.4712643\",\n \"0.47105512\",\n \"0.47086182\",\n \"0.47074437\",\n \"0.4701523\",\n \"0.47004974\",\n \"0.46852964\",\n \"0.468433\",\n \"0.46821404\",\n \"0.4674161\",\n \"0.46724218\",\n \"0.4670526\",\n \"0.46687353\",\n \"0.4664457\",\n \"0.46617666\",\n \"0.46520832\",\n \"0.46509528\",\n \"0.46488714\",\n \"0.4646461\",\n \"0.46414647\",\n \"0.4638216\",\n \"0.4628284\",\n \"0.4614609\",\n \"0.46106306\",\n \"0.46102706\",\n \"0.4610234\",\n \"0.46059433\",\n \"0.460509\",\n \"0.46035022\",\n \"0.46033466\",\n \"0.45995682\",\n \"0.45831963\",\n \"0.45829993\",\n \"0.45809388\",\n \"0.45746848\",\n \"0.4571079\",\n \"0.45705158\",\n \"0.4568609\",\n \"0.45666903\",\n \"0.4565555\",\n \"0.45641777\",\n \"0.45631903\",\n \"0.45613208\",\n \"0.45513272\",\n \"0.4548814\",\n \"0.45480672\",\n \"0.45476145\",\n \"0.4546041\",\n \"0.4545571\",\n \"0.45414534\",\n \"0.45412874\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":228,"numItemsPerPage":100,"numTotalItems":95772,"offset":22800,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjY2MDExMiwianRpIjoiM2M4NTRmMDQtZGNkOC00ODFkLTkwMmYtMDU5NzE0NGMwZTUyIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODY2NjM3MTIsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.mMTWNoCHyi0SaYJiT2Nml0lGChsFRVAqH2ce1x4owUrqkcJj3_KLWgDeDQjCp9_eNudYZ9qyzDeXvNPptJt4BA","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 |
|---|---|---|---|---|---|---|
A set of unicode strings the allowed usage of the key from the extended key usage extension. | def extended_key_usage(self):
if self._extended_key_usage is None:
return set()
return set(self._extended_key_usage.native) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ext_key_usages(self) -> pulumi.Output[Optional[Sequence[str]]]:\n return pulumi.get(self, \"ext_key_usages\")",
"def ext_key_usages(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\n return pulumi.get(self, \"ext_key_usages\")",
"def ext_key_usages(self) -> Optional[pulumi.Input[... | [
"0.7455842",
"0.7374315",
"0.7374315",
"0.71024346",
"0.6737492",
"0.6654881",
"0.6457139",
"0.6399681",
"0.6399681",
"0.60323876",
"0.591794",
"0.58423394",
"0.57243574",
"0.5681344",
"0.5556404",
"0.5525818",
"0.55181473",
"0.54313207",
"0.5347413",
"0.5326456",
"0.53208786... | 0.7662352 | 0 |
Location of the certificate revocation list (CRL) for the certificate. | def crl_url(self):
if self._crl_distribution_points is None:
return None
return self._get_crl_url(self._crl_distribution_points) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delta_crl_url(self):\n\n if self._freshest_crl is None:\n return None\n\n return self._get_crl_url(self._freshest_crl)",
"def getCRLNumber(self):\n\n return self.get_POW().getCRLNumber()",
"def verify_crl(cert, path, validation_context, use_deltas=True, cert_description=None... | [
"0.60479736",
"0.60283333",
"0.59533787",
"0.5584155",
"0.5403625",
"0.5297503",
"0.5247908",
"0.5099858",
"0.47928554",
"0.4789441",
"0.47877467",
"0.47574297",
"0.47253102",
"0.47195476",
"0.4710957",
"0.4671869",
"0.46657896",
"0.46578422",
"0.4616067",
"0.46016717",
"0.45... | 0.5565284 | 4 |
Location of the delta CRL for the certificate. Will be one of the | def delta_crl_url(self):
if self._freshest_crl is None:
return None
return self._get_crl_url(self._freshest_crl) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delta_crl_distribution_points(self):\n\n if self._delta_crl_distribution_points is None:\n self._delta_crl_distribution_points = []\n\n if self.freshest_crl_value is not None:\n for distribution_point in self.freshest_crl_value:\n distribution_poin... | [
"0.6988407",
"0.6318833",
"0.6084879",
"0.56201124",
"0.5176203",
"0.51518315",
"0.50600994",
"0.48365542",
"0.48194048",
"0.4758225",
"0.47277874",
"0.46993938",
"0.46964672",
"0.4641692",
"0.46160996",
"0.46053565",
"0.46053565",
"0.46053565",
"0.46053565",
"0.45939425",
"0... | 0.72536683 | 0 |
Grabs the first URL out of a asn1crypto.x509.CRLDistributionPoints object | def _get_crl_url(self, distribution_points):
if distribution_points is None:
return None
for distribution_point in distribution_points:
name = distribution_point['distribution_point']
if name.name == 'full_name' and name.chosen[0].name == 'uniform_resource_identifie... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def crl_url(self):\n\n if self._crl_distribution_points is None:\n return None\n\n return self._get_crl_url(self._crl_distribution_points)",
"def _make_crl_distribution_points(self, name, value):\n\n if value is None:\n return None\n\n is_tuple = isinstance(value... | [
"0.667195",
"0.6278513",
"0.5788191",
"0.57319546",
"0.5548122",
"0.5375431",
"0.53468317",
"0.5276551",
"0.5264446",
"0.5262795",
"0.5246713",
"0.5246206",
"0.519427",
"0.5137729",
"0.5130993",
"0.5105424",
"0.5057051",
"0.5054585",
"0.503951",
"0.5028308",
"0.5016119",
"0... | 0.7561168 | 0 |
Constructs an asn1crypto.x509.CRLDistributionPoints object | def _make_crl_distribution_points(self, name, value):
if value is None:
return None
is_tuple = isinstance(value, tuple)
if not is_tuple and not isinstance(value, str_cls):
raise TypeError(_pretty_message(
'''
%s must be a unicode string o... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delta_crl_distribution_points(self):\n\n if self._delta_crl_distribution_points is None:\n self._delta_crl_distribution_points = []\n\n if self.freshest_crl_value is not None:\n for distribution_point in self.freshest_crl_value:\n distribution_poin... | [
"0.54835486",
"0.5322369",
"0.5205519",
"0.49923587",
"0.48922306",
"0.48400053",
"0.4827509",
"0.48133376",
"0.4768135",
"0.47563958",
"0.47420117",
"0.47342488",
"0.46844715",
"0.46796644",
"0.46796644",
"0.4675792",
"0.46536493",
"0.46308368",
"0.46132258",
"0.45735577",
"... | 0.6899878 | 0 |
Location of the OCSP responder for this certificate. Will be one of the | def ocsp_url(self):
if self._authority_information_access is None:
return None
for ad in self._authority_information_access:
if ad['access_method'].native == 'ocsp' and ad['access_location'].name == 'uniform_resource_identifier':
return ad['access_location'].cho... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def determine_ocsp_server(self, cert_path):\n try:\n url, _err = util.run_script(\n [\"openssl\", \"x509\", \"-in\", cert_path, \"-noout\", \"-ocsp_uri\"],\n log=logger.debug)\n except errors.SubprocessError:\n logger.info(\"Cannot extract OCSP URI ... | [
"0.6131117",
"0.5615289",
"0.5481226",
"0.52892077",
"0.5258419",
"0.5220536",
"0.51888037",
"0.51888037",
"0.510542",
"0.50266665",
"0.5012942",
"0.49867067",
"0.49449998",
"0.49422258",
"0.49315235",
"0.49149665",
"0.49149665",
"0.48778692",
"0.48690465",
"0.48679858",
"0.4... | 0.61559165 | 0 |
A bool if the certificate should have the OCSP no check extension. Only applicable to certificates created for signing OCSP responses. Such certificates should normally be issued for a very short period of time since they are effectively whitelisted by clients. | def ocsp_no_check(self, value):
if value is None:
self._ocsp_no_check = None
else:
self._ocsp_no_check = bool(value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def has_own_cert(self):\n return os.path.isfile(self.get_own_cert_path())",
"def _has_certs_in_ocsp_response(certs):\n global PYASN1_VERSION\n if PYASN1_VERSION <= 3000:\n return certs is not None\n else:\n return certs is not None and certs.hasValue() and certs[0].hasValue()",
"d... | [
"0.6640712",
"0.6638826",
"0.64836407",
"0.6184736",
"0.60924083",
"0.60924083",
"0.6009329",
"0.5859004",
"0.5826376",
"0.5821309",
"0.57753557",
"0.5768901",
"0.5729878",
"0.57177037",
"0.5646141",
"0.56311846",
"0.56311846",
"0.5621099",
"0.5600893",
"0.55848324",
"0.55529... | 0.6420999 | 3 |
Sets the value for an extension using a fully constructed asn1crypto.core.Asn1Value object. Normally this should not be needed, and the convenience attributes should be sufficient. See the definition of asn1crypto.x509.Extension to determine the appropriate object type for a given extension. Extensions are marked as cr... | def set_extension(self, name, value, allow_deprecated=False):
extension = x509.Extension({
'extn_id': name
})
# We use native here to convert OIDs to meaningful names
name = extension['extn_id'].native
if name in self._deprecated_extensions and not allow_deprecated:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new_extension(name, value, critical=0, _pyfree=1):\n if name == 'subjectKeyIdentifier' and \\\n value.strip('0123456789abcdefABCDEF:') is not '':\n raise ValueError('value must be precomputed hash')\n lhash = m2.x509v3_lhash()\n ctx = m2.x509v3_set_conf_lhash(lhash)\n x509_ext_ptr = m... | [
"0.6438263",
"0.6328225",
"0.6300037",
"0.61802584",
"0.6002731",
"0.5839028",
"0.5822578",
"0.5822578",
"0.57922786",
"0.56969255",
"0.5691874",
"0.5555141",
"0.55509424",
"0.5463055",
"0.53673494",
"0.5295832",
"0.52437776",
"0.5206584",
"0.51691777",
"0.50493395",
"0.49365... | 0.73829615 | 0 |
Validates the certificate information, constructs the ASN.1 structure and then signs it | def build(self, signing_private_key):
is_oscrypto = isinstance(signing_private_key, asymmetric.PrivateKey)
if not isinstance(signing_private_key, keys.PrivateKeyInfo) and not is_oscrypto:
raise TypeError(_pretty_message(
'''
signing_private_key must be an ins... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Certificate(self) -> _n_8_t_0:",
"def Certificate(self) -> _n_8_t_0:",
"def sign_command(args):\n if args.files:\n die(\"Unexpected positional arguments\")\n\n # Load certificate request\n if not args.request:\n die(\"Need --request\")\n subject_csr = load_req(args.request)\n\n ... | [
"0.61315787",
"0.61315787",
"0.59517",
"0.5880631",
"0.58634347",
"0.57155013",
"0.5710871",
"0.57072276",
"0.56894225",
"0.56489754",
"0.5619481",
"0.55772793",
"0.5548957",
"0.5527686",
"0.5521173",
"0.54978174",
"0.54738504",
"0.54585457",
"0.5449486",
"0.5449079",
"0.5438... | 0.5624256 | 10 |
Calculates the accuracy of a (multiclass) classifier, defined as the fraction of correct classifications. | def calc_accuracy(true, predicted):
return sum([t==p for t,p in zip(true, predicted)]) / float(len(true)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def multiclass_accuracy(prediction, ground_truth):\n correct = sum(a == b for a, b in zip(prediction, ground_truth))\n\n accuracy = correct / len(ground_truth)\n\n return accuracy",
"def accuracy(cls, test_labels):\n N = len(test_labels)\n\n # Calculate total correct as precentage\n ... | [
"0.8062225",
"0.7989661",
"0.7957554",
"0.7913096",
"0.7886881",
"0.77577",
"0.7662704",
"0.7636037",
"0.76325977",
"0.76278996",
"0.75958216",
"0.7560955",
"0.75587344",
"0.7547818",
"0.754766",
"0.75229615",
"0.75066584",
"0.74955165",
"0.7488491",
"0.7473771",
"0.7405914",... | 0.72045815 | 38 |
Calculates the precision, recall and Fscore of a classifier. | def precision_recall_fscore(true, predicted, beta=1, labels=None, pos_label=None, average=None):
# Build contingency table as ldict
ldict = {}
for l in labels:
ldict[l] = {"tp": 0., "fp": 0., "fn": 0., "support": 0.}
for t, p in zip(true, predicted):
if t == p:
ldict[t]["tp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def score(label_recall, label_precision, pred_recall, pred_precision):\n f11 = 6*label_recall*label_precision/(5*label_recall+label_precision)\n f12 = 5*pred_recall*pred_precision/(2*pred_recall+3*pred_precision)\n\n return 0.4*f11 + 0.6*f12",
"def precision(self):\n self.overall_precision = prec... | [
"0.76547",
"0.75400555",
"0.7316806",
"0.7304719",
"0.7169431",
"0.7160372",
"0.71144414",
"0.7101537",
"0.7096566",
"0.7079038",
"0.7062186",
"0.70435596",
"0.7024895",
"0.69993293",
"0.69966674",
"0.697652",
"0.69500256",
"0.6949167",
"0.69278425",
"0.69204175",
"0.6903022"... | 0.6980734 | 15 |
Helper function for slicing the audio file by window size and sample rate with [1stride] percent overlap (default 50%). | def slice_signal(file, window_size, stride, sample_rate):
wav, sr = librosa.load(file, sr=sample_rate)
hop = int(window_size * stride)
slices = []
for end_idx in range(window_size, len(wav), hop):
start_idx = end_idx - window_size
slice_sig = wav[start_idx:end_idx]
#print(type(sl... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_clips_by_stride2(stride, frames_list, sequence_size):\n clips = []\n sz = len(frames_list)\n clip = []\n cnt = 0\n for start in range(0, sz-sequence_size):\n for i in range(start, start+sequence_size):\n clip.append(frames_list[i])\n clips.append(clip)\n clip ... | [
"0.600388",
"0.5930789",
"0.58244437",
"0.5814211",
"0.5788517",
"0.57616496",
"0.5741947",
"0.5716796",
"0.5714888",
"0.5699974",
"0.56802857",
"0.56785756",
"0.56071216",
"0.5601426",
"0.55252904",
"0.5479792",
"0.54793173",
"0.5475118",
"0.5470689",
"0.54675853",
"0.542913... | 0.70155334 | 0 |
Onestop IDE for smart contract. | def smartx_cmd(ctx):
webbrowser.open("https://smartx.ont.io/") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def contract_pepo_pbc():\n pass",
"def main():\n\n api = SymbolService()",
"def init():\n try:\n compile_contract(\n \"fishcake\", f\"Fishcake(sp.address('{pub_key_hash}'),{default_supply})\")\n fishcake_addr = deploy(\"fishcake\")\n print(\"\\n\")\n compile_cont... | [
"0.57452",
"0.5450769",
"0.53970563",
"0.5168819",
"0.5165328",
"0.51380014",
"0.5120251",
"0.5116236",
"0.51133585",
"0.5109121",
"0.50889903",
"0.50777507",
"0.505974",
"0.5058526",
"0.5046549",
"0.50383246",
"0.5038014",
"0.5036075",
"0.50294083",
"0.5006385",
"0.49798456"... | 0.0 | -1 |
self.Nodes is a list of nodes self.States is a list of (dictionary of) states | def __init__(self,setup):
if isinstance(setup, KFSetup) == True:
self.Nodes = setup.Nodes
elif isinstance(setup, list) == True:
for node in setup:
if isinstance(node, KFNode) == False:
print "List of nodes must be of type KNode"
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def states(self) -> Type[Any]:\n return []",
"def get_states(self):\n raise NotImplementedError()",
"def states(self):\n return self._x_list",
"def state_list(self) -> Sequence[TState]:\n pass",
"def __init__(self):\n\n self.nodes = {}",
"def state_nodes(self) -> np.nda... | [
"0.6639524",
"0.6583393",
"0.6522062",
"0.6484665",
"0.6410268",
"0.6396257",
"0.6363788",
"0.63094705",
"0.62580496",
"0.62406516",
"0.6234366",
"0.62304926",
"0.6182667",
"0.617986",
"0.61758226",
"0.61434454",
"0.6099685",
"0.6057645",
"0.6055081",
"0.60545105",
"0.6047305... | 0.63547057 | 7 |
Helper function to make calls to Airtable REST API. | def airtable_api(base, table, token, action = '', parameters = {}, method = 'get', data = {}):
headers = {
'Content-type': 'application/json',
'Accept-Encoding': 'gzip',
'Authorization': 'Bearer %s' % token
}
url = "https://api.airtable.com/v0/%s/%s/%s" % (base, table, action)
i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _api_call(self, **kwargs):\n params = {\n 'format': 'json',\n }\n params.update(kwargs)\n r = requests.get(self.api_base_url, params=params)\n return r.json()",
"def test_api_response(self):\n # url = 'http://127.0.0.1:8000/api/aircraft/'\n url = re... | [
"0.61390936",
"0.61125934",
"0.60539144",
"0.6022661",
"0.59775054",
"0.597503",
"0.5948181",
"0.5932787",
"0.59238493",
"0.59189403",
"0.5911685",
"0.5896667",
"0.58928114",
"0.5880146",
"0.58788973",
"0.586516",
"0.5859757",
"0.5797205",
"0.5797205",
"0.579526",
"0.5782091"... | 0.765456 | 0 |
Perform recursive expansion of ${vars}. Works by looking for a string matching the expansion syntax and replacing that with the value of the ivars dict corresponding to the key inside {}. If no key matching key is found, the expansion is escaped (by duplicating the $), to make sure the expansion ends. Cyclic expansions... | def interpolate(self, string, ivars, settings=None):
if not isinstance(string, basestring):
return string
if settings is None:
settings = self.settings
ret = string
m = self._INTERP_REGEX.search(ret)
i = 0
while m is not None:
k = m.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def expand(self, s, lvars):\n if is_String(s):\n try:\n s0, s1 = s[:2]\n except (IndexError, ValueError):\n return s\n if s0 != '$':\n return s\n if s1 == '$':\n # In this case keep the double $'s which w... | [
"0.6811773",
"0.66787976",
"0.6488473",
"0.6440492",
"0.6396849",
"0.6386581",
"0.63629097",
"0.6258556",
"0.5814664",
"0.5750376",
"0.5742669",
"0.56797206",
"0.5659204",
"0.55962145",
"0.55536675",
"0.5550205",
"0.5548363",
"0.55258036",
"0.5493188",
"0.54344845",
"0.541024... | 0.48064128 | 50 |
Tokenize data file and turn into tokenids using given vocabulary file. This function loads data linebyline from data_path, calls the above sentence_to_token_ids, and saves the result to target_path. See comment for sentence_to_token_ids on the details of tokenids format. | def data_to_token_ids(data_path, target_path, vocabulary_path,
tokenizer=None, normalize_digits=True):
if not gfile.Exists(target_path):
print("Tokenizing data in %s" % data_path)
vocab, _ = data_utils.initialize_vocabulary(vocabulary_path)
with gfile.GFile(data_path, m... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def data_to_token_ids(data_path, target_path, vocabulary_path):\n if not gfile.Exists(target_path):\n print(\"Tokenizing data in %s\" % data_path)\n vocab, _ = initialize_vocabulary(vocabulary_path)\n with gfile.GFile(data_path, mode=\"rb\") as data_file:\n with gfile.GFile(targe... | [
"0.88158065",
"0.8449106",
"0.83855826",
"0.8366422",
"0.82797813",
"0.8102873",
"0.7367587",
"0.726734",
"0.7234463",
"0.7134788",
"0.7093858",
"0.70898783",
"0.70898783",
"0.70594037",
"0.7039706",
"0.6949376",
"0.6746222",
"0.67304814",
"0.6648989",
"0.6558965",
"0.6438027... | 0.8453001 | 1 |
Read data from source file and put into buckets. | def read_data(tokenized_dialog_path, buckets, max_size=None, reversed=False):
data_set = [[] for _ in buckets]
with gfile.GFile(tokenized_dialog_path, mode="r") as fh:
utterences = fh.readline().split('\t')
source = utterences[0] if len(utterences) >= 2 else None
target = utterences[1] if len(utt... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_data(source_path, target_path, opt):\n data_set = [[] for _ in _buckets]\n with tf.gfile.GFile(source_path, mode=\"r\") as source_file:\n with tf.gfile.GFile(target_path, mode=\"r\") as target_file:\n source, target = source_file.readline(), target_file.readline() \n ... | [
"0.65618515",
"0.65262836",
"0.6054701",
"0.5990696",
"0.58459795",
"0.58217275",
"0.5660017",
"0.5587472",
"0.55752623",
"0.5531793",
"0.5517406",
"0.54970056",
"0.54949343",
"0.548751",
"0.5446074",
"0.5389549",
"0.5365129",
"0.53465563",
"0.5338558",
"0.52951324",
"0.52681... | 0.53149813 | 19 |
Updates sbfdInitiator resource on the server. | def update(self, MplsLabelCount=None, Name=None):
# type: (int, str) -> SbfdInitiator
return self._update(self._map_locals(self._SDM_ATT_MAP, locals())) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_candidate_initiation_status(request):\n candidate_pk = request.POST.get('candidate')\n if not candidate_pk:\n return json_response(status=404)\n candidate = get_object_or_none(Candidate, pk=candidate_pk)\n initiated = json.loads(request.POST.get('initiated'))\n if not candidate or ... | [
"0.5474608",
"0.5050383",
"0.4984643",
"0.4836667",
"0.48322695",
"0.47715214",
"0.47665533",
"0.47395217",
"0.47383836",
"0.4738318",
"0.4738305",
"0.47367153",
"0.47344047",
"0.4676075",
"0.4672489",
"0.4661571",
"0.46312398",
"0.46172616",
"0.46114567",
"0.4608545",
"0.460... | 0.45967504 | 21 |
Finds and retrieves sbfdInitiator resources from the server. All named parameters are evaluated on the server using regex. The named parameters can be used to selectively retrieve sbfdInitiator resources from the server. To retrieve an exact match ensure the parameter value starts with ^ and ends with $ By default the ... | def find(
self,
Count=None,
DescriptiveName=None,
MplsLabelCount=None,
Name=None,
SessionInfo=None,
):
# type: (int, str, int, str, List[str]) -> SbfdInitiator
return self._select(self._map_locals(self._SDM_ATT_MAP, locals())) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _generic_find(controller, heading, patterns):\n msg.info(heading)\n msg.info(\"--------------------------\")\n msg.blank()\n for pattern in patterns:\n for entry in controller.find(pattern):\n if hasattr(entry, \"uuid\"):\n eid = entry.uuid\n elif hasattr... | [
"0.49518782",
"0.48978445",
"0.47183838",
"0.4708106",
"0.45406547",
"0.45046747",
"0.44876707",
"0.44648275",
"0.4458623",
"0.43709165",
"0.4347843",
"0.43476033",
"0.43475124",
"0.4342113",
"0.43302515",
"0.4325594",
"0.43250877",
"0.43101805",
"0.43035924",
"0.42664522",
"... | 0.5184359 | 0 |
Retrieves a single instance of sbfdInitiator data from the server. Args | def read(self, href):
return self._read(href) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_initiator(self, init_key):\n if init_key[:5] != 'init_':\n raise Exception('Incorrect key passed to model.get_initiator(): ' +\n init_key)\n init_data = self.client.get(init_key)\n if init_data is None:\n return None\n else:\n ... | [
"0.5901854",
"0.54212874",
"0.52505374",
"0.5221172",
"0.5157096",
"0.5156483",
"0.5131844",
"0.5088491",
"0.5056409",
"0.49985048",
"0.4995144",
"0.4982457",
"0.49813747",
"0.49672472",
"0.4965639",
"0.4940197",
"0.48944193",
"0.4890838",
"0.4848253",
"0.48449358",
"0.484028... | 0.0 | -1 |
Base class infrastructure that gets a list of sbfdInitiator device ids encapsulated by this object. Use the optional regex parameters in the method to refine the list of device ids encapsulated by this object. Args | def get_device_ids(
self,
PortNames=None,
Active=None,
DestIPAddr=None,
MyDiscriminator=None,
PeerDiscriminator=None,
TimeoutMultiplier=None,
TxInterval=None,
):
return self._get_ngpf_device_ids(locals()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_switch_ids():\n\n device_id_list = []\n url = 'https://' + APIC_EM + '/network-device'\n header = {'accept': 'application/json', 'X-Auth-Token': APIC_EM_TICKET}\n device_response = requests.get(url, headers=header, verify=False)\n device_json = device_response.json()\n device_info = devic... | [
"0.5543624",
"0.5481396",
"0.5470194",
"0.54409117",
"0.5349738",
"0.52898645",
"0.5209259",
"0.516662",
"0.50579447",
"0.505697",
"0.5042077",
"0.5039442",
"0.5039277",
"0.5031319",
"0.5025321",
"0.49606717",
"0.49584898",
"0.4925496",
"0.49149588",
"0.49119374",
"0.48910332... | 0.53746444 | 4 |
Remove HTML markup from the given string. | def clean_html(html):
html = re.sub(r"(?s)<!--(.*?)-->[\n]?", "\\1", html)
html = re.sub(r"<!--", "", html)
if html == '':
return ''
s = MLStripper()
s.feed(html)
return s.get_data().strip() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_html(text):\n return re.sub(r'<.*?>', r'', text)",
"def strip_html(inputString):\r\n return BeautifulSoup(inputString, \"html.parser\").text",
"def remove_html(x: str) -> str:\n regex = r\"<.+?>\"\n return re.sub(regex, \"\", x)",
"def remove_html_tags(self,text):\n #https://med... | [
"0.8168552",
"0.81124836",
"0.7949947",
"0.79056764",
"0.7832942",
"0.78204197",
"0.7808701",
"0.78075194",
"0.7798221",
"0.7784998",
"0.7784378",
"0.7784378",
"0.7782839",
"0.77705145",
"0.77632415",
"0.77590126",
"0.7699831",
"0.7595308",
"0.7575034",
"0.75212544",
"0.75212... | 0.7026485 | 40 |
Add L1feature selection (LASSO) to a classifier | def with_l1_feature_selection(class_T, **kwargs):
class FeatureSelect(class_T):
def fit(self, X, y):
# The smaller C, the stronger the regularization.
# The more regularization, the more sparsity.
self.transformer_ = class_T(penalty="l1", **kwargs)
logger.inf... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def select_features(self):\n print 'tuning alpha'\n hyper_params_model = lm.LassoCV(normalize=True, n_jobs=-1).fit(\n self.data.loc[self.train_index, self.features_], self.data.loc[self.train_index, self.target_name])\n print 'alpha is: {}'.format(hyper_params_model.alpha_)\n ... | [
"0.62955976",
"0.606903",
"0.59849876",
"0.5970041",
"0.5945682",
"0.59200114",
"0.5896963",
"0.58824384",
"0.5863572",
"0.5863572",
"0.57160354",
"0.56982696",
"0.5672844",
"0.5630173",
"0.56192195",
"0.5605374",
"0.5594883",
"0.55813015",
"0.5549581",
"0.55495733",
"0.55330... | 0.6665041 | 0 |
Match separating punctuation (commas, periods, but not colons, hyphens) | def punct_filter_(w):
return w in {u'.', u',', u';', u'?', u'!', u'(', u')', u'[', u']'} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ignored_punctuation_regex():\n\treturn r'[!\\\"#$%&()*+\\,-./:;<=>?@\\[\\]\\\\^_`{}|~]+'",
"def is_punctuation(ch):\n if (ch == '.'): return False\n if (ch >= '!' and ch <= '/'): return True\n if (ch >= ':' and ch <= '@'): return True\n if (ch >= '\\u2010' and ch <= '\\u2014'): return True # var... | [
"0.7343635",
"0.7006425",
"0.6784772",
"0.67299044",
"0.6666127",
"0.6530255",
"0.64739627",
"0.64473224",
"0.6433608",
"0.63660544",
"0.6341165",
"0.63242084",
"0.6294799",
"0.62875867",
"0.62520057",
"0.6225957",
"0.62174493",
"0.6176782",
"0.61660147",
"0.61554426",
"0.615... | 0.6504791 | 6 |
Clear all stored response. | def clear(self):
self.vars = [] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clear(self):\r\n self._state[\"data\"].clear()\r\n self._state[\"session\"].request_rerun()",
"def clear(self):\r\n self._state[\"data\"].clear()\r\n self._state[\"session\"].request_rerun()",
"def clear(self):\n self._state[\"data\"].clear()\n self._state[\"sessio... | [
"0.7446551",
"0.7446551",
"0.7436163",
"0.7436163",
"0.7436163",
"0.7329332",
"0.72736454",
"0.72287416",
"0.71536124",
"0.7138875",
"0.70830476",
"0.70826596",
"0.70713127",
"0.6988227",
"0.69602025",
"0.69010556",
"0.69010556",
"0.68921775",
"0.6891574",
"0.68742424",
"0.68... | 0.0 | -1 |
Read template file and render file. | def create_document(self, output):
if not os.path.exists(self.template_path):
raise IOError('Template file not found.')
documents = []
with open(self.template_path, 'rb') as f:
data = f.read()
template = Template(to_unicode(data))
indent_targets =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _render_template(self, tplfile, env):\n with open(tplfile) as fp:\n tpl = Template(fp.read())\n return tpl.render(Context(env))",
"def render(self, tmpl_file, context):\n template = Template(tmpl_file.read_text(), keep_trailing_newline=True)\n return template.render(con... | [
"0.759074",
"0.7526526",
"0.7398593",
"0.71414816",
"0.7093139",
"0.70328003",
"0.70211214",
"0.70048916",
"0.6959408",
"0.6915279",
"0.6914749",
"0.68996215",
"0.6845751",
"0.68133366",
"0.6812965",
"0.67076325",
"0.6701488",
"0.6701488",
"0.6679855",
"0.6670298",
"0.6639249... | 0.0 | -1 |
Parse WebTest response. .describe('/ GET') | def describe(self, *args, **kwargs):
def _autodoc(func, *_args, **_kwargs):
if len(_args) > 0:
#: Instance or class method.
response = func(_args[0])
else:
#: Function.
if len(_kwargs) > 0:
response = fun... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_method(self):\n self.getPage('/')\n self.assertStatus('200 OK')\n self.assertHeader('Content-Type', 'application/json')\n self.assertBody('{\"mystring\": \"\"}')",
"def test_get(self):\n return self.doRequest(self.url, method=\"GET\", body=self.input)",
"def test... | [
"0.6889347",
"0.6758513",
"0.6715704",
"0.664328",
"0.661729",
"0.6605064",
"0.6605064",
"0.6479323",
"0.64753807",
"0.646049",
"0.64558667",
"0.64163375",
"0.64055413",
"0.6396195",
"0.63906515",
"0.63906515",
"0.6344304",
"0.6327143",
"0.63212115",
"0.631387",
"0.63123506",... | 0.0 | -1 |
Generate document. .generate('output_file.rst', template='template.rst') | def generate(self, *args, **kwargs):
#: TODO Use decorator instead.
def _generate(func):
@wraps(func)
def __generate(*_args):
if len(_args) > 0:
arg = _args[0]
else:
arg = _args
if self._is_r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_document(self, output):\n if not os.path.exists(self.template_path):\n raise IOError('Template file not found.')\n\n documents = []\n with open(self.template_path, 'rb') as f:\n data = f.read()\n template = Template(to_unicode(data))\n ind... | [
"0.76528835",
"0.69006985",
"0.67696035",
"0.6688092",
"0.6625607",
"0.6345653",
"0.6247454",
"0.6246112",
"0.6218659",
"0.6213572",
"0.61888826",
"0.6187535",
"0.6181747",
"0.61376876",
"0.61268723",
"0.612233",
"0.61221707",
"0.61131835",
"0.61126673",
"0.61126673",
"0.6101... | 0.64648503 | 5 |
move objects randomly, used to create startgoalconfigurations | def move_objects(self):
def get_new_obj_pose(curr_pos, curr_quat):
angular_disp = 0.0
delta_alpha = np.random.uniform(-angular_disp, angular_disp)
delta_rot = Quaternion(axis=(0.0, 0.0, 1.0), radians=delta_alpha)
curr_quat = Quaternion(curr_quat)
newq... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _move_randomly(self):\n a, b = randint(0, len(self.state) - 1), randint(0, len(self.state) - 1)\n wiz1, wiz2 = self.state[a], self.state[b]\n self._swap_wizards(wiz1, wiz2)",
"def MoveRandom(self):\n r = random.randint(0,3)\n if r == 0: self.x += 1\n elif r == 1: sel... | [
"0.7378422",
"0.7229374",
"0.7224192",
"0.71494836",
"0.7106477",
"0.69178057",
"0.68823785",
"0.6878625",
"0.6782675",
"0.67623246",
"0.67030305",
"0.66793734",
"0.6674687",
"0.66025436",
"0.65941995",
"0.6520001",
"0.6509973",
"0.64586425",
"0.64313936",
"0.64313936",
"0.64... | 0.7156799 | 3 |
Computes growing degree days for one day. | def compute_gdd(tmin, tmax, base):
gdd = (tmin + tmax) / 2 - base
if gdd < 0:
return 0
else:
return gdd | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def day_angle(day):\n return 2*pi*( day - 1 )/365",
"def declination_degree(day_date, TY):\n\n return 23.45 * np.vectorize(sin)((2 * pi / (TY)) * (day_date - 81))",
"def compute(self, days=1):\n raise NotImplementedError",
"def compute_days(start: date, end: date) -> int:\n delta = end - star... | [
"0.63740456",
"0.6364502",
"0.62554413",
"0.5825322",
"0.5759924",
"0.5728445",
"0.57181114",
"0.56224924",
"0.56181675",
"0.56117284",
"0.5574303",
"0.55253017",
"0.54893756",
"0.5466688",
"0.54473484",
"0.5437151",
"0.5433859",
"0.54293084",
"0.54293084",
"0.5399242",
"0.53... | 0.0 | -1 |
Inserts or updates a row in the agdds table. | def add_agdd_row(station_id, source_id, gdd, agdd, year, doy, date, base, missing, tmin, tmax):
cursor = mysql_conn.cursor(buffered=True)
cursor.execute(search_for_agdd_row, (station_id, source_id, date, base))
if cursor.rowcount < 1:
cursor.execute(insert_agdd_row, (station_id, source_id, gdd, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def insert_or_update(self, table, connection, row):\n\n # find line, if it exist\n dbrow = self.find(connection, table, row)\n\n # TODO XXX use actual database function instead of this stupid thing\n now = datetime.datetime.now()\n\n column_names = table.columns.keys()\n\n ... | [
"0.71272016",
"0.64908445",
"0.64370745",
"0.6415218",
"0.63375866",
"0.62611103",
"0.62001574",
"0.61876833",
"0.6153674",
"0.6153602",
"0.6137083",
"0.6070958",
"0.6063594",
"0.60508627",
"0.6006844",
"0.59999216",
"0.5953526",
"0.5928303",
"0.59262604",
"0.5911096",
"0.590... | 0.6496721 | 1 |
Retrieves tmin and tmax data from climate source and computes agdds to be inserted into the agdd table. | def populate_agdds(start_date, end_date, source, source_id, stations):
# possibly grab ACIS station data (for entire date range)
if source == 'ACIS':
station_ids = []
for station in stations:
station_ids.append(station['char_network_id'])
acis_data = get_acis_climate_da... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calc_temps(start_date, end_date):\n \n return session.query(func.min(Measurement.tobs), func.avg(Measurement.tobs), func.max(Measurement.tobs)). filter(Measurement.date >= start_date).filter(Measurement.date <= end_date).all()",
"def calc_temps(start_date, end_date):\n engine = create_engine(... | [
"0.5735708",
"0.5730932",
"0.5722183",
"0.56052613",
"0.5589223",
"0.55774945",
"0.555737",
"0.5545903",
"0.55298",
"0.5475786",
"0.5471325",
"0.5433377",
"0.5417408",
"0.54048234",
"0.5404228",
"0.5385842",
"0.5363252",
"0.5359528",
"0.5340754",
"0.5295347",
"0.52815783",
... | 0.6996738 | 0 |
Populates the agdds table with urma, acis, and prism temps and agdds for qc purposes. | def populate_agdd_qc(urma_start, urma_end, acis_start, acis_end, prism_start, prism_end):
logging.info(' ')
logging.info('-----------------beginning climate quality check population-----------------')
stations = get_stations()
sources = get_sources()
acis_source_id = None
urma_source_i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def populate_agdds(start_date, end_date, source, source_id, stations):\r\n # possibly grab ACIS station data (for entire date range)\r\n if source == 'ACIS':\r\n station_ids = []\r\n for station in stations:\r\n station_ids.append(station['char_network_id'])\r\n acis_data = ge... | [
"0.7020696",
"0.59384745",
"0.57721275",
"0.55029595",
"0.54911304",
"0.535942",
"0.5247746",
"0.52255356",
"0.5182375",
"0.51726794",
"0.5150156",
"0.5148654",
"0.5112237",
"0.510183",
"0.5043503",
"0.5028003",
"0.5018343",
"0.5009472",
"0.5000762",
"0.4996117",
"0.49891308"... | 0.6922955 | 1 |
Compute the reciprocal rank of a ranked list against some ground truth. | def reciprocal_rank(ranking, references, atk=None):
for k, prediction in enumerate(ranking[:atk], 1):
if prediction in references:
return 1.0 / k
return 0.0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def recip_rank(recs, truth):\n good = recs['item'].isin(truth.index)\n npz, = np.nonzero(good)\n if len(npz):\n return 1.0 / (npz[0] + 1.0)\n else:\n return 0.0",
"def mrr(ground_truth, prediction):\n rr = 0.\n for rank, item in enumerate(prediction):\n if item in ground_tr... | [
"0.73031837",
"0.6954642",
"0.69224846",
"0.6495415",
"0.6495415",
"0.6495415",
"0.64866287",
"0.63244474",
"0.62833434",
"0.6090479",
"0.6087416",
"0.6059336",
"0.6052769",
"0.5926173",
"0.59248835",
"0.5920617",
"0.59073466",
"0.58768547",
"0.5853657",
"0.57954407",
"0.5781... | 0.7614039 | 0 |
Compute the average precision of a ranked list against some ground truth | def average_precision(ranking, references, atk=None):
total, num_correct = 0.0, 0.0
for k, prediction in enumerate(ranking[:atk], 1):
if prediction in references:
num_correct += 1
total += num_correct / k
return total / num_correct if total > 0 else 0.0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def precision(ground_truth, prediction):\n ground_truth = remove_duplicates(ground_truth)\n prediction = remove_duplicates(prediction)\n precision_score = count_a_in_b_unique(prediction, ground_truth) / float(len(prediction))\n assert 0 <= precision_score <= 1\n return precision_score",
"def avera... | [
"0.7208344",
"0.7128738",
"0.70493734",
"0.70493734",
"0.69964546",
"0.69185257",
"0.6745876",
"0.6717349",
"0.6709977",
"0.670711",
"0.66209596",
"0.66137177",
"0.65935045",
"0.65935045",
"0.6568909",
"0.6563142",
"0.65568525",
"0.6533323",
"0.6532258",
"0.65147334",
"0.6491... | 0.7527089 | 0 |
Compute the mean average precision. Input should be a list of prediction rankings and a list of ground truth rankings. | def mean_average_precision(rankings, references, atk=None):
return _mean_score(rankings, references, partial(average_precision, atk=atk)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mean_average_precision(ground_truth_boxes, predicted_boxes):\n # DO NOT EDIT THIS CODE\n all_gt_boxes = []\n all_prediction_boxes = []\n confidence_scores = []\n\n for image_id in ground_truth_boxes.keys():\n pred_boxes = predicted_boxes[image_id][\"boxes\"]\n scores = predicted_bo... | [
"0.7831679",
"0.7574589",
"0.75513065",
"0.75513065",
"0.75288075",
"0.74372524",
"0.732722",
"0.7210581",
"0.7141075",
"0.6975217",
"0.69228095",
"0.6889771",
"0.6889771",
"0.6876503",
"0.67573595",
"0.67374164",
"0.6712426",
"0.668879",
"0.66805184",
"0.66583216",
"0.664517... | 0.77060956 | 1 |
Compute the mean reciprocal precision. Input should be a list of prediction rankings and a list of ground truth rankings. | def mean_reciprocal_rank(rankings, references, atk=None):
return _mean_score(rankings, references, partial(reciprocal_rank, atk=atk)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def average_precision(ranking, references, atk=None):\n total, num_correct = 0.0, 0.0\n for k, prediction in enumerate(ranking[:atk], 1):\n if prediction in references:\n num_correct += 1\n total += num_correct / k\n return total / num_correct if total > 0 else 0.0",
"def me... | [
"0.7065807",
"0.70518625",
"0.70157504",
"0.70157504",
"0.68720365",
"0.685541",
"0.6840075",
"0.67997265",
"0.67997265",
"0.67997265",
"0.67128766",
"0.67063826",
"0.6668957",
"0.6668957",
"0.666502",
"0.6556388",
"0.65000385",
"0.63746715",
"0.6370327",
"0.6348512",
"0.6345... | 0.6964207 | 4 |
Return 1 if the predicted ranking is not perfect. | def is_error(ranking, references):
return 1 if average_precision(ranking, references) < 1 else 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def determine_rank(self, X, err):\n singularValues,_,_,_ = self.compute_svd(X,k=-1)\n ratio = np.array([np.linalg.norm(singularValues[k:]) / np.linalg.norm(singularValues) for k in\n range(len(singularValues) - 1, 0, -1)])\n find_idx = numpy.nonzero(ratio <= err)\n rank ... | [
"0.69346136",
"0.672925",
"0.651005",
"0.646099",
"0.6448155",
"0.6444491",
"0.64425844",
"0.64425844",
"0.64425844",
"0.64425844",
"0.6406233",
"0.63962543",
"0.6384781",
"0.6384781",
"0.63778514",
"0.63349134",
"0.6325778",
"0.63230485",
"0.6310548",
"0.6310548",
"0.6278173... | 0.64548105 | 4 |
Return the margin, or absolute difference between the highest irrelevant item and the lowest relevant one. | def margin(ranking, references):
lowest_relevant, highest_irrelevant = 0, 0
for k, prediction in enumerate(ranking, 1):
if prediction not in references and highest_irrelevant is 0:
highest_irrelevant = k
if prediction in references and k > lowest_relevant:
lowest_relevant... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def available_margin(self) -> float:\n return self.position.exchange.available_margin",
"def score_margin(self):\n if self.previous_event is None:\n score = self.score\n else:\n score = self.previous_event.score\n offense_team_id = self.get_offense_team_id()\n ... | [
"0.6683197",
"0.6535715",
"0.6526499",
"0.64784586",
"0.6443067",
"0.637917",
"0.63374513",
"0.6324491",
"0.6324483",
"0.6308849",
"0.62230015",
"0.59055555",
"0.576389",
"0.57285047",
"0.56073964",
"0.56070846",
"0.55782366",
"0.5575528",
"0.55331033",
"0.55096865",
"0.54899... | 0.6742604 | 0 |
Discounted cumulative gain at rank (DCG) | def dcg(relevances, rank=10):
relevances = np.asarray(relevances)[:rank]
n_relevances = len(relevances)
if n_relevances == 0:
return 0.
discounts = np.log2(np.arange(n_relevances) + 2)
return np.sum(relevances / discounts) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def discounted_cumulative_gain(ranked_list):\n total_ndcg = 0\n for query in ranked_list:\n relevances = [doc[0] for doc in query[1]]\n dcg = 0\n for i, rel in enumerate(relevances, 1):\n dcg += rel / (math.log(i + 1, 2))\n\n idcg = 0\n for i, rel in enumerate(so... | [
"0.71784985",
"0.71222025",
"0.6881122",
"0.68019325",
"0.6787491",
"0.67346466",
"0.6697927",
"0.6597123",
"0.64656633",
"0.6435575",
"0.6423271",
"0.63383526",
"0.6318887",
"0.63159037",
"0.6252899",
"0.6227333",
"0.62143683",
"0.62141496",
"0.6133122",
"0.61255443",
"0.612... | 0.66329145 | 7 |
Normalized discounted cumulative gain (NDGC) | def ndcg(relevances, rank=10):
best_dcg = dcg(sorted(relevances, reverse=True), rank)
if best_dcg == 0:
return 0.
return dcg(relevances, rank) / best_dcg | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _dcg(scores, discount=np.log2):\n scores = np.nan_to_num(scores)\n ranks = np.arange(1, len(scores) + 1)\n disc = discount(ranks)\n np.maximum(disc, 1, out=disc)\n np.reciprocal(disc, out=disc)\n return np.dot(scores, disc)",
"def _get_cg_discount(top_k_int=1):\n log_2 = tf.log(tf.constant... | [
"0.65538585",
"0.6481912",
"0.6384384",
"0.6360059",
"0.6212594",
"0.6171593",
"0.61645573",
"0.6149474",
"0.6141358",
"0.6097007",
"0.6049013",
"0.60426986",
"0.59782493",
"0.59467566",
"0.59015936",
"0.5899923",
"0.5890733",
"0.5869578",
"0.5842891",
"0.583804",
"0.5810907"... | 0.5687919 | 27 |
Handles a new ride for the bird. | def NewRide(self, ride, startTime):
self.currRide = ride
self.waitTimes.append(int(startTime) - int(self.idleTime)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ride(vehicle_id):\n form = EndRideForm()\n vehicle_at_start = movr.get_vehicle(vehicle_id)\n if vehicle_at_start is None: # Vehicle not found in database\n flash(\"Vehicle `{}` not found.\".format(vehicle_id))\n return redirect(url_for('vehicles', _external=True))\n elif not vehicle_... | [
"0.6446078",
"0.6432448",
"0.6353472",
"0.61630404",
"0.6094398",
"0.60312307",
"0.5896501",
"0.57249016",
"0.55817395",
"0.5569545",
"0.53594303",
"0.5137688",
"0.51246005",
"0.507295",
"0.5052853",
"0.50418717",
"0.5041374",
"0.50409484",
"0.5001274",
"0.4959977",
"0.495907... | 0.59893584 | 6 |
Completes the bird's active ride. | def CompleteRide(self,endTime,endX,endY):
ride = self.currRide
ride.EndRide(endX,endY,endTime)
self.totalDistance+=ride.GetDistance()
self.totalDuration+=ride.GetDuration()
self.rides.append(ride)
self.currRide = None
self.idleTime = endTime
self.Calculat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def end(self):\n # Stop driving\n self.robot.drivetrain.arcade_drive(0.0, 0.0)",
"def end(self, interrupted: bool) -> None:\n self.drive.arcadeDrive(0, 0)",
"def endCompetition(self):\n self.robot_exit = True",
"def complete(self):\n self._is_complete = True",
"def end(se... | [
"0.6222994",
"0.60794526",
"0.6044299",
"0.6004306",
"0.59830385",
"0.5944956",
"0.5893873",
"0.5867495",
"0.57774293",
"0.5750507",
"0.5740049",
"0.5732889",
"0.57264733",
"0.5721332",
"0.56923115",
"0.56396633",
"0.5600887",
"0.55898863",
"0.55898863",
"0.5544427",
"0.55334... | 0.6494587 | 0 |
Calculate the bird's distance from the drop point | def CalculateDistanceFromDropPoint(self,endPosX,endPosY):
R = 6371.0
startLat = math.radians(float(self.dropX))
startLong = math.radians(float(self.dropY))
endLat = math.radians(float(endPosX))
endLong = math.radians(float(endPosY))
longDist = endLong - startLong
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetDistanceFromDropPoint(self):\n return self.distanceFromDropPoint",
"def distance(self) -> float:\n return self._dist_two_wire() # at this time we only support 2-wire meausre",
"def compute_distance(self):\n loc = np.extend_dims(self.state[:, :, Boids.Attr.LOC], axis=-1)\n m ... | [
"0.71565235",
"0.6582328",
"0.65763086",
"0.6385657",
"0.62829095",
"0.62786025",
"0.6270165",
"0.6270165",
"0.6270165",
"0.6270165",
"0.6270165",
"0.6270165",
"0.6270165",
"0.62629414",
"0.62093073",
"0.61642647",
"0.6148952",
"0.6113482",
"0.61008674",
"0.60697323",
"0.6023... | 0.65202206 | 3 |
Getter for overall distance Return | def GetTotalDistanceTraveled(self):
return self.totalDistance | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_distance(self) -> int:\n return self.get_measurement_data().distance",
"def get(cls, approach):\n return approach.distance",
"def distance(self):\n return self._distance",
"async def distance(self):\n return round(await self._rpc.distance(), 2)",
"def _get_admin_distance... | [
"0.7741126",
"0.77363366",
"0.7720084",
"0.7548991",
"0.75194705",
"0.736661",
"0.7225689",
"0.72174215",
"0.7111943",
"0.70954406",
"0.7094097",
"0.7026749",
"0.6943714",
"0.6880381",
"0.68690765",
"0.6821791",
"0.67623985",
"0.6749115",
"0.67360604",
"0.669975",
"0.6680262"... | 0.7153402 | 8 |
Getter for distance from drop point Return | def GetDistanceFromDropPoint(self):
return self.distanceFromDropPoint | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def distance(self):\n return self._distance",
"def get_distance(self) -> int:\n return self.get_measurement_data().distance",
"def get_distance(start, end):\n\n\t\tloc_start, loc_end, dst_node = create_distance(start, end)\n\t\tdistance = cmds.getAttr(\"%s.distance\" % dst_node)\n\n\t\tcmds.delet... | [
"0.76265997",
"0.7575346",
"0.73508847",
"0.7346014",
"0.7258451",
"0.7191502",
"0.70774806",
"0.7016465",
"0.7005957",
"0.6948037",
"0.68207526",
"0.68057805",
"0.67899567",
"0.676611",
"0.6720881",
"0.6713946",
"0.6695198",
"0.6695198",
"0.6695198",
"0.6695198",
"0.6695198"... | 0.8377415 | 0 |
Getter for maximum wait time Return | def GetMaxWaitTime(self):
return max(self.waitTimes) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def MaxWaitTime(self):\r\n\t\treturn self._get_attribute('maxWaitTime')",
"def max_timeout(self):\n return self._max_timeout",
"def max_waiting(self):\n return self._max_waiting",
"def get_timeout(self) -> int:",
"def get_wait_timeout(self):\n if self.__wait_timeout is not None:\n ... | [
"0.82421374",
"0.8093026",
"0.8073709",
"0.7785421",
"0.7377285",
"0.7354005",
"0.730726",
"0.72938687",
"0.72644025",
"0.71912974",
"0.7185561",
"0.7089766",
"0.70715714",
"0.69640744",
"0.69640744",
"0.69523233",
"0.69438374",
"0.69140947",
"0.6854665",
"0.6839531",
"0.6828... | 0.81754684 | 1 |
Getter for total Duration Return | def GetTotalDuration(self):
return self.totalDuration | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_duration(self):\n return self.duration",
"def get_duration(self):\n return self._duration",
"def Duration(self):\r\n\t\treturn self._get_attribute('duration')",
"def Duration(self):\n\t\treturn self._get_attribute('duration')",
"def duration(self):\n return self._get('duration'... | [
"0.8640967",
"0.8465019",
"0.8192792",
"0.81764585",
"0.81736344",
"0.81567216",
"0.81567216",
"0.81567216",
"0.81567216",
"0.81567216",
"0.81567216",
"0.81567216",
"0.81567216",
"0.81281835",
"0.81279856",
"0.81210256",
"0.80905044",
"0.79546475",
"0.7880334",
"0.78671366",
... | 0.8545387 | 1 |
Getter for id Return | def GetID(self):
return self.id | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def id_getter(self):\n return self._id",
"def _get_id(self):\n return self.id",
"def id(self):\n return self.getattr('id')",
"def get_id(self):\n return self.id",
"def get_id(self):\n return self.id",
"def get_id(self):\n return self.id",
"def get_id(self):\n ... | [
"0.8621182",
"0.8557873",
"0.84580034",
"0.84160674",
"0.84160674",
"0.84160674",
"0.84160674",
"0.84160674",
"0.84160674",
"0.84160674",
"0.84160674",
"0.84160674",
"0.84160674",
"0.84160674",
"0.84160674",
"0.84160674",
"0.84160674",
"0.84160674",
"0.84160674",
"0.84160674",
... | 0.81307554 | 70 |
returns all options of the strip characters in required length | def bruteforce(strip, min_length, max_length):
return (''.join(char) for char in chain.from_iterable(product(strip, repeat=x)
for x in range(min_length, max_length+1))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _sanitize(self, opts_list):\n for opt in opts_list:\n if len(opt.strip()) == 0:\n opts_list.remove(opt)\n return opts_list",
"def lstrip(self, chars=None):\n return asarray(lstrip(self, chars))",
"def filter_min_length(self, string):\n newstring = strin... | [
"0.56886077",
"0.5513566",
"0.53906834",
"0.5386568",
"0.5321687",
"0.5275547",
"0.5219687",
"0.52139086",
"0.5201099",
"0.5179651",
"0.5171791",
"0.5100026",
"0.5069645",
"0.50526756",
"0.5038516",
"0.50358015",
"0.49880165",
"0.4964224",
"0.4960884",
"0.49529618",
"0.494691... | 0.60040057 | 0 |
data could be numpy array or list of lists of dataframe if x and y provided, assume a 2D data set with X and Y >> scatter if X only > imshow from array or pandas | def scatter_hist(x, y=None,
kargs_scatter={'s':20, 'c':'b'},
kargs_grids={},
kargs_histx={},
kargs_histy={},
hist_position='right',
width=.5,
height=.5,
offset_x=.10,
offset_y=.10,
gap=0.06,
grid=True,
**kargs):
# if 2... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def visualize_2d_data(X, y):\n assert len(X.shape) == len(y.shape) == 2, f\"Input/output pairs must be 2D-arrays. X: {X.shape}, y: {y.shape}\"\n (N, D) = X.shape\n assert N == y.shape[0], f\"Number of samples must match for input/output pairs. X: {N}, y: {y.shape[0]}\"\n assert D == 2, f\"Expected 2 fe... | [
"0.6581301",
"0.6562821",
"0.6548173",
"0.6538196",
"0.649233",
"0.64503056",
"0.63920987",
"0.6099296",
"0.6082181",
"0.60210073",
"0.6002888",
"0.59204847",
"0.59161323",
"0.5893735",
"0.5887856",
"0.5883411",
"0.58474094",
"0.5835318",
"0.58278733",
"0.58179444",
"0.578762... | 0.54975533 | 47 |
This function updates knownfaces dynamo table with the data derived from Slack and AWS Rekognition | def update_dynamo(username, userid, match_percentage, image_id, url, \
age, gender, smile, beard, happy, sad, angry):
put_into_dynamo = RekognitionKnown(
user_name = username,
slack_user_id = userid,
match_percentage = match_percentage,
image_id = image_id,
image_url = ur... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_data():\n fetch_missingpersons = request.get_json()\n update_data = MissingPerson.query.filter_by(id=fetch_missingpersons['id']).first()\n update_data.embedding = fetch_missingpersons['embedding']\n db.session.commit()\n return jsonify(fetch_missingpersons)",
"def update_unknown_dynamo(... | [
"0.5749878",
"0.56376445",
"0.55223274",
"0.5288706",
"0.5233593",
"0.5223677",
"0.5190544",
"0.51581466",
"0.51386875",
"0.5101116",
"0.50991535",
"0.50734353",
"0.5036171",
"0.5016885",
"0.49960828",
"0.496741",
"0.49518254",
"0.4918262",
"0.49122834",
"0.49036375",
"0.4895... | 0.6076229 | 0 |
This function updates unknownfaces dynamo table with the data derived AWS Rekognition | def update_unknown_dynamo(url, age, gender, \
smile, beard, happy, sad, angry):
put_into_unknown_dynamo = RekognitionUnknown(
image_url = url,
age_range = age,
gender = gender,
is_smiling = smile,
has_beard = beard,
is_happy = happy,
is_sad = sad,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_dynamo(username, userid, match_percentage, image_id, url, \\\n age, gender, smile, beard, happy, sad, angry):\n put_into_dynamo = RekognitionKnown(\n user_name = username,\n slack_user_id = userid,\n match_percentage = match_percentage,\n image_id = image_id,\n i... | [
"0.6149813",
"0.5659518",
"0.56375855",
"0.5558385",
"0.54713255",
"0.5422148",
"0.5335955",
"0.5258836",
"0.5254008",
"0.5233241",
"0.5213646",
"0.51518",
"0.5145294",
"0.51217556",
"0.51177675",
"0.5106467",
"0.5100847",
"0.50853866",
"0.50845665",
"0.5082567",
"0.5066661",... | 0.6175062 | 0 |
Returns a default LabelStoreConfig to fill in any missing ones. | def get_default_label_store(self, scene: SceneConfig) -> LabelStoreConfig:
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_default_config(cls):\n default = super(LSHNearestNeighborIndex, cls).get_default_config()\n\n lf_default = plugin.make_config(get_lsh_functor_impls())\n default['lsh_functor'] = lf_default\n\n di_default = plugin.make_config(get_descriptor_index_impls())\n default['descri... | [
"0.6221486",
"0.60220504",
"0.5819019",
"0.5805407",
"0.5782555",
"0.57711416",
"0.57619035",
"0.57562435",
"0.5748874",
"0.56956226",
"0.56690294",
"0.5653731",
"0.5632784",
"0.55963796",
"0.55954915",
"0.55846584",
"0.55831254",
"0.55684423",
"0.5543517",
"0.55301565",
"0.5... | 0.77048916 | 0 |
Returns a default EvaluatorConfig to use if one isn't set. | def get_default_evaluator(self) -> EvaluatorConfig:
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_default_config():\n # pylint: disable=cyclic-import\n from raylab.agents.sac import DEFAULT_CONFIG\n\n return DEFAULT_CONFIG",
"def get_default_config(self):\n return config.read(pathlib.Path(__file__).parent / \"ext.conf\")",
"def default(self):\n return self._config... | [
"0.69978195",
"0.67205906",
"0.6683171",
"0.6621579",
"0.63026786",
"0.62763005",
"0.62488645",
"0.62030625",
"0.61780494",
"0.61780494",
"0.6141372",
"0.6116631",
"0.6102302",
"0.6101332",
"0.60781455",
"0.6034338",
"0.6029229",
"0.60245436",
"0.5991673",
"0.5976192",
"0.596... | 0.85756123 | 0 |
Add intervals to the figure as rectangles. | def _generate_rectangle(figure: plotting.figure, source: plotting.ColumnDataSource):
return figure.rect(
x="x",
y="y",
width="width",
height="height",
line_color="#000000",
fill_color="color",
fill_alpha=0.7,
line_width=1.5,
source=source,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw_rects(self):\n width = 1.0 / self.rows\n height = 1.0 / self.rows\n\n for x in xrange(0, self.rows, 1):\n for y in xrange(0, self.rows, 1):\n rect = Rectangle((x/float(self.rows), y/float(self.rows)), width, height, facecolor=\"#000000\")\n sel... | [
"0.7189564",
"0.6219012",
"0.6094361",
"0.60833675",
"0.60436827",
"0.60337275",
"0.602918",
"0.60240656",
"0.60226893",
"0.6018765",
"0.6016253",
"0.59641397",
"0.5936662",
"0.5932538",
"0.59318054",
"0.5924499",
"0.580369",
"0.57975924",
"0.57900375",
"0.5789951",
"0.571219... | 0.56621635 | 24 |
Visualization routine for generating a calendar visualization with Bokeh. | def _bokeh_visualization(
calendar: "Calendar",
n_years: int,
relative_dates: bool,
add_yticklabels: bool = True,
**kwargs,
) -> plotting.figure:
if add_yticklabels:
tooltips = [
("Interval", "@desc"),
("Size", "@width_days days"),
("Type", "@type"),
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bokeh_dashboard_creator(dataframe):\r\n ############################################\r\n # Revenue, Impressions by Day by Partner\r\n ############################################\r\n \r\n output_file(\"dashboard.html\")\r\n \r\n df = dataframe\r\n df['Day'] = pd.to_datetime(df['Day'])\r... | [
"0.68911076",
"0.68793774",
"0.60817",
"0.6039826",
"0.5992555",
"0.5942231",
"0.5935102",
"0.58497673",
"0.58346933",
"0.57104707",
"0.56599814",
"0.565917",
"0.5641684",
"0.5613914",
"0.56110364",
"0.56102514",
"0.55630434",
"0.5560685",
"0.5560528",
"0.5540341",
"0.553218"... | 0.7399681 | 0 |
Visualization routine for generating a calendar visualization with Bokeh. | def bokeh_visualization(
calendar,
n_years: int,
relative_dates: bool,
add_yticklabels: bool = True,
**kwargs,
) -> None:
bokeh_fig = _bokeh_visualization(
calendar, n_years, relative_dates, add_yticklabels, **kwargs
)
if "pytest" in sys.modules: # Do not open browser if we are ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _bokeh_visualization(\n calendar: \"Calendar\",\n n_years: int,\n relative_dates: bool,\n add_yticklabels: bool = True,\n **kwargs,\n) -> plotting.figure:\n if add_yticklabels:\n tooltips = [\n (\"Interval\", \"@desc\"),\n (\"Size\", \"@width_days days\"),\n ... | [
"0.7399681",
"0.68911076",
"0.60817",
"0.6039826",
"0.5992555",
"0.5942231",
"0.5935102",
"0.58497673",
"0.58346933",
"0.57104707",
"0.56599814",
"0.565917",
"0.5641684",
"0.5613914",
"0.56110364",
"0.56102514",
"0.55630434",
"0.5560685",
"0.5560528",
"0.5540341",
"0.553218",... | 0.68793774 | 2 |
removes file without error on non existing file | def silent_remove(filename):
try:
os.remove(filename)
except OSError as err:
if err.errno != errno.ENOENT: # errno.ENOENT = no such file or directory
raise # re-raise exception if a different error occurred | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _removeFile(self, filename):\n try:\n #delete the output file\n os.remove(filename)\n except:\n #print (\"Failed to remove the file: \" + filename)\n pass",
"def rm_file(filename):\n try:\n os.unlink(filename)\n except FileNotFoundError:\... | [
"0.81589264",
"0.8088351",
"0.8077004",
"0.7990209",
"0.7931335",
"0.7897219",
"0.7851091",
"0.7844677",
"0.7837529",
"0.7830017",
"0.7830017",
"0.7794231",
"0.77705145",
"0.77115726",
"0.76478285",
"0.7643525",
"0.7634688",
"0.7624167",
"0.7613937",
"0.76029307",
"0.7598251"... | 0.75850594 | 23 |
main function to track fish | def main():
parser = argparse.ArgumentParser(description="Tracks adult fish")
# add options for argument parser
parser.add_argument("in_path",
help="Path to the video directory.")
parser.add_argument("out_path",
help="Directory for results. Should be empty... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def falcon():",
"def main():\n ff = FileForensics()\n # ff.scan_dir(\"/Users/ns/notes\") # FIXME\n ff.scan_dir(\"/Users/ns/work/termination_data\")\n\n print \"\\n--- BIG FILES ---\"\n for (size, mime, filename) in ff.get_big_files():\n print (bcolors.FAIL+\"{:>10} MB\"+bcolors.ENDC+\" {... | [
"0.626659",
"0.592361",
"0.5907526",
"0.59051025",
"0.5881423",
"0.587882",
"0.58329105",
"0.58329105",
"0.58329105",
"0.58329105",
"0.58329105",
"0.58329105",
"0.58329105",
"0.58329105",
"0.58329105",
"0.58329105",
"0.58329105",
"0.58329105",
"0.58329105",
"0.58329105",
"0.5... | 0.5814685 | 31 |
Registers a global stack transformation that merges a set of tags with whatever was also explicitly added to the resource definition. | def register_auto_tags(auto_tags: Mapping[str, str]) -> None:
pulumi.runtime.register_stack_transformation(lambda args: auto_tag(args, auto_tags)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_tags(event):\n\n add_tags_from_presets()",
"def add_tags_to_resource(ResourceId=None, Tags=None):\n pass",
"def hook_tags_for_projects(task):\n if task['project'] in TAGS_FOR_PROJECTS.keys():\n for tag in TAGS_FOR_PROJECTS[task['project']]:\n task['tags'].add(tag)",
"def au... | [
"0.5524886",
"0.54226065",
"0.51583046",
"0.51563334",
"0.50898856",
"0.506334",
"0.49708322",
"0.49250105",
"0.4869671",
"0.48399723",
"0.48346636",
"0.47867766",
"0.47468102",
"0.47392708",
"0.47238922",
"0.4723705",
"0.46952054",
"0.46935907",
"0.46483028",
"0.46255636",
"... | 0.61592054 | 0 |
Applies the given tags to the resource properties if applicable. | def auto_tag(
args: pulumi.ResourceTransformationArgs, auto_tags: Mapping[str, str]
) -> pulumi.ResourceTransformationResult | None:
if is_taggable(args.type_):
# Ignore the typing because this is code we didn't actually
# write (see note above)
args.props["tags"] = {**(args.props["tags"... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_property(self, resources, resource, model, prop, context):\n pass",
"def add_tags_to_resource(ResourceId=None, Tags=None):\n pass",
"def remove_tags_from_resource(ResourceId=None, TagKeys=None):\n pass",
"def add_tags():\n\n tags = shallow_copy(e['ResourceProperties'].get('Tag... | [
"0.6113242",
"0.58627033",
"0.54521155",
"0.5443542",
"0.54036754",
"0.5331512",
"0.52759224",
"0.52736276",
"0.5259163",
"0.5252262",
"0.5227304",
"0.5164752",
"0.5161838",
"0.511677",
"0.50644654",
"0.50644654",
"0.50644654",
"0.5043394",
"0.5038415",
"0.5038415",
"0.503841... | 0.0 | -1 |
Returns true if the given resource type is an AWS resource that supports tags. | def is_taggable(t: str) -> bool:
return t in taggable_resource_types | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def IsTagExists(self, ResourceId, TagName):\n\n try:\n if self.Service == 'ec2':\n response = self.DescribeTags(ResourceId)\n if TagName in list(map(lambda x: x['Key'], [x for x in response['Tags']])):\n return True\n elif self.Service =... | [
"0.6399579",
"0.63201123",
"0.62766284",
"0.6256046",
"0.62011147",
"0.61333555",
"0.6058019",
"0.6058019",
"0.5869327",
"0.5817959",
"0.57866144",
"0.5778956",
"0.57481205",
"0.57481205",
"0.57481205",
"0.5704926",
"0.5670921",
"0.5625209",
"0.55327207",
"0.551816",
"0.54557... | 0.7635412 | 0 |
Data providing function. Run type argument specifies which set of data to load, e.g. augmented, denoised. | def data():
run_type = 'standardised'
sr = 48000
train_perc = 0.9
if sr == 48000:
time_dimension = 282
if sr == 44100:
time_dimension = 259
x_train, y_train, x_test, y_test = essential.compile_dataset(run_type, sr)
# reshape for CNN input
x_train = np.array([x.reshape... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_data (arguments):\n if arguments.define_labels:\n data.define_labels()\n elif arguments.preprocess:\n # Preprocess from data_raw --> data_preprocessed\n data.preprocess()\n elif arguments.annotate:\n # Annotate from data_preprocessed --> data_annotated\n reverse = False # DEBUG\n annot... | [
"0.64160925",
"0.6190907",
"0.60048896",
"0.5920387",
"0.5856521",
"0.58437264",
"0.580692",
"0.5792205",
"0.57894427",
"0.5783844",
"0.57578003",
"0.57564956",
"0.5756411",
"0.5743674",
"0.5704999",
"0.5696924",
"0.5683071",
"0.56713223",
"0.56644464",
"0.5656992",
"0.564022... | 0.0 | -1 |
Saves the running configuration to memory | def write_mem(self):
request = 'commands/writemem'
return self._post(request) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save():\n\n env.config.save(env.config_file)",
"def save(self):\r\n with open(self.filename, 'wb') as configfile:\r\n self.write(configfile)",
"def save(self):\n file = open(self.path, 'w')\n self.config.write(file)\n file.close()",
"def save_config(self):\n ... | [
"0.7493188",
"0.72542393",
"0.72524124",
"0.72474897",
"0.71941704",
"0.7145096",
"0.709614",
"0.70905155",
"0.6976864",
"0.6925252",
"0.69204694",
"0.68928176",
"0.68441886",
"0.68203056",
"0.6806835",
"0.67773426",
"0.6760707",
"0.67580456",
"0.6750563",
"0.67335844",
"0.67... | 0.0 | -1 |
add a file full of user agents to use The loading of more than one user agent implies the use of random user agents. | def add_user_agent(self, useragent_path):
with open(useragent_path) as wordlist_f:
for useragent in wordlist_f.read().split("\n"):
useragent = useragent.strip()
if useragent:
self.user_agents.append(useragent) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_user_agents(self, file_name):\n with open(file_name) as f:\n self.user_agents = json.load(f)\n self.headers[\"User-Agent\"] = random.choice(self.user_agents)",
"def add_user_agent(self, value):\n # type: (str) -> None\n self.user_agent_policy.add_user_agent(value)",... | [
"0.7073403",
"0.70005083",
"0.65844756",
"0.64439905",
"0.6365973",
"0.62721574",
"0.62331593",
"0.6203372",
"0.6203372",
"0.6193418",
"0.6089249",
"0.59869266",
"0.5959281",
"0.5702221",
"0.55101806",
"0.5510148",
"0.54230016",
"0.5420298",
"0.5412782",
"0.5324192",
"0.53180... | 0.8312047 | 0 |
Run a full attack on the domain with which we have been configured. Brute force a directory and file structure based on the wordlists with which we have been configured. | def brute(self, follow_redirects, max_depth, method="GET"):
"""TODO option to make max_depth be obeyed relative to the
last
successful dir?
ie: with max_depth 3, example.com/fail/fail/fail fails out but
once we hit example.com/fail/success/, keep going until we hit
exam... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def runAttacks(self,\n policy: Policy,\n outputDir: str=None):\n outputDir = policy.getOutputDir(parent=outputDir) if \\\n policy else outputDir\n\n acCache = AccessListCache.get()\n acListInst = acCache.getAccessListFromPolicy(policy)\n\n ... | [
"0.61052847",
"0.5582462",
"0.5421415",
"0.5398599",
"0.5380833",
"0.52952486",
"0.5163187",
"0.5157558",
"0.50875354",
"0.50039095",
"0.49987626",
"0.4996667",
"0.49739432",
"0.4954363",
"0.4850667",
"0.4829968",
"0.47634757",
"0.47529042",
"0.47518617",
"0.47344095",
"0.472... | 0.5599937 | 1 |
initialize your data structure here. | def __init__(self):
self.stack=[]
self.top1=-1
| {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_empty(self):\n self._data = []",
"def __init__(self):\n self.data = []\n self.record = {}",
"def __init__(self):\n self.structure = {}",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self... | [
"0.7761043",
"0.76102185",
"0.7555967",
"0.7549892",
"0.7549892",
"0.7549892",
"0.7549892",
"0.7549892",
"0.7549892",
"0.752797",
"0.7446006",
"0.7446006",
"0.7446006",
"0.7446006",
"0.7446006",
"0.743338",
"0.743338",
"0.7408609",
"0.7385719",
"0.737986",
"0.737986",
"0.73... | 0.0 | -1 |
Computes the discounted reward for the entire episode. | def accumulate_rewards(rewards, gamma):
reversed_rewards = rewards[::-1] # list reversal
acc = list(itertools.accumulate(reversed_rewards, lambda x, y: x*gamma + y))
return np.array(acc[::-1]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def discount_and_normalize_rewards(self, episode_rewards):\n # Get empty array with the same size as the rewards array\n discounted_episode_rewards = np.zeros_like(episode_rewards)\n\n # Variable that stores value of the discounted reward being calculated by the loop\n current_reward = ... | [
"0.74826664",
"0.7430066",
"0.741672",
"0.7255326",
"0.71947306",
"0.7184354",
"0.71606743",
"0.7058474",
"0.6957285",
"0.69207364",
"0.6917125",
"0.6786361",
"0.6777256",
"0.675367",
"0.6746068",
"0.6699113",
"0.6676255",
"0.6666142",
"0.6660753",
"0.6658038",
"0.6646817",
... | 0.0 | -1 |
The function formats the data into input, output format for keras. | def format_data(data_history, gamma, constant_baseline=0.0):
inp_rec_seq, inp_reward_seq, output_recs, reward_weights = [], [], [], []
for curr_recs, curr_rewards in zip(data_history['recommendation_seqs'],
data_history['reward_seqs']):
inp_rec_seq.append(curr_recs[:-1])
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _format_data(self, data: np.ndarray) -> np.ndarray:\n if self._validate:\n if len(data.shape) <= 1:\n raise DataProcessorError(\n \"The data should be an array with at least two dimensions.\"\n )\n\n return data",
"def format_data(self... | [
"0.6314015",
"0.6246027",
"0.6231632",
"0.61880815",
"0.6053848",
"0.6035714",
"0.59119385",
"0.58998334",
"0.58435905",
"0.5785506",
"0.57303697",
"0.57288903",
"0.5716272",
"0.56407213",
"0.5639877",
"0.56329596",
"0.5605512",
"0.5576301",
"0.55761236",
"0.5567073",
"0.5542... | 0.5448296 | 27 |
The function formats the data into input, output format for keras. This function is specific to the implementation of CVaR safety constraint. | def format_data_safe_rl(data_history, gamma, constant_baseline=0.0):
inp_rec_seq, inp_reward_seq, output_recs, reward_weights = [], [], [], []
trajectories_cost = []
for curr_recs, curr_rewards, curr_safety_costs in zip(
data_history['recommendation_seqs'],
data_history['reward_seqs'],
data_hist... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _format_data(self, data: np.ndarray) -> np.ndarray:\n if self._validate:\n if len(data.shape) <= 1:\n raise DataProcessorError(\n \"The data should be an array with at least two dimensions.\"\n )\n\n return data",
"def _format_data(sel... | [
"0.6250772",
"0.5920552",
"0.5892971",
"0.5890803",
"0.5845975",
"0.5780606",
"0.54537845",
"0.54380304",
"0.5425152",
"0.5380497",
"0.5314547",
"0.5235957",
"0.5224633",
"0.5224549",
"0.51962775",
"0.51615614",
"0.51596385",
"0.5113475",
"0.5094499",
"0.5078179",
"0.50427276... | 0.49504268 | 31 |
Format data for movielens RNN agent update step. | def format_data_movielens(data_history, gamma, constant_baseline=0.0,
mask_already_recommended=False, user_id_input=True,
**kwargs):
inp_rec_seq, inp_reward_seq, output_recs, reward_weights = [], [], [], []
user_id_seq = []
trajectories_cost = []
if mask_alrea... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def format_data(self, data):",
"def format(self, data):",
"def _formatData(self):\r\n assert self._runData is not None\r\n\r\n # Getting Axes data into separate lists\r\n x=[]; y=[]; z=[]\r\n for i in range(len(self._runData)):\r\n ySet = []; xSet = []; zSet = []\r\n ... | [
"0.62151235",
"0.61034393",
"0.5625424",
"0.5501767",
"0.5371727",
"0.533092",
"0.5279299",
"0.5247887",
"0.5191981",
"0.5178478",
"0.5173216",
"0.51704234",
"0.51599264",
"0.5084671",
"0.5054417",
"0.50439805",
"0.50328034",
"0.5023124",
"0.49991286",
"0.49879792",
"0.491233... | 0.0 | -1 |
Format data for movielens RNN agent update step. | def format_data_batch_movielens(data_history,
gamma,
constant_baseline=0.0,
mask_already_recommended=False,
user_id_input=True,
**kwargs):
inp_rec_seq, inp_re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def format_data(self, data):",
"def format(self, data):",
"def _formatData(self):\r\n assert self._runData is not None\r\n\r\n # Getting Axes data into separate lists\r\n x=[]; y=[]; z=[]\r\n for i in range(len(self._runData)):\r\n ySet = []; xSet = []; zSet = []\r\n ... | [
"0.62151235",
"0.61034393",
"0.5625424",
"0.5501767",
"0.5371727",
"0.533092",
"0.5279299",
"0.5247887",
"0.5191981",
"0.5178478",
"0.5173216",
"0.51704234",
"0.51599264",
"0.5084671",
"0.5054417",
"0.50439805",
"0.50328034",
"0.5023124",
"0.49991286",
"0.49879792",
"0.491233... | 0.0 | -1 |
Loads RNNAgent model from the path. | def load_model(filepath,
optimizer_name,
learning_rate=None,
momentum=None,
gradient_clip_value=None,
gradient_clip_norm=None):
tmp_model_file_path = os.path.join(tempfile.gettempdir(), 'tmp_model.h5')
file_util.copy(filepath, tmp_model_file... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_model(self, model_path: str):",
"def load_model(self, path):\n pass",
"def load(path_to_model):\n pass",
"def load_model(self):\n if os.stat('code/lr-model.pt').st_size == 0:\n return\n params = torch.load('code/lr-model.pt')\n self.set_params(params)",
... | [
"0.7680528",
"0.76016873",
"0.7450854",
"0.74493736",
"0.73280495",
"0.72616035",
"0.72341067",
"0.72091913",
"0.7154966",
"0.71253365",
"0.7112163",
"0.711106",
"0.7059853",
"0.6976574",
"0.6972874",
"0.6958696",
"0.6945698",
"0.6940508",
"0.693897",
"0.69260585",
"0.6889142... | 0.0 | -1 |
Produce a message to be sent to the client | async def producer():
# TODO
await asyncio.sleep(1)
return "Test" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write(self, msg):\n cmd = self.__compose(msg)\n self.sock.send(cmd)",
"def produce(self, message):\n self.producer.send(self.topic, message)",
"async def send(self, message):",
"def send(self, msg):\n self.message('Me', msg)",
"def send(self, msg):\n pass",
"def... | [
"0.67657566",
"0.67215765",
"0.6719323",
"0.6709652",
"0.66985375",
"0.66985375",
"0.66985375",
"0.6639729",
"0.663648",
"0.65998",
"0.6583822",
"0.6571753",
"0.6563523",
"0.6556051",
"0.6508014",
"0.6472861",
"0.6471602",
"0.6410295",
"0.63898164",
"0.63897264",
"0.6379636",... | 0.0 | -1 |
Handle an incoming message from the client | async def consumer(message):
# TODO
print(message) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handle(self, message):\n print(\"You received a message:\")\n print(message)\n # Overwrite this function to do something with the message!",
"def handle(self, message):",
"def _handle_message(self, msg):\n self.event('message', msg)",
"def handle(self):\n self.ip = self... | [
"0.80266124",
"0.7809786",
"0.77366966",
"0.76922536",
"0.76625097",
"0.76180035",
"0.75640327",
"0.7540196",
"0.7486705",
"0.7470195",
"0.7465139",
"0.7313078",
"0.7188383",
"0.71748143",
"0.71278876",
"0.7114025",
"0.7101321",
"0.7091043",
"0.7091043",
"0.70842177",
"0.7083... | 0.0 | -1 |
Handle sending to and receiving from client | async def handler(websocket, path):
print("Connected")
# print(vars(websocket))
# global connected
# # Register.
# connected.add(websocket)
# try:
# # Implement logic here.
# await asyncio.wait([ws.send("Hello!") for ws in connected])
# await asyncio.sleep(10)
#... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handle(self):\n self.ip = self.client_address[0]\n self.port = self.client_address[1]\n self.connection = self.request\n #self.logged_in = False\n\n # Loop that listens for messages from the client\n while True:\n received_string = self.connection.recv(4096)... | [
"0.708529",
"0.7018448",
"0.69944143",
"0.6946621",
"0.69224364",
"0.6911591",
"0.6822991",
"0.6816772",
"0.6740385",
"0.67231447",
"0.66530687",
"0.6620048",
"0.6618178",
"0.6612965",
"0.66045904",
"0.65902686",
"0.65812224",
"0.6549281",
"0.65410584",
"0.652811",
"0.6524247... | 0.0 | -1 |
Get the checkpoint path from the given model output directory | def _get_checkpoint(self):
ckpt = tf.train.get_checkpoint_state(self.model)
if ckpt and ckpt.model_checkpoint_path:
ckpt_path = ckpt.model_checkpoint_path
else:
raise RuntimeError('No checkpoint file found')
return ckpt_path | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def output_dir(self):\n return os.path.join(self.checkpoint_dir, self.model_dir)",
"def _checkpoint_dir(job_log_dir: str) -> str:\n return os.path.join(job_log_dir, 'checkpoints')",
"def get_checkpoint_path(self) -> str:\n return self._j_checkpoint_storage.getCheckpointPath().toString()",
"def... | [
"0.8124849",
"0.7751144",
"0.7577298",
"0.746758",
"0.7276259",
"0.71268463",
"0.7119968",
"0.7004831",
"0.6968759",
"0.6910264",
"0.68485147",
"0.6757792",
"0.6754972",
"0.67422986",
"0.67221975",
"0.6708189",
"0.6678933",
"0.6621704",
"0.65912944",
"0.65912944",
"0.6507298"... | 0.7458354 | 4 |
String for representing the Organization object (in Admin site etc.). | def __str__(self):
if self.name != None and self.name != '':
return self.name
else:
return "Organization object owned by %s."%(self.owner) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self):\n return str('%s (%s)' % (self.company, self.owner))",
"def organization_name(self):\n if self.organization is not None:\n return self.organization.name\n\n return ''",
"def org_urn(self):\n return f\"psc:org:{self.credentials.org_key}\"",
"def organi... | [
"0.7165319",
"0.6806214",
"0.6790389",
"0.64104795",
"0.6407919",
"0.6346011",
"0.6310931",
"0.63100046",
"0.630681",
"0.6305702",
"0.6300019",
"0.62802875",
"0.6278159",
"0.6271169",
"0.626531",
"0.62608826",
"0.6247357",
"0.620912",
"0.6205226",
"0.61515045",
"0.61467075",
... | 0.76456773 | 0 |
Return a graph of station data. | def data_graph():
station_reference = request.args.get("stationReference")
station_name = request.args.get("stationName")
station_name = station_name.replace(" ","+")
if station_name is not None:
# station_data = station_data.replace(" ", "+")
station = station_data.loc[station_data.sta... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stationdata():\n # * Return a JSON list of stations from the dataset.\n # as this should be a list, I'm just grabbing the station name\n session = Session(engine)\n results = session.query(Station.name).all()\n session.close()\n\n stations = list(np.ravel(results))\n return jsonify(stati... | [
"0.67551476",
"0.656002",
"0.65165",
"0.6463983",
"0.64335907",
"0.6389499",
"0.6388792",
"0.638696",
"0.6359457",
"0.6335296",
"0.6310423",
"0.6298127",
"0.62936765",
"0.6238035",
"0.6215655",
"0.6190057",
"0.6184878",
"0.61778945",
"0.617618",
"0.61750436",
"0.61674297",
... | 0.5977963 | 41 |
Return station tide info. | def draw_html():
station_reference = request.args.get("stationReference")
station_name = request.args.get("stationName")
station_name = station_name.replace(" ","+")
# print("**********")
# print(station_name)
# print("**********")
# print("**********")
# print(station_data.stationName)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_station(station_id):\n return STATIONS.station_details_for(station_id)",
"def weatherstation_info_command(station_id):\n station = stations.get_station(station_id)\n print(station)",
"def get_station_boroughs(self):\\",
"def prism_station_details(self, station_id):\n if self.cursor is... | [
"0.6912989",
"0.6862332",
"0.64211416",
"0.63385594",
"0.6311428",
"0.60967267",
"0.608455",
"0.6082878",
"0.60771835",
"0.60742456",
"0.60365105",
"0.60324866",
"0.59842825",
"0.5912893",
"0.588451",
"0.5863232",
"0.5842666",
"0.58136994",
"0.58136994",
"0.58052826",
"0.5803... | 0.0 | -1 |
Generates nonlinearly separable data and returns the samples and class labels | def load_non_linearly_separable_data():
x, y = make_gaussian_quantiles(n_features=2, n_classes=2, random_state=1)
assert np.bitwise_or(y == 0, y == 1).all()
return x, y | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_data(groups):\n # get path list for the intended classification problem\n input_paths = generate_input_list(groups) \n X_lst = []\n y = []\n for p in input_paths:\n dp = pd.read_csv(p, sep = '\\t') #datapoint\n # Normalization \n # norm = lambda x: (x - x.mean()) / ... | [
"0.6725396",
"0.64309126",
"0.63958347",
"0.63937193",
"0.6377529",
"0.636468",
"0.63290304",
"0.62903607",
"0.6288107",
"0.6281172",
"0.62540567",
"0.62314403",
"0.62133723",
"0.6178726",
"0.614421",
"0.6132435",
"0.612361",
"0.61162657",
"0.6115919",
"0.6110773",
"0.6107986... | 0.60316014 | 26 |
setup GPU device if available, move model into configured device | def _prepare_device(self, n_gpu_use):
n_gpu = torch.cuda.device_count()
if n_gpu_use > 0 and n_gpu == 0:
self.logger.warning(
"Warning: There\'s no GPU available on this machine, training will be performed on CPU.")
n_gpu_use = 0
if n_gpu_use > n_gpu:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_device(n_gpus: int) -> object:\n if n_gpus >= 1 and torch.cuda.is_available():\n LOG.info('\\n CUDA is available! using GPU...')\n return torch.device('cuda')\n else:\n LOG.info('\\n Using CPU...')\n return torch.device('cpu')",
"def create_gpu_device_if_present():\n ... | [
"0.7189841",
"0.6974946",
"0.68392825",
"0.68199843",
"0.67975026",
"0.6781155",
"0.67694235",
"0.6714223",
"0.6713853",
"0.6688746",
"0.66411406",
"0.66013426",
"0.6601249",
"0.65606564",
"0.6550351",
"0.6538365",
"0.6532433",
"0.6494333",
"0.6494088",
"0.6472267",
"0.645544... | 0.6146334 | 42 |
Training logic for an epoch | def _train_epoch(self, epoch):
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train_one_epoch(self):\n raise NotImplementedError",
"def train(self, training_steps=10):",
"def train():\n pass",
"def train_epoch(self, data_loader):\n raise NotImplementedError",
"def train(self):\n self.epoch = 0\n self.step = 0\n self.start_time = time.tim... | [
"0.81284416",
"0.8044275",
"0.795282",
"0.7818035",
"0.7789884",
"0.7776823",
"0.7748766",
"0.7745458",
"0.77287894",
"0.7725468",
"0.76904434",
"0.7620618",
"0.7620618",
"0.7620618",
"0.7620618",
"0.7620618",
"0.76109827",
"0.75628734",
"0.7556383",
"0.7547646",
"0.7536899",... | 0.84083605 | 2 |
Resume from saved checkpoints | def _resume_checkpoint(self, resume_path):
self.logger.info("Loading checkpoint: {} ...".format(resume_path))
checkpoint = torch.load(resume_path)
self.start_epoch = checkpoint['epoch'] + 1
self.mnt_best = checkpoint['monitor_best']
# load model params from checkpoint.
i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resume(self, checkpoint):\n model_dict = paddle.load(checkpoint)\n self.model.set_state_dict(model_dict)",
"def _resume_checkpoint(self, resume_path):\n self.logger.info(\"Loading checkpoint: {} ...\".format(resume_path))\n checkpoint = torch.load(resume_path)\n self.start_... | [
"0.7948833",
"0.79420406",
"0.7860005",
"0.7762703",
"0.7674831",
"0.7672587",
"0.75724417",
"0.74276704",
"0.72801906",
"0.72801906",
"0.72801906",
"0.72574735",
"0.71175265",
"0.7104059",
"0.71037406",
"0.7057032",
"0.6996928",
"0.69433475",
"0.69009686",
"0.68490225",
"0.6... | 0.78904974 | 2 |
Yields counts of character ngrams from string s of order n. | def extract_char_ngrams(self, s: str, n: int) -> Counter:
return Counter([s[i:i + n] for i in range(len(s) - n + 1)]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extract_char_ngrams(s: str, n: int) -> Counter:\n return Counter([s[i:i + n] for i in range(len(s) - n + 1)])",
"def precook(s, n=4, out=False):\n words = s.split()\n counts = defaultdict(int)\n for k in xrange(1,n+1):\n for i in xrange(len(words)-k+1):\n ngram = tuple(words[i:i+k])\n coun... | [
"0.82485414",
"0.76264787",
"0.73532337",
"0.73268604",
"0.71129584",
"0.7092459",
"0.70224917",
"0.6941578",
"0.6845443",
"0.67267495",
"0.6712389",
"0.6680387",
"0.66529167",
"0.6583822",
"0.6576275",
"0.65749717",
"0.65712875",
"0.6563945",
"0.6559195",
"0.6554432",
"0.653... | 0.8287722 | 1 |
Yields counts of character ngrams from string s of order n. | def extract_char_ngrams(self, s: str, n: int) -> Counter:
return Counter([s[i:i + n] for i in range(len(s) - n + 1)]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extract_char_ngrams(s: str, n: int) -> Counter:\n return Counter([s[i:i + n] for i in range(len(s) - n + 1)])",
"def precook(s, n=4, out=False):\n words = s.split()\n counts = defaultdict(int)\n for k in xrange(1,n+1):\n for i in xrange(len(words)-k+1):\n ngram = tuple(words[i:i+k])\n coun... | [
"0.82485414",
"0.76264787",
"0.73532337",
"0.73268604",
"0.71129584",
"0.7092459",
"0.70224917",
"0.6941578",
"0.6845443",
"0.67267495",
"0.6712389",
"0.6680387",
"0.66529167",
"0.6583822",
"0.6576275",
"0.65749717",
"0.65712875",
"0.6563945",
"0.6559195",
"0.6554432",
"0.653... | 0.8287722 | 0 |
Computes ChrF on a single sentence pair. | def sentence_score(self, hypothesis: str, references: List[str]) -> CHRFScore:
hypothesis, references = references[0], [hypothesis]
assert not isinstance(references, str), \
"sentence_score needs a list of references, not a single string"
stats = self.get_sentence_statistics(hypothe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def chrf(hypotheses, references):\n return sacrebleu.corpus_chrf(hypotheses=hypotheses, references=references)",
"def _chrf_score_compute(total_preds_char_n_grams: Dict[int, Tensor], total_preds_word_n_grams: Dict[int, Tensor], total_target_char_n_grams: Dict[int, Tensor], total_target_word_n_grams: Dict[int,... | [
"0.6330933",
"0.60219",
"0.5845918",
"0.5628675",
"0.55938405",
"0.55922145",
"0.55860597",
"0.5574938",
"0.555412",
"0.5540551",
"0.5536721",
"0.55080277",
"0.5410617",
"0.5399693",
"0.5389467",
"0.53649914",
"0.52740103",
"0.5269019",
"0.5247514",
"0.5240202",
"0.52391034",... | 0.5269137 | 17 |
Extracts all the ngrams (min_order <= n <= max_order) from a sequence of tokens. | def extract_ngrams(line, min_order=1, max_order=BLEU.NGRAM_ORDER) -> Counter:
ngrams = Counter() # type: Counter
tokens = line.split()
for n in range(min_order, max_order + 1):
for i in range(0, len(tokens) - n + 1):
ngram = ' '.join(tokens[i: i + n])
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def n_grams(tokens, n):\n return zip(*[tokens[i:] for i in range(n)])",
"def build_ngrams(tokens, n=2):\n ngrams = zip(*(islice(group, idx, None) for idx, group in enumerate(tee(tokens, n))))\n return ngrams",
"def get_ngrams(tokens, min_n, max_n):\n all_ngrams = list()\n n_tokens = len(tokens)\... | [
"0.8024978",
"0.78923404",
"0.7772897",
"0.75658435",
"0.75516206",
"0.7496225",
"0.7459337",
"0.7409229",
"0.7395054",
"0.7372828",
"0.7341489",
"0.728606",
"0.7244324",
"0.7237867",
"0.72247565",
"0.7176616",
"0.7175382",
"0.71394616",
"0.71245074",
"0.71214175",
"0.7113682... | 0.7025471 | 23 |
Extracts reference statistics for a given segment. | def reference_stats(refs, output_len):
ngrams = Counter()
closest_diff = None
closest_len = None
for ref in refs:
tokens = ref.split()
reflen = len(tokens)
diff = abs(output_len - reflen)
if closest_diff is None or diff < closest_diff:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_references(alignedsegment):\n \n references = [alignedsegment.reference_name]\n \n # Some reads don't have secondary hits\n if not alignedsegment.has_tag('XA'):\n return references\n \n # XA is a string contigname1,<other info>;contigname2,<other info>; ...\n secondary_al... | [
"0.5470782",
"0.53688884",
"0.53582793",
"0.53248024",
"0.5299202",
"0.5170791",
"0.5132248",
"0.5121406",
"0.51021016",
"0.504924",
"0.5033814",
"0.5031647",
"0.5017428",
"0.4956699",
"0.4956699",
"0.4898067",
"0.4897853",
"0.48240963",
"0.4789918",
"0.47849065",
"0.47824642... | 0.48478 | 17 |
Produces BLEU scores along with its sufficient statistics from a source against one or more references. | def corpus_score(self, sys_stream: Union[str, Iterable[str]],
ref_streams: Union[str, List[Iterable[str]]],
use_effective_order: bool = False) -> BLEUScore:
# Add some robustness to the input arguments
if isinstance(sys_stream, str):
sys_stream = [s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bleu_score(references, generated, n_gram=4, smooth=False):\r\n formatted_ref = [[ref] for ref in references]\r\n bleu_s, _, _, _, _, _ = compute_bleu(formatted_ref, generated, n_gram, smooth)\r\n return bleu_s * 100",
"def bleu_stats(hypothesis, reference):\n stats = []\n stats.append(len(hypo... | [
"0.6538913",
"0.611638",
"0.611638",
"0.5920825",
"0.58097124",
"0.57767993",
"0.56798124",
"0.56685686",
"0.56611174",
"0.5635664",
"0.5564803",
"0.5557683",
"0.5550513",
"0.552961",
"0.552961",
"0.5481987",
"0.5463703",
"0.54276645",
"0.5392559",
"0.5389487",
"0.5355115",
... | 0.49421677 | 48 |
Perform ZCA whitening on an image. | def whiten(x, e):
x = x - x.mean(0).repeat(x.size()[1], 1)
sigma = x * x.t / x.shape[1]
u, s, _ = torch.svd(sigma, some=False)
return u * torch.diag(1 / torch.sqrt(S.diag() + e)) * u.t * x | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ZCA_whitening(imageVector):\n\n sigma = np.dot(inputs, inputs.T)/inputs.shape[1] #Correlation matrix\n U,S,V = np.linalg.svd(sigma) #Singular Value Decomposition\n epsilon = 0.1 #Whitening constant, it prevents division by zero\n ZCAMatrix = np.dot(np.dot(U, np.diag(1.0/np.sqrt(np.di... | [
"0.6916947",
"0.65716195",
"0.6485328",
"0.6384206",
"0.63341457",
"0.62049633",
"0.5988863",
"0.5755377",
"0.56526095",
"0.55399",
"0.5451515",
"0.5449809",
"0.54059184",
"0.5369222",
"0.53182316",
"0.530681",
"0.52628165",
"0.5259321",
"0.5207307",
"0.5207307",
"0.5117338",... | 0.5035 | 24 |
Apply Gaussian noise to an input tensor. | def gaussian_noise(tensor, mean, stddev):
noise = Variable(tensor.data.new(tensor.size()).normal_(mean, std))
return tensor + noise | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gaussian_noise(self, tensor):\n return tensor.new_empty(tensor.size()).normal_(std=self._discreteness)",
"def task_gaussian_noise(input_array, noise_factor):\n return(np.random.normal(0, noise_factor, input_array.shape))",
"def add_gaussian_noise(X, mu=0, sigma=0.1):\n noise = np.random.normal... | [
"0.78414464",
"0.7245466",
"0.71811473",
"0.71459424",
"0.68363976",
"0.6799063",
"0.66733646",
"0.66543114",
"0.65751487",
"0.6564241",
"0.6492763",
"0.64736784",
"0.64736784",
"0.64586484",
"0.64251614",
"0.6397649",
"0.6334172",
"0.63252485",
"0.6302892",
"0.6299813",
"0.6... | 0.7755156 | 1 |
Add a `canon` option to `f` which toggles canonicalizes the return value of `f`. | def canon(f):
@wraps(f)
def wrapped(G, H, canon=True):
game = f(G, H)
if canon:
game = canonicalize(game)
return game
return wrapped | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pony_func(func):\n func.is_pony_func = True\n return func",
"def main():\n parser = argparse.ArgumentParser(description=(\n 'Canonicalize Call Graphs to FASTEN Canonical Call Graphs'))\n parser.add_argument('directory', help=(\n 'a directory with the Call Graph, and description file... | [
"0.49801686",
"0.48075998",
"0.4801738",
"0.47585616",
"0.47026438",
"0.47009388",
"0.46868795",
"0.46559855",
"0.46223104",
"0.46175477",
"0.45939246",
"0.45530087",
"0.4538339",
"0.44475698",
"0.4445085",
"0.44408873",
"0.44223046",
"0.4421128",
"0.44015473",
"0.43992308",
... | 0.635531 | 0 |
Move in exactly one component. | def disjunctive(G, H):
left_1 = {disjunctive(G_L, H) for G_L in G._left}
left_2 = {disjunctive(G, H_L) for H_L in H._left}
right_1 = {disjunctive(G_R, H) for G_R in G._right}
right_2 = {disjunctive(G, H_R) for H_R in H._right}
return Game(left_1 | left_2, right_1 | right_2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move(self):\n pass",
"def move(self):\n raise NotImplementedError",
"def move_to_position1(self):",
"def move_to_position2(self):",
"def _move_in_one_more_block():\n with tik_inst.for_range(0, sub_h_align_block_size) as sub_h_idx:\n tik_inst.data_move(dst[sub_w_block * d... | [
"0.6899064",
"0.66450226",
"0.6615794",
"0.63474816",
"0.62919295",
"0.6285745",
"0.62708914",
"0.6266035",
"0.6195555",
"0.61668605",
"0.61501706",
"0.6106435",
"0.60828984",
"0.6042071",
"0.6039131",
"0.60356104",
"0.6013029",
"0.60085666",
"0.59947014",
"0.5982884",
"0.597... | 0.0 | -1 |
Move in all components. Play ends when any one of them terminates. | def conjunctive(G, H):
left = {conjunctive(G_L, H_L) for G_L in G._left for H_L in H._left}
right = {conjunctive(G_R, H_R) for G_R in G._right for H_R in H._right}
return Game(left, right) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move(self):\n pass",
"def handleMove(self):\n pass",
"def run(self):\n while not self.turn_over:\n self.go()",
"def run(self):\n for _ in range(self.num_iteration):\n self.move()\n time.sleep(self.speed)\n if not self.is_running:\n ... | [
"0.67165536",
"0.6450276",
"0.642639",
"0.63869965",
"0.6380625",
"0.63037014",
"0.6282754",
"0.6249404",
"0.6245922",
"0.62315774",
"0.62287354",
"0.6171988",
"0.6170963",
"0.6135099",
"0.6109948",
"0.61098945",
"0.6106997",
"0.6100875",
"0.6084784",
"0.60692745",
"0.6066481... | 0.0 | -1 |
Move in any number of components, but at least one. | def selective(G, H):
left_1 = {selective(G_L, H) for G_L in G._left}
left_2 = {selective(G, H_L) for H_L in H._left}
left_3 = {selective(G_L, H_L) for G_L in G._left for H_L in H._left}
right_1 = {selective(G_R, H) for G_R in G._right}
right_2 = {selective(G, H_R) for H_R in H._right}
right_3 = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _move_in_one_more_block():\n with tik_inst.for_range(0, sub_h_align_block_size) as sub_h_idx:\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block * sub_h_idx],\n src[w_offset + w_size * sub_h_idx], 0, 1, sub_w_block, 0, 0)\n # in order to avoid d... | [
"0.6018227",
"0.59535146",
"0.59033984",
"0.5829751",
"0.5825883",
"0.57707506",
"0.5694387",
"0.56823575",
"0.5666963",
"0.5642597",
"0.5641661",
"0.5638052",
"0.55918825",
"0.5589538",
"0.55241865",
"0.55067444",
"0.54987234",
"0.54837316",
"0.5470003",
"0.5466049",
"0.5463... | 0.0 | -1 |
Move in exactly one component. Play ends immediately when any one of them terminates. | def diminished_disjunctive(G, H):
if G == 0 or H == 0:
return Game(0)
else:
left_1 = {diminished_disjunctive(G_L, H) for G_L in G._left}
left_2 = {diminished_disjunctive(G, H_L) for H_L in H._left}
right_1 = {diminished_disjunctive(G_R, H) for G_R in G._right}
right_2 = {... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def play_one_move(self):\n self.print(\"top of move\")\n # 1) grab three cups\n c1 = self.take_cup_after(self.current_cup_idx())\n c2 = self.take_cup_after(self.current_cup_idx())\n c3 = self.take_cup_after(self.current_cup_idx())\n print(f\"pick up: {c1}, {c2}, {c3}\")\n ... | [
"0.647995",
"0.6420473",
"0.64017844",
"0.6215315",
"0.61987627",
"0.6173288",
"0.6152753",
"0.6094539",
"0.60649693",
"0.6058507",
"0.602774",
"0.6017141",
"0.5978515",
"0.5970727",
"0.594726",
"0.5940435",
"0.5864352",
"0.58516985",
"0.5839466",
"0.58298063",
"0.58190876",
... | 0.0 | -1 |
Move in all nonterminal components. Play ends only after all components terminate. | def continued_conjunctive(G, H):
if G == 0 or H == 0:
return disjunctive(G, H)
else:
left = {continued_conjunctive(G_L, H_L) for G_L in G._left for H_L in H._left}
right = {continued_conjunctive(G_R, H_R) for G_R in G._right for H_R in H._right}
return Game(left, right) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move(self):\r\n segments = len(self.all_turtles) - 1\r\n for i in range(len(self.all_turtles)):\r\n if segments == 0:\r\n self.all_turtles[segments].forward(MOVE_DISTANCE)\r\n else:\r\n new_x = self.all_turtles[segments - 1].xcor()\r\n ... | [
"0.58747476",
"0.5517833",
"0.5281134",
"0.521895",
"0.5170323",
"0.5140568",
"0.50613856",
"0.50562793",
"0.5037675",
"0.49982315",
"0.49946517",
"0.49908346",
"0.49866736",
"0.49725467",
"0.4972026",
"0.49627477",
"0.49455985",
"0.494381",
"0.49339187",
"0.49254557",
"0.489... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.