= 3 :\\n ani.save(sys.argv[2], writer='imagemagick', fps=5)\\n\\n plt.show()\",\n \"def plotHistory(history):\\n \\n acc = history.history['acc']\\n val_acc = history.history['val_acc']\\n loss = history.history['loss']\\n val_loss = history.history['val_loss']\\n\\n epochs = range(len(acc))\\n \\n # Make and save the plot for our accuracy\\n plt.plot(epochs, acc, 'bo', label='Training acc')\\n plt.plot(epochs, val_acc, 'b', label='Validation acc')\\n plt.title('Training and validation accuracy')\\n plt.legend()\\n plt.savefig(\\\"trainValAccSecond.png\\\")\\n\\n # Make and save the plots for our loss \\n plt.figure()\\n plt.plot(epochs, loss, 'bo', label='Training loss')\\n plt.plot(epochs, val_loss, 'b', label='Validation loss')\\n plt.title('Training and validation loss')\\n plt.legend()\\n plt.show()\\n plt.savefig(\\\"trainValLossSecond.png\\\")\",\n \"def plot_loss_and_acc(history):\\n hist = history.history\\n x_arr = np.arange(len(hist['loss'])) + 1\\n fig = plt.figure(figsize=(12,4))\\n ax = fig.add_subplot(1,2,1)\\n ax.plot(x_arr, hist['loss'], '-o', label='Train loss')\\n ax.plot(x_arr, hist['val_loss'], '--<', label='Validation loss')\\n ax.legend(fontsize=15)\\n ax.set_xlabel('Epoch', size=15)\\n ax.set_ylabel('Loss', size=15)\\n\\n ax = fig.add_subplot(1,2,2)\\n ax.plot(x_arr, hist['accuracy'], '-o', label='Train acc.')\\n ax.plot(x_arr, hist['val_accuracy'], '--<', label='Validation acc.')\\n ax.legend(fontsize=15)\\n ax.set_xlabel('Epoch', size=15),\\n ax.set_ylabel('Accuracy', size=15)\\n plt.show()\",\n \"def show_training(history: tf.keras.callbacks.History) -> None:\\n hist = history.history\\n\\n if \\\"loss\\\" not in hist:\\n print(\\\"Error: 'loss' values not found in the history\\\")\\n return\\n\\n # plot training\\n plt.figure(figsize=(14, 4))\\n plt.subplot(121)\\n plt.plot(hist[\\\"loss\\\"], label=\\\"Training\\\")\\n if \\\"val_loss\\\" in hist:\\n plt.plot(hist[\\\"val_loss\\\"], label=\\\"Validation\\\")\\n plt.xlabel(\\\"epoch\\\")\\n plt.ylabel(\\\"loss\\\")\\n plt.legend()\\n\\n if \\\"accuracy\\\" in hist:\\n plt.subplot(122)\\n plt.plot(hist[\\\"accuracy\\\"], label=\\\"Training\\\")\\n if \\\"val_accuracy\\\" in hist:\\n plt.plot(hist[\\\"val_accuracy\\\"], label=\\\"Validation\\\")\\n plt.xlabel(\\\"epoch\\\")\\n plt.ylabel(\\\"accuracy\\\")\\n plt.legend()\\n\\n plt.suptitle(\\\"Training history\\\")\\n plt.show()\\n\\n # show final results\\n print(\\\"\\\\nTraining loss: \\\\t{:.4f}\\\".format(hist[\\\"loss\\\"][-1]))\\n if \\\"val_loss\\\" in hist:\\n print(\\\"Validation loss: \\\\t{:.4f}\\\".format(hist[\\\"val_loss\\\"][-1]))\\n if \\\"accuracy\\\" in hist:\\n print(\\\"\\\\nTraining accuracy: \\\\t{:.3f}\\\".format(hist[\\\"accuracy\\\"][-1]))\\n if \\\"val_accuracy\\\" in hist:\\n print(\\\"Validation accuracy:\\\\t{:.3f}\\\".format(hist[\\\"val_accuracy\\\"][-1]))\",\n \"def cross_validation_visualization(lambds, score_tr, score_te):\\n plt.semilogx(lambds, score_tr, marker=\\\".\\\", color='b', label='train score');\\n plt.semilogx(lambds, score_te, marker=\\\".\\\", color='r', label='test score');\\n plt.xlabel(\\\"lambda\\\")\\n plt.ylabel(\\\"score\\\")\\n plt.title(\\\"cross validation\\\")\\n plt.legend(loc=2)\\n plt.grid(True)\\n plt.savefig(\\\"cross_validation_test\\\")\",\n \"def main():\\n args = parse_args()\\n\\n with open(args.train_details_json, mode='r', encoding='utf-8') as json_f:\\n results_dict = json.load(json_f)[-1]\\n\\n losses_plot = plt.figure()\\n plt.plot(range(1, len(results_dict['train_loss']) + 1),\\n results_dict['train_loss'])\\n plt.plot(range(1, len(results_dict['val_loss']) + 1),\\n results_dict['val_loss'])\\n plt.plot(range(1, len(results_dict['test_loss']) + 1),\\n results_dict['test_loss'])\\n plt.legend(['train', 'val', 'test'])\\n plt.title(f'loss vs epoch for {args.model} model on {args.dataset} dataset')\\n plt.xlabel('epoch')\\n plt.ylabel('loss')\\n plt.grid(True)\\n losses_plot.set_size_inches((8, 8))\\n losses_plot.savefig(\\n os.path.join(FIGURES_DIR,\\n f'{args.dataset}_{args.model}_losses_plot.png'))\\n\\n accuracies_plot = plt.figure()\\n plt.plot(range(1, len(results_dict['train_acc']) + 1),\\n results_dict['train_acc'])\\n plt.plot(range(1, len(results_dict['val_acc']) + 1),\\n results_dict['val_acc'])\\n plt.plot(range(1, len(results_dict['test_acc']) + 1),\\n results_dict['test_acc'])\\n plt.legend(['train', 'val', 'test'])\\n plt.title(f'accuracy vs epoch for {args.model} '\\n f'model on {args.dataset} dataset')\\n plt.xlabel('epoch')\\n plt.ylabel('accuracy')\\n plt.grid(True)\\n accuracies_plot.set_size_inches((8, 8))\\n accuracies_plot.savefig(\\n os.path.join(FIGURES_DIR,\\n f'{args.dataset}_{args.model}_accuracies_plot.png'))\",\n \"def plot_fit_history(fit_history_obj):\\r\\n plt.plot(fit_history_obj.history['loss'])\\r\\n plt.plot(fit_history_obj.history['val_loss'])\\r\\n plt.title('model mean squared error loss')\\r\\n plt.ylabel('mean squared error loss')\\r\\n plt.xlabel('epoch')\\r\\n plt.legend(['training set', 'validation set'], loc='upper right')\\r\\n plt.show()\",\n \"def plot_training_history(history):\\n fig, (ax_loss, ax_acc) = plt.subplots(1, 2, figsize=(15, 5))\\n ax_loss.plot(history.epoch, history.history[\\\"loss\\\"], label=\\\"Train loss\\\")\\n ax_loss.plot(history.epoch, history.history[\\\"val_loss\\\"], label=\\\"Validation loss\\\")\\n ax_loss.legend()\\n ax_acc.plot(history.epoch, history.history[\\\"iou_score\\\"], label=\\\"Train iou\\\")\\n ax_acc.plot(history.epoch, history.history[\\\"val_iou_score\\\"], label=\\\"Validation iou\\\")\\n ax_acc.legend()\",\n \"def plot_train_test_errors(train_errors, test_errors, lambda_str , K , path, rng):\\n plt.plot(range(rng), train_errors, marker='o', label='Training Data');\\n plt.plot(range(rng), test_errors, marker='v', label='Test Data');\\n plt.title('ALS-WR Learning Curve, lambda = %s, K = %d'%(lambda_str, K))\\n plt.xlabel('Number of Epochs');\\n plt.ylabel('RMSE');\\n plt.legend()\\n plt.grid()\\n plt.savefig(\\\"../results/test_train_rmse_\\\"+path)\\n plt.show()\",\n \"def train_plot_update(self, pred_, validate_y, steps_displayed, elastic_losses = None, restart_triggered = False):\\n if self.interactive:\\n display.clear_output(wait=True) \\n \\n pred_2plot = pred_.detach().to(\\\"cpu\\\")\\n if not self.ODE_order:\\n validate_y_2plot = validate_y.detach().to(\\\"cpu\\\")\\n try:\\n self.ax[1].clear()\\n self.ax[0].clear()\\n except:\\n pass\\n\\n \\n\\n labels = \\\"best value\\\", \\\"all samples\\\"\\n #log2 = np.log(2)\\n\\n # Plot 1: the training history of the bayesian optimization\\n # if not self.log_score:\\n # self.ax[0].plot(np.log(self.errorz_step), alpha = 0.5, color = \\\"blue\\\", label = labels[0] )\\n # self.ax[0].plot(np.log(self.errorz), alpha = 0.2, color = \\\"green\\\", label = labels[1])\\n # else:\\n font_dict = {\\\"prop\\\" : {\\\"size\\\":14}}\\n ticks_font_size = 14\\n\\n self.ax[0].plot(10**np.array(self.errorz_step), alpha = 0.5, color = \\\"blue\\\", label = labels[0] )\\n self.ax[0].plot(10**np.array(self.errorz), alpha = 0.2, color = \\\"green\\\", label = labels[1])\\n #self.ax[0].set_title(\\\"log(error) vs Thompson Sampling step\\\")\\n self.ax[0].set_ylabel(f\\\"log({self.scoring_method})\\\")\\n self.ax[0].set_xlabel(\\\"BO step\\\")\\n self.ax[0].set_ylabel(\\\"Error\\\")\\n self.ax[0].legend(**font_dict)\\n self.ax[0].set_yscale(\\\"log\\\")\\n #self.ax[0].set_ylim(10**-8,1)\\n # self.ax[0].set_xtickslabels(fontsize= ticks_font_size )\\n # self.ax[0].set_ytickslabels(fontsize= ticks_font_size )\\n \\n #plot 2: the turbo state #plot 2: the turbo state\\n self.ax[1].axhline(np.log(self.state.length_max)/self.log2, color = 'green', label = 'max length')\\n self.ax[1].set_title(\\\"TURBO state\\\")\\n self.ax[1].plot(np.log(self.length_progress)/self.log2, color = 'blue', label = 'current length')\\n self.ax[1].axhline(np.log(self.state.length_min)/self.log2, color = 'red', label = 'target length')\\n self.ax[1].legend() \\n\\n #plot 3 (most recent prediction)\\n self.ax[2].clear()\\n if not self.ODE_order:\\n self.ax[2].plot(validate_y_2plot.to(\\\"cpu\\\"), alpha = 0.5, color = \\\"blue\\\", label = \\\"val set\\\") #[:steps_displayed]\\n self.ax[2].set_ylim(self.y.min().item() - 0.1, self.y.max().item() )\\n self.ax[2].plot(pred_2plot[:steps_displayed], alpha = 0.3, color = \\\"red\\\", label = \\\"latest pred\\\")\\n \\n self.ax[2].set_title(\\\"Val Set Prediction\\\")\\n self.ax[2].set_ylabel(\\\"y\\\")\\n self.ax[2].set_xlabel(r'$t$')\\n\\n pl.legend()\\n pl.tight_layout()\\n\\n display.display(pl.gcf())\\n\\n #clear the plot outputt and then re-plot\",\n \"def plot_history(H, epochs):\\n plt.style.use(\\\"fivethirtyeight\\\")\\n plt.figure()\\n plt.plot(np.arange(0, epochs), H.history[\\\"loss\\\"], label=\\\"train_loss\\\")\\n plt.plot(np.arange(0, epochs), H.history[\\\"val_loss\\\"], label=\\\"val_loss\\\")\\n plt.plot(np.arange(0, epochs), H.history[\\\"accuracy\\\"], label=\\\"train_acc\\\")\\n plt.plot(np.arange(0, epochs), H.history[\\\"val_accuracy\\\"], label=\\\"val_acc\\\")\\n plt.title(\\\"Training Loss and Accuracy\\\")\\n plt.xlabel(\\\"Epoch #\\\")\\n plt.ylabel(\\\"Loss/Accuracy\\\")\\n plt.legend()\\n plt.tight_layout()\\n plt.show()\",\n \"def plot_on_ax(ax, trn_ls, val_ls, ylabel=\\\"Accuracy\\\"):\\n ax.plot(trn_ls, 'o-', label='Training')\\n ax.plot(val_ls, 'x-', label='Validation')\\n ax.set_xlabel('Epochs')\\n ax.set_ylabel(ylabel)\\n ax.legend()\",\n \"def plot_data():\\n \\n [X_train, X_dev, X_test, Y_train, Y_dev, Y_test, numOutputNodes] = load_data('regression') \\n \\n traindev = np.concatenate((Y_train, Y_dev), 1)\\n traindevtest = np.concatenate((traindev, Y_test), 1)\\n tdt = traindevtest.reshape(traindevtest.shape[1],)\\n\\n Y_train = Y_train.reshape(Y_train.shape[1],)\\n Y_dev = Y_dev.reshape(Y_dev.shape[1],)\\n Y_test = Y_test.reshape(Y_test.shape[1],)\\n\\n sigma = np.round(np.std(tdt), 3)\\n mu = np.round(np.mean(tdt), 3)\\n\\n # plots histogram of all data together, indicating values of mean and standard deviation\\n plt.figure(1)\\n plt.hist(tdt)\\n plt.title(\\\"{} data points, mu = {}, sigma = {}\\\".format(tdt.size, mu, sigma))\\n plt.xlabel(\\\"average Fe coordination number\\\")\\n plt.ylabel(\\\"frequency\\\")\\n plt.show()\\n\\n # plots histogram where the training, cross-validation, and test sets have separate bars\\n plt.figure(2)\\n plt.hist([Y_train, Y_dev, Y_test], label = ['training', 'cross-validation', 'test'], density = True)\\n plt.xlabel(\\\"average Fe coordination number\\\")\\n plt.ylabel(\\\"frequency\\\")\\n plt.legend()\\n plt.show()\\n\\n # below is graphing for the charge data, as opposed to the averaged spectrum data\\n [X_train1, X_dev1, X_test1, _, _, _, Y_train1, Y_dev1, Y_test1, numOutputNodes1] = load_data('multi_task')\\n traindev1 = np.concatenate((Y_train1, Y_dev1), 1)\\n traindevtest1 = np.concatenate((traindev1, Y_test1), 1)\\n tdt1 = traindevtest1.reshape(traindevtest1.shape[1],)\\n\\n Y_train1 = Y_train1.reshape(Y_train1.shape[1],)\\n Y_dev1 = Y_dev1.reshape(Y_dev1.shape[1],)\\n Y_test1 = Y_test1.reshape(Y_test1.shape[1],)\\n\\n sigma = np.round(np.std(tdt1), 3)\\n mu = np.round(np.mean(tdt1), 3)\\n\\n # plots histogram of all data together, indicating values of mean and standard deviation\\n plt.figure(3)\\n plt.hist(tdt1)\\n plt.title(\\\"{} data points, mu = {}, sigma = {}\\\".format(tdt1.size, mu, sigma))\\n plt.xlabel(\\\"charge\\\")\\n plt.ylabel(\\\"frequency\\\")\\n plt.show()\\n\\n # plots histogram where the training, cross-validation, and test sets have separate bars\\n plt.figure(4)\\n plt.hist([Y_train1, Y_dev1, Y_test1], label = ['training', 'cross-validation', 'test'], density = True)\\n plt.xlabel(\\\"charge\\\")\\n plt.ylabel(\\\"frequency\\\")\\n plt.legend()\\n plt.show()\\n\\n return None\",\n \"def plot_loss(experiment_name, model='pix2pix'):\\n \\n # load data file\\n data = pd.read_csv(os.path.join('./checkpoints', experiment_name, 'loss_log.txt'), skiprows=1, sep='\\\\s*', engine='python', header=None)\\n \\n if model == 'pix2pix':\\n epoch = data[1].str.replace(',', '').astype('int')\\n iters = data[3].str.replace(',', '').astype('int') / 1928\\n epoch = epoch + iters - 1\\n \\n # convert string to float32 data\\n G_GAN = data[9].astype('float32')\\n G_L1 = data[11].astype('float32')\\n D_real = data[13].astype('float32')\\n D_fake = data[15].astype('float32')\\n \\n plt.figure(figsize=(15,8))\\n plt.xlabel('epoch', fontsize=18, labelpad=20)\\n plt.ylabel('loss', fontsize=18, labelpad=20)\\n plt.title(experiment_name + 'loss over time', fontsize=18, pad=30)\\n plt.plot(epoch.values, G_GAN.values, 'b', label='G_GAN')\\n plt.plot(epoch.values, G_L1.values, 'C1', label='G_L1')\\n plt.plot(epoch.values, D_real.values, 'g', label='D_real')\\n plt.plot(epoch.values, D_fake.values, 'r', label='D_fake')\\n plt.tick_params(labelsize=14)\\n plt.legend(loc='best', fontsize=14)\\n plt.grid(True)\\n # save the png image into the corresponding dir \\n plt.savefig(os.path.join('./results', experiment_name, 'test_latest', experiment_name + '.png'))\\n plt.show()\\n \\n if model == 'cyclegan':\\n epoch = data[1].str.replace(',', '').astype('int')\\n iters = data[3].str.replace(',', '').astype('int') / 1928\\n epoch = epoch + iters - 1\\n\\n D_A = data[9].astype('float32')\\n G_A = data[11].astype('float32')\\n cycle_A = data[13].astype('float32')\\n idt_A = data[15].astype('float32')\\n \\n D_B = data[17].astype('float32')\\n G_B = data[19].astype('float32')\\n cycle_B = data[21].astype('float32')\\n idt_B = data[23].astype('float32')\\n \\n plt.figure(figsize=(15,8))\\n plt.xlabel('epoch', fontsize=18, labelpad=20)\\n plt.ylabel('loss', fontsize=18, labelpad=20)\\n plt.title(experiment_name + 'loss over time', fontsize=18, pad=30)\\n plt.plot(epoch.values, D_A.values, 'C1', label='D_A')\\n plt.plot(epoch.values, G_A.values, 'C2', label='G_A')\\n plt.plot(epoch.values, cycle_A.values, 'C3', label='cycle_A')\\n plt.plot(epoch.values, idt_A.values, 'C4', label='idt_A')\\n plt.plot(epoch.values, D_B.values, 'C5', label='D_B')\\n plt.plot(epoch.values, G_B.values, 'C6', label='G_B')\\n plt.plot(epoch.values, cycle_B.values, 'C7', label='cycle_B')\\n plt.plot(epoch.values, idt_B.values, 'C8', label='idt_B')\\n plt.tick_params(labelsize=14)\\n plt.legend(loc='best', fontsize=14)\\n plt.grid(True)\\n plt.savefig(os.path.join('./results', experiment_name, 'test_latest', experiment_name + '.png'))\\n plt.show()\",\n \"def plot_acc (history, acc='acc', val_acc='val_acc'):\\n \\n history_dict = history.history\\n acc = history_dict[acc]\\n val_acc = history_dict[val_acc]\\n loss_values = history_dict['loss']\\n epochs = range(1, len(loss_values) + 1)\\n\\n plt.plot (epochs, acc, 'bo', label='Training accuracy')\\n plt.plot (epochs, val_acc, 'b', label=\\\"validation accuracy\\\")\\n plt.title('Training and validation accuracy')\\n plt.xlabel('Epochs')\\n plt.ylabel('Accuracy')\\n plt.legend()\\n plt.show()\",\n \"def plot_training_history(history, title_str=''):\\n acc = history.history['accuracy']\\n val_acc = history.history['val_accuracy']\\n loss = history.history['loss']\\n val_loss = history.history['val_loss']\\n \\n epochs = range(len(acc))\\n\\n plt.plot(epochs, acc, 'r', label='Training accuracy')\\n plt.plot(epochs, val_acc, 'b', label='Validation accuracy')\\n plt.title('Training and validation accuracy ' + title_str)\\n\\n ymin = min([min(acc), min(val_acc)])\\n\\n axes = plt.gca()\\n axes.set_xlim([0, len(acc)])\\n axes.set_ylim([ymin, 1])\\n\\n plt.legend(loc=0)\\n plt.figure()\\n plt.show\\n \\n plt.plot(epochs, loss, 'r', label='Training loss')\\n plt.plot(epochs, loss, 'b', label='Validation loss')\\n plt.title('Training and validation loss ' + title_str)\\n\\n ymin = min([min(loss), min(val_loss)])\\n\\n axes = plt.gca()\\n axes.set_xlim([0, len(loss)])\\n axes.set_ylim([ymin, 1])\\n\\n plt.legend(loc=0)\\n plt.show()\",\n \"def plot_error(self, maxstep=20):\\n plt.ion()\\n plt.xlabel(\\\"step\\\")\\n plt.ylabel(\\\"Ave Logloss (bits)\\\")\\n train_errors = []\\n if self.dataset.test:\\n test_errors = []\\n for i in range(maxstep):\\n self.learn(1)\\n train_errors.append( sum(self.logloss(tple) for tple in self.dataset.train)\\n /len(self.dataset.train))\\n if self.dataset.test:\\n test_errors.append( sum(self.logloss(tple) for tple in self.dataset.test)\\n /len(self.dataset.test))\\n plt.plot(range(1,maxstep+1),train_errors,\\n label=str(self.num_classes)+\\\" classes. Training set\\\")\\n if self.dataset.test:\\n plt.plot(range(1,maxstep+1),test_errors,\\n label=str(self.num_classes)+\\\" classes. Test set\\\")\\n plt.legend()\\n plt.draw()\",\n \"def plot_acc(acc_v, acc_t, save_plots_path):\\n\\n plt.figure()\\n plt.plot(acc_v, label='Validation acc')\\n plt.plot(acc_t, label='Training acc')\\n plt.legend()\\n title = 'Accuracy per epoch'\\n plt.title(title)\\n plt.xlabel(\\\"Epoch\\\")\\n plt.ylabel(\\\"Accuracy\\\")\\n plt.savefig(save_plots_path + \\\"swag_accuracy_plot.png\\\")\",\n \"def plot_train_and_valid_curves(ax, train_points, valid_points, learning_rate_updates_epoch, best_per_lr, mode=\\\"loss\\\"):\\n if mode==\\\"loss\\\":\\n name = \\\"Loss\\\"\\n names = \\\"losses\\\"\\n factor = [1.2, 1.22]\\n loc_legend = 1\\n elif mode ==\\\"acc\\\":\\n name = \\\"Accuracy\\\"\\n names = \\\"acc\\\"\\n factor = [0.9, 0.88]\\n loc_legend = 4\\n else:\\n print \\\"Mode not understood. Available modes : 'loss' and 'acc'\\\"\\n return\\n\\n #ax = plt.subplot(1,1,1)#\\n # Plot training and valid loss curves\\n ax.plot(np.arange(len(train_points)),train_points, c=\\\"k\\\", zorder=1)\\n ax.plot(np.arange(len(valid_points)),valid_points, c=\\\"k\\\", zorder=1)\\n ax.scatter(np.arange(len(train_points)),train_points, c=\\\"b\\\", label=\\\"Train %s\\\"%names, zorder=2)\\n ax.scatter(np.arange(len(valid_points)),valid_points, c=\\\"r\\\", label=\\\"Valid %s\\\"%names, zorder=2)\\n # Plot vertical line when the learning rate was updated\\n first = True\\n for elem in learning_rate_updates_epoch:\\n if first:\\n plt.plot([elem-.5,elem-.5], [1.4*valid_points[elem],train_points[elem]*0.6], c=\\\"k\\\", label=\\\"LR updates\\\", linestyle=\\\"--\\\")\\n first = False\\n else:\\n plt.plot([elem-.5,elem-.5], [1.4*valid_points[elem],train_points[elem]*0.6], c=\\\"k\\\", linestyle=\\\"--\\\")\\n # Plot best model in each region\\n first = True\\n for i,elem in enumerate(best_per_lr):\\n if first:\\n x = elem[0]\\n y = elem[1]\\n plt.scatter(x,y, c=\\\"g\\\", label=\\\"Best models\\\", marker=\\\"*\\\", zorder=3, s=100)\\n plt.plot([x,x],[y,factor[0]*y], c=\\\"g\\\")\\n plt.text(x,factor[1]*y, \\\"Epoch %d\\\"%(x), fontsize=8)\\n first = False\\n else:\\n x = elem[0]+learning_rate_updates_epoch[i-1]\\n y = elem[1]\\n plt.scatter(x,y, c=\\\"g\\\", marker=\\\"*\\\", zorder=3, s=100)\\n plt.plot()\\n plt.plot([x,x],[y,factor[0]*y], c=\\\"g\\\")\\n plt.text(x,factor[1]*y, \\\"Epoch %d\\\"%(x), fontsize=8)\\n # Xlim, Ylim, labels, legend...\\n ax.set_ylim([0,1])\\n ax.set_xlim([0,len(train_points)+5])\\n ax.set_xlabel(\\\"Epochs\\\")\\n ax.set_ylabel(name)\\n handles,labels = ax.get_legend_handles_labels()\\n sorted_zip = sorted(zip([2,0,1,3],handles, labels))\\n index, handles, labels = zip(*sorted_zip)\\n ax.legend(handles,labels, loc=loc_legend, prop={'size':10})\",\n \"def plot_training_history(history, title_str=''):\\n acc = history.history['accuracy']\\n val_acc = history.history['val_accuracy']\\n loss = history.history['loss']\\n val_loss = history.history['val_loss']\\n \\n epochs = range(len(acc))\\n\\n plt.plot(epochs, acc, 'r', label='Training accuracy')\\n plt.plot(epochs, val_acc, 'b', label='Validation accuracy')\\n plt.title('Training and validation accuracy ' + title_str)\\n\\n ymin = min([min(acc), min(val_acc)])\\n\\n axes = plt.gca()\\n axes.set_xlim([0, len(acc)])\\n axes.set_ylim([ymin, 1])\\n\\n plt.legend(loc=0)\\n plt.figure()\\n plt.show\\n \\n plt.plot(epochs, loss, 'r', label='Training loss')\\n plt.plot(epochs, loss, 'b', label='Validation loss')\\n plt.title('Training and validation loss ' + title_str)\\n\\n ymin = min([min(loss), min(val_loss)])\\n\\n axes = plt.gca()\\n axes.set_xlim([0, len(loss)])\\n axes.set_ylim([ymin, 1])\\n\\n plt.legend(loc=0)\\n plt.figure()\\n plt.show()\",\n \"def train_nn(train_nn_results, label, title, yaxis):\\n plt.figure(figsize=(12,5))\\n for i in range(len(label)):\\n plt.plot(train_nn_results[i], label=label[i], alpha=0.75)\\n plt.title(title)\\n plt.xlabel('epoch')\\n plt.ylabel(yaxis)\\n plt.legend(bbox_to_anchor=(1.05, 1.0), loc='upper left')\\n plt.tight_layout()\\n plt.show()\",\n \"def visualize_train_history(history):\\n cat_acc = history.history['categorical_accuracy']\\n val_cat_acc = history.history['val_categorical_accuracy']\\n loss = history.history['loss']\\n val_loss = history.history['val_loss']\\n\\n epochs = range(1, len(cat_acc) + 1)\\n\\n plt.plot(epochs, cat_acc, 'bo', label='Training cat_acc')\\n plt.plot(epochs, val_cat_acc, 'b', label='Validation cat_acc')\\n plt.title('Training and validation accuracy')\\n plt.legend()\\n\\n plt.figure()\\n\\n plt.plot(epochs, loss, 'bo', label='Training loss')\\n plt.plot(epochs, val_loss, 'b', label='Validation loss')\\n plt.title('Training and validation loss')\\n plt.legend()\\n\\n plt.show()\",\n \"def train_model_and_plot_results(**kwargs):\\n epochs = kwargs[\\\"epochs\\\"]\\n\\n history, model = train_model(**kwargs)\\n\\n dice = history.history['dice_loss']\\n val_dice = history.history['val_dice_loss']\\n\\n loss = history.history['loss']\\n val_loss = history.history['val_loss']\\n\\n epochs_range = range(epochs)\\n\\n plt.figure(figsize=(16, 8))\\n plt.subplot(1, 2, 1)\\n plt.plot(epochs_range, dice, label='Training Dice Loss')\\n plt.plot(epochs_range, val_dice, label='Validation Dice Loss')\\n plt.legend(loc='upper right')\\n plt.title('Training and Validation Dice Loss')\\n\\n plt.subplot(1, 2, 2)\\n plt.plot(epochs_range, loss, label='Training Loss')\\n plt.plot(epochs_range, val_loss, label='Validation Loss')\\n plt.legend(loc='upper right')\\n plt.title('Training and Validation Loss')\\n\\n plt.show()\",\n \"def summarize_diagnostics(self):\\n # plot loss\\n pyplot.subplot(211)\\n pyplot.title('Cross Entropy Loss')\\n pyplot.plot(self.history.history['loss'], color='blue', label='train')\\n pyplot.plot(self.history.history['val_loss'], color='orange', label='test')\\n # plot accuracy\\n pyplot.subplot(212)\\n pyplot.title('Classification Accuracy')\\n pyplot.plot(self.history.history['accuracy'], color='blue', label='train')\\n pyplot.plot(self.history.history['val_accuracy'], color='orange', label='test')\\n # save plot to file\\n pyplot.savefig(f'{self.project_home / \\\"o\\\"}/{self.model.name}_plot.png')\\n pyplot.close()\",\n \"def plot_run_basic():\\n # Define files prefix, model variables to plot and title\\n str_learning_rate = ['lr_', 'learning_rate', 'Learning rate', 'LR']\\n str_f_number = ['f_', 'F', 'Filter number', 'F']\\n str_regular = ['reg_param_', 'reg_par', 'Regularization', 'RP']\\n\\n fig = plt.figure(figsize=(16,12))\\n # Plot learning rate\\n acc_span, acc_tot, setting_val = CNN.get_acc_run_basic(str_learning_rate[0], str_learning_rate[1])\\n CNN.subplot_run_basic(acc_span, acc_tot, setting_val, str_learning_rate[2], str_learning_rate[3], [2,2,1])\\n # Plot F number\\n acc_span, acc_tot, setting_val = CNN.get_acc_run_basic(str_f_number[0], str_f_number[1])\\n CNN.subplot_run_basic(acc_span, acc_tot, setting_val, str_f_number[2], str_f_number[3], [2,2,2])\\n # Plot Regularization\\n acc_span, acc_tot, setting_val = CNN.get_acc_run_basic(str_regular[0], str_regular[1])\\n CNN.subplot_run_basic(acc_span, acc_tot, setting_val, str_regular[2], str_regular[3], [2,2,3])\\n plt.suptitle('Validation accuracy - Sweep parameters', fontsize=20)\\n plt.show();\\n \\n # Save as PDF file if wanted\\n if DataLoader.SAVE_FIGURE:\\n DataLoader.save_plot(fig, 'sweep_parameters_CNN.pdf')\",\n \"def plot_loss(loss_values_dict, save_name):\\n fig, ax = plt.subplots(figsize=(10, 10))\\n # Add each method to the plot\\n for (method_name, loss_val_array) in loss_values_dict.items():\\n print(method_name, len(loss_val_array))\\n ax.plot(range(len(loss_val_array)), loss_val_array, label=method_name)\\n ax.legend(loc='upper right')\\n plt.xlabel('iteration')\\n plt.ylabel('loss')\\n plt.title('Grad Descent in Hyperbolic Space')\\n plt.savefig(save_name)\",\n \"def visualize_train(train_data_full, train_labels, train_data, thetas, losses, niter):\\n fig1, ax1 = plt.subplots()\\n ax1.scatter(train_data_full[\\\"Weight\\\"], train_data_full[\\\"Height\\\"], color = 'blue')\\n\\n # De-standarize\\n train_mean = train_data_full[\\\"Weight\\\"].mean()\\n train_std = train_data_full[\\\"Weight\\\"].std()\\n train_data_for_plot = train_mean + train_data[\\\"Weight\\\"] * train_std\\n\\n ax1.plot(train_data_for_plot, predict(train_data, thetas[niter - 1]), color = 'red', linewidth = 2)\\n ax1.set_xlabel(\\\"Height\\\")\\n ax1.set_ylabel(\\\"Weight\\\")\\n\\n fig2, ax2 = plt.subplots()\\n ax2.plot(range(len(losses)), losses, color = 'blue', linewidth = 2)\\n ax2.set_xlabel(\\\"Iteration\\\")\\n ax2.set_ylabel(\\\"MSE\\\")\\n\\n fig3, ax3 = plt.subplots()\\n np_gradient_ws = np.array(thetas)\\n\\n w = np.linspace(min(np_gradient_ws[:, 0]), max(np_gradient_ws[:, 0]), len(np_gradient_ws[:, 0]))\\n b = np.linspace(min(np_gradient_ws[:, 1]), max(np_gradient_ws[:, 1]), len(np_gradient_ws[:, 1]))\\n x, y = np.meshgrid(w, b)\\n z = compute_z_loss(train_labels, train_data, np.stack((w,b)).T)\\n cp = ax3.contourf(x, y, z, cmap = plt.cm.jet)\\n fig3.colorbar(cp, ax = ax3)\\n ax3.plot(3.54794951, 66.63949115837143, color = 'red', marker = '*', markersize = 20)\\n if niter > 0:\\n thetas_to_plot = np_gradient_ws[:niter]\\n ax3.plot(thetas_to_plot[:, 0], thetas_to_plot[:, 1], marker = 'o', color = 'w', markersize = 10)\\n ax3.set_xlabel(r'$w$')\\n ax3.set_ylabel(r'$b$')\\n return fig1, fig2, fig3\",\n \"def training_summary(history, model, train_generator, eval_generator):\\n nrows, ncols = 2, 3\\n fig, axes = plt.subplots(nrows, ncols, figsize=(20, 12))\\n fig.suptitle(\\\"Training Summary\\\")\\n axes = np.ravel(axes)\\n\\n keys = history.history.keys()\\n print(keys)\\n\\n axes[0].plot(history.history[\\\"loss\\\"], label=\\\"training loss\\\", c=\\\"blue\\\")\\n axes[0].plot(history.history[\\\"val_loss\\\"], label=\\\"validation loss\\\", c=\\\"green\\\")\\n axes[0].set_xlabel(\\\"epoch\\\")\\n axes[0].set_ylabel(\\\"loss\\\")\\n axes[0].legend(loc=\\\"best\\\")\\n\\n axes[1].plot(history.history[\\\"acc\\\"], label=\\\"training acc\\\", c=\\\"blue\\\")\\n axes[1].plot(history.history[\\\"val_acc\\\"], label=\\\"validation acc\\\", c=\\\"green\\\")\\n axes[1].set_xlabel(\\\"epoch\\\")\\n axes[1].set_ylabel(\\\"loss\\\")\\n axes[1].legend(loc=\\\"best\\\")\\n\\n eval_model(model, train_generator, eval_generator, axes[2:])\\n plt.show()\",\n \"def get_metrics(self):\\n f = Figure(title='DRM_Gradient Train Loss', x_axis_label='Epoch', y_axis_label='Value')\\n f.line(color='blue',\\n x=range(len(self.train_stats['loss_lst'])),\\n y=self.train_stats['loss_lst'],\\n legend='Loss')\\n f.line(color='green',\\n x=range(len(self.train_stats['objective_lst'])),\\n y=self.train_stats['objective_lst'],\\n legend='CPIT')\\n return [f.draw()]\",\n \"def plot_train(func):\\n def plotting_func(model, train_config, arch, data_loader, epoch, handle_dict, optimizers):\\n output_dict = func(model, train_config, arch, data_loader, epoch, optimizers)\\n metrics = [output_dict['avg_elbo'], output_dict['avg_cond_log_like'], output_dict['avg_kl']]\\n plot_average_metrics(metrics, epoch, handle_dict, 'Train')\\n plot_param_grad_mags(output_dict['avg_param_grad_mags'], epoch, handle_dict)\\n plot_state_grad_mags(output_dict['avg_state_grad_mags'], epoch, handle_dict)\\n plot_opt_lr(optimizers, epoch, handle_dict)\\n return output_dict, handle_dict\\n return plotting_func\",\n \"def plot_metrics(history):\\n\\n pyplot.plot(history.history['loss'], label='loss')\\n\\n pyplot.plot(history.history['val_loss'], label='val_loss')\\n\\n pyplot.legend()\\n\\n pyplot.show()\",\n \"def acc_loss_graph(accuracies, losses):\\n fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 6))\\n\\n for experiment_id in accuracies.keys():\\n ax1.plot(accuracies[experiment_id], label=experiment_id)\\n ax1.legend()\\n ax1.set_title('Validation Accuracy')\\n fig.tight_layout()\\n\\n for experiment_id in accuracies.keys():\\n ax2.plot(losses[experiment_id], label=experiment_id)\\n ax2.legend()\\n ax2.set_title('Validation Loss');\\n\\n fig.tight_layout()\",\n \"def plot_progress(self):\\n plt.plot(-self.training_average_reward, label='negative average reward')\\n plt.plot(self.training_average_electricity_cost_in_euros, label='electricity cost in euros')\\n plt.legend()\\n plt.xlabel('Epoch')\\n plt.ylabel('cost in euros')\\n plt.title('Average electricity cost in euros and reward')\\n plt.show()\",\n \"def plot_learning_curve(model, X_train, X_test, y_train, y_test):\\n\\n m, train_scores, valid_scores = learning_curve(estimator = model, \\n X = X_train, y = y_train.ravel(), train_sizes = np.linspace(0.1,1.0, 80))\\n\\n train_cv_err = np.mean(train_scores, axis=1)\\n test_cv_err = np.mean(valid_scores, axis=1)\\n tr, = plt.plot(m, train_cv_err)\\n ts, = plt.plot(m, test_cv_err)\\n plt.legend((tr, ts), ('training error', 'test error'), loc = 'best')\\n plt.title('Learning Curve')\\n plt.xlabel('Data Points')\\n plt.ylabel('Accuracy')\",\n \"def plot_loss(self):\\n #x = [k for k in range(self.rep)]\\n loss = self.min_list[:,0]//100 #For clarity\\n #plt.plot(x,self.min_list[:,0])\\n plt.hist(loss,density=True)\\n plt.xlabel(self.list_name + '_loss//100')\\n plt.ylabel('Frequency')\\n #plt.xticks(range(8),[0,250,500,750,1000,1250,1500,1750])\\n plt.title('Distribution of '+self.list_name+'_loss ('+str(self.rep)+' iterations)')\\n plt.savefig('img/stats/'+self.list_name+'_lossFrequency_'+self.model_name+'.png')\\n plt.show()\",\n \"def plot_train_results(metrics2record, loss_metric,\\n train_metrics, test_metrics):\\n pyplot.figure(figsize=(10, 5))\\n min_, max_ = np.min(loss_metric), np.max(loss_metric)\\n lg, = pyplot.plot(loss_metric)\\n pyplot.yticks(min_ + np.arange(5) * (max_ - min_))\\n # if learning_rate is not None:\\n # lg, = pyplot.plot(learning_rate)\\n pyplot.title('Loss')\\n pyplot.xlabel('Epoch')\\n pyplot.yscale('log')\\n pyplot.show()\\n\\n for prm in basic_metrics:\\n if prm in metrics2record:\\n leg = []\\n met_idx = metrics2record.index(prm)\\n pyplot.figure(figsize=(10, 5))\\n lg, = pyplot.plot(train_metrics[:, met_idx], label=('train'))\\n leg.append(lg)\\n lg, = pyplot.plot(test_metrics[:, met_idx], label=('test'))\\n leg.append(lg)\\n\\n pyplot.legend(handles=leg)\\n pyplot.title(prm)\\n pyplot.xlabel('Epoch')\\n pyplot.show()\\n\\n has_prf = any([(prm in PRF_metrics) for prm in metrics2record])\\n if has_prf:\\n pyplot.figure(figsize=(10, 5))\\n leg = []\\n for prm in PRF_metrics:\\n if prm in metrics2record:\\n met_idx = metrics2record.index(prm)\\n lg, = pyplot.plot(train_metrics[:, met_idx],\\n label=(prm + ':train'))\\n leg.append(lg)\\n\\n for prm in PRF_metrics:\\n if prm in metrics2record:\\n met_idx = metrics2record.index(prm)\\n lg, = pyplot.plot(test_metrics[:, met_idx],\\n label=(prm + ':test'))\\n leg.append(lg)\\n\\n pyplot.legend(handles=leg)\\n pyplot.title('Precision / Recall')\\n pyplot.xlabel('Epoch')\\n pyplot.show()\",\n \"def show_learning_curve(self):\\n\\n # Loop output classes\\n for c in range(1,self.n_output_classes):\\n # Get data\\n x_values = np.array(self.n_class_samples_list[c])\\n accuracy = np.array(self.accuracy_list[c])\\n precision = np.array(self.precision_list[c])\\n recall = np.array(self.recall_list[c])\\n F1 = np.array(self.F1_list[c])\\n\\n # Make plot\\n with sns.axes_style(\\\"ticks\\\"):\\n fig,ax = plt.subplots()\\n plt.plot([np.min(x_values),np.max(x_values)],[0.5,0.5],\\n color='#777777',linestyle='--')\\n plt.plot([np.min(x_values),np.max(x_values)],[0.66,0.66],\\n color='#777777',linestyle=':')\\n plt.plot([np.min(x_values),np.max(x_values)],[0.8,0.8],\\n color='#777777',linestyle=':')\\n plt.plot([np.min(x_values),np.max(x_values)],[0.9,0.9],\\n color='#777777',linestyle=':')\\n\\n plt.plot( x_values, accuracy, color='#000000',\\n linewidth=1, label='Accuracy' )\\n plt.plot( x_values, precision, color='#0000aa',\\n linewidth=1, label='Precision' )\\n plt.plot( x_values, recall, color='#00aa00',\\n linewidth=1, label='Recall' )\\n plt.plot( x_values, F1, color='#aa0000',\\n linewidth=2, label='F1' )\\n\\n plt.yticks( [0, 0.5, 0.66, 0.8, 0.9, 1.0],\\n ['0','0.5','0.66','0.8','0.9','1.0'], ha='right' )\\n plt.xlim(np.max(x_values)*-0.02,np.max(x_values)*1.02)\\n plt.ylim(-0.02,1.02)\\n plt.xlabel('Number of training samples')\\n plt.ylabel('Performance')\\n plt.title('Learning curve, class {}'.format(c))\\n sns.despine(ax=ax, offset=0, trim=True)\\n lgnd = plt.legend(loc=4, ncol=1, frameon=True, fontsize=9)\\n lgnd.get_frame().set_facecolor('#ffffff')\\n ax.spines['left'].set_bounds(0,1)\\n ax.spines['bottom'].set_bounds(np.min(x_values),np.max(x_values))\",\n \"def acc_plotter(model_history, ax = None):\\n \\n import matplotlib.pyplot as plt\\n import seaborn as sns\\n \\n training_loss = model_history['loss']\\n\\n acc = model_history['accuracy']\\n \\n val_acc = model_history['val_accuracy']\\n\\n epoch_count = range(1,len(training_loss)+1)\\n \\n sns.set(font_scale=1.15)\\n \\n sns.lineplot(\\n x=epoch_count,\\n y=acc,\\n ax=ax\\n )\\n \\n sns.lineplot(\\n x=epoch_count,\\n y=val_acc,\\n ax=ax\\n )\\n\\n ax.set_title('Accuracy Curves: Pre-Trained VGG-16 with 2 Trained Layers',fontsize=19)\\n \\n ax.set_ylabel('Accuracy',fontsize=18)\\n \\n ax.set_xlabel('Epochs',fontsize=18)\\n\\n plt.legend(['Training Accuracy', 'Validation Accuracy'])\\n\\n plt.show()\",\n \"def train_test_error(e_train, e_test, model_params):\\n\\n fig = plt.figure(figsize=FIG_SIZE)\\n plt.plot(model_params, e_train, label='Training Set')\\n plt.plot(model_params, e_train, label='Test Set')\\n plt.xlabel('Model Parameter')\\n plt.ylabel('MSE of model')\\n plt.legend()\\n\\n return fig\",\n \"def plot_loss(model_dir):\\n ## extract loss from csv\\n file_dir = os.path.join(model_dir, 'losses.csv')\\n data = pd.read_csv(file_dir)\\n epochs = data['epoch'].ravel()\\n loss = data['loss'].ravel()\\n\\n fig, ax = plt.subplots(1, 1, figsize=(7, 5), sharey=True, sharex=True, dpi=400)\\n ax.plot(epochs, loss, #label=r'Loss', \\n color='green', linewidth=1.0, alpha=0.8)\\n ax.set_ylabel('Loss', fontsize=10)\\n ax.set_xlabel('Number of iterations', fontsize=10)\\n ax.legend(loc='lower right', prop={\\\"size\\\": 15}, ncol=3, framealpha=0.5)\\n ax.set_title(\\\"Loss\\\")\\n ax.spines['top'].set_visible(False)\\n ax.spines['right'].set_visible(False)\\n plt.tight_layout()\\n\\n ## create saving directory\\n loss_dir = os.path.join(model_dir, 'figures', 'loss')\\n os.makedirs(loss_dir, exist_ok=True)\\n file_name = os.path.join(loss_dir, 'loss.png')\\n plt.savefig(file_name, dpi=400)\\n print(\\\"Plot saved to: {}\\\".format(file_name))\\n file_name = os.path.join(loss_dir, 'loss.pdf')\\n plt.savefig(file_name, dpi=400)\\n plt.close()\\n print(\\\"Plot saved to: {}\\\".format(file_name))\",\n \"def _plot_errors(self):\\n for task_id, loss_type in self.task_ids.iteritems():\\n x = np.arange(len(self.training_errors[task_id]))\\n fig, ax = plt.subplots(1, 1)\\n ax.set_xlabel('Number of epochs of training')\\n if loss_type is LossTypes.mse:\\n ax.set_ylabel('RMSE Error')\\n elif loss_type is LossTypes.cross_entropy:\\n ax.set_xlabel('(1 - accuracy)')\\n plt.plot(x, self.training_errors[task_id], 'r', label='training')\\n plt.plot(x, self.validation_errors[task_id], 'b', label='validation')\\n plt.legend(loc=\\\"best\\\", framealpha=0.3)\\n fig.savefig(\\\"error-curve-task-{}.png\\\".format(task_id))\\n plt.close('all')\",\n \"def plot_data(losses, accuracies, name):\\n # convert accuracies to percentages\\n accuracies['Train'] = [acc * 100 for acc in accuracies['Train']]\\n accuracies['Valid'] = [acc * 100 for acc in accuracies['Valid']]\\n # set fontsize\\n plt.rcParams.update({'font.size': 13})\\n fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(8,5))\\n ax1.set_xlabel('Number of Epochs')\\n ax1.set_ylabel('Cross Entropy Loss')\\n ax1.set_ylim(0,2)\\n ax1.plot(losses['Train'], label='Training')\\n ax1.plot(losses['Valid'], label='Validation')\\n ax1.legend(loc='upper right')\\n\\n ax2.set_xlabel('Number of Epochs')\\n ax2.set_ylabel('Accuracy (%)')\\n ax2.set_ylim(0,100)\\n ax2.plot(accuracies['Train'], label='Training')\\n ax2.plot(accuracies['Valid'], label='Validation')\\n ax2.legend(loc='upper left')\\n\\n fig.tight_layout()\\n fig.savefig('../outputs/' + name)\",\n \"def plot_accuracy(self):\\n plot_title, img_title = self.prep_titles(\\\"\\\")\\n test_legend = ['training data', 'test data']\\n\\n # Data for plotting x- and y-axis\\n x = np.arange(1, CFG.EPOCHS + 1)\\n y = [self.tr_accuracy, self.test_accuracy]\\n\\n # prints x and y-axis values\\n print(f'x: {x}')\\n print(f'training: {self.tr_accuracy}')\\n print(f'test: {self.test_accuracy}')\\n\\n plt.figure(figsize=(CFG.FIG_WIDTH, CFG.FIG_HEIGHT))\\n\\n # Create the lineplot\\n for line in range(2):\\n ax = sns.lineplot(x=x, y=y[line], color=CFG.COLOR_ACCURACY[line], label=test_legend[line])\\n\\n if CFG.ANNOTATE:\\n ax.set(xlabel='Epochs',\\n ylabel='Accuracy (%)',\\n title=plot_title,\\n xlim=(1, CFG.EPOCHS + 2),\\n ylim=(0, 119))\\n\\n for line in range(2):\\n for e in range(0, CFG.EPOCHS):\\n if y[line][e] > CFG.ANNOTATE_LEVEL:\\n value = \\\"{:.2f}\\\".format(y[line][e])\\n label = \\\"epoch \\\" + str(e + 1) + \\\"\\\\n\\\" + value + \\\"%\\\"\\n plt.annotate(label,\\n xy=(x[e], y[line][e]),\\n alpha=1,\\n size=9,\\n rotation=45,\\n textcoords='offset pixels', xytext=(0, 7),\\n ha='left', va='bottom')\\n else:\\n ax.set(xlabel='Epochs',\\n ylabel='Accuracy (%)',\\n title=plot_title,\\n xlim=(1, CFG.EPOCHS),\\n ylim=(0, 102))\\n\\n ax.legend(loc='best')\\n\\n self.save_plot(img_title)\\n plt.show()\",\n \"def plot_errors(self):\\n\\n plt.title(\\\"Prediction Error\\\")\\n plt.plot(self.errors)\\n plt.ylabel(\\\"MSE (Mean Squared Error)\\\")\\n plt.xlabel(\\\"Iteration\\\")\\n plt.show()\",\n \"def calc_loss_train_val(history):\\r\\n # overall loss\\r\\n fig = go.Figure()\\r\\n fig.add_trace(go.Scattergl(\\r\\n y=history.history['loss'],\\r\\n name='Train'))\\r\\n fig.add_trace(go.Scattergl(\\r\\n y=history.history['val_loss'],\\r\\n name='Validation'))\\r\\n fig.update_layout(height=500,\\r\\n width=700,\\r\\n title='Overall loss',\\r\\n xaxis_title='Epoch',\\r\\n yaxis_title='Loss')\\r\\n fig.show()\",\n \"def learning_curve():\\n loss = []\\n val_loss = []\\n data_size = []\\n\\n x_slid, y_slid = sliding_window_main(x, y)\\n x_train, y_train, x_val, y_val, x_test, y_test = data_splitting_main(x_slid, y_slid)\\n m_tot = x_train.shape[0]\\n\\n batch_step = 50\\n try:\\n for m in range(batch_size, m_tot, batch_step*batch_size):\\n print(\\\"Training: \\\", m)\\n net = create_network()\\n history = trainer(net, x_train[:m], y_train[:m], x_val, y_val)\\n loss.append(history.history[\\\"loss\\\"][-1])\\n val_loss.append(history.history[\\\"val_loss\\\"][-1])\\n data_size.append(m)\\n\\n print(\\\"Loss:\\\", loss[-1])\\n print()\\n\\n finally:\\n plt.plot(data_size, loss, label=\\\"Loss\\\", marker=\\\"o\\\")\\n plt.plot(data_size, val_loss, label=\\\"Val Loss\\\", marker=\\\"o\\\")\\n plt.xlabel(\\\"m\\\")\\n plt.ylabel(\\\"Losses\\\")\\n plt.title(\\\"Model Loss\\\")\\n plt.legend()\\n plt.savefig(\\\"img/\\\" + datetime.now().strftime(\\\"%y%m%d_%H%M\\\") + \\\"_learning_curve.png\\\")\\n plt.show()\\n plt.close()\\n\\n return loss, val_loss\",\n \"def visualize(self):\\r\\n self.aggregator.plot_loss()\\r\\n self.save_figure()\",\n \"def cross_validation_visualization_mean(epochs, means, save=False, filename = \\\"cross_validation_mean\\\"):\\n plt.plot(epochs, means, marker=\\\".\\\", color='b', label='means')\\n plt.xlabel(\\\"epoch\\\")\\n plt.ylabel(\\\"mean loss\\\")\\n plt.title(\\\"cross validation\\\")\\n plt.legend(loc=2)\\n plt.grid(True)\\n if (save):\\n plt.savefig(filename)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7867429","0.78592646","0.7805997","0.7769233","0.7716918","0.76086384","0.7583472","0.75043344","0.7502236","0.74993914","0.74954724","0.7421947","0.7350023","0.7309471","0.7306232","0.72990686","0.72583","0.72438455","0.7241214","0.7193638","0.7188506","0.71776074","0.7174294","0.71340305","0.7130715","0.71270907","0.71115315","0.7101607","0.70886827","0.7084036","0.7065371","0.705521","0.70507","0.7036305","0.7035262","0.7017388","0.69861233","0.6966518","0.6964948","0.69551694","0.69513047","0.6939345","0.69183683","0.68931526","0.6857993","0.6840316","0.6840016","0.6821531","0.6821218","0.6814254","0.68139845","0.68099105","0.6803585","0.6795071","0.67937183","0.6791491","0.67867136","0.6754793","0.6752201","0.67418706","0.67392707","0.67316055","0.672116","0.67173564","0.67126304","0.66904753","0.66601527","0.66599196","0.6655159","0.6652627","0.6651047","0.6651036","0.6643727","0.66291344","0.6626593","0.66262877","0.6621856","0.6615239","0.6605605","0.6603083","0.65763116","0.6556577","0.6544007","0.6543779","0.65350825","0.65285224","0.6519503","0.65097094","0.65004945","0.6494062","0.6481788","0.64660186","0.6453438","0.6449345","0.6438696","0.6434576","0.64345545","0.64311975","0.6427622","0.6427074"],"string":"[\n \"0.7867429\",\n \"0.78592646\",\n \"0.7805997\",\n \"0.7769233\",\n \"0.7716918\",\n \"0.76086384\",\n \"0.7583472\",\n \"0.75043344\",\n \"0.7502236\",\n \"0.74993914\",\n \"0.74954724\",\n \"0.7421947\",\n \"0.7350023\",\n \"0.7309471\",\n \"0.7306232\",\n \"0.72990686\",\n \"0.72583\",\n \"0.72438455\",\n \"0.7241214\",\n \"0.7193638\",\n \"0.7188506\",\n \"0.71776074\",\n \"0.7174294\",\n \"0.71340305\",\n \"0.7130715\",\n \"0.71270907\",\n \"0.71115315\",\n \"0.7101607\",\n \"0.70886827\",\n \"0.7084036\",\n \"0.7065371\",\n \"0.705521\",\n \"0.70507\",\n \"0.7036305\",\n \"0.7035262\",\n \"0.7017388\",\n \"0.69861233\",\n \"0.6966518\",\n \"0.6964948\",\n \"0.69551694\",\n \"0.69513047\",\n \"0.6939345\",\n \"0.69183683\",\n \"0.68931526\",\n \"0.6857993\",\n \"0.6840316\",\n \"0.6840016\",\n \"0.6821531\",\n \"0.6821218\",\n \"0.6814254\",\n \"0.68139845\",\n \"0.68099105\",\n \"0.6803585\",\n \"0.6795071\",\n \"0.67937183\",\n \"0.6791491\",\n \"0.67867136\",\n \"0.6754793\",\n \"0.6752201\",\n \"0.67418706\",\n \"0.67392707\",\n \"0.67316055\",\n \"0.672116\",\n \"0.67173564\",\n \"0.67126304\",\n \"0.66904753\",\n \"0.66601527\",\n \"0.66599196\",\n \"0.6655159\",\n \"0.6652627\",\n \"0.6651047\",\n \"0.6651036\",\n \"0.6643727\",\n \"0.66291344\",\n \"0.6626593\",\n \"0.66262877\",\n \"0.6621856\",\n \"0.6615239\",\n \"0.6605605\",\n \"0.6603083\",\n \"0.65763116\",\n \"0.6556577\",\n \"0.6544007\",\n \"0.6543779\",\n \"0.65350825\",\n \"0.65285224\",\n \"0.6519503\",\n \"0.65097094\",\n \"0.65004945\",\n \"0.6494062\",\n \"0.6481788\",\n \"0.64660186\",\n \"0.6453438\",\n \"0.6449345\",\n \"0.6438696\",\n \"0.6434576\",\n \"0.64345545\",\n \"0.64311975\",\n \"0.6427622\",\n \"0.6427074\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7015908"},"document_rank":{"kind":"string","value":"36"}}},{"rowIdx":78586,"cells":{"query":{"kind":"string","value":"Generates a 'learning curve' i.e. the analysis for each data size 0 to full. Obsolete function."},"document":{"kind":"string","value":"def learning_curve():\n loss = []\n val_loss = []\n data_size = []\n\n x_slid, y_slid = sliding_window_main(x, y)\n x_train, y_train, x_val, y_val, x_test, y_test = data_splitting_main(x_slid, y_slid)\n m_tot = x_train.shape[0]\n\n batch_step = 50\n try:\n for m in range(batch_size, m_tot, batch_step*batch_size):\n print(\"Training: \", m)\n net = create_network()\n history = trainer(net, x_train[:m], y_train[:m], x_val, y_val)\n loss.append(history.history[\"loss\"][-1])\n val_loss.append(history.history[\"val_loss\"][-1])\n data_size.append(m)\n\n print(\"Loss:\", loss[-1])\n print()\n\n finally:\n plt.plot(data_size, loss, label=\"Loss\", marker=\"o\")\n plt.plot(data_size, val_loss, label=\"Val Loss\", marker=\"o\")\n plt.xlabel(\"m\")\n plt.ylabel(\"Losses\")\n plt.title(\"Model Loss\")\n plt.legend()\n plt.savefig(\"img/\" + datetime.now().strftime(\"%y%m%d_%H%M\") + \"_learning_curve.png\")\n plt.show()\n plt.close()\n\n return loss, val_loss"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def finetune_learningrate_createData():\n acc,auc = [],[]\n for i in tqdm([j*0.005 for j in range(1,31)],desc='Progress(max_depth)',ncols=70,smoothing=0.5):\n X_train, X_test, y_train, y_test, X, y_binary = initializing()\n XGBCla = get_XGBmodel(lr=i)\n XGBCla = XGBCla.fit(X_train, y_train)\n acc.append(accuracy_score(XGBCla.predict(X_test),y_test))\n auc.append(roc_auc_score(XGBCla.predict(X_test),y_test))\n np.save(\"npy-data/result_learningrate_tuning_acc_auc_crossval_train\",acc+auc)","def active_learning(data, n_iter, n_sample, epochs):\n evaluation = []\n weights = []\n for i in range(n_iter):\n print(\"Iteration: {}\".format(i+1)) \n if i == 0:\n sampled_data, data = sample_random(n_sample,data)\n training_data = sampled_data \n model =LogisticRegression()\n print(\"Start training\")\n model.fit(training_data[:,:2], training_data[:,2], epochs=epochs, verbose=0, shuffle=True)\n print(\"End training\")\n eval_i = model.evaluate(data[:,:2], data[:,2])[1]\n evaluation.append(eval_i)\n print(\"Accuracy: {}\".format(eval_i)) \n weights.append(model.get_weights())\n sampled_data, rest_data = sample_highest_margin(model, data,n_sample)\n data = rest_data\n# import pdb; pdb.set_trace()\n training_data = np.concatenate([training_data, sampled_data]) \n print(\"---------------------------\")\n return evaluation, weights, training_data","def get_learning_rate():\n return 0.00001","def learn(self):\n Xt = np.append(np.ones((self.X.shape[0], 1)), self.X, axis=1)\n Yt = self.Y * 2 - 1\n\n w = np.ones(Xt.shape[1]) # avoiding random init, for debugging\n lw = [[] for k in range(len(w))]\n \n for iter in range(self.max_steps):\n P = Yt * np.dot(Xt, w)\n M = np.where(P <= 0)[0] # indices of misclassified datapoints\n\n if len(M) == 0: \n self.logger.debug(\"Found linearly separable hyperplane!\")\n break\n\n if self.is_stochastic:\n # just pick one randomly from M\n M = [M[random.randint(0, len(M)-1)]]\n\n grad = -1 * np.sum((Yt[M] * Xt[M].T), axis=1) / len(M)\n\n if self.reg_constant > 0:\n grad += self.reg_constant * w\n \n eta = self.step_size * 10000 / (10000 + iter)\n \n w = w - grad * eta\n \n if iter % 100 == 0:\n for k in range(len(w)):\n lw[k].append(w[k])\n \n if iter % 1000 == 0:\n self.logger.debug(\"Iter %s:\\t %f %f %f\" %(iter, w[0], w[1], w[2]))\n \n self.logger.debug(\"Iterations: %s\" %(iter))\n\n# x_range = range(len(lw[0]))\n# fig = plt.figure()\n# ax1 = fig.add_subplot(111) \n# for j, lwn in enumerate(lw):\n# if j % 3 >= 2: # plot an arbitrary subset of features\n# a = w[j]\n# ax1.plot(x_range, [(x-a) for x in lwn], label=str(j))\n# \n# plt.xlabel(\"Iteration\")\n# plt.ylabel(\"Feature weight\")\n# plt.show()\n \n #self.logger.debug(\"%s\" % np.array2string(w, precision=2, separator=','))\n \n self.w = w","def learning_curve(self, features, labels):\n return learning_curve(self._model, features, labels)","def ann_learning_curve(trainx, trainy, testx, testy, n_hidden=[5, 3],\n\t\t\t\t\t\tn_iter=5, cv=5, train_sizes=np.linspace(.1, 1.0, 10)):\n\n\tcv_train_scores = [[0] * len(train_sizes)]\n\tcv_test_scores = [[0] * len(train_sizes)]\n\tfor c in range(cv):\n\t\ttrain_scores = []\n\t\ttest_scores = []\n\t\tfor ts in train_sizes:\n\t\t\tn_examples = int(round(len(trainx) * ts))\n\t\t\trows = random.sample(range(len(trainx)), n_examples)\n\t\t\tsubx = trainx.iloc[rows, ]\n\t\t\tsuby = trainy.iloc[rows, ]\n\t\t\tstart = time.time()\n\t\t\ta, b = test_ann2(subx, suby, testx, testy,\n\t\t\t\t\t\t\t\tn_hidden=n_hidden, n_iter=n_iter)\n\t\t\tprint(\"training time: {} secs\".format(time.time() - start))\n\t\t\tcurrent_train_score = a\n\t\t\tcurrent_test_score = b\n\t\t\ttrain_scores.append(current_train_score)\n\t\t\ttest_scores.append(current_test_score)\n\t\tcv_train_scores.append(train_scores)\n\t\tcv_test_scores.append(test_scores)\n\taverage_train_scores = [sum(i) / cv for i in zip(*cv_train_scores)]\n\taverage_test_scores = [sum(i) / cv for i in zip(*cv_test_scores)]\n\treturn train_sizes, average_train_scores, average_test_scores","def learn(self, Xtrain, ytrain):","def learning_curve(ww_training, rw_training, ww_test, rw_test):\n accuracy_list = []\n # finds the smallest number of rows for n\n if ww_training.shape[0] <= rw_training.shape[0]:\n n = ww_training.shape[0]\n else:\n n = rw_training.shape[0]\n\n for i in range(1,n+1):\n np.random.shuffle(ww_training)\n np.random.shuffle(rw_training)\n recent = experiment(ww_training[:i], rw_training[:i], ww_test, rw_test)\n accuracy_list.append(recent)\n plt.plot(range(1,n+1), accuracy_list)","def main():\n ###################\n ## Dataset ##\n ###################\n # (X, y) m = 100, n = 1\n _data_x, data_y = make_regression(n_samples=100, n_features=1, noise=10)\n\n # show the dataset\n plt.subplot(2, 2, 1)\n plt.title(\"dataset\")\n plt.scatter(_data_x, data_y)\n\n # Transform the dataset into matrices.\n # That is used for writing the equations in the matrix form.\n data_x = np.hstack((_data_x, np.ones(_data_x.shape)))\n data_y = data_y.reshape(data_y.shape[0], 1)\n\n #################\n ## Model ##\n #################\n # initial parameters\n init_params = np.random.randn(2, 1)\n\n # initial model\n init_model = model(data_x, init_params)\n\n # plot initial model\n plt.subplot(2, 2, 2)\n plt.title(\"initial model\")\n plt.scatter(_data_x, data_y)\n plt.plot(_data_x, init_model, c='g')\n\n #########################\n ## cost function ##\n #########################\n # show cost function for initial parameters\n print(cost_function(data_x, data_y, init_params))\n\n ####################\n ## training ##\n ####################\n # learning rate\n learn_rate = 0.005\n # number of iterations\n number_iterations = 1_000\n\n # final parameters for our model\n final_params, cost_tracking = gradient_descent(\n data_x, data_y, init_params, learn_rate, number_iterations)\n\n # final model\n final_model = model(data_x, final_params)\n\n # show cost function for final parameters\n print(cost_function(data_x, data_y, final_params))\n\n # plot final model\n plt.subplot(2, 2, 3)\n plt.title(\"final model\")\n plt.scatter(_data_x, data_y)\n plt.plot(_data_x, final_model, c='r')\n\n ##########################\n ## learning curve ##\n ##########################\n # plot Cost history\n plt.subplot(2, 2, 4)\n plt.title(\"cost tracking\")\n plt.plot(range(number_iterations), cost_tracking)\n\n ########################################\n ## Coefficient of determination ##\n ########################################\n print(coefficient_determination(data_y, final_model))\n\n plt.show()","def train(self,features,y):\r\n \r\n if self.learn_type == \"nn\":\r\n #generate supervised dataset\r\n return(self.learner.train_on_batch(features,y))\r\n elif self.learn_type == \"linear\":\r\n grad = 0\r\n n = len(features)\r\n for i in range(n):\r\n #sum over the instances to get an estimate of the gradient\r\n print((y[i] - self.learner.activate(features[i])))\r\n grad -= (y[i] - self.learner.activate(features[i])) * \\\r\n self.learner.grad(features[i])\r\n grad /= n\r\n #update paramter\r\n param = np.copy(self.learner.param)\r\n self.learner.param = param - self.alpha * grad\r\n #print(self.learner.param)\r","def learn(self):\r\n \r\n # unpack\r\n X = self.Train.X\r\n Y = self.Train.Y\r\n DY = self.Train.DY\r\n \r\n NX ,ND = X.shape\r\n NDY,_ = DY.shape\r\n \r\n print 'Build Information Matricies ...'\r\n \r\n # functions\r\n ay0 = np.array([[1.]]*NX)\r\n ay1 = X\r\n ay2 = np.reshape( np.einsum('ij,ik->ijk',X,X) , [-1,ND*ND] )\r\n\r\n # reduce redundant basis variables\r\n i_doub = np.tri(ND,k=-1).T == 1\r\n ay2[:,i_doub.ravel()] = ay2[:,i_doub.ravel()] * 2. \r\n i_keep = np.tri(ND,k=0).T == 1\r\n ay2 = ay2[:,i_keep.ravel()]\r\n\r\n # basis matrix, functions\r\n Ay = np.hstack([ay0,ay1,ay2])\r\n \r\n # arrays for the least squares regression\r\n At = Ay\r\n Yt = Y\r\n \r\n # gradients\r\n if NDY:\r\n ad0 = np.array([[0.]]*NX*ND)\r\n \r\n ad1 = np.tile( np.eye(ND) , [NX,1] )\r\n \r\n ad2a = np.repeat( np.eye(ND)[:,None,:] , ND , 1 )\r\n ad2a = np.reshape( ad2a , [-1,ND*ND] ) \r\n ad2a = np.repeat( ad2a, NX, axis=0 ) * np.repeat( np.tile( X, [ND,1] ) , ND, axis=1 )\r\n \r\n ad2b = np.repeat( np.eye(ND)[:,:,None] , ND , 2 )\r\n ad2b = np.reshape( ad2b , [-1,ND*ND] ) \r\n ad2b = np.repeat( ad2b, NX, axis=0 ) * np.tile( np.tile( X, [ND,1] ) , [1,ND] )\r\n \r\n ad2 = ad2a + ad2b\r\n \r\n # reduce redundant bases\r\n ad2[:,i_doub.ravel()] = ad2[:,i_doub.ravel()] * 2.\r\n ad2 = ad2[:,i_keep.ravel()] \r\n \r\n Ad = np.hstack([ad0,ad1,ad2])\r\n \r\n # add to arrays for least squares regression\r\n At = np.vstack([At,Ad])\r\n Yt = np.vstack([Yt, np.ravel(DY.T)[:,None]])\r\n \r\n print 'Least Squares Solve ...'\r\n B = sp.linalg.lstsq(At,Yt)[0] \r\n \r\n # unpack data\r\n c = B[0,0]\r\n b = B[1:ND+1]\r\n \r\n A = np.zeros([ND,ND])\r\n A[i_keep] = B[ND+1:,0]\r\n A[i_keep.T] = A.T[i_keep.T]\r\n \r\n # problem forumulation\r\n A = A*2.\r\n \r\n # store results\r\n self.c = c\r\n self.b = b\r\n self.A = A\r\n \r\n print ''","def __init__(self, hidden_size, num_step=2000, print_interval=1000):\n self.num_step = num_step\n self.print_interval = print_interval\n\n # Model parameters initialization\n # Please initiate your network parameters here.\n self.w1 = np.array([[random.random() for i in range(hidden_size)] for j in range(2)]) #2 * hidden_size matrix\n self.w2 = np.array([[random.random() for i in range(hidden_size)] for j in range(hidden_size)])\n self.w3 = np.array([[random.random()] for j in range(hidden_size)])\n \n \n self.learning_rate = 0.05\n \n self.A1 = []\n self.A2 = []\n self.Y = []\n \n ...","def plot_learning_curve(model, X_train, X_test, y_train, y_test):\n\n m, train_scores, valid_scores = learning_curve(estimator = model, \n X = X_train, y = y_train.ravel(), train_sizes = np.linspace(0.1,1.0, 80))\n\n train_cv_err = np.mean(train_scores, axis=1)\n test_cv_err = np.mean(valid_scores, axis=1)\n tr, = plt.plot(m, train_cv_err)\n ts, = plt.plot(m, test_cv_err)\n plt.legend((tr, ts), ('training error', 'test error'), loc = 'best')\n plt.title('Learning Curve')\n plt.xlabel('Data Points')\n plt.ylabel('Accuracy')","def train_LR(self, X, y, eta=1e-3, batch_size=1, num_iters=1000) :\n loss_history = []\n N,d = X.shape\n for t in np.arange(num_iters):\n X_batch = None\n y_batch = None\n # ================================================================ #\n # YOUR CODE HERE:\n # Sample batch_size elements from the training data for use in gradient descent. \n # After sampling, X_batch should have shape: (batch_size,1), y_batch should have shape: (batch_size,)\n # The indices should be randomly generated to reduce correlations in the dataset. \n # Use np.random.choice. It is better to user WITHOUT replacement.\n # ================================================================ #\n \n # sample indices without replacement\n batch_idx = np.random.choice(N, batch_size, replace = False)\n X_batch = X[batch_idx]\n y_batch = y[batch_idx]\n \n \n # ================================================================ #\n # END YOUR CODE HERE\n # ================================================================ #\n loss = 0.0\n grad = np.zeros_like(self.w)\n # ================================================================ #\n # YOUR CODE HERE: \n # evaluate loss and gradient for batch data\n # save loss as loss and gradient as grad\n # update the weights self.w\n # ================================================================ #\n \n # compute the loss and gradient\n # loss_and_grad will take responsible for these\n \n loss, grad = self.loss_and_grad(X_batch, y_batch)\n \n self.w = self.w - eta * grad\n \n # ================================================================ #\n # END YOUR CODE HERE\n # ================================================================ #\n loss_history.append(loss)\n return loss_history, self.w","def run():\n trials = 100\n\n multipliers = [0.25, 0.3, 0.35, 0.5, 0.75, 1, 1.25, 1.45, 1.5, 1.55, 1.6] # Coefficients for learning rate\n\n mean_penalty = []\n median_penalty = []\n std_penalty = []\n\n mean_trial_time = []\n median_trial_time = []\n std_trial_time = []\n\n mean_success_rate = []\n median_success_rate = []\n std_success_rate = []\n\n for m in multipliers:\n all_penalties = [] # All penalties from trail sets\n all_average_trial_time = []\n all_success_rates = []\n\n for i in range(0, 20):\n # print \"Trial set:\", i\n # Set up environment and agent\n e = Environment() # create environment (also adds some dummy traffic)\n agent = e.create_agent(LearnerAgent) # create agent\n agent.mult = m\n e.set_primary_agent(agent, enforce_deadline=True) # specify agent to track\n\n # Now simulate it\n sim = Simulator(e, update_delay=0.0, display=False) # create simulator (uses pygame when display=True, if available)\n\n sim.run(n_trials=trials) # run for a specified number of trials\n\n all_penalties.append(agent.all_trails_penalties)\n all_average_trial_time.append(agent.time/float(trials))\n all_success_rates.append(float(trials-agent.aborted_trials)/trials)\n\n mean_penalty.append(np.mean(all_penalties))\n median_penalty.append(np.median(all_penalties))\n std_penalty.append(np.std(all_penalties))\n\n mean_trial_time.append(np.mean(all_average_trial_time))\n median_trial_time.append(np.median(all_average_trial_time))\n std_trial_time.append(np.std(all_average_trial_time))\n\n mean_success_rate.append(np.mean(all_success_rates))\n median_success_rate.append(np.median(all_success_rates))\n std_success_rate.append(np.std(all_success_rates))\n\n for i in range(0, len(multipliers)):\n print \"\"\n print \"Multiplier:\", multipliers[i]\n print \"\"\n print \"Mean penalty per {} trials:\".format(trials), mean_penalty[i]\n print \"Median penalty per {} trials:\".format(trials), median_penalty[i]\n print \"Std.Dev. penalty per {} trials:\".format(trials), std_penalty[i]\n\n print \"\"\n print \"Mean trial time:\", mean_trial_time[i]\n print \"Median trial time:\", median_trial_time[i]\n print \"Std.Dev. trial time:\", std_trial_time[i]\n\n print \"\"\n print \"Mean success rate per {} trials:\".format(trials), mean_success_rate[i]\n print \"Median success rate per {} trials:\".format(trials), median_success_rate[i]\n print \"Std.Dev. success rate per {} trials:\".format(trials), std_success_rate[i]","def ytrain(self,)->list:","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 get_learning_curve(estimator, X, y, ylim=None, cv=None, n_jobs=4, train_sizes=np.linspace(.125, 1.0, 8)):\n if ylim is not None:\n plt.ylim(*ylim)\n train_sizes, train_scores, test_scores = learning_curve(\n estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes)\n train_scores_mean = np.mean(train_scores, axis=1)\n train_scores_std = np.std(train_scores, axis=1)\n test_scores_mean = np.mean(test_scores, axis=1)\n test_scores_std = np.std(test_scores, axis=1)\n\n return train_sizes, train_scores_mean, test_scores_mean, train_scores_std, test_scores_std","def train(self, trainingData, trainingLabels, validationData, validationLabels ):\n\n self.setWeights(trainingData.shape[1])\n # DO NOT ZERO OUT YOUR WEIGHTS BEFORE STARTING TRAINING, OR\n # THE AUTOGRADER WILL LIKELY DEDUCT POINTS.\n \n # Hyper-parameters. Your can reset them. Default batchSize = 100, weight_decay = 1e-3, learningRate = 1e-2\n \"*** YOU CODE HERE ***\"\n self.batchSize = 100\n self.weight_decay = 1e-3\n self.learningRate = 0.1\n\n def Softmax(x):\n x_max = np.max(x, axis=0)\n x_exp = np.exp(x - x_max)\n x_exp_sum = np.sum(x_exp, axis=0)\n return x_exp / x_exp_sum\n\n for iteration in range(self.max_iterations):\n if iteration % 10 == 0:\n print(\"Starting iteration \", iteration, \"...\")\n self.learningRate *= 0.9\n dataBatches = self.prepareDataBatches(trainingData, trainingLabels)\n for batchData, batchLabel in dataBatches:\n \"*** YOUR CODE HERE ***\"\n Y = np.zeros((len(self.legalLabels), self.batchSize))\n for i in range(self.batchSize):\n Y[batchLabel[i]][i] = 1\n Y_pred = Softmax((batchData @ self.weights + self.bias).T)\n d_weight = ((Y_pred - Y) @ batchData / batchData.shape[0]).T + self.weight_decay * sum(self.weights)\n d_bias = np.mean(Y_pred - Y, axis=1) + self.weight_decay * sum(self.bias)\n self.weights -= d_weight * self.learningRate\n self.bias -= d_bias * self.learningRate","def train_model(self, \n num_epochs, \n learning_rate, \n momentum, \n num_iters,\n report_pseudo_cost,\n save_every_epoch,\n report_step,\n report_p_tilda,\n report_w_norm,\n exp_path,\n test_gradients = False):\n \n if report_p_tilda:\n \n p_t_i = 0\n \n p_tilda_all = np.zeros(\n [num_epochs*num_iters//report_step,self.batch_size]\n )\n \n else:\n \n p_tilda_all = []\n \n pseudo_losses = []\n \n if report_w_norm:\n \n w_norms = np.zeros(num_epochs*num_iters//report_step)\n \n w_i = 0\n \n else:\n \n w_norms = []\n \n start_train_time = timeit.default_timer()\n \n for epoch_index in range(num_epochs):\n \n epoch_time0 = timeit.default_timer()\n \n perm_inds = self.np_rand_gen.permutation(self.N_train)\n \n #put different learning_rate rules (per epoch) for now here:\n \n #lrate_epoch = learning_rate\n \n if self.mixture:\n \n lrate_epoch =\\\n (1.0/(1+epoch_index/10000.0))*learning_rate/self.batch_size\n \n else:\n lrate_epoch =\\\n (1.0/(1+epoch_index/100.0))*learning_rate/self.batch_size\n \n # lrate_epoch = (0.9**epoch_index)*learning_rate # 0.99\n \n # lrate_epoch = learning_rate\n \n if self.use_momentum:\n \n momentum_epoch = momentum\n \n print(\"Learning rate for epoch %d --- %f\"%\n (epoch_index,lrate_epoch))\n \n if report_pseudo_cost:\n \n avg_pseudo_cost_val = []\n \n for i in range(num_iters):\n \n iter_start_time = timeit.default_timer()\n \n minibatch_inds =\\\n perm_inds[self.batch_size*i:self.batch_size*(i+1)]\n \n if \"CSS\" in self.algorithm:\n \n assert self.num_samples > 0 \n \n is_samples, is_probs =\\\n self.is_sampler(minibatch_set =list(minibatch_inds),\n t = epoch_index)\n \n is_samples = np.asarray(is_samples, \n dtype = theano.config.floatX)\n if test_gradients:\n \n t0 = timeit.default_timer()\n \n approx_cost, p_tilda =\\\n self.optimize(is_samples, \n list(minibatch_inds),\n lrate_epoch)\n \n t1 = timeit.default_timer() \n print(\"Gradient computation with implementation 1 took\"+\\\n \" --- %f minutes\"%((t1 - t0)/60.0))\n W_implicit = np.asarray(self.W.get_value())\n b_implicit = np.asarray(self.b.get_value())\n t0 = timeit.default_timer()\n self.test_grad_computations(is_samples, list(minibatch_inds))\n t1 = timeit.default_timer()\n print(\"Gradient computation with implementation 2 took \"+\\\n \"--- %f minutes\"%((t1 - t0)/60.0))\n W_explicit = np.asarray(self.W.get_value())\n b_explicit = np.asarray(self.b.get_value())\n print(\"Equivalence of W updates in two implementations:\")\n print((np.round(W_implicit,12) == np.round(W_explicit,12)).all())\n print(\"Equivalence of b updates in two implementations:\")\n print((np.round(b_implicit,12) == np.round(b_explicit,12)).all())\n sys.exit()\n \n if ((self.mf_steps > 0) and (self.alpha >0)): \n \n if self.use_momentum:\n \n approx_cost, p_tilda =\\\n self.optimize(is_samples, \n list(minibatch_inds),\n is_probs,\n lrate_epoch,\n momentum_epoch)\n \n elif (not self.use_momentum):\n \n approx_cost, p_tilda =\\\n self.optimize(is_samples, \n list(minibatch_inds),\n is_probs,\n lrate_epoch)\n \n elif ((self.alpha ==0) or (self.mf_steps ==0) or\\\n self.mixture) and self.gibbs_steps ==0:\n \n if self.use_momentum:\n \n approx_cost, p_tilda =\\\n self.optimize(is_samples, \n list(minibatch_inds),\n lrate_epoch,\n momentum_epoch)\n \n elif (not self.use_momentum):\n \n approx_cost, p_tilda =\\\n self.optimize(is_samples, \n list(minibatch_inds),\n lrate_epoch)\n \n elif self.gibbs_steps > 0:\n \n if self.use_momentum:\n \n approx_cost, p_tilda =\\\n self.optimize(is_samples, \n list(minibatch_inds),\n is_probs,\n lrate_epoch,\n momentum_epoch)\n \n elif (not self.use_momentum):\n \n approx_cost, p_tilda =\\\n self.optimize(is_samples, \n list(minibatch_inds),\n is_probs,\n lrate_epoch)\n \n elif \"CD\" in self.algorithm:\n \n if self.num_hidden ==0:\n \n if \"PCD\" in self.algorithm:\n \n mf_sample, cd_sample = self.cd_sampling()\n \n self.x_gibbs.set_value(np.transpose(cd_sample))\n \n else:\n ### \"CD\" \n mf_sample, cd_sample =\\\n self.cd_sampling(list(minibatch_inds))\n \n self.x_gibbs.set_value(np.transpose(cd_sample))\n \n if self.use_momentum:\n \n approx_cost, p_tilda = self.optimize(list(minibatch_inds),\n lrate_epoch,\n momentum_epoch)\n \n else:\n \n approx_cost, p_tilda = self.optimize(list(minibatch_inds),\n lrate_epoch)\n \n avg_pseudo_cost_val.append(approx_cost)\n \n if report_pseudo_cost:\n \n if i % report_step ==0:\n \n print('Training epoch %d ---- Iter %d ----'%\n (epoch_index, i)+' pseudo cost value: %f'%approx_cost)\n \n if report_p_tilda:\n \n if i % report_step == 0:\n print(\"p_tilda values for training examples:\")\n if self.batch_size >=20:\n print_inds = range(0,20)\n print(p_tilda[print_inds])\n else:\n print(p_tilda[0:self.batch_size])\n print(\"sum of these values:\")\n if self.batch_size >= 20:\n print_inds = range(0,20)\n print(p_tilda[print_inds])\n else:\n print(np.sum(p_tilda[0:self.batch_size])) \n \n p_tilda_all[p_t_i,:] = p_tilda[0:self.batch_size]\n \n p_t_i +=1\n \n if report_w_norm: \n \n curr_w = self.W.get_value() \n \n w_norms[w_i] = np.sum(np.multiply(curr_w, curr_w))\n \n w_i +=1\n \n iter_end_time = timeit.default_timer()\n \n print('Training iteration took %f minutes'%\n ((iter_end_time - iter_start_time) / 60.))\n \n if report_pseudo_cost:\n \n avg_pseudo_cost_val = np.mean(avg_pseudo_cost_val)\n \n pseudo_losses.append(avg_pseudo_cost_val)\n \n print('Training epoch %d ---- average pseudo cost value: %f'\n %(epoch_index, avg_pseudo_cost_val))\n \n epoch_time1 = timeit.default_timer()\n \n print ('Training epoch took %f minutes'%\n ((epoch_time1 - epoch_time0)/60.))\n \n if save_every_epoch:\n \n params_to = os.path.join(exp_path,\"TRAINED_PARAMS_END.model\")\n \n self.save_model_params(params_to)\n \n end_train_time = timeit.default_timer()\n \n training_time = (end_train_time - start_train_time)/60.0\n\n print('Training process took %f minutes'%training_time)\n \n params_to = os.path.join(exp_path,\"TRAINED_PARAMS_END.model\")\n \n self.save_model_params(params_to)\n \n return p_tilda_all, pseudo_losses, training_time, w_norms","def SGD(epochs, eta):\n # print([[[k] for k in i] for i in self.x])\n # print([[j] for j in self.y])\n # print([i] for)\n\n # if test_data: n_test = len(test_data)\n for j in xrange(epochs):\n # mini_batches = [training_data[k:k + mini_batch_size] for k in xrange(0, n, mini_batch_size)]\n # for mini_batch in mini_batches:\n # update_mini_batch(mini_batch, eta)\n nabla_b = [np.zeros(b.shape) for b in self.biases]\n nabla_w = [np.zeros(w.shape) for w in self.weights]\n for x, y in training_data:\n delta_nabla_b, delta_nabla_w = backprop(x, y)\n nabla_b = [nb + dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]\n nabla_w = [nw + dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]\n # for x, y in training_data:\n # delta_nabla_b, delta_nabla_w = backprop(x, y)\n # nabla_b = [nb + dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]\n # nabla_w = [nw + dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]\n self.weights = [w - (eta ) * nw\n for w, nw in zip(self.weights, nabla_w)]\n self.biases = [b - (eta ) * nb\n for b, nb in zip(self.biases, nabla_b)]\n\n # print 'Epoch {0}'.format(j)\n # print self.weights\n # print self.biases\n\n # if test_data:\n # print \"Epoch {0}: {1} / {2}\".format(\n # j, evaluate(test_data), n_test)\n # else:\n # print \"Epoch {0} complete\".format(j)","def learn(self):\n metrics_hist = dict()\n max_runs = 3\n for run in range(max_runs):\n all_indices, initial_indices = self._init_al_dataset()\n\n metrics_hist[str(run)] = dict()\n\n current_indices = list(initial_indices)\n \n for split in self.data_splits_frac:\n print(f'\\nRUN {run} - SPLIT - {split*100:0.0f}%')\n\n # Initialise models\n self._init_models(mode='svaal')\n\n # Do some label stuff\n unlabelled_indices = np.setdiff1d(list(all_indices), current_indices)\n unlabelled_sampler = data.sampler.SubsetRandomSampler(unlabelled_indices)\n unlabelled_dataloader = data.DataLoader(self.datasets['train'],\n sampler=unlabelled_sampler,\n batch_size=64,\n drop_last=False)\n\n print(f'Labelled: {len(current_indices)} Unlabelled: {len(unlabelled_indices)} Total: {len(all_indices)}')\n\n # TODO: Make the SVAAL allow 100% labelled and 0% unlabelled to pass through it. Breaking out of loop for now when data hits 100% labelled.\n if len(unlabelled_indices) == 0:\n break\n\n metrics, svae, discriminator = self.train(dataloader_l=self.labelled_dataloader,\n dataloader_u=unlabelled_dataloader,\n dataloader_v=self.val_dataloader,\n dataloader_t=self.test_dataloader,\n mode='svaal') \n print(f'Test Eval.: F1 Scores - Macro {metrics[0]*100:0.2f}% Micro {metrics[1]*100:0.2f}%') \n \n # Record performance at each split\n metrics_hist[str(run)][str(split)] = metrics\n\n \n sampled_indices = self.sample_adversarial(svae, discriminator, unlabelled_dataloader, indices=unlabelled_indices, cuda=True) # TODO: review usage of indices arg\n current_indices = list(current_indices) + list(sampled_indices)\n sampler = data.sampler.SubsetRandomSampler(current_indices)\n self.labelled_dataloader = data.DataLoader(self.datasets['train'], sampler=sampler, batch_size=self.batch_size, drop_last=True)\n \n # write results to disk\n with open('results.json', 'w') as fj:\n json.dump(metrics_hist, fj, indent=4)","def learn(self):\n pass","def learn(self):\n pass","def train(self, training_steps=10):","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 bonus(l, m, n):\n # initialize variables\n lrs = [1.5, 0.25, 0.03, 0.005, 0.001]\n (y, x) = gen(l, m, n, 10000, True) \n # placeholder \n (y_train, x_train) = gen(l, m, n, 1, True)\n (y_test, x_test) = gen(l, m, n, 1, False)\n size, samples, loops, R = 10000, 10000, 50, None\n \n # build online learning algorithms\n adagrad = AdaGrad(R, x, x_train, x_test, y, y_train, y_test, n, samples, size, loops, lrs)\n \n # draw plots\n draw_bonus_error(adagrad.error)\n draw_bonus_loss(adagrad.loss)","def train(self, X, Y, num_iterations = 1000, learning_rate = 0.01, print_cost = False, plot_cost = False):\n costs = []\n \n for i in range(num_iterations + 1):\n grads, cost = self.propagate(X,Y)\n \n # Retrieve derivatives from grads\n dw = grads[\"dw\"]\n db = grads[\"db\"]\n \n # Update rule\n self.weight = self.weight - learning_rate * dw\n self.bias = self.bias - learning_rate * db\n \n # Record the costs\n if i % 100 == 0:\n costs.append(cost)\n \n # Print the cost every 100 training examples\n if print_cost and i % 100 == 0:\n print(f\"cost after iteration: {i} is {np.round(cost, 4)}\")\n \n grads = {\"dw\": dw,\n \"db\": db}\n\n if plot_cost:\n plt.plot(np.arange(len(costs)) * 100, costs)\n plt.xlabel(\"epoch\")\n plt.ylabel(\"cost\")\n plt.title(f\"Logistic curve fitting loss function (learning rate={learning_rate})\")\n plt.show()\n \n return grads, costs","def learn(self):\n total_error = 0\n threshold = 0.05\n\n counter = len(self._training_set)*len(self._perceptrons)\n total_error+=self.learning_step()\n\n while total_error/counter > threshold:\n counter += len(self._training_set)*len(self._perceptrons)\n total_error +=self.learning_step()","def stochastic_fit(self):\r\n self.init_plot(self.FEATURES)\r\n\r\n # YOUR CODE HERE\r\n\r\n while self.training_iteration == 0 or self.training_iteration < self.MAX_ITERATIONS*self.DATAPOINTS:\r\n print('Iteration: ', self.training_iteration)\r\n datapoint = np.random.randint(0, self.DATAPOINTS)\r\n\r\n self.compute_gradient(datapoint)\r\n self.upd_theta()\r\n\r\n # plot every 100th iteration\r\n if not self.training_iteration % 100:\r\n self.update_plot(np.sum(np.square(self.gradient)))\r\n\r\n self.training_iteration += 1","def main():\n \n # The following 5 command lines can be outcommented if the features are already created.\n # There is no need to process the data every single time.\n # Fine tuning the learning algorythm is much faster without that extra step.\n \n # by reading the train dataset the feature index is created.\n # First calling of the processdata function\n # Data limited to 300000\n featureIndexes = processData(os.path.join(dataFolder,\"avito_train.tsv\"), itemsLimit=600000)\n print \"featureIndex generated!\"\n print len(featureIndexes)\n\n # Trainfeature is created using the indexfeatures...\n # Second calling of the processdata function\n trainFeatures, trainTargets, trainItemIds, trainPrices, trainUrls, trainPhones, trainEmails, trainLength = processData(os.path.join(dataFolder,\"avito_train.tsv\"), itemsLimit=600000) # Original itemsLimit=300000\n\n # Building the test dataset... just like the training...\n testFeatures, testItemIds, testPrices, testUrls, testPhones, testEmails, testLength = processData(os.path.join(dataFolder,\"avito_test.tsv\"), featureIndexes)\n\n # Dumping data into file...\n # joblib.dump((trainFeatures, trainTargets, trainItemIds, testFeatures, testItemIds), os.path.join(dataFolder,\"train_data.pkl\"))\n joblib.dump((trainFeatures,trainTargets,trainItemIds,trainPrices,trainUrls,trainPhones,trainEmails,trainLength,\n testFeatures, testItemIds,testPrices,testUrls,testPhones,testEmails,testLength), os.path.join(dataFolder,\"SeparatedByCategory.pkl\"))\n\n\n # loading data pack...\n # trainFeatures, trainTargets, trainItemIds, testFeatures, testItemIds = joblib.load(os.path.join(dataFolder,\"train_data.pkl\"))\n\n #logging.info(\"Feature preparation done, fitting model...\")\n\n # Stochastic gradient model","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","def main():\n # Initializing learning rate\n learning_rate = 0.0005\n # Initializing stopping criteria\n stopping_criteria = 0.01\n # load the data training data from a csv file with an url\n training_x,testing_x, training_y, testing_y,mean,sd= ai.store_data(\"https://github.com/santiagocantu98/K-Nearest-Neightbours/raw/master/diabetes.csv\",\"training\")\n normal_testing = np.copy(testing_x)\n\n # scalates the features of the testing data\n testing_data_scaled,mean,sd = ai.scale_features(testing_x,mean,sd)\n ai.print_scaled_data(testing_data_scaled,\"testing\")\n ai.calculate_euclidean_distance(training_x, training_y , testing_data_scaled, testing_y,normal_testing)","def test_learning_curves():\n\n p = pipeline.Pipeline(\n FX_TRAIN,\n FX_TEST,\n FX_LOOKUP,\n RESULTS_DIR\n )\n\n data = p.learning_curves()","def train(self, iterations = 100):\n arguments = ()\n print(\"training...\")\n results = optimize.minimize(self.CostFunction,x0 = self.Thetas, args = arguments, options = {'disp':True, 'maxiter': iterations}, method = \"L-BFGS-B\", jac = True)\n self.Thetas = results['x']\n FinalCost, _ = self.CostFunction(self.Thetas)\n print(\"successfully trained the model\") \n print(\"Final Cost for this model is:\", FinalCost)","def learn(self):\n Qsa = self.evalQsa(self.features)[self.chosenA]\n print Qsa\n dQ = self.alpha*(self.reward + self.gamma * self.maxQsa(self.next_features) - Qsa)\n self.thetas += dQ*self.features[:,self.chosenA]\n print self.thetas\n # self.thetas /= np.sqrt(np.sum(np.power(self.thetas,2)))","def sgd_optimization(data_type, target, model_dir, learning_rate=0.1, n_epochs=10, batch_size=100):\r\n\r\n test_fold = 1 #xxxxxxxxxxxx TEMP XXXXXXXXXXXXXXXX\r\n write_model_file = model_dir + '/model.' + target + '.' + str(test_fold) +'.pkl'\r\n fold_path = helpers.get_fold_path(data_type)\r\n targets = helpers.build_targets(fold_path, data_type)\r\n fnames = targets[target]\r\n\r\n fold_accuracies = {}\r\n did_something = False\r\n\r\n # pct_ct = []\r\n # roc_auc = []\r\n # run 4 folds vs 1 fold with each possible scenario\r\n # for curr_fl in range(5):\r\n # print 'Building data for target: ' + target + ', fold: ' + str(curr_fl)\r\n\r\n # loop through all folds, for now just do 1!\r\n datasets, test_set_labels = helpers.th_load_data(data_type, fold_path, target, fnames, 0, test_fold)\r\n\r\n train_set_x, train_set_y = datasets[0]\r\n test_set_x, test_set_y = datasets[1]\r\n valid_set_x = train_set_x\r\n valid_set_y = train_set_y\r\n\r\n # compute number of rows for training, validation and testing\r\n rows_train = train_set_x.get_value(borrow=True).shape[0]\r\n rows_valid = valid_set_x.get_value(borrow=True).shape[0]\r\n rows_test = test_set_x.get_value(borrow=True).shape[0]\r\n\r\n # compute number of minibatches for training, validation and testing\r\n n_train_batches = rows_train / batch_size\r\n n_valid_batches = rows_valid / batch_size\r\n n_test_batches = rows_test / batch_size\r\n\r\n ####################### BUILD ACTUAL MODEL #######################\r\n # allocate symbolic variables for the data\r\n index = T.lscalar() # index to a [mini]batch\r\n\r\n # generate symbolic variables for input (x and y represent a minibatch)\r\n x = T.matrix('x') # data, presented as rasterized images\r\n y = T.ivector('y') # labels, presented as 1D vector of [int] labels\r\n\r\n # construct the logistic regression class\r\n # n_in: Each MNIST image has size 32*32 = 1024\r\n # n_out: 10 different digits - multi-task LR\r\n classifier = LogisticRegression(input=x, n_in=32 * 32, n_out=2)\r\n\r\n # the cost we minimize during training is the negative log likelihood of the model in symbolic format\r\n cost = classifier.negative_log_likelihood(y)\r\n\r\n # compiling a Theano function that computes the mistakes that are made by the model on a minibatch\r\n test_model = theano.function( inputs=[index], outputs=classifier.errors(y),\r\n givens={\r\n x: test_set_x[index * batch_size: (index + 1) * batch_size],\r\n y: test_set_y[index * batch_size: (index + 1) * batch_size]\r\n }\r\n )\r\n\r\n validate_model = theano.function(\r\n inputs=[index],\r\n outputs=classifier.errors(y),\r\n givens={\r\n x: valid_set_x[index * batch_size: (index + 1) * batch_size],\r\n y: valid_set_y[index * batch_size: (index + 1) * batch_size]\r\n }\r\n )\r\n\r\n # compute the gradient of cost with respect to theta = (W,b)\r\n g_W = T.grad(cost=cost, wrt=classifier.W)\r\n g_b = T.grad(cost=cost, wrt=classifier.b)\r\n\r\n # start-snippet-3\r\n # specify how to update the parameters of the model as a list of\r\n # (variable, update expression) pairs.\r\n updates = [(classifier.W, classifier.W - learning_rate * g_W),\r\n (classifier.b, classifier.b - learning_rate * g_b)]\r\n\r\n # compiling a Theano function `train_model` that returns the cost, but in\r\n # the same time updates the parameter of the model based on the rules\r\n # defined in `updates`\r\n train_model = theano.function( inputs=[index], outputs=cost, updates=updates,\r\n givens={\r\n x: train_set_x[index * batch_size: (index + 1) * batch_size],\r\n y: train_set_y[index * batch_size: (index + 1) * batch_size]\r\n }\r\n )\r\n # end-snippet-3\r\n\r\n ################ TRAIN MODEL ################\r\n # early-stopping parameters\r\n patience = 5000 # look as this many examples regardless\r\n patience_increase = 2 # wait this much longer when a new best is found\r\n improvement_threshold = 0.995 # a relative improvement of this much is considered significant\r\n validation_frequency = min(n_train_batches, patience / 2)\r\n # go through this many minibatches before checking the network on the validation set; in this case we check every epoch\r\n\r\n best_validation_loss = numpy.inf\r\n test_score = 0.\r\n start_time = time.clock()\r\n\r\n done_looping = False\r\n epoch = 0\r\n while (epoch < n_epochs) and (not done_looping):\r\n epoch = epoch + 1\r\n for minibatch_index in xrange(n_train_batches):\r\n\r\n minibatch_avg_cost = train_model(minibatch_index)\r\n\r\n # iteration number\r\n iter = (epoch - 1) * n_train_batches + minibatch_index\r\n\r\n if (iter + 1) % validation_frequency == 0:\r\n # compute zero-one loss on validation set\r\n validation_losses = [validate_model(i)\r\n for i in xrange(n_valid_batches)]\r\n this_validation_loss = numpy.mean(validation_losses)\r\n\r\n # print( 'epoch %i, minibatch %i/%i, validation error %f %%' %\r\n # (epoch, minibatch_index + 1, n_train_batches, this_validation_loss * 100.) )\r\n\r\n # if we got the best validation score until now\r\n if this_validation_loss < best_validation_loss:\r\n #improve patience if loss improvement is good enough\r\n if this_validation_loss < best_validation_loss * \\\r\n improvement_threshold:\r\n patience = max(patience, iter * patience_increase)\r\n\r\n best_validation_loss = this_validation_loss\r\n # test it on the test set\r\n\r\n test_losses = [test_model(i)\r\n for i in xrange(n_test_batches)]\r\n test_score = numpy.mean(test_losses)\r\n\r\n # print( (' epoch %i, minibatch %i/%i, test error of best model %f %%' ) %\r\n # ( epoch, minibatch_index + 1, n_train_batches, test_score * 100. ) )\r\n\r\n # save the best model\r\n with open(write_model_file, 'w') as f:\r\n cPickle.dump(classifier, f)\r\n\r\n if patience <= iter:\r\n done_looping = True\r\n break\r\n\r\n end_time = time.clock()\r\n\r\n print( ('Optimization complete for %d with best validation score of %f %% with test performance %f %%')\r\n % (test_fold, best_validation_loss * 100., test_score * 100.) )\r\n print 'The code ran for %d epochs, with %f epochs/sec' % (epoch, 1. * epoch / (end_time - start_time))\r\n # print >> sys.stderr, ('The code for file ' + os.path.split(__file__)[1] + ' ran for %.1fs' % ((end_time - start_time)))\r\n\r\n # end-snippet-4\r\n # Now we do the predictions\r\n\r\n # load the saved best model for this fold\r\n classifier = cPickle.load(open(write_model_file))\r\n\r\n # compile a predictor function\r\n predict_model = theano.function(inputs=[classifier.input], outputs=[classifier.y_pred,classifier.p_y_given_x])\r\n # compile a confidence predictor function\r\n # predict_conf_model = theano.function( inputs=[classifier.input], outputs=classifier.p_y_given_x)\r\n # We can test it on some examples from test test\r\n\r\n \"\"\" *************** build AUC curve *************** \"\"\"\r\n # get the probability of our predictions\r\n test_set = test_set_x.get_value()\r\n predicted_values, conf_preds = predict_model(test_set[:(rows_test)])\r\n\r\n conf_predictions = []\r\n for i in range(len(conf_preds)):\r\n # ignore the first column; this gives a lower score that seems wrong.\r\n conf_predictions.append(conf_preds[i][1])\r\n\r\n # determine ROC / AUC\r\n fpr, tpr, thresholds = metrics.roc_curve(test_set_labels, conf_predictions)\r\n auc = metrics.auc(fpr, tpr) # e.g. 0.855\r\n \"\"\" *********************************************** \"\"\"\r\n\r\n num_correct = 0\r\n num_false = 0\r\n for i in range(len(predicted_values)):\r\n if predicted_values[i] == test_set_labels[i]:\r\n num_correct += 1\r\n else:\r\n num_false += 1\r\n\r\n total = len(predicted_values)\r\n percent_correct = num_correct / float(total)\r\n\r\n fold_results = ''\r\n fold_results += '#################### Results for ' + data_type + ' ####################' + '\\n'\r\n fold_results += 'target:' + target + ' fold:' + str(test_fold) + ' predicted: ' + \\\r\n str(total) + ' wrong: ' + \\\r\n str(num_false) + ' pct correct: ' + str(percent_correct) + ', auc: ' + str(auc)\r\n\r\n print fold_results\r\n\r\n write_predictions_file = model_dir + '/predictions.' + target + '.' + str(test_fold) +'.txt'\r\n with open(write_predictions_file, 'w') as f:\r\n f.write(fold_results + \"\\n\")\r\n\r\n\r\n\r\n# def run_predictions(data_type, curr_target):\r\n\r\n# fold_path = get_fold_path(data_type)\r\n# targets = build_targets(fold_path, data_type)\r\n# # print \"Found \" + str(len(targets)) + \" targets for \" + data_type\r\n\r\n# fold_accuracies = {}\r\n# did_something = False\r\n# for target, fnames in targets.iteritems():\r\n# if (target != curr_target):\r\n# continue\r\n# else:\r\n# did_something = True\r\n\r\n# # retrieve our stratified folds\r\n# folds = get_folds(data_type, fold_path, target, fnames)\r\n\r\n# pct_ct = []\r\n# roc_auc = []\r\n# # run 4 folds vs 1 fold with each possible scenario\r\n# for curr_fl in range(5):\r\n# print 'Building data for target: ' + target + ', fold: ' + str(curr_fl)\r\n\r\n# # folds 1-4\r\n# temp_data = []\r\n# for i in range(len(folds)):\r\n# if(i == curr_fl):\r\n# # don't include the test fold\r\n# continue\r\n# else:\r\n# temp_data += folds[i]\r\n\r\n# # vs current 5th test fold\r\n# test_data = folds[curr_fl]\r\n \r\n# \"\"\" Turning 1024 bits into features is a slow process \"\"\"\r\n# # build training data\r\n# X = []\r\n# Y = []\r\n# for i in range(len(temp_data)):\r\n# row = []\r\n# for bit in temp_data[i][0]:\r\n# row.append(int(bit))\r\n# X.append(row)\r\n# Y.append(int(temp_data[i][1]))\r\n\r\n# X = np.array(X)\r\n# Y = np.array(Y)\r\n\r\n# # build test data\r\n# X_test = []\r\n# Y_test = []\r\n# for i in range(len(test_data)):\r\n# row = []\r\n# for bit in test_data[i][0]:\r\n# row.append(int(bit))\r\n# X_test.append(row)\r\n# Y_test.append(int(test_data[i][1]))\r\n\r\n# X_test = np.array(X_test)\r\n# Y_test = np.array(Y_test)\r\n\r\n# percent_correct, auc = random_forest(target, X, Y, X_test, Y_test, curr_fl)\r\n# pct_ct.append(percent_correct)\r\n# roc_auc.append(auc)\r\n\r\n\r\n# # now get the average fold results for this target\r\n# accuracy = sum(pct_ct) / float(len(pct_ct))\r\n# all_auc = sum(roc_auc) / float(len(roc_auc))\r\n# print 'Results for '+ target + ': accuracy: ' + str(accuracy) + ', auc: ' + str(all_auc)\r\n# # update fold accuracies\r\n# fold_accuracies[target] = (accuracy, all_auc)\r\n\r\n\r\n if(did_something == False):\r\n print curr_target + ' not found in ' + data_type + '!'\r\n exit(0)\r\n \r\n print '#################### Results for ' + data_type + ' ####################'\r\n # output results\r\n accuracies = 0.00\r\n aucs = 0.00\r\n num_targets = 0.00\r\n for target, obj in fold_accuracies.iteritems():\r\n acc = obj[0]\r\n auc = obj[1]\r\n print target + ' accuracy: ' + str(acc) + ', auc:' + str(auc)\r\n accuracies += acc\r\n aucs += auc\r\n num_targets += 1\r\n\r\n # overall_acc = accuracies / num_targets\r\n # overall_auc = aucs / num_targets\r\n # print ' overall accuracy: ' + str(overall_acc) + ', overall auc: ' + str(overall_auc)\r\n print '############################################################'","def draw_learning_curve(self, estimator, cvs=5, n_jobs=5, space_size=10,\n **kwargs):\n train_sizes, train_scores, test_scores = learning_curve(\n estimator=estimator, X=self.x_matrix, y=self.y_vector,\n train_sizes=numpy.linspace(.1, 1., space_size), cv=cvs,\n n_jobs=n_jobs, **kwargs\n )\n\n train_scores_mean = numpy.mean(train_scores, axis=1)\n train_scores_std = numpy.std(train_scores, axis=1)\n test_scores_mean = numpy.mean(test_scores, axis=1)\n test_scores_std = numpy.std(test_scores, axis=1)\n\n fig, ax_learning = pyplot.subplots(figsize=(10, 10))\n\n ax_learning.fill_between(\n train_sizes,\n train_scores_mean + train_scores_std,\n train_scores_mean - train_scores_std,\n alpha=0.1\n )\n ax_learning.plot(\n train_sizes, train_scores_mean, color='r',\n label='Training score'\n )\n\n ax_learning.fill_between(\n train_sizes,\n test_scores_mean + test_scores_std,\n test_scores_mean - test_scores_std,\n alpha=0.1\n )\n ax_learning.plot(\n train_sizes, test_scores_mean, color='g',\n label='Cross-validation score'\n )\n\n ax_learning.set(\n title='Learning curve',\n xlabel='Training examples', ylabel='Score'\n )\n ax_learning.legend(loc='best')\n\n self.learning_line = (fig, ax_learning)","def sgd(self, lr=0.01, decay=0.5, max_iters=1000,\n batch_size=128, early_stop=150, decay_intval=50, decay_lim=9):\n np.set_printoptions(precision=4)\n w = self.weights[0]\n loss = self.compute_loss(self.train_y, self.train_x, w)\n best_loss = loss\n best_counter = 0\n decay_counter = 0\n # print(\"initial loss is {} \".format(loss))\n for epoch in range(max_iters):\n\n for batch_y, batch_x in batch_iter(self.train_y, self.train_x, batch_size):\n grad = self.get_gradient(batch_y, batch_x, w)\n w = w - lr * grad\n loss = self.compute_loss(self.train_y, self.train_x, w)\n mis_class = self.compute_metrics(self.train_y, self.train_x, w)\n\n self.weights.append(w)\n self.losses.append(loss)\n self.misclass_rate.append(mis_class)\n if self.validation is True:\n valid_loss = self.compute_loss(self.valid_y, self.valid_x, w)\n valid_mis_class = self.compute_metrics(self.valid_y, self.valid_x, w)\n self.valid_losses.append(valid_loss)\n self.valid_misclass_rate.append(valid_mis_class)\n # Display every 25 epoch\n if (epoch + 1) % 25 == 0:\n print('Epoch {e} in {m}'.format(e=epoch + 1, m=max_iters), end=\"\\t\")\n if self.validation is True:\n # print('\\tTrain Loss {0:0.4f}, \\tTrain mis-class {0:0.4f}, '\n # '\\tvalid loss {0:0.4f}, \\tvalid mis-class {0:0.4f}'.\n # format(loss, mis_class, valid_loss, valid_mis_class))\n print('\\tTrain Loss {}, \\tTrain mis-class {}, '\n '\\tvalid loss {}, \\tvalid mis-class {}'.\n format(loss, mis_class, valid_loss, valid_mis_class))\n else:\n print('\\tTrain Loss {}, \\tTrain mis-class {}'.\n format(loss, mis_class))\n # judge the performance\n if best_loss - loss > 0.000001:\n best_loss = loss\n best_counter = 0\n else:\n best_counter += 1\n if best_counter > early_stop:\n print(\"Learning early stop since loss not improving for {} epoch.\".format(best_counter))\n break\n if best_counter % decay_intval == 0:\n print(\"weight decay by {}\".format(decay))\n lr *= decay\n decay_counter += 1\n if decay_counter > decay_lim:\n print(\"decay {} times, stop\".format(decay_lim))\n break\n return self.weights[-1]","def plot_learning_curve(X_train_all, X_val_all, y_train_all, y_val_all, train_sizes, title):\n\n errors_df = pd.DataFrame(columns = ['train_size', 'train_acc', 'val_acc'])\n\n # Loop through example sizes and get the training and validation error\n for train_size in train_sizes:\n # Select Subset of Data\n X_train = X_train_all[:train_size]\n X_val = X_val_all[:train_size]\n y_train = y_train_all[:train_size]\n y_val = y_val_all[:train_size]\n\n # Initialize Model\n model = svm.SVC(kernel='linear')\n\n # Fit model\n print(f\"Training {title} using {train_size} examples\")\n model.fit(X_train, y_train)\n\n # Get Predictions \n train_pred = model.predict(X_train)\n val_pred = model.predict(X_val)\n\n # Get Accuracy Score for X_Train and X_Val\n errors = pd.DataFrame({\n 'train_size': [train_size],\n 'train_acc': [accuracy_score(y_train, train_pred)],\n 'val_acc': [accuracy_score(y_val, val_pred)]\n })\n \n # Concatenate Dataframes\n errors_df = pd.concat([errors_df, errors])\n\n # Plot Learning Curve\n fig, ax = plt.subplots()\n\n errors_df.plot(x='train_size', y='train_acc',kind='line', ax=ax)\n errors_df.plot(x='train_size', y='val_acc',kind='line', color='red', ax=ax)\n\n ax.set_xlabel(\"Training Size\")\n ax.set_ylabel(\"Accuracy\")\n ax.set_title(title)\n\n # Save Figure\n plt.savefig('figs/' + title + '_learning_curve.png')","def learnign_rate_examples():\n #######\n bad_larning_rate = 0.1\n not_bad_learning_rate = 1e-4\n good_learning_rate = 1e-3\n #######\n return bad_larning_rate, not_bad_learning_rate, good_learning_rate","def train2(self):\n for epoch in range(self.epochs):\n print \"epoch: \", epoch\n self.train(self.D)\n self.alpha -= 0.002 # decrease the learning rate\n self.min_alpha = model.alpha # fix the learning rate, no decay","def plot_learning_curve(X, y, maxdepth, estimator, plt):\n # create cv training and test scores for various training set sizes\n train_sizes, train_scores, test_scores = learning_curve(estimator,\n X, # feature matrix\n y, # target vector\n cv=10, # number of folds in cross-validation\n scoring='neg_mean_squared_error', # metric\n n_jobs=-1, # use all computer cores,\n train_sizes=np.linspace(0.01, 1.0, 30) # 30 different sizes of the training set\n )\n # create means and standart deviations of training set scores\n train_mean = np.mean(train_scores, axis=1)\n train_std = np.std(train_scores, axis=1)\n\n # create means and standart deviations of test set scores\n test_mean = np.mean(test_scores, axis=1)\n test_std = np.std(test_scores, axis=1)\n\n # draw lines\n plt.plot(train_sizes, train_mean, '--', color='#111111', label=\"Training score\")\n plt.plot(train_sizes, test_mean, color='#111111', label=\"Cross-validation score\")\n\n # draw bands\n plt.fill_between(train_sizes, train_mean - train_std, train_mean + train_std, color=\"#DDDDDD\")\n plt.fill_between(train_sizes, test_mean - test_std, test_mean + test_std, color=\"#f4d0d7\")\n \n # create plot \n plt.title(\"Learning curve\")\n plt.xlabel(\"Training set size\", fontsize=18)\n plt.ylabel(\"mse\", fontsize=18)\n plt.legend(loc=\"best\")\n plt.tight_layout()","def train(self, i):\n\t\tlearningRate = self.learningRateFn(i)\n\t\tdiscountFactor = self.discountFactorFn(i)\n\t\ttrainingTuples = []\n\t\twhile self.currentSAVRSAVIndex < len(self.SAVRSAV):\n\t\t\tcurrentSAVRSAV = self.SAVRSAV[self.currentSAVRSAVIndex]\n\t\t\tvalue = currentSAVRSAV['predictedValueOfAction'] + learningRate * (currentSAVRSAV['reward'] + discountFactor*currentSAVRSAV['predictedValueOfNewAction'] - currentSAVRSAV['predictedValueOfAction'])\n\t\t\ttrainingTuples.append((currentSAVRSAV['state'],currentSAVRSAV['action'],value))\n\t\t\tself.currentSAVRSAVIndex += 1\n\t\treturn self.neuralNet.train(trainingTuples)","def train(self, iterations: int):\n\n s = \"{:3d} reward {:6.2f}/{:6.2f}/{:6.2f} len {:6.2f} epsilon {:1.3f} {}\"\n s_check = \"{:3d} reward {:6.2f}/{:6.2f}/{:6.2f} len {:6.2f} epsilon {:1.3f} saved {} \"\n total_steps = 0\n iter_metrics = []\n for n in range(iterations):\n r_min, r_mean, r_max, iter_steps = self.train_iter()\n iter_metrics.append((r_min, r_mean, r_max))\n total_steps += iter_steps\n\n if n == int(iterations / 2):\n self.steps_to_update_target_model = int(self.steps_to_update_target_model / 2)\n\n # checkpointing & logging\n s_print = s\n file_name = \"\"\n if n % self.checkpoint_freq == 0:\n file_name = f'my_dqn_{n}.pth'\n torch.save(self.target_dqn.state_dict(), os.path.join(self.checkpoint_path, file_name))\n s_print = s_check\n\n if self.verbose:\n print(s_print.format(\n n + 1,\n r_min,\n r_mean,\n r_max,\n total_steps,\n self.e_greedy,\n file_name\n ))\n iter_min = np.mean([x[0] for x in iter_metrics])\n iter_mean = np.mean([x[1] for x in iter_metrics])\n iter_max = np.mean([x[2] for x in iter_metrics])\n return iter_min, iter_mean, iter_max","def learning_curve(dataframe:object, analysis_type:str, loss_skip_15pct:bool=False):\n\n\t\t# Spline seems to crash with too many points.\n\t\tif (dataframe.shape[0] >= 400):\n\t\t\tline_shape = 'linear'\n\t\telif (dataframe.shape[0] < 400):\n\t\t\tline_shape = 'spline'\n\n\t\tdf_loss = dataframe[['loss','val_loss']]\n\t\tdf_loss = df_loss.rename(columns={\"loss\": \"train_loss\", \"val_loss\": \"validation_loss\"})\n\t\tdf_loss = df_loss.round(3)\n\n\t\tif loss_skip_15pct:\n\t\t\tdf_loss = df_loss.tail(round(df_loss.shape[0]*.85))\n\n\t\tfig_loss = px.line(\n\t\t\tdf_loss\n\t\t\t, title = '<i>Training History: Loss</i>'\n\t\t\t, line_shape = line_shape\n\t\t)\n\t\tfig_loss.update_layout(\n\t\t\txaxis_title = \"Epochs\"\n\t\t\t, yaxis_title = \"Loss\"\n\t\t\t, legend_title = None\n\t\t\t, font_family = \"Avenir\"\n\t\t\t, font_color = \"#FAFAFA\"\n\t\t\t, plot_bgcolor = \"#181B1E\"\n\t\t\t, paper_bgcolor = \"#181B1E\"\n\t\t\t, height = 400\n\t\t\t, hoverlabel = dict(\n\t\t\t\tbgcolor = \"#0F0F0F\"\n\t\t\t\t, font_size = 15\n\t\t\t\t, font_family = \"Avenir\"\n\t\t\t)\n\t\t\t, yaxis = dict(\n\t\t\t\tside = \"right\"\n\t\t\t\t, tickmode = 'auto'# When loss is initially high, the 0.1 tickmarks are overwhelming.\n\t\t\t\t, tick0 = -1\n\t\t\t\t, nticks = 9\n\t\t\t)\n\t\t\t, legend = dict(\n\t\t\t\torientation=\"h\"\n\t\t\t\t, yanchor=\"bottom\"\n\t\t\t\t, y=1.02\n\t\t\t\t, xanchor=\"right\"\n\t\t\t\t, x=1\n\t\t\t)\n\t\t\t, margin = dict(\n\t\t\t\tt = 5\n\t\t\t\t, b = 0\n\t\t\t),\n\t\t)\n\t\tfig_loss.update_xaxes(zeroline=False, gridcolor='#262B2F', tickfont=dict(color='#818487'))\n\t\tfig_loss.update_yaxes(zeroline=False, gridcolor='#262B2F', tickfont=dict(color='#818487'))\n\n\t\tif (\"classification\" in analysis_type):\n\t\t\tdf_acc = dataframe[['accuracy', 'val_accuracy']]\n\t\t\tdf_acc = df_acc.rename(columns={\"accuracy\": \"train_accuracy\", \"val_accuracy\": \"validation_accuracy\"})\n\t\t\tdf_acc = df_acc.round(3)\n\n\t\t\tfig_acc = px.line(\n\t\t\tdf_acc\n\t\t\t\t, title = '<i>Training History: Accuracy</i>'\n\t\t\t\t, line_shape = line_shape\n\t\t\t)\n\t\t\tfig_acc.update_layout(\n\t\t\t\txaxis_title = \"epochs\"\n\t\t\t\t, yaxis_title = \"accuracy\"\n\t\t\t\t, legend_title = None\n\t\t\t\t, font_family = \"Avenir\"\n\t\t\t\t, font_color = \"#FAFAFA\"\n\t\t\t\t, plot_bgcolor = \"#181B1E\"\n\t\t\t\t, paper_bgcolor = \"#181B1E\"\n\t\t\t\t, height = 400\n\t\t\t\t, hoverlabel = dict(\n\t\t\t\t\tbgcolor = \"#0F0F0F\"\n\t\t\t\t\t, font_size = 15\n\t\t\t\t\t, font_family = \"Avenir\"\n\t\t\t\t)\n\t\t\t\t, yaxis = dict(\n\t\t\t\tside = \"right\"\n\t\t\t\t, tickmode = 'linear'\n\t\t\t\t, tick0 = 0.0\n\t\t\t\t, dtick = 0.05\n\t\t\t\t)\n\t\t\t\t, legend = dict(\n\t\t\t\t\torientation=\"h\"\n\t\t\t\t\t, yanchor=\"bottom\"\n\t\t\t\t\t, y=1.02\n\t\t\t\t\t, xanchor=\"right\"\n\t\t\t\t\t, x=1\n\t\t\t\t)\n\t\t\t\t, margin = dict(\n\t\t\t\t\tt = 5\n\t\t\t\t),\n\t\t\t)\n\t\t\tfig_acc.update_xaxes(zeroline=False, gridcolor='#262B2F', tickfont=dict(color='#818487'))\n\t\t\tfig_acc.update_yaxes(zeroline=False, gridcolor='#262B2F', tickfont=dict(color='#818487'))\n\t\t\tfig_acc.show()\n\t\tfig_loss.show()","def learn(self):\r\n \r\n # take a mini-batch from replay experience\r\n cur_batch_size = min(len(self.replay_exp), self.batch_size)\r\n mini_batch = random.sample(self.replay_exp, cur_batch_size)\r\n \r\n # batch data\r\n sample_states = np.ndarray(shape = (cur_batch_size, self.state_size)) # replace 128 with cur_batch_size\r\n sample_actions = np.ndarray(shape = (cur_batch_size, 1))\r\n sample_rewards = np.ndarray(shape = (cur_batch_size, 1))\r\n sample_next_states = np.ndarray(shape = (cur_batch_size, self.state_size))\r\n sample_dones = np.ndarray(shape = (cur_batch_size, 1))\r\n\r\n temp=0\r\n for exp in mini_batch:\r\n sample_states[temp] = exp[0]\r\n sample_actions[temp] = exp[1]\r\n sample_rewards[temp] = exp[2]\r\n sample_next_states[temp] = exp[3]\r\n sample_dones[temp] = exp[4]\r\n temp += 1\r\n \r\n \r\n sample_qhat_next = self.brain_target.predict(sample_next_states)\r\n \r\n # set all Q values terminal states to 0\r\n sample_qhat_next = sample_qhat_next * (np.ones(shape = sample_dones.shape) - sample_dones)\r\n # choose max action for each state\r\n sample_qhat_next = np.max(sample_qhat_next, axis=1)\r\n \r\n sample_qhat = self.brain_policy.predict(sample_states)\r\n \r\n for i in range(cur_batch_size):\r\n a = sample_actions[i,0]\r\n sample_qhat[i,int(a)] = sample_rewards[i] + self.gamma * sample_qhat_next[i]\r\n \r\n q_target = sample_qhat\r\n \r\n self.brain_policy.fit(sample_states, q_target, epochs = 1, verbose = 0)\r\n \r\n \r\n \r\n \"\"\"\r\n \r\n for state, action, reward, next_state, done in mini_batch:\r\n target_Q_s_a = 0 # new target for Q(s,a)\r\n state = np.reshape(state, [1, state_size])\r\n next_state = np.reshape(next_state, [1, state_size])\r\n \r\n # if it is not the terminal state\r\n if not done:\r\n qhat_next = self.brain_target.predict(next_state) # estimate Q(s',a')\r\n target_Q_s_a = reward + self.gamma * np.amax(qhat_next[0]) # because the output is m * n, so we need to consider the dimension [0]\r\n else:\r\n target_Q_s_a = reward\r\n \r\n target_output = self.brain_policy.predict(state) # we will replace target of Q(s,a) for specific a later\r\n target_output[0][action] = target_Q_s_a # new target for state s and action a\r\n \r\n self.brain_policy.fit(state, target_output, epochs = 1, verbose = 0)\r\n \r\n \"\"\"","def train( self, trainingData, trainingLabels, validationData, validationLabels ):\n\n self.features = trainingData[0].keys() # could be useful later\n # DO NOT ZERO OUT YOUR WEIGHTS BEFORE STARTING TRAINING, OR\n # THE AUTOGRADER WILL LIKELY DEDUCT POINTS.\n for iteration in range(self.max_iterations):\n #pdb.set_trace() # esto es un break point para que puedas comprobar el formato de los datos\n print (\"Starting iteration \", iteration, \"...\")\n for i in range(len(trainingData)):#training data\n max = -10000000\n for j in range(len(self.weights)):\n prod = np.dot(self.weights[j], trainingData[i]) #este sería x0 (en la primera vuelta) (xj)\n if (prod > max):\n max=prod #en max guardamos la distancia a la instancia que más cerca está de la que estamos recorriendo\n indclase=j #guardas el índice de la clase a la que predices que pertenece\n\n if(indclase != trainingLabels[i]):\n # recalcular pesos\n self.weights[trainingLabels[i]].__radd__(trainingData[i]) #honek jarraian egiten du gehiketa pisu guztientzat\n #pdb.set_trace() # esto es un break point para que puedas comprobar el formato de los datos\n self.weights[indclase].__sub__(trainingData[i]) #honek jarraian egiten du kenketa pisu guztientzat\n\n\n\n\n\n ########################################################################################\n # 1. i es el indice de un ejemplo (un item, f(x) de un ejemplo) del conjunto de entrenamiento.\n # 2. Asi pues, en cada vuelta de este loop se trata un solo ejemplo\n # por cada ejemplo calculareis el producto punto (dotProduct) w*item\n # NOTAS: Recordad que cada ejemplo viene representado por varios rasgos (o features), es decir, es un vector de rasgos, tantos como nos marca el atributo self.features.\n # Asi cada ejemplo es de dimension 1 filas y self.features).\n # La dimension del vector w tambien es self.features, es decir, habra tantos pesos en w_rasgo dentro de w como rasgos haya en cada item de ejemplo\n # Recordad tambien que es una clasificacion multiclase en este caso. Hay tantas clases como nos marca el atributo self.legalLabels\n #########################################################################################","def learn(self):\n raise NotImplementedError","def generate(self):\r\n \r\n components = []\r\n components.append(nn.Linear(self.n_features,self.hidden_sizes[0]))\r\n self._activation(components,self.activation)\r\n self._dropout(components,self.dropout)\r\n \r\n for i in range(1,len(self.hidden_sizes)):\r\n components.append(nn.Linear(self.hidden_sizes[i-1],self.hidden_sizes[i]))\r\n self._activation(components,self.activation)\r\n self._dropout(components,self.dropout)\r\n \r\n components.append(nn.Linear(self.hidden_sizes[-1],self.n_classes))\r\n\r\n mlp = nn.Sequential(*components)\r\n \r\n num_params = sum(p.numel() for p in mlp.parameters() if p.requires_grad)\r\n print(\"Created MLP with \"+str(num_params)+\" learnable params\")\r\n \r\n return mlp","def train(epoch, model, loss_fn, optimizer, dataloder,pair_generation_tnf):\n model.train()\n train_loss =0\n for batch_idx, batch in enumerate(tqdm(dataloder, desc='Epoch {}'.format(epoch))):\n optimizer.zero_grad()\n #batch = pair_generation_tnf(batch)\n \n theta = model(batch)\n print()\n loss= loss_fn(theta, batch['theta'])\n \n \n \n loss.backward()\n optimizer.step()\n train_loss += loss.data.cpu().numpy().item()\n train_loss /= len(dataloader)\n print('Train set: Average loss: {:.4f}'.format(train_loss))\n return train_loss","def finetune_n_estimators_createData():\n acc, auc = [], []\n for i in tqdm([j*10 for j in range(1,31)],desc='Progress(n_estimators)',ncols=70,smoothing=0.5):\n X_train, X_test, y_train, y_test, X, y_binary = initializing()\n XGBCla = get_XGBmodel(n_est=i)\n XGBCla = XGBCla.fit(X_train, y_train)\n acc.append(accuracy_score(XGBCla.predict(X_test),y_test))\n auc.append(roc_auc_score(XGBCla.predict(X_test),y_test))\n np.save(\"npy-data/result_n_estimators_tuning_acc_auc_crossval_train\",acc+auc)","def train(self, game_life):\n rewards = [obs.get('reward') for obs in game_life]\n cum_rewards = sum(rewards)\n\n # manage the graphics\n self.reward_graph.append(cum_rewards)\n plt.plot(self.reward_graph)\n x, y, z = peri_bounding_box\n\n # The amound of nudge\n if cum_rewards:\n displacement = cum_rewards * self.displacement\n else:\n displacement = 0 - self.displacement\n\n # Store observations and perturbed predictions\n data, targets = [], []\n\n for obs in game_life:\n\n # Perturb action\n action, prediction = obs.get('action')\n if self.epsilon and (random.uniform(0, 1.0) < self.epsilon):\n action = random.randrange(18)\n\n # Copy\n update = list(prediction)\n\n # Update only the target action\n update[0][action] = update[0][action] + displacement\n\n\n data.append(\n # Apply bounding box before appending\n np.array(obs.get('observation')[x[0]:x[1], y[0]:y[1], :])\n )\n\n\n update = np.array(update).reshape(1,18),\n targets.append(update)\n\n if data and len(data) > 15:\n # Image processing\n datagen = preprocessing.image.ImageDataGenerator(\n featurewise_center=True,\n featurewise_std_normalization=True,\n rotation_range=20,\n width_shift_range=0.2,\n height_shift_range=0.2,\n horizontal_flip=True)\n datagen.fit(data)\n\n # Training data generator\n train = datagen.flow(np.array(data), np.squeeze(np.array(targets)),\n batch_size=16)\n\n # Finally train\n self.graph.fit_generator(train, steps_per_epoch=len(data)/16,\n epochs=30, verbose=0,\n callbacks=[\n callbacks.EarlyStopping(monitor='acc'),\n # callbacks.ModelCheckpoint() ?\n ]\n )","def train():\n pass","def plot_learning_curve(self, estimators, title, labels, colors, X, y, \n ylim=None, cv=None, n_jobs=1, train_sizes=np.linspace(.1, 1.0, 10)):\n plt.figure(figsize = (6,8))\n plt.title(title)\n if ylim is not None:\n plt.ylim(*ylim)\n plt.xlabel(\"Training examples\")\n plt.ylabel(\"Accuracy\")\n for i in range(len(estimators)): \n estimator = estimators[i]\n line_label = labels[i]\n line_color = colors[i]\n train_sizes, train_scores, test_scores = learning_curve(\n estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes)\n train_scores_mean = np.mean(train_scores, axis=1)\n train_scores_std = np.std(train_scores, axis=1)\n test_scores_mean = np.mean(test_scores, axis=1)\n test_scores_std = np.std(test_scores, axis=1)\n\n plt.fill_between(train_sizes, train_scores_mean - train_scores_std,\n train_scores_mean + train_scores_std, alpha=0.1,\n color=line_color[0])\n plt.fill_between(train_sizes, test_scores_mean - test_scores_std,\n test_scores_mean + test_scores_std, alpha=0.1, color=line_color[1])\n plt.plot(train_sizes, train_scores_mean, \"o-\", color=line_color[0],\n label=line_label[0])#\"Training accuracy\"\n plt.plot(train_sizes, test_scores_mean, \"o-\", color=line_color[1],\n label=line_label[1]) #\"Cross-validation accuracy\"\n\n plt.grid() \n plt.legend(bbox_to_anchor=(0., 1.05, 1., .105),loc=3, mode=\"expand\",\n borderaxespad=0.)\n plt.savefig(\"../Figures/\" + title + \".png\", bbox_inches=\"tight\")\n return plt","def train (self, data, targets, epochs = 100, etaDataLayer = 0.2, etaHiddenLayer = 0.2, hiddenLayers = 1, hiddenNeurons = 200, dataWeightsLimit = 0.05, hiddenWeightsLimit = 0.5, regression = True, backPropagate = False, verbose = False):\n\t\tself.data[\"input\"] \t\t= numpy.array(data)\n\t\tself.data[\"rows\"] \t\t= len(data)\n\t\tself.data[\"cols\"] \t\t= len(data[0])\n\t\tself.targets \t\t\t= targets\n\t\tself.classCount \t\t= len(set(targets))\n\t\tself.epochs \t\t\t= epochs\n\t\tself.etaDataLayer \t\t= float(etaDataLayer)\n\t\tself.etaHiddenLayer \t= float(etaHiddenLayer)\n\t\tself.hiddenLayers \t\t= hiddenLayers\n\t\tself.hiddenNeurons \t\t= hiddenNeurons\n\t\tself.dataWeightsLimit \t= float(dataWeightsLimit)\n\t\tself.hiddenWeightsLimit\t= float(hiddenWeightsLimit)\n\t\tself.regression \t\t= regression\n\t\tself.backPropagate \t\t= backPropagate\n\t\tself.verbose \t\t\t= verbose\n\t\tself.report \t\t\t= {}\n\t\tself.report[\"total\"] \t= self.epochs * len(data)\n\t\tself.dataWeights \t\t= self.dataWeightsLimit * numpy.random.random_sample((self.data[\"cols\"], self.hiddenNeurons))\n\t\tself.hiddenWeights \t\t= self.hiddenWeightsLimit * numpy.random.random_sample((self.hiddenNeurons + 1, 1))\n\t\tprint \"========================================\"\n\t\tprint \"--- Training . . . ---------------------\"\n\t\tprint \"========================================\"\n\t\tfor epoch in range(self.epochs):\n\t\t\thits \t\t\t\t= 0\n\t\t\tmisses \t\t\t\t= 0\n\t\t\tprocessed \t\t\t= 0\n\t\t\tdistances \t\t\t= []\n\t\t\tpredictedClass \t\t= None\n\t\t\tsampleIndices \t\t= sorted(range(len(self.data[\"input\"])), key = lambda k: random.random())\n\t\t\tif self.verbose == True:\n\t\t\t\tprint \"----------------------------------------\"\n\t\t\t\tprint \"--- Epoch\", epoch\n\t\t\t\tprint \"----------------------------------------\"\n\t\t\tfor sampleIndex in sampleIndices:\n\t\t\t\tprint self.dataWeights\n\t\t\t\tsample \t\t\t= self.data[\"input\"][sampleIndex]\n\t\t\t\ttarget \t\t\t= self.targets[sampleIndex]\n\t\t\t\tif self.verbose == True:\n\t\t\t\t\tprint \"--- Feeding Forward . . . --------------\"\n\t\t\t\t\tprint \" Sample\", sampleIndex + 1, \"of Epoch\", epoch + 1\n\t\t\t\t# Forward Propagation\n\t\t\t\ta \t\t\t\t= 1.0 / (1.0 + numpy.exp(- numpy.dot(sample, self.dataWeights)))\n\t\t\t\tb \t\t\t\t= numpy.concatenate([[1], a])\n\t\t\t\toutput \t\t\t= 1.0 / (1.0 + numpy.exp(- numpy.dot(b, self.hiddenWeights)))[0]\n\t\t\t\t# Metric Computation & Communication\n\t\t\t\tif self.regression == False:\n\t\t\t\t\terror \t\t\t= 0.5 * (((target / (self.classCount - 1)) - output) ** 2)\n\t\t\t\t\tdistance \t\t= abs(target - (output * (self.classCount - 1)))\n\t\t\t\t\tpredictedClass \t= round(self.classCount * output) - 1\n\t\t\t\t\tif predictedClass == target:\n\t\t\t\t\t\thits += 1\n\t\t\t\t\telse:\n\t\t\t\t\t\tmisses += 1\n\t\t\t\t\tif self.verbose == True:\n\t\t\t\t\t\tprint \" Annotated Class: \\t\", target\n\t\t\t\t\t\tprint \" Computed Class: \\t\", predictedClass\n\t\t\t\t\t\tprint \" Computed SSE: \\t\\t%0.4f\" % error\n\t\t\t\t\t\tprint \" Raw Distance: \\t\\t%0.4f\" % distance\n\t\t\t\t\t\tif predictedClass == target:\n\t\t\t\t\t\t\tprint \" Prediction Status: \\tHit! :)\"\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tprint \" Prediction Status: \\tOops! :(\"\n\n\t\t\t\telse:\n\t\t\t\t\terror \t\t\t= 0.5 * ((target - output) ** 2)\n\t\t\t\t\tdistance \t\t= abs(target - output)\n\t\t\t\t\tif self.verbose == True:\n\t\t\t\t\t\tprint \" Annotated Value: \\t\", target\n\t\t\t\t\t\tprint \" Computed Value: \\t%0.4f\" % output\n\t\t\t\t\t\tprint \" Computed SSE: \\t\\t%0.4f\" % error\n\t\t\t\t\t\tprint \" Raw Distance: \\t\\t%0.4f\" % distance\n\t\t\t\tprocessed += 1\n\t\t\t\tdistances.append(distance)\n\t\t\t\t# Back Propagation\n\t\t\t\tif self.verbose == True:\n\t\t\t\t\tprint \"--- Back Propagating . . . -------------\"\n\t\t\t\tdeltaDataWeights \t= ((target / self.classCount - 1) - output) * output * (1 - output)\n\t\t\t\tdeltaHiddenWeights \t= numpy.delete((b * (1 - b) * self.hiddenWeights * deltaDataWeights)[0], 0.0)\n\t\t\t\tupdateHiddenWeights = etaHiddenLayer * b * deltaDataWeights\n\t\t\t\tupdatedHiddenLayer \t= b + updateHiddenWeights\n\t\t\t\tself.hiddenWeights \t= numpy.transpose(numpy.atleast_2d(updatedHiddenLayer))\n\t\t\t\tupdateDataWeights \t= etaDataLayer * numpy.outer(sample, deltaHiddenWeights)\n\t\t\t\tself.dataWeights \t= self.dataWeights + updateDataWeights\n\t\t\t\tprint self.dataWeights\n\t\t\t\tif self.verbose == True:\n\t\t\t\t\tprint \"--- Sample Processed -------------------\\n\"\n\n\t\t\t\t# updateDataWeights \t= etaDataLayer * numpy.array(sample) * deltaHiddenWeights\n\n\t\t\t\t# # Multiple Hidden Layer Routine\n\t\t\t\t# for hiddenLayer in range(hiddenLayers):\n\t\t\tif self.verbose == True:\n\t\t\t\tprint \"----------------------------------------\"\n\t\t\t\tprint \"--- Epoch\", epoch, \"Complete\"\n\t\t\t\tprint \"----------------------------------------\"\n\t\t\t\tif self.regression == False:\n\t\t\t\t\taccuracy \t\t= (hits/processed) * 100\n\t\t\t\t\tprint \" \tEpoch Hits / Total:\\t\", hits, \"/\", processed\n\t\t\t\t\tprint \" \tEpoch Hit Percent:\\t%0.2f\" % (float(hits) / processed * 100), \"\\n\"\n\t\t\t\telse:\n\t\t\t\t\tprint \"\\n\"\n\t\tprint \"========================================\"\n\t\tprint \"--- Training Complete ------------------\"\n\t\tprint \"========================================\"","def Q_learning_test(env,alpha,gamma,episodes, q_table):\n %time\n \n # For plotting metrics\n all_epochs = []\n all_penalties = []\n rewards = []\n \n total_reward = 0\n \n for i in range(1, episodes+1):\n state = env.reset()\n episode_rewards = []\n\n epochs, penalties, reward, = 0, 0, 0\n done = False\n\n while not done:\n \n action = np.argmax(q_table[state]) # Exploit learned values by choosing optimal values\n next_state, reward, done, info = env.step(action) \n\n\n if reward == -10:\n penalties += 1\n \n state = next_state\n episode_rewards.append(reward)\n epochs += 1\n \n if done == True:\n break \n if epochs == 1000:\n break \n \n total_reward += reward\n rewards.append(np.sum(episode_rewards))\n \n if i % 1000 == 0:\n clear_output(wait=True)\n print(f\"Episode: {i}\")\n\n \n print(\"Training finished.\\n\")\n \n \n plt.plot(savgol_filter(rewards, 1001, 3, mode = \"interp\"))\n plt.title(\"Smoothened testing reward per episode\", pad = 30 , size = BIGGER_SIZE)\n plt.xlabel('Episodes', labelpad = 20);\n plt.ylabel('Total Reward', labelpad = 20);\n plt.tick_params(axis='both', which='major', labelsize=16);\n plt.tick_params(axis='both', which='minor', labelsize=16);\n #plt.xlim(100000, 200000);\n #plt.ylim(0,50)\n # plt.xticks(np.arange(0, episodes+1, 5000));\n # plt.yticks(np.arange(min(rewards), max(rewards)+1, 1000));","def part_1(l, m, n, size, noise):\n # initilize variables\n (y, x) = gen(l, m, n, size, noise)\n samples, loops, R = size / 10, 20, None\n lrs = [1.5, 0.25, 0.03, 0.005, 0.001]\n alphas = [1.1, 1.01, 1.005, 1.0005, 1.0001]\n gammas = [2.0, 0.3, 0.04, 0.006, 0.001]\n \n # divide dataset: 10% - training, 10% - test.\n left, right = random.sample(range(10),2)\n x_train, x_test = x[left*samples:(left+1)*samples], x[right*samples:(right+1)*samples]\n y_train, y_test = y[left*samples:(left+1)*samples], y[right*samples:(right+1)*samples]\n \n # build online learning algorithms\n perceptron = Perceptron(R, x_train, x_test, y_train, y_test, n, samples, size)\n perceptron_margin = Perceptron_Margin(R, x, x_train, x_test, y, y_train, y_test, n, samples, size, loops, lrs)\n winnon = Winnon(R, x, x_train, x_test, y, y_train, y_test, n, samples, size, loops, alphas)\n winnon_margin = Winnon_Margin(R, x, x_train, x_test, y, y_train, y_test, n, samples, size, loops, alphas, gammas)\n adagrad = AdaGrad(R, x, x_train, x_test, y, y_train, y_test, n, samples, size, loops, lrs)\n \n # draw plots\n draw_1(size, l, m, n, perceptron.error, perceptron_margin.error, winnon.error, winnon_margin.error, adagrad.error)","def createModel(data, eta, epoch, file_name, plot_name, no_of_input=2):\n logging.info(f\"\\n\\n>>>>>>>>>>Starting training>>>>>>>>>>>>>>>>{file_name}\")\n logging.info(f\"eta = {str(eta)} epochs ={str(epoch)}\\n\")\n\n df = pd.DataFrame(data)\n\n X,y = prepare_data(df)\n logging.info(f\"X={X}\")\n logging.info(f\"Y={y}\") \n\n model = Perceptron(eta, epoch, no_of_input)\n\n model.fit(X, y)\n\n model.predict(X)\n\n model.total_loss()\n\n save_model(model, file_name)\n\n \n logging.info(f\">>>>>>>>>>>>>>>>>>>>>>>>>>>>>\")\n\n if no_of_input == 2:\n save_plot(df, plot_name, model)","def Q_learning_train(env,alpha,gamma,epsilon,episodes):\n %time\n # For plotting metrics\n all_epochs = []\n all_penalties = []\n rewards = []\n \n #Initialize Q table of 22500 x 8 size (22500 states and 8 actions) with all zeroes\n q_table = np.zeros([env.observation_space.n, env.action_space.n]) \n \n for i in range(1, episodes+1):\n state = env.reset()\n episode_rewards = []\n\n epochs, penalties, reward, = 0, 0, 0\n done = False\n\n while not done:\n if random.uniform(0, 1) < epsilon:\n action = env.action_space.sample() # Explore action space randomly\n else:\n action = np.argmax(q_table[state]) # Exploit learned values by choosing optimal values\n\n next_state, reward, done, info = env.step(action) \n\n old_value = q_table[state, action]\n next_max = np.max(q_table[next_state])\n\n new_value = (1 - alpha) * old_value + alpha * (reward + gamma * next_max)\n q_table[state, action] = new_value\n\n if reward == -10:\n penalties += 1\n \n\n state = next_state\n episode_rewards.append(reward)\n epochs += 1\n \n if done == True:\n break \n if epochs == 1000:\n break \n rewards.append(np.sum(episode_rewards))\n \n if i % 1000 == 0:\n clear_output(wait=True)\n print(f\"Episode: {i}\")\n \n \n print(\"Training finished.\\n\")\n \n plt.plot(savgol_filter(rewards, 1001, 3, mode = \"interp\"))\n plt.title(\"Smoothened training reward per episode\", pad = 30, size = BIGGER_SIZE)\n plt.legend()\n plt.xlabel('Episodes', labelpad = 20);\n plt.ylabel('Total Reward', labelpad = 20);\n plt.tick_params(axis='both', which='major');\n plt.tick_params(axis='both', which='minor');\n #plt.xlim(0, 60000);\n #plt.ylim(0,50)\n #plt.xticks(np.arange(0, episodes+1, 5000));\n #plt.yticks(np.arange(min(rewards), max(rewards)+1, 1000));","def generate(self):\n self.training_data.gen_x(self.x_func)\n self.training_data.gen_a(self.a_func)\n self.training_data.gen_y(self.y_func)\n \n self.testing_data.gen_x(self.x_func)\n self.testing_data.gen_ys(self.y_func)\n self.testing_data.gen_azero(self.ytotal_func)","def __init__(\n self,\n n = 2,\n learning_rate = 0.0001,\n early_stop = 1e-4,\n steps = 100000,\n ):\n self.n = n\n self.learning_rate = learning_rate\n self.early_stop = early_stop\n self.steps = steps\n self.coefficients = self.random_coefficients(n)\n self.loss = np.array([])\n self.x_values = np.array([])\n self.y_values = np.array([])\n self.old_loss = 0","def train(self, X, y, batch_size=8, learning_rate=1, n_steps=100):\n self.training_w = np.zeros((n_steps, self.n_in+1))\n self.training_loss = np.zeros(n_steps)\n for s in tqdm(range(n_steps)):\n # draw a random batch\n batch_idx = np.random.choice(X.shape[0], batch_size, replace=False)\n # compute and store mean loss\n self.training_loss[s] = np.mean(self.loss(y[batch_idx], self.predict(X[batch_idx])))\n # store current weights\n self.training_w[s,:self.n_in] = self.w\n self.training_w[s,-1] = self.b\n # perform a gradient descent step\n self.gradient_descent_step(X[batch_idx], y[batch_idx], learning_rate)","def learn_offline(self, dataset, sparsity_coeff, learning_rate,\n max_steps, base_norm_coeff, precision):\n # The list of all data processed per layer devided for sublayer \n # input_data[sublayer][actual_recording][events, timestamp if 0 or xy coordinates if 1]\n input_data = []\n # In the first layer the input_data is the input dataset given by the user\n input_data.append(dataset)\n \n for layer in range(self.layers):\n # now let's generate the surfaces and train the layers\n single_layer_surfaces = []\n single_layer_errors = []\n # The result of a single layer learning that will serve as input for the \n # next one\n outrecordings = []\n for sublayer in range(len(self.basis[layer])):\n sub_layer_surfaces = []\n sub_layer_errors = []\n sub_layer_outevents_on = []\n sub_layer_outevents_off = []\n # A single array containing all the generated surfaces \n # for a single sublayer used for full offline learning \n all_surfaces = []\n all_reference_events = []\n # Generate and allocate plots for online plotting\n if self.verbose is True:\n plot_names = []\n # Building a list to contain the basis at each run\n for i in range(len(self.basis[layer][sublayer])):\n plot_names.append(\"Base N: \"+str(i))\n live_figures, live_axes = surface_live_plot(surfaces=self.basis[layer][sublayer], fig_names=plot_names)\n for recording in range(len(input_data[sublayer])):\n recording_surfaces = []\n for k in range(len(input_data[sublayer][recording][0])):\n single_event = [input_data[sublayer][recording][0][k], input_data[sublayer][recording][1][k]]\n tsurface = Time_Surface_event(xdim = self.surfaces_dimensions[layer][0],\n ydim = self.surfaces_dimensions[layer][1],\n event=single_event,\n timecoeff=self.taus[layer],\n dataset=input_data[sublayer][recording],\n num_polarities=self.polarities[layer],\n verbose=False)\n recording_surfaces.append(tsurface)\n # A single array containing all the generated surfaces \n # for a single sublayer used for full recording learning\n all_surfaces.append(tsurface) \n all_reference_events.append(single_event)\n sub_layer_surfaces.append(recording_surfaces)\n \n # Learning time\n n_steps = 0 \n previous_err = 0\n err = precision + 1\n while (abs(err-previous_err)>precision) & (n_steps<max_steps):\n #Let's compute the activations\n sub_layer_activations = []\n for i in range(len(all_surfaces)):\n self.sublayer_response_CG(layer, sublayer, all_surfaces[i], sparsity_coeff, 0)\n sub_layer_activations.append(self.activations[layer][sublayer].copy()) \n #Let's compute the basis\n opt_res = update_basis_offline_CG(self.basis[layer][sublayer],\n self.surfaces_dimensions[layer][0]*self.polarities[layer],\n self.surfaces_dimensions[layer][1], \n self.features_number[layer], sub_layer_activations,\n all_surfaces, base_norm_coeff)\n \n self.basis[layer][sublayer] = opt_res.x.reshape(self.features_number[layer],\n self.surfaces_dimensions[layer][1], self.surfaces_dimensions[layer][0]*self.polarities[layer])\n sub_layer_errors.append(opt_res.fun)\n n_steps += 1\n previous_err = err\n err = sub_layer_errors[-1]\n # Update plots\n if self.verbose is True: \n live_figures, live_axes = surface_live_plot(surfaces=self.basis[layer][sublayer], figures=live_figures, axes=live_axes)\n print(\"Layer:\"+np.str(layer)+\" Sublayer:\"+np.str(sublayer)+\" Base optimization process:\"+np.str((n_steps/max_steps)*100)+\"%\")\n if (n_steps<max_steps):\n print(\"Execution stopped, requested precision reached\")\n else:\n print(\"Maximum number of step reached, last delta error was :\" + np.str(abs(err-previous_err)))\n \n #Let's compute again the activations after defining the set of basis\n sub_layer_activations = []\n for i in range(len(all_surfaces)):\n self.sublayer_response_CG(layer, sublayer, all_surfaces[i], sparsity_coeff, 0)\n sub_layer_activations.append(self.activations[layer][sublayer].copy()) \n # sub_layer_activations contains all the activations to all the time surfaces\n # of different recordings, in order to build the next layer input data \n # I need to redefine the original ordering of the data\n current_position = 0\n for recording in range(len(input_data[sublayer])):\n current_recording_length = len(input_data[sublayer][recording][0]) \n # Obtaining the events resulting from the activations in a single recording\n outevents = events_from_activations(sub_layer_activations[current_position:(current_position+current_recording_length)],\n all_reference_events[current_position:(current_position+current_recording_length)],\n self.delay_coeff)\n sub_layer_outevents_on.append(outevents[0])\n sub_layer_outevents_off.append(outevents[1])\n current_position += current_recording_length\n \n single_layer_surfaces.append(sub_layer_surfaces)\n single_layer_errors.append(sub_layer_errors)\n # Saving each sub layer events deviding between negative and positive\n # activations, they will be used to optimize the consequent of \n # sublayers in the next layer\n outrecordings.append(sub_layer_outevents_on) \n outrecordings.append(sub_layer_outevents_off)\n # Close plots before displaying next set of basis\n if self.verbose is True:\n for i in range(len(live_figures)):\n plt.close(fig=live_figures[i])\n live_axes.clear()\n live_figures.clear()\n input_data = outrecordings.copy()\n self.surfaces.append(single_layer_surfaces)\n self.errors.append(single_layer_errors)","def train(self, adata, num_epochs = 2000, batch_size = 64, val_split = 0.1, lr = 1e-03, decay_factor = 1/3,\n patience_LR = 3, patience_ES = 9):\n \n tf.keras.backend.clear_session()\n \n loss = NBloss\n \n dataset = self.makegenerators(adata, val_split = 0.1, batch_size = batch_size, splitseed = self.splitseed)\n \n counter_LR = 0\n counter_ES = 0\n best_loss = np.inf\n \n self.optimizer.lr = lr\n \n total_start = time()\n \n for epoch in range(num_epochs):\n epoch_start = time()\n \n epoch_loss_avg = tf.keras.metrics.Mean()\n epoch_loss_avg_val = tf.keras.metrics.Mean()\n \n # Training loop - using batches of batch_size\n for x, target in dataset(val = False):\n loss_value, grads = grad(self, x, target, loss)\n self.optimizer.apply_gradients(zip(grads, self.trainable_variables))\n epoch_loss_avg(loss_value) # Add current batch loss\n \n # Validation Loop\n for x, target in dataset(val = True):\n output = self(*x)\n loss_value = loss(target, output)\n epoch_loss_avg_val(loss_value)\n \n current_loss_val = epoch_loss_avg_val.result()\n\n epoch_time = round(time() - epoch_start, 1)\n \n print(\"Epoch {:03d}: Training Loss: {:.3f}, Validation Loss: {:.3f}, Time: {:.1f} s\".format(epoch, epoch_loss_avg.result().numpy(), epoch_loss_avg_val.result().numpy(), epoch_time))\n \n if(current_loss_val + 10**(-3) < best_loss):\n counter_LR = 0\n counter_ES = 0\n best_loss = current_loss_val\n else:\n counter_LR = counter_LR + 1\n counter_ES = counter_ES + 1\n\n if patience_ES <= counter_ES:\n break\n\n if patience_LR <= counter_LR:\n self.optimizer.lr = self.optimizer.lr * decay_factor\n counter_LR = 0\n print(\"\\nDecaying Learning Rate to: \" + str(self.optimizer.lr.numpy()))\n \n # End epoch\n \n total_time = round(time() - total_start, 2)\n \n if not os.path.isdir(\"./\" + self.weights_dir):\n os.mkdir(\"./\" + self.weights_dir)\n \n self.save_weights(os.path.join(self.weights_dir, \"countmodel_weights_\" + self.name_), save_format='tf')\n \n print('\\nTraining Completed')\n print(\"Total training time: \" + str(total_time) + \" seconds\")","def __init__(self, hidden_size, num_step=2000, print_interval=100, af=relu, lr=0.1):\n np.random.seed(3023)\n self.num_step = num_step\n self.print_interval = print_interval\n self.af = af # activation function\n self.lr = lr # learning rate\n self.accuracy_box = []\n\n # Model parameters initialization\n # Please initiate your network parameters here.\n self.hidden1_weights = np.random.randn(2, hidden_size) # The dimension of the dataset is 2, so the initial dimension of the hidden weights is 2 x hidden size\n self.hidden2_weights = np.random.randn(hidden_size, hidden_size)\n self.output3_weights = np.random.randn(hidden_size, 1) # output is binary, so the output size is 1","def train_naive(): # add arguments as needed\n pass","def train(self, X, y, lr, epoch, method='adam', quit=1e-4):\n if len(y.shape) == 1:\n y = y.reshape((-1, 1))\n if not (0 < lr < 1):\n raise self.ANNException('learning rate cannot be negative or exceeds 1')\n if epoch <= 0:\n raise self.ANNException('epoch must be postitive integer')\n if method == 'gd':\n for _ in range(epoch):\n nodes = self._forward(X)\n self._backpropagate(y, nodes, lr)\n elif method == 'adam':\n alpha = 0.1\n beta1 = 0.5\n beta2 = 0.999\n epsilon = 1e-8\n mt = np.zeros(shape=self.weight.shape)\n vt = np.zeros(shape=self.weight.shape)\n before_err = self._energy(X, y)\n for t in range(1, epoch+1):\n nodes = self._forward(X)\n gt = self._backpropagate(y, nodes, alpha, ret=True)\n mt = beta1*mt + (1-beta1)*gt\n vt = beta2*vt + (1-beta2)*gt**2\n mthat = mt / (1-np.power(beta1, t))\n vthat = vt / (1-np.power(beta2, t))\n self.weight -= alpha * mthat/(np.sqrt(vthat)+epsilon)\n after_err = self._energy(X, y)\n if 0 < after_err-before_err < quit:\n return\n else:\n before_err = after_err\n else:\n raise self.ANNException('only gd and adam optimizer are supported')","def SGD(self, X_train, Y_train, X_validation, Y_validation, epochs, mini_batch_size, learning_rate, decay):\n \n training_data = zip(X_train, Y_train)\n validation_data = zip(X_validation, Y_validation)\n\n \n \"\"\"Take the training data and make a list out of it\"\"\"\n training_data = list(training_data)\n \n \"\"\"Check if there is data in the test_data\"\"\"\n if validation_data:\n validation_data = list(validation_data)\n n_validation_data = len(validation_data)\n \n \"\"\"\n Mini-batches: Each mini-batch contains mini_batch_size elements from the training set.\n \n Splits the training data into mini-bachtes, and for each mini-batches we train the network. \n \n \"\"\" \n\n# Updated for the testing\n# ========================\n mini_batches = []\n high_score = [0,0]\n for j in range(epochs):\n random.shuffle(training_data)\n for k in range(0, len(training_data), mini_batch_size):\n mini_batches.append(training_data[k:k+mini_batch_size])\n for mini_batch in mini_batches:\n self.update_mini_batch(mini_batch, learning_rate)\n if validation_data:\n new_score = self.evaluate(X_validation, Y_validation)\n if high_score[0] < new_score:\n high_score[0] = new_score\n high_score[1] = j + 1\n learning_rate = learning_rate * (1-decay)\n \n return high_score[0], high_score[1]\n# ========================\n\n\n \"\"\"\n Update the network's weights and biases by applying\n gradient descent using backpropagation to a single mini batch.\n The ``mini_batch`` is a list of tuples ``(x, y)``, and ``eta``\n is the learning rate.\"\"\"","def train():\n # YOUR TRAINING CODE GOES HERE","def fit(self, w):\n w_former = w\n w_next = w\n w_t = w\n w_t_100 = w\n w_diff = 10000\n i = 0\n #tim_beg = t.time()\n # use two part to calculate the a(w,w0):calculate the gradient using regular or SDG, batch = 10\n # calculate the gradient and update the w,w0\n while i < 10000 and np.abs(w_diff) > 0.00001:\n loss_func = self.lost\n grads = self.gradient(loss_func)\n # calculate the y_pred(eta)\n w_next = w_former - grads(w_former) / (10000)\n k =self.lost(w_next) - self.lost(w_former)\n m = np.dot(w_next-w_former, grads(w_former).T)\n if i != 0 and i % 100 == 0:\n w_t = w_t_100\n w_t_100 = w_next\n w_diff = 1 / len(w) * (np.sum(np.abs(w_t_100 - w_t)))\n i_loss = self.lost(w_next)\n print(\"Iteration < %d > with loss < %f >\" % (i, i_loss))\n #self.los_plt.append(i_loss)\n #tim = t.time() - tim_beg\n #self.tim.append(tim)\n i += 1\n w_former = w_next\n #plt.plot(self.tim, self.los_plt)\n #plt.xlabel(\"time\")\n #plt.ylabel('loss')\n #plt.show()\n if i >= 10000:\n print(\"~Optimization stops because finishing iteration~\")\n if np.abs(w_diff) <= 0.00001:\n print(\"~Optimization stops because of difference between weights are less than 0.00001~\")\n self.w_result = w_next","def train_dynamic(batch_size=10):\n \n return","def sgd(self, training_data, epochs, batch_size, eta=0.01, lambda_r=0.2, verbose=False, test_data=None):\n stagnation_epochs = 5\n eta_divide_factor = 4\n eta_decrease_available = 4\n\n self.accuracies = np.zeros(epochs)\n self.costs = np.zeros(epochs)\n self.eta = eta\n self.lambda_r = lambda_r\n\n n = len(training_data)\n curr_stagnation = stagnation_epochs\n min_cost = float('inf')\n\n for idx, e in enumerate(range(epochs)):\n np.random.shuffle(training_data)\n batches = [np.array(training_data[k:k + batch_size], dtype=object)\n for k in range(0, len(training_data), batch_size)]\n\n for batch in batches:\n self.gradient_descent_step(batch, eta, lambda_r, n)\n\n self.costs[idx] = self.cost_func.prediction_cost(self.feed_forward([x_ for x_, y_ in training_data])[2],\n np.array([y_ for x_, y_ in training_data])) + \\\n self.weights_cost(n, self.lambda_r)\n\n if verbose:\n print('Epoch {} ended with cost {:.3f}'.format(e + 1, self.costs[idx]))\n\n min_cost = min(min_cost, self.costs[idx])\n\n if idx != 0:\n curr_stagnation = curr_stagnation - 1 if self.costs[idx] != min_cost else stagnation_epochs\n\n if curr_stagnation == 0:\n curr_stagnation = stagnation_epochs\n eta /= eta_divide_factor\n eta_decrease_available -= 1\n min_cost = float('inf')\n\n if eta_decrease_available < 0:\n if verbose:\n print('Eta decreased maximum available times, terminating')\n break\n\n if verbose:\n print('Decreasing eta to {:.5f}'.format(eta))\n\n if test_data:\n self.accuracies[idx] = self.metric.metric_value(self.predict([x_ for x_, y_ in test_data]),\n [y_ for x_, y_ in test_data])\n\n if verbose:\n self.plot_costs()\n\n if test_data:\n self.plot_metric_values()","def run_learning_curve_experiment(X, y, dataset_name, train_ratio=0.7):\n gkr_cv, tau_opt, s2_opt = pick_optimal_params_using_cv(X, y)\n K, K_mmd = create_krr_mmd_kernel_matrices(X, s2_opt)\n n = K.shape[0]\n train_indices, test_indices = train_test_indices(\n n, train_ratio=train_ratio)\n\n learning_curves_mc_train, learning_curves_mc_test = sample_mc_learning_curves_train_test(\n K, y, train_indices, test_indices, tau_opt, num_trajectories=10)\n\n K_train = K[np.ix_(train_indices, train_indices)]\n fw = alg.FrankWolfe(K_train)\n fw.run_frank_wolfe()\n learning_curve_fw_train, learning_curve_fw_test = calculate_learning_curves_train_test(K, y,\n train_indices,\n test_indices,\n fw.sampled_order,\n tau_opt)\n\n save_dir = 'learning_curves-{}'.format(dataset_name)\n save_dir = Path(data_experiments_dir) / save_dir\n print(save_dir)\n save_dir.mkdir(parents=True, exist_ok=False)\n\n # Save all of the learning curves\n np.save(save_dir / 'learning_curve_fw_train', learning_curve_fw_train)\n np.save(save_dir / 'learning_curve_fw_test', learning_curve_fw_test)\n np.save(save_dir / 'learning_curves_mc_train', learning_curves_mc_train)\n np.save(save_dir / 'learning_curves_mc_test', learning_curves_mc_test)\n\n # Save json file of interesting information for this particular run\n euclidean_dist_q05 = kernel_quantile_heuristic(X, q=0.05)\n euclidean_dist_q95 = kernel_quantile_heuristic(X, q=0.95)\n\n param_config = {\n 'n': X.shape[0],\n 'd': X.shape[1],\n 'tau_opt_KRR': tau_opt,\n 's2_opt_KRR': s2_opt,\n 'train_ratio': train_ratio,\n 'euclidean_dist_q05': euclidean_dist_q05,\n 'euclidean_dist_q95': euclidean_dist_q95,\n 'time_created': str(datetime.now().strftime('%Y-%m-%d_%H:%M:%S'))\n }\n\n with open(save_dir / 'experiment_config.json', 'w') as json_file:\n json.dump(param_config, json_file)","def learn(self):\n\n for i in range(self.args.n_iters):\n diff = self.iteration()\n\n if diff < self.args.epsilon:\n self.save(self.save_path, i)\n break\n elif (i + 1) % self.args.save_frequency == 0:\n self.save(self.save_path, i)","def show_learning_curve(self):\n\n # Loop output classes\n for c in range(1,self.n_output_classes):\n # Get data\n x_values = np.array(self.n_class_samples_list[c])\n accuracy = np.array(self.accuracy_list[c])\n precision = np.array(self.precision_list[c])\n recall = np.array(self.recall_list[c])\n F1 = np.array(self.F1_list[c])\n\n # Make plot\n with sns.axes_style(\"ticks\"):\n fig,ax = plt.subplots()\n plt.plot([np.min(x_values),np.max(x_values)],[0.5,0.5],\n color='#777777',linestyle='--')\n plt.plot([np.min(x_values),np.max(x_values)],[0.66,0.66],\n color='#777777',linestyle=':')\n plt.plot([np.min(x_values),np.max(x_values)],[0.8,0.8],\n color='#777777',linestyle=':')\n plt.plot([np.min(x_values),np.max(x_values)],[0.9,0.9],\n color='#777777',linestyle=':')\n\n plt.plot( x_values, accuracy, color='#000000',\n linewidth=1, label='Accuracy' )\n plt.plot( x_values, precision, color='#0000aa',\n linewidth=1, label='Precision' )\n plt.plot( x_values, recall, color='#00aa00',\n linewidth=1, label='Recall' )\n plt.plot( x_values, F1, color='#aa0000',\n linewidth=2, label='F1' )\n\n plt.yticks( [0, 0.5, 0.66, 0.8, 0.9, 1.0],\n ['0','0.5','0.66','0.8','0.9','1.0'], ha='right' )\n plt.xlim(np.max(x_values)*-0.02,np.max(x_values)*1.02)\n plt.ylim(-0.02,1.02)\n plt.xlabel('Number of training samples')\n plt.ylabel('Performance')\n plt.title('Learning curve, class {}'.format(c))\n sns.despine(ax=ax, offset=0, trim=True)\n lgnd = plt.legend(loc=4, ncol=1, frameon=True, fontsize=9)\n lgnd.get_frame().set_facecolor('#ffffff')\n ax.spines['left'].set_bounds(0,1)\n ax.spines['bottom'].set_bounds(np.min(x_values),np.max(x_values))","def learn_online(self, dataset, method=\"Exp distance\", base_norm=\"Thresh\", \n noise_ratio=[0,0,1], sparsity_coeff=[0,0,1], sensitivity=[0,0,1],\n learning_rate=[0,0,1], base_norm_coeff=0):\n # The list of all data processed per layer devided for sublayer \n # input_data[sublayer][actual_recording][events, timestamp if 0 or xy coordinates if 1]\n input_data = []\n # In the first layer the input_data is the input dataset given by the user\n input_data.append(dataset)\n\n # Preallocating evolution methods, for plotting the network evolution.\n self.evolution_pre_allocation(len(dataset))\n \n for layer in range(self.layers):\n # now let's generate the surfaces and train the layers\n single_layer_surfaces = []\n single_layer_errors = []\n # The result of a single layer learning that will serve as input for the \n # next one\n outrecordings = []\n \n for sublayer in range(len(self.basis[layer])):\n \n # Create network evolution parameters, at the moment I'm using \n # an exponential decay kernel as a function, it can be changed in the code pretty\n # easly\n \n # end_time: how many time surfaces will be generated in the learing \n # process for this sublayer\n end_time = 0\n for i in range(len(input_data[sublayer])):\n end_time += len(input_data[sublayer][i][0])\n time = np.arange(end_time)\n \n noise_evolution = exp_decay(noise_ratio[0], noise_ratio[1], noise_ratio[2], time)\n learning_evolution = exp_decay(learning_rate[0], learning_rate[1], learning_rate[2], time)\n sparsity_evolution = exp_decay(sparsity_coeff[0], sparsity_coeff[1], sparsity_coeff[2], time) \n sensitivity_evolution = exp_decay(sensitivity[0], sensitivity[1], sensitivity[2], time)\n \n # Generate and allocate plots for online plotting\n if self.verbose is True and layer==1:\n # Building a list to contain the basis at each run and the original timesurface (the whole picture)\n # at the position 0\n timesurfaces_list = [Time_Surface_all(xdim=35, ydim=35, timestamp=dataset[0][0][-1], timecoeff=self.taus[0], dataset=dataset[0], num_polarities=1, minv=0.1, verbose=False)]\n plot_names = [\"Original Time Surface\"]\n for i in range(len(self.basis[layer][sublayer])):\n timesurfaces_list.append(self.basis[layer][sublayer][i])\n plot_names.append(\"Base N: \"+str(i))\n live_figures, live_axes = surface_live_plot(surfaces=timesurfaces_list, fig_names=plot_names)\n\n\n \n # Counter of surfaces that will be used to update evolution parameters\n time = 0\n sub_layer_surfaces = []\n sub_layer_reference_events = []\n sub_layer_errors = [] \n \n for recording in range(len(input_data[sublayer])):\n recording_surfaces = []\n recording_reference_events = []\n for k in range(len(input_data[sublayer][recording][0])):\n single_event = [input_data[sublayer][recording][0][k], input_data[sublayer][recording][1][k]]\n tsurface = Time_Surface_event(xdim = self.surfaces_dimensions[layer][0],\n ydim = self.surfaces_dimensions[layer][1],\n event=single_event,\n timecoeff=self.taus[layer],\n dataset=input_data[sublayer][recording],\n num_polarities=self.polarities[layer],\n verbose=False)\n if method==\"CG\" :\n sub_layer_errors.append(self.sublayer_response_CG(layer, sublayer,\n tsurface,\n sparsity_evolution[time], \n noise_evolution[time]))\n if method==\"Exp distance\" :\n sub_layer_errors.append(self.sublayer_response_exp_distance(layer, sublayer,\n tsurface,\n sparsity_evolution[time], \n noise_evolution[time], \n sensitivity_evolution[time]))\n if method==\"Dot product\":\n sub_layer_errors.append(self.sublayer_response_dot_product(layer, sublayer,\n tsurface,\n sparsity_evolution[time], \n noise_evolution[time], \n sensitivity_evolution[time]))\n recording_surfaces.append(tsurface)\n recording_reference_events.append(single_event)\n # Run a single step of the gradient descent\n if base_norm==\"L2\":\n update_basis_online(self.basis[layer][sublayer], self.activations[layer][sublayer],\n learning_evolution[time], tsurface, base_norm_coeff, 1, 0)\n if base_norm==\"Thresh\":\n update_basis_online_hard_treshold(self.basis[layer][sublayer], self.activations[layer][sublayer],\n learning_evolution[time], tsurface, 1, 0)\n \n time += 1\n if time!=0: \n self.evolution_save_point(layer, sublayer, recording, noise_evolution[time-1], sparsity_evolution[time-1], sensitivity_evolution[time-1], learning_evolution[time-1])\n # Update plots\n if self.verbose is True and layer==1: \n timesurfaces_list[0]=Time_Surface_all(xdim=35, ydim=35, timestamp=dataset[recording][0][-1], timecoeff=self.taus[0], dataset=dataset[recording], num_polarities=1, minv=0.1, verbose=False)\n for i in range(len(self.basis[layer][sublayer])):\n timesurfaces_list[i+1]=self.basis[layer][sublayer][i]\n live_figures, live_axes = surface_live_plot(surfaces=timesurfaces_list, figures=live_figures, axes=live_axes)\n print(\"Layer:\"+np.str(layer)+\" Sublayer:\"+np.str(sublayer)+\" Base optimization process per recording:\"+np.str(((recording+1)/len(input_data[sublayer]))*100)+\"%\")\n sub_layer_surfaces.append(recording_surfaces)\n sub_layer_reference_events.append(recording_reference_events)\n # Close plots before displaying next set of basis\n if self.verbose is True and layer==1:\n for i in range(len(live_figures)):\n plt.close(fig=live_figures[i])\n live_axes.clear()\n live_figures.clear()\n \n \n # Check if we are at the last layer or we need to recompute the activations\n # to train the next layer\n if layer+1 != self.layers:\n # Let's compute again the activations after defining the set of basis!\n \n # I use the evolution parameters at the steady state\n time = time - 1\n # Where I store all the events computed in a sublayer\n # on and off activations originate two batches out of a single one\n sub_layer_outevents_on = []\n sub_layer_outevents_off = []\n for recording in range(len(input_data[sublayer])):\n recording_activations = []\n for k in range(len(input_data[sublayer][recording][0])):\n if method==\"CG\" :\n self.sublayer_response_CG(layer, sublayer,\n sub_layer_surfaces[recording][k],\n sparsity_evolution[time], \n noise_evolution[time])\n if method==\"Exp distance\" :\n self.sublayer_response_exp_distance(layer, sublayer,\n sub_layer_surfaces[recording][k],\n sparsity_evolution[time], \n noise_evolution[time], \n sensitivity_evolution[time])\n if method==\"Dot product\":\n sub_layer_errors.append(self.sublayer_response_dot_product(layer, sublayer,\n sub_layer_surfaces[recording][k],\n sparsity_evolution[time], \n noise_evolution[time], \n sensitivity_evolution[time]))\n recording_activations.append(self.activations[layer][sublayer].copy())\n\n # Obtaining the events resulting from the activations in a single recording\n outevents = events_from_activations(recording_activations,\n sub_layer_reference_events[recording],\n self.delay_coeff)\n \n sub_layer_outevents_on.append(outevents[0])\n sub_layer_outevents_off.append(outevents[1])\n \n \n # They will be used to optimize the consequent of sublayers\n # in the next layer\n outrecordings.append(sub_layer_outevents_on) \n outrecordings.append(sub_layer_outevents_off) \n \n single_layer_surfaces.append(sub_layer_surfaces)\n single_layer_errors.append(sub_layer_errors)\n input_data = outrecordings.copy()\n self.surfaces.append(single_layer_surfaces)\n self.errors.append(single_layer_errors)","def trainNet():","def learner(self):\n for N in range(self.N_learn):\n trajectories = self.sample_trajectories()\n\n # TODO: Both these methods take the full trajectories at the moment, a speedup could be achieved here\n self.qmodel.train(trajectories)\n self.amodel.train(trajectories)","def plot_learning(self):\n plt.plot([i for i in range(len(self.fitness_list))], self.fitness_list)\n plt.ylabel(\"Fitness\")\n plt.xlabel(\"Iteration\")\n plt.show()","def train_model(self):\r\n alpha, accuracy_rate = self.select_model()\r\n # Initialize logistic regression with alpha(learning rate)\r\n lg = logisticregression(C=alpha)\r\n # Train the model.\r\n lg.fit(self.training_data, self.target_data)\r\n # Save the trained model as .pkl file.\r\n joblib.dump(value=lg, filename=self.intention_id+'.pkl', compress=1)\r\n print \"Estimated Parameters of Logistic Regression\"\r\n # Estimated parameters of logistic regression.\r\n print lg.get_params()","def test_learning_rate(lrmin=0.1,lrmax=1,lrstep=0.2):\n for lrate in np.arange(lrmin,lrmax,lrstep):\n print(\"learning rate: %s\" % lrate)\n get_nn_parameters(epochs=1, learning_rate=lrate)","def train(self, batch_size=None, alpha=0.1, epochs=100, verbose=False, save_cost_hist=False):\n cost_hist = []\n nexamples = self.X_train.shape[1]\n batch_size = nexamples if batch_size is None else batch_size\n number_batches = int(np.floor(nexamples / batch_size))\n for epoch in range(epochs):\n X_batch, y_batch = self.shuffle_dataset()\n for batch in range(number_batches):\n if batch % 10 == 0:\n print(f\"training batch {batch} for epoch {epoch} of size {batch_size}\", end=\"\\r\")\n # Correction factor if training dataset is not evenly divisible\n fact = 0 if number_batches - 1 != batch else nexamples % batch_size\n columns = range(batch * batch_size,\n (batch + 1) * batch_size + fact)\n X_batch_train = X_batch[:, columns]\n y_batch_train = y_batch[:, columns]\n grads = self.compute_grads(X_batch_train, y_batch_train)\n self.theta = self.theta - alpha * grads\n\n if save_cost_hist:\n cost = self.cost()\n cost_hist.append(cost)\n\n if verbose and epoch % 10 == 0:\n cost = self.cost()\n print(f\"Total cost after epoch {epoch + 1}: {cost}\")\n\n if save_cost_hist:\n self.cost_hist = cost_hist","def learn(self, Xtrain, ytrain):\n pass\n self.weights = np.zeros(Xtrain.shape[1],)\n\n ### YOUR CODE HERE\n \n lmbd = self.params['lamb']\n \n numsamples = Xtrain.shape[0]\n # Xless = Xtrain[:,self.params['features']]\n Xless = Xtrain\n self.weights = np.random.rand(Xless.shape[1])\n err = 10000;\n #cw =0;\n tolerance = 10*np.exp(-4)\n i=0;\n \n \n w1 = self.weights\n # cw_v =(np.dot(Xless, self.weights)-ytrain)\n #cw = (np.linalg.norm(cw_v)**2)/(2*numsamples)\n cw_v = np.dot(Xless, self.weights.T)\n cw = self.logit_cost(cw_v, Xless, ytrain) + lmbd * self.regularizer[0](self.weights)\n # print(cw)\n errors = []\n runtm = []\n epch = []\n \n err = 1\n iteration= 1000\n #tm= time.time()\n while (abs(cw-err)>tolerance) and (i <iteration):\n err = cw\n g = self.logit_cost_grad(cw_v, Xless, ytrain)\n obj = cw\n j=0\n ita = -1* self.params['stepsize']\n w = self.weights\n # w1 = np.add(w,np.dot(ita,g))\n while(j<iteration):\n w1 = np.add(w,np.dot(ita,g))\n # cw_v =(np.dot(Xless, w1)-ytrain)\n # cw = (np.linalg.norm(cw_v)**2)/(2*numsamples)\n cw_v = np.dot(Xless, w1.T)\n cw = self.logit_cost(cw_v, Xless, ytrain)+lmbd * self.regularizer[0](w1)\n ## print (cw)\n \n if(cw<np.absolute(obj-tolerance)): ############################################\n break\n ita = 0.7*ita\n j=j+1\n \n if(j==iteration):\n self.weights=w\n ita =0\n else:\n self.weights = w1\n \n # cw_v =(np.dot(Xless, self.weights)-ytrain)\n #cw = (np.linalg.norm(cw_v)**2)/(2*numsamples)\n cw_v = np.dot(Xless, self.weights.T)\n cw = self.logit_cost(cw_v, Xless, ytrain)\n #tm1 = time.time()-tm\n #runtm.append(tm1)\n #err = cw\n errors.append(err)\n i=i+1\n epch.append(i)","def nnRegression(data):","def learn(self, D, **kwargs):\n pass","def get_sgd_solution(TRAINING_PHI, TEST_PHI, VAL_PHI, W_Now, TrainingData,\n TrainingTarget, TestData, ValData):\n # Gradient Descent Solution for Linear Regression\n La = 2\n # learningRate = 0.01\n L_Erms_Val, L_Erms_TR, L_Erms_Test, L_Accuracy_Test, W_Mat = [], [], [], [], []\n\n for i in range(0, 400):\n\n # print (f'---------Iteration: {i} M{M} LR {learningRate} L :{C_Lambda}--------------')\n Delta_E_D = -np.dot(\n (TrainingTarget[i] - np.dot(np.transpose(W_Now), TRAINING_PHI[i])),\n TRAINING_PHI[i])\n La_Delta_E_W = np.dot(La, W_Now)\n Delta_E = np.add(Delta_E_D, La_Delta_E_W)\n Delta_W = -np.dot(learningRate, Delta_E)\n W_T_Next = W_Now + Delta_W\n W_Now = W_T_Next\n\n #-----------------TrainingData Accuracy---------------------#\n TR_TEST_OUT = GetValTest(TRAINING_PHI, W_T_Next)\n Erms_TR = GetErms(TR_TEST_OUT, TrainingTarget)\n L_Erms_TR.append(float(Erms_TR.split(',')[1]))\n\n #-----------------ValidationData Accuracy---------------------#\n VAL_TEST_OUT = GetValTest(VAL_PHI, W_T_Next)\n Erms_Val = GetErms(VAL_TEST_OUT, ValDataAct)\n L_Erms_Val.append(float(Erms_Val.split(',')[1]))\n\n #-----------------TestingData Accuracy---------------------#\n TEST_OUT = GetValTest(TEST_PHI, W_T_Next)\n Erms_Test = GetErms(TEST_OUT, TestDataAct)\n L_Erms_Test.append(float(Erms_Test.split(',')[1]))\n L_Accuracy_Test.append(float(Erms_Test.split(',')[0]))\n\n return ([L_Erms_TR, L_Erms_Val, L_Erms_Test, L_Accuracy_Test])","def train(features, targets, weights, bias):\n # see gradient_descent for explanation\n epochs = 100\n learning_rate = 0.1\n\n picture_nb = 2\n\n # Print current accuracy. How many people have been classified as sick/healthy correctly?\n predictions = predict(features, weights, bias)\n print(\"Accuracy: \", np.mean(predictions == targets))\n\n for epoch in range(epochs):\n if epoch % 10 == 0:\n # get normalized scores\n predictions = activation(pre_activation(features, weights, bias))\n # compare with targets to see how bad our algorithm is\n print(\"Cost = %s\" % cost(predictions, targets))\n # Replot graph. Check in create_dataset for explanation of parameters\n if picture_nb == 2:\n plt.plot(features[:, 0], (weights[0] * features[:, 0] + bias) / -weights[1], color='red')\n elif picture_nb == 11:\n plt.plot(features[:, 0], (weights[0] * features[:, 0] + bias) / -weights[1], color='green')\n else:\n plt.plot(features[:, 0], (weights[0] * features[:, 0] + bias) / -weights[1], color='orange')\n picture_nb+=1\n\n # Initialize gradients\n # weights_gradients is 2D array with 2 values\n weights_gradients = np.zeros(weights.shape)\n bias_gradient = 0\n # Go through each row\n for feature, target in zip(features, targets):\n # Compute prediction\n z = pre_activation(feature, weights, bias)\n # Get normalized score\n y = activation(z)\n # Update gradients based on formulas established before. Look at gradient_descent to understand what we\n # are doing. Also, the formulas are below, just before the call of the function train.\n weights_gradients += (y - target) * derivative_activation(z) * feature\n # no multiplication of feature because it does not depend on some coordinates.\n bias_gradient += (y - target) * derivative_activation(z)\n\n # Update variables. These are the lines that result the cost to get reduced.\n weights = weights - learning_rate * weights_gradients\n bias = bias - learning_rate * bias_gradient\n\n # Print final accuracy. How many people have been classified as sick/healthy correctly?\n predictions = predict(features, weights, bias)\n print(\"Accuracy: \", np.mean(predictions == targets))\n\n plt.scatter(features[:, 0], features[:, 1], s=40, c=targets, cmap=plt.cm.Spectral)\n plt.savefig(\"DataPointsLineEvolution.png\")\n # legend for understanding\n plt.legend(['Original division', 'New division', 'New division', 'New division', 'New division', 'New division',\n 'New division', 'New division', 'New division', 'Final division'], loc='upper left')\n # save picture of data points drawn.\n plt.savefig(\"DataPointsLineEvolutionLegend.png\")","def fit(self, X, y, X_validate, y_validate):\n \n iterate = 800\n \n self.SGD_theta_list = [0]*len(X[0])\n self.SGD_bias = 0\n\n SGD_cost_history = []\n SGD_validate_cost_history = []\n\n for i in range(iterate):\n if(i%100==0):\n print(i,\" iterations\")\n selection = random.randint(0, len(X)-1) #selecting one random row for SGD\n temp_X = []\n temp_X.append(X[selection])\n temp_y = []\n temp_y.append(y[selection])\n self.SGD_bias, self.SGD_theta_list = self.update_thetas(np.array(temp_X), np.array(temp_y), self.SGD_theta_list, self.SGD_bias,self.training_rate)\n SGD_cost = self.cost_function(X, y, self.SGD_theta_list, self.SGD_bias)\n SGD_cost_history.append(SGD_cost)\n SGD_validate_cost = self.cost_function(X_validate, y_validate,self.SGD_theta_list, self.SGD_bias)\n SGD_validate_cost_history.append(SGD_validate_cost)\n\n self.FINAL_SGD_TRAIN_LOSS.append(SGD_cost_history[-1])\n self.FINAL_SGD_VALIDATE_LOSS.append(SGD_validate_cost_history[-1])\n\n plt.plot(list(range(iterate)), SGD_cost_history)\n plt.plot(list(range(iterate)), SGD_validate_cost_history)\n plt.xlabel(\"Iterations\")\n plt.ylabel(\"Loss SGD\")\n plt.show()\n \n \n self.BGD_theta_list = [0]*len(X[0])\n self.BGD_bias = 0\n\n BGD_cost_history = []\n BGD_validate_cost_history = []\n\n for i in range(iterate):\n if(i%100==0):\n print(i,\" iterations\")\n selection = random.randint(0, len(X)-1)\n \n self.BGD_bias, self.BGD_theta_list = self.update_thetas(X, y, self.BGD_theta_list, self.BGD_bias,self.training_rate)\n\n BGD_cost = self.cost_function(X, y, self.BGD_theta_list, self.BGD_bias)\n BGD_cost_history.append(BGD_cost)\n BGD_validate_cost = self.cost_function(X_validate, y_validate,self.BGD_theta_list, self.BGD_bias)\n BGD_validate_cost_history.append(BGD_validate_cost)\n\n self.FINAL_BGD_TRAIN_LOSS.append(BGD_cost_history[-1])\n self.FINAL_BGD_VALIDATE_LOSS.append(BGD_validate_cost_history[-1])\n\n plt.plot(list(range(iterate)), BGD_cost_history)\n plt.plot(list(range(iterate)), BGD_validate_cost_history)\n plt.xlabel(\"Iterations\")\n plt.ylabel(\"Loss BGD\")\n plt.show()\n\n print(\"FINAL_SGD_TRAIN_LOSS\\n\",self.FINAL_SGD_TRAIN_LOSS)\n print(\"FINAL_SGD_VALIDATE_LOSS\\n\",self.FINAL_SGD_VALIDATE_LOSS)\n print(\"FINAL_BGD_TRAIN_LOSS\\n\",self.FINAL_BGD_TRAIN_LOSS)\n print(\"FINAL_BGD_VALIDATE_LOSS\\n\",self.FINAL_BGD_VALIDATE_LOSS)\n\n \n return self","def online_dictionary_learning(self, dinit, tinit, winit, pars, trainingdata, HMat, QMat):\n num_images = trainingdata.shape[1]\n # n0 = num_images/10\n n0 = num_images/(pars['batchSize']*10)\n model = dict(\n D=dinit, # dictionary\n A=tinit, # transform matrix\n W=winit, # classifier\n )\n\n param = {\n 'lambda1': pars['lambda_'],\n 'lambda2': 0,\n 'mode': 2\n }\n\n # crf iterations\n fobj_avg = dict()\n\n if not os.path.isdir(settings.GENERATED_DATA_DIRECTORY):\n os.mkdir(settings.GENERATED_DATA_DIRECTORY)\n\n for iter_ in range(pars['maxIters']):\n tic = time.time()\n # Take a random permutation of the samples\n filename = 'permute_{}_{}_{}.npy'.format(iter_, pars['numBases'], pars['dataset'])\n full_path = os.path.join(settings.GENERATED_DATA_DIRECTORY, filename)\n\n if os.path.isfile(full_path):\n ind_rnd = np.load(full_path, allow_pickle=False, fix_imports=False)\n else:\n ind_rnd = np.random.permutation(num_images)\n np.save(full_path, ind_rnd, allow_pickle=False, fix_imports=False)\n\n for batch in range(num_images//pars['batchSize']):\n # load the dataset\n # we only loads one sample or a small batch at each iteration\n # batch_idx = ind_rnd((1:pars.batchSize)+pars.batchSize*(batch-1));\n lower_index = pars['batchSize'] * batch\n upper_index = lower_index + pars['batchSize']\n batch_idx = ind_rnd[lower_index:upper_index]\n yt = trainingdata[:, batch_idx]\n ht = HMat[:, batch_idx]\n qt = QMat[:, batch_idx]\n # TODO: Review if in these cases it's mandatory to assign copies\n D = model['D']\n W = model['W']\n A = model['A']\n # sparse coding\n # S = L1QP_FeatureSign_Set(yt, D, gamma, lambda);\n\n S = lasso(\n yt,\n D if np.isfortran(D) else np.asfortranarray(D),\n **param\n )\n\n # compute the gradient of crf parameters\n grad_W = (1-pars['mu'])*(W@S - ht)@S.T + pars['nu2']*W\n grad_A = pars['mu']*(A@S - qt)@S.T + pars['nu1']*A\n grad_S1 = W.T @ (W@S - ht) # gradient w.r.t S for 0.5*||H-WS||_2^2\n grad_S2 = A.T @ (A@S - qt) # gradient w.r.t S for 0.5*||Q-AS||_2^2\n\n # compute the gradient of dictionary\n # find the active set and compute beta\n B1 = np.zeros((pars['numBases'], pars['batchSize']), dtype=np.int)\n B2 = np.zeros((pars['numBases'], pars['batchSize']), dtype=np.int)\n DtD = D.T@D\n for j in range(pars['batchSize']):\n active_set = np.array(np.nonzero(S[:, j] != 0)).ravel()\n # DtD = D(:,active_set)'*D(:,active_set) + gamma*eye(length(active_set));\n DtD_hat = DtD[active_set, active_set] + pars['gamma']*np.eye(active_set.shape[0])\n\n # DtD_inv = DtD\\eye(length(active_set));\n DtD_inv = np.linalg.solve(DtD_hat, np.eye(active_set.shape[0]))\n\n B1[active_set, j] = (DtD_inv @ grad_S1[active_set, j]).T\n\n B2[active_set, j] = (DtD_inv @ grad_S2[active_set, j]).T\n\n grad_D = (1-pars['mu'])*(-D@B1@S.T + (yt - D@S)@B1.T) + pars['mu'] * \\\n (-D@B2@S.T + (yt - D@S)@B2.T) # dD = -D*B*S' + (X - D*S)*B';\n\n # use yang's method\n # gfullMat = zeros([size(D),size(D,2)]);\n # [gMat, IDX] = sparseDerivative(D, full(S), yt);\n # gfullMat(:,IDX,IDX) = gMat;\n # gradSmat = repmat(reshape(grad_S1,[1 1 length(grad_S1)]),size(D));\n # grad_D = sum(gfullMat.*gradSmat,3);\n\n # update the learning rate\n rho_i = min(pars['rho'], pars['rho']*n0/(batch+1))\n\n # update model parameters\n D = D - rho_i*grad_D\n D = D / np.tile(np.linalg.norm(D, axis=0), (D.shape[0], 1))\n model['D'] = D\n\n W = W - rho_i*grad_W\n model['W'] = W\n\n A = A - rho_i*grad_A\n model['A'] = A\n\n # get statistics\n S = lasso(\n trainingdata,\n D if np.isfortran(D) else np.asfortranarray(D),\n **param\n )\n fobj = self.get_objective_lc(D, S, trainingdata, W, HMat, A, QMat, pars['lambda_'], pars['mu'])[0]\n # *** numpy.linalg.LinAlgError: Last 2 dimensions of the array must be square\n # stat['fobj_avg'][iter_] = fobj + 0.5*nu1*np.sum(W**2) + 0.5*nu2*np.sum(A**2)\n fobj_avg[iter_] = fobj + 0.5*pars['nu1']*np.sum(np.multiply(W, W)) + 0.5*pars['nu2']*np.sum(A**2)\n # filename = 'model_{}_{}_{}.npy'.format(iter_, num_bases, pars['dataset'])\n # full_path = os.path.join(generated_data_directory, filename)\n # ValueError: Object arrays cannot be saved when allow_pickle=False\n # the model is being saved in three different files to avoid\n # setting allow_pickle=True when trying to save the whole model\n # np.save(full_path, model, allow_pickle=True, fix_imports=False)\n for key, value in model.items():\n filename = '{}_{}_{}_{}.npy'.format(key, iter_, pars['numBases'], pars['dataset'])\n full_path = os.path.join(settings.GENERATED_DATA_DIRECTORY, filename)\n np.save(full_path, value, allow_pickle=False, fix_imports=False)\n\n toc = time.time()\n print('Iter = {}, Elapsed Time = {}'.format(iter_, toc-tic))\n\n stat_filename = 'stat_{}_{}.json'.format(pars['numBases'], pars['dataset'])\n stat_full_path = os.path.join(settings.GENERATED_DATA_DIRECTORY, stat_filename)\n # saving as JSON to avoid using pickle\n with open(stat_full_path, 'w') as file_:\n json.dump(fobj_avg, file_)\n\n return model, fobj_avg","def RatingsGradientDescent(params, Y, R, num_users, num_movies, num_features, lbd, alpha, num_iters):\n J_history = np.zeros(num_iters)\n for i in range(num_iters):\n J_history[i], grad = cofiCostFunc(params, Y, R, num_users, num_movies, num_features, lbd)\n params = params-alpha*grad\n if i % 100 == 99:\n print('Step %i, cost=%f' % (i+1, J_history[i]))\n return params, J_history","def model(X_train, Y_train, X_test, Y_test, num_iterations, learning_rate, print_cost):\n\n\n # initialize parameters with zeros\n w, b = initialize_with_zeros(X_train.shape[0]);\n\n print(\"w.shape() = \" +str(w.shape)+ \", b = \" +str(b));\n\n # Gradient descent\n parameters, grads, costs = optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost);\n \n # Retrieve parameters w and b from dictionary \"parameters\"\n w = parameters[\"w\"]\n b = parameters[\"b\"]\n \n # Predict test/train set examples \n Y_prediction_test = predict(w, b, X_test)\n Y_prediction_train = predict(w, b, X_train)\n\n # Print train/test Errors\n print(\"train accuracy: {} %\".format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100))\n print(\"test accuracy: {} %\".format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100))\n \n d = {\"costs\": costs,\n \"Y_prediction_test\": Y_prediction_test, \n \"Y_prediction_train\" : Y_prediction_train, \n \"w\" : w,\n \"b\" : b,\n \"learning_rate\" : learning_rate,\n \"num_iterations\": num_iterations}\n \n return d","def increase_learning(self, factor):\n pass","def batchlearn(self, final_state=False):\n # what to do anyway with finals states in batch learning ???\n\n TDe = self.estimate_TDioa() \n self.actQoa += self.alpha * TDe\n self.X = self.policy_func(self.actQoa)\n \n \n print(\"\\r>> batchlearn at {}\".format(self.total_step), \n end='', flush=True) if self.verbose else None\n print() if self.verbose else None\n print('actQ:\\n', self.actQoa) if self.verbose else None\n print('TDe:\\n', TDe) if self.verbose else None\n print() if self.verbose else None\n\n\n #re-init\n self.count_oa.fill(0)\n self.count_oao.fill(0)\n self.reward_oa.fill(0)\n # self.valQoa = self.actQoa.copy() # may not be needed\n self.batch_step = 0","def learn(self, purge_memory=True):\n observed_inputs, observed_reward, predicted_outputs, distance_from_reward = self._preprocess_experience()\n # now train. DataFeeder automatically reshuffles data.\n self.dataset_feeder = DataFeeder(\n [observed_inputs, predicted_outputs, observed_reward],\n batch_size=self.batch_size)\n # determine number of iterations:\n self.iterations = int(self.epochs * len(observed_inputs) / self.batch_size)\n for _ in range(self.iterations):\n self._batch()\n # TODO: write a method that computes and prints training stats\n # if _ % 1000:\n # self._train_stats(_)\n if purge_memory:\n self.purge_memory()","def learn(filePath):\n filename = filePath.stem\n processedJAFFE = load(str(filePath))\n processedDF = pd.DataFrame(processedJAFFE)\n processedDF.columns = ['name', 'data', 'emotion']\n processedDF = processedDF.sort_values(by=['name', 'emotion'])\n grouped = processedDF.groupby(['name', 'emotion'])\n train = grouped.nth([0, 1])\n test = grouped.nth([2, 3, 4])\n\n yTrain = train.index.get_level_values(1).tolist()\n xTrain = train.values.ravel().tolist()\n yTest = test.index.get_level_values(1).tolist()\n xTest = test.values.ravel().tolist()\n\n parameters = {\n 'C': [\n 1.00E-12, 1.00E-11, 1.00E-10, 1.00E-09, 1.00E-08, 1.00E-07, 1.00E-06,\n 1.00E-05, 1.00E-04, 1.00E-03, 2.00E-03, 1.00E-02, 1.00E-01, 1.00,\n 1.00E+01, 1.00E+02, 1.00E+03, 1.00E+04, 1.00E+05\n ],\n 'gamma': [\n 1.00E00,\n 1.00E-01,\n 1.00E-02,\n 1.00E-03,\n 5.00E-04, 2.00E-04, 1.50E-04, 1.10E-04, 1.05E-04, 1.00E-04,\n 9.50E-05, 9.00E-05, 7.00E-05, 5.00E-05, 1.90E-05, 1.00E-05,\n 1.00E-06,\n 1.00E-07,\n ],\n }\n\n models = []\n models.append(['gamma \\\\ C', 1.00E-12, 1.00E-11, 1.00E-10, 1.00E-09, 1.00E-08,\n 1.00E-07, 1.00E-06, 1.00E-05, 1.00E-04, 1.00E-03, 2.00E-03, 1.00E-02,\n 1.00E-01, 1.00, 1.00E+01, 1.00E+02, 1.00E+03, 1.00E+04, 1.00E+05 ])\n gridTimeStart = time()\n numIteration = len(parameters['gamma']) * len(parameters['C'])\n iteration = 0\n meanTime = 0\n for gamma in parameters['gamma']:\n row = [gamma]\n for C in parameters['C']:\n print('C = %s \\t gamma = %s'%(C, gamma))\n timeStart = time()\n svc = OneVsRestClassifier(SVC(random_state=0, decision_function_shape='ovr',\n C=C, kernel='rbf', gamma=gamma), n_jobs=4)\n svc.fit(xTrain, yTrain)\n yTrue, yPred = yTest, svc.predict(xTest)\n yTrue = np.array(yTrue, dtype=np.unicode_)\n yPred = np.array(yPred, dtype=np.unicode_)\n correct = np.sum(yTrue == yPred)\n \n print(\"accuracy: %d/%d = \"%(correct, len(yTrue)),\n D('%.2f'%(correct/len(yTrue)*100)))\n row.append(D('%.2f'%(correct/len(yTrue)*100)))\n \n iterTime = time()-timeStart\n iteration = iteration + 1\n meanTime = meanTime * (iteration-1)/iteration + iterTime/iteration\n remainingTime = (numIteration-iteration)*meanTime\n print('--------------------------(%d sec)--remaining: %s'%\n (iterTime, str(timedelta(seconds=int(remainingTime)))))\n models.append(row)\n gridTime = time() - gridTimeStart\n gridTime = timedelta(seconds=int(gridTime))\n print('time: %s'%str(gridTime))\n print('saving file: %s.csv'%filename)\n with open('../csv/%s.csv'%filename, 'w') as csvFile:\n writer = csv.writer(csvFile)\n writer.writerows(models)","def learn(self, Xtrain, ytrain):\n\n ### YOUR CODE HERE\n \n self.numfeatures = Xtrain.shape[1]\n numsamples = Xtrain.shape[0]\n #print (self.numfeatures)\n count = 0\n for i in ytrain:\n if (i>count):\n count+=1\n self.numclasses = count + 1\n \n if(self.params['usecolumnones']==False):\n b = np.ones((numsamples, self.numfeatures-1))\n b = Xtrain[:,:-1]\n Xtrain = b\n self.numfeatures -= 1\n # print(Xtrain.shape[1])\n\n ### END YOUR CODE\n\n origin_shape = (self.numclasses, self.numfeatures)\n self.means = np.zeros(origin_shape)\n self.stds = np.zeros(origin_shape)\n\n ### YOUR CODE HERE\n countclass = np.zeros(self.numclasses)\n for i in range (0, numsamples):\n k = int(ytrain[i])\n countclass[k] += 1\n for j in range (0, self.numfeatures):\n self.means[k][j]+=Xtrain[i][j]\n \n for i in range (0, self.numclasses):\n #np.true_divide(self.means[i], countclass[i])\n for j in range (0, self.numfeatures):\n self.means[i][j] = self.means[i][j]/(countclass[i]+1e-8)\n \n self.yprob = np.true_divide(countclass, numsamples)\n \n for i in range (0, numsamples):\n k = int(ytrain[i])\n for j in range (0, self.numfeatures):\n self.stds[k][j]+= (Xtrain[i][j] - self.means[k][j])**2\n # print (self.stds)\n \n for i in range (0, self.numclasses):\n #np.true_divide(self.stds[i], countclass[i])\n for j in range (0, self.numfeatures):\n self.stds[i][j] = self.stds[i][j]/(countclass[i]+1e-8)\n \n # print (self.means)\n # print (self.stds)\n ### END YOUR CODE\n\n assert self.means.shape == origin_shape\n assert self.stds.shape == origin_shape","def plot_learning_curve(estimator, title, X, y, ylim=None, cv=None,\n n_jobs=None, train_sizes=np.linspace(.1, 1.0, 5)):\n \n \n\n \n font = {'family': 'serif',\n 'color': 'black',\n 'weight': 'bold',\n 'size': 10,\n }\n \n fig=plt.figure(figsize=(5,3))\n\n plt.title(title, fontdict= font)\n if ylim is not None:\n plt.ylim(*ylim)\n plt.xlabel(\"Training examples\", fontdict=font)\n plt.ylabel(\"Score\", fontdict=font)\n train_sizes, train_scores, test_scores = learning_curve(\n estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes)\n train_scores_mean = np.mean(train_scores, axis=1)\n train_scores_std = np.std(train_scores, axis=1)\n test_scores_mean = np.mean(test_scores, axis=1)\n test_scores_std = np.std(test_scores, axis=1)\n \n plt.grid(b=True, which='both', color='w', linewidth=1.0) \n# \n\n plt.fill_between(train_sizes, train_scores_mean - train_scores_std,\n train_scores_mean + train_scores_std, alpha=0.1,\n color=\"blue\")\n plt.fill_between(train_sizes, test_scores_mean - test_scores_std,\n test_scores_mean + test_scores_std, alpha=0.1, color=\"orange\")\n plt.plot(train_sizes, train_scores_mean, 'o--', color=\"blue\",\n label=\"Training score\")\n plt.plot(train_sizes, test_scores_mean, '--o', color=\"orange\",\n label=\"Cross-validation score\")\n \n plt.legend(facecolor='white',loc=\"best\")\n\n fig.savefig(\"learning_Curve.pdf\", dpi=300,bbox_inches='tight')\n plt.close(fig)\n\n return plt","def train_logisticRegression(data: np.array, labels: np.array)->None:\n\n n_examples = np.size(data, 0)\n n_features = np.size(data, 1)\n n_categories = np.size(labels, 1)\n\n data = np.hstack((np.ones((n_examples, 1)), data))\n\n print(data[0:5, :])\n\n X_train, X_test, y_train, y_test, idx_test = split_data(data, labels, 0.7)\n\n convergence_goal = 1e-3\n learning_rate = 0.01\n\n theta = np.random.uniform(size=((n_features+1, n_categories)))\n\n for i in range(n_categories):\n\n cost_var = 1\n\n previous_cost = 1e6\n iterations = 0\n cost_to_plot = []\n\n while cost_var > convergence_goal:\n iterations += 1\n cost, grad = costFunction(X_train, y_train[:, i], theta[:, i])\n theta[:, i] = update_theta(theta[:, i], grad, learning_rate)\n cost_var = previous_cost - cost\n previous_cost = cost\n if iterations == 1: cost_var = 1\n cost_to_plot.append(cost)\n # print(cost)\n\n plt.plot(range(iterations), cost_to_plot, 'g-', label = 'cost')\n plt.xlabel('iterations')\n plt.ylabel('cost')\n # plt.show()\n\n predictions = lrPredict(theta, X_test)\n\n print(predictions[0:5, :])\n print(y_test[0:5, :])\n\n accuracy = np.mean([p == l for p, l in zip(predictions, y_test)])\n print(\"Accuracy = {}\".format(accuracy))\n\n pass","def plot_learning_curve(estimator, title, X, y, ylim=None, cv=None,\n n_jobs=-1, train_sizes=np.linspace(.1, 1.0, 5),color1 = \"g\",color2 = \"r\",\n plotmedian=True, includebasetext=False, baselinepos=[180,0.9]):\n fig,ax = plt.subplots(1,1,figsize=(10,7))\n plt.title(title, color=\"dimgray\", loc=\"left\", size=20)\n plt.xlabel(\"Training sample size\", color=\"dimgrey\",size=15)\n plt.ylabel(\"Accuracy score\", color=\"dimgrey\",size=15)\n train_sizes, train_scores, test_scores = learning_curve(\n estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes)\n print (\"number of element in train sample = \", train_sizes)\n\n \n \n train_scores_mean = np.mean(train_scores, axis=1)\n train_scores_median = np.median(train_scores, axis=1)\n\n train_scores_std = np.std(train_scores, axis=1)\n test_scores_mean = np.mean(test_scores, axis=1)\n if plotmedian:\n test_scores_median = np.median(test_scores, axis=1)\n test_scores_std = np.std(test_scores, axis=1)\n #plt.grid()\n plt.plot(train_sizes[:], np.zeros(len(train_sizes))+0.889, ls=\"--\", color = \"dimgrey\", lw=2)\n if includebasetext:\n plt.text(baselinepos[0], baselinepos[1], \"baseline prediction\",color=\"dimgrey\",size=15)\n\n plt.fill_between(train_sizes, train_scores_mean - train_scores_std,\n train_scores_mean + train_scores_std, alpha=0.3,\n color=color2)\n plt.fill_between(train_sizes, test_scores_mean - test_scores_std,\n test_scores_mean + test_scores_std, alpha=0.3, color=color1)\n plt.plot(train_sizes, train_scores_mean, 'o-', color=color2, lw=2,\n label=\"Training\")\n if plotmedian:\n plt.plot(train_sizes, train_scores_median, 'x:', color=color2,alpha=0.3,\n label=\"Training\")\n plt.plot(train_sizes, test_scores_mean, 'o-', color=color1,\n label=\"Cross-validation\", lw=3)\n if plotmedian:\n plt.plot(train_sizes, test_scores_median, 'x:', color=color1, alpha=0.3,\n label=\"Cross-validation\")\n plt.ylim([0.8,1.05])\n\n legend=plt.legend(loc=\"best\")\n plt.setp(legend.get_texts(), color='dimgray', size=15)\n\n ax.spines['bottom'].set_color('dimgray')\n ax.spines['top'].set_visible(False)\n ax.spines['right'].set_visible(False)\n ax.spines['left'].set_color('dimgray')\n ax.tick_params(axis='x', colors='dimgray')\n ax.tick_params(axis='y', colors='dimgray', size=3)\n ax.get_yaxis().set_ticks([0.8,0.9,1.0])\n\n ax.tick_params(labelsize=14)\n\n return plt"],"string":"[\n \"def finetune_learningrate_createData():\\n acc,auc = [],[]\\n for i in tqdm([j*0.005 for j in range(1,31)],desc='Progress(max_depth)',ncols=70,smoothing=0.5):\\n X_train, X_test, y_train, y_test, X, y_binary = initializing()\\n XGBCla = get_XGBmodel(lr=i)\\n XGBCla = XGBCla.fit(X_train, y_train)\\n acc.append(accuracy_score(XGBCla.predict(X_test),y_test))\\n auc.append(roc_auc_score(XGBCla.predict(X_test),y_test))\\n np.save(\\\"npy-data/result_learningrate_tuning_acc_auc_crossval_train\\\",acc+auc)\",\n \"def active_learning(data, n_iter, n_sample, epochs):\\n evaluation = []\\n weights = []\\n for i in range(n_iter):\\n print(\\\"Iteration: {}\\\".format(i+1)) \\n if i == 0:\\n sampled_data, data = sample_random(n_sample,data)\\n training_data = sampled_data \\n model =LogisticRegression()\\n print(\\\"Start training\\\")\\n model.fit(training_data[:,:2], training_data[:,2], epochs=epochs, verbose=0, shuffle=True)\\n print(\\\"End training\\\")\\n eval_i = model.evaluate(data[:,:2], data[:,2])[1]\\n evaluation.append(eval_i)\\n print(\\\"Accuracy: {}\\\".format(eval_i)) \\n weights.append(model.get_weights())\\n sampled_data, rest_data = sample_highest_margin(model, data,n_sample)\\n data = rest_data\\n# import pdb; pdb.set_trace()\\n training_data = np.concatenate([training_data, sampled_data]) \\n print(\\\"---------------------------\\\")\\n return evaluation, weights, training_data\",\n \"def get_learning_rate():\\n return 0.00001\",\n \"def learn(self):\\n Xt = np.append(np.ones((self.X.shape[0], 1)), self.X, axis=1)\\n Yt = self.Y * 2 - 1\\n\\n w = np.ones(Xt.shape[1]) # avoiding random init, for debugging\\n lw = [[] for k in range(len(w))]\\n \\n for iter in range(self.max_steps):\\n P = Yt * np.dot(Xt, w)\\n M = np.where(P <= 0)[0] # indices of misclassified datapoints\\n\\n if len(M) == 0: \\n self.logger.debug(\\\"Found linearly separable hyperplane!\\\")\\n break\\n\\n if self.is_stochastic:\\n # just pick one randomly from M\\n M = [M[random.randint(0, len(M)-1)]]\\n\\n grad = -1 * np.sum((Yt[M] * Xt[M].T), axis=1) / len(M)\\n\\n if self.reg_constant > 0:\\n grad += self.reg_constant * w\\n \\n eta = self.step_size * 10000 / (10000 + iter)\\n \\n w = w - grad * eta\\n \\n if iter % 100 == 0:\\n for k in range(len(w)):\\n lw[k].append(w[k])\\n \\n if iter % 1000 == 0:\\n self.logger.debug(\\\"Iter %s:\\\\t %f %f %f\\\" %(iter, w[0], w[1], w[2]))\\n \\n self.logger.debug(\\\"Iterations: %s\\\" %(iter))\\n\\n# x_range = range(len(lw[0]))\\n# fig = plt.figure()\\n# ax1 = fig.add_subplot(111) \\n# for j, lwn in enumerate(lw):\\n# if j % 3 >= 2: # plot an arbitrary subset of features\\n# a = w[j]\\n# ax1.plot(x_range, [(x-a) for x in lwn], label=str(j))\\n# \\n# plt.xlabel(\\\"Iteration\\\")\\n# plt.ylabel(\\\"Feature weight\\\")\\n# plt.show()\\n \\n #self.logger.debug(\\\"%s\\\" % np.array2string(w, precision=2, separator=','))\\n \\n self.w = w\",\n \"def learning_curve(self, features, labels):\\n return learning_curve(self._model, features, labels)\",\n \"def ann_learning_curve(trainx, trainy, testx, testy, n_hidden=[5, 3],\\n\\t\\t\\t\\t\\t\\tn_iter=5, cv=5, train_sizes=np.linspace(.1, 1.0, 10)):\\n\\n\\tcv_train_scores = [[0] * len(train_sizes)]\\n\\tcv_test_scores = [[0] * len(train_sizes)]\\n\\tfor c in range(cv):\\n\\t\\ttrain_scores = []\\n\\t\\ttest_scores = []\\n\\t\\tfor ts in train_sizes:\\n\\t\\t\\tn_examples = int(round(len(trainx) * ts))\\n\\t\\t\\trows = random.sample(range(len(trainx)), n_examples)\\n\\t\\t\\tsubx = trainx.iloc[rows, ]\\n\\t\\t\\tsuby = trainy.iloc[rows, ]\\n\\t\\t\\tstart = time.time()\\n\\t\\t\\ta, b = test_ann2(subx, suby, testx, testy,\\n\\t\\t\\t\\t\\t\\t\\t\\tn_hidden=n_hidden, n_iter=n_iter)\\n\\t\\t\\tprint(\\\"training time: {} secs\\\".format(time.time() - start))\\n\\t\\t\\tcurrent_train_score = a\\n\\t\\t\\tcurrent_test_score = b\\n\\t\\t\\ttrain_scores.append(current_train_score)\\n\\t\\t\\ttest_scores.append(current_test_score)\\n\\t\\tcv_train_scores.append(train_scores)\\n\\t\\tcv_test_scores.append(test_scores)\\n\\taverage_train_scores = [sum(i) / cv for i in zip(*cv_train_scores)]\\n\\taverage_test_scores = [sum(i) / cv for i in zip(*cv_test_scores)]\\n\\treturn train_sizes, average_train_scores, average_test_scores\",\n \"def learn(self, Xtrain, ytrain):\",\n \"def learning_curve(ww_training, rw_training, ww_test, rw_test):\\n accuracy_list = []\\n # finds the smallest number of rows for n\\n if ww_training.shape[0] <= rw_training.shape[0]:\\n n = ww_training.shape[0]\\n else:\\n n = rw_training.shape[0]\\n\\n for i in range(1,n+1):\\n np.random.shuffle(ww_training)\\n np.random.shuffle(rw_training)\\n recent = experiment(ww_training[:i], rw_training[:i], ww_test, rw_test)\\n accuracy_list.append(recent)\\n plt.plot(range(1,n+1), accuracy_list)\",\n \"def main():\\n ###################\\n ## Dataset ##\\n ###################\\n # (X, y) m = 100, n = 1\\n _data_x, data_y = make_regression(n_samples=100, n_features=1, noise=10)\\n\\n # show the dataset\\n plt.subplot(2, 2, 1)\\n plt.title(\\\"dataset\\\")\\n plt.scatter(_data_x, data_y)\\n\\n # Transform the dataset into matrices.\\n # That is used for writing the equations in the matrix form.\\n data_x = np.hstack((_data_x, np.ones(_data_x.shape)))\\n data_y = data_y.reshape(data_y.shape[0], 1)\\n\\n #################\\n ## Model ##\\n #################\\n # initial parameters\\n init_params = np.random.randn(2, 1)\\n\\n # initial model\\n init_model = model(data_x, init_params)\\n\\n # plot initial model\\n plt.subplot(2, 2, 2)\\n plt.title(\\\"initial model\\\")\\n plt.scatter(_data_x, data_y)\\n plt.plot(_data_x, init_model, c='g')\\n\\n #########################\\n ## cost function ##\\n #########################\\n # show cost function for initial parameters\\n print(cost_function(data_x, data_y, init_params))\\n\\n ####################\\n ## training ##\\n ####################\\n # learning rate\\n learn_rate = 0.005\\n # number of iterations\\n number_iterations = 1_000\\n\\n # final parameters for our model\\n final_params, cost_tracking = gradient_descent(\\n data_x, data_y, init_params, learn_rate, number_iterations)\\n\\n # final model\\n final_model = model(data_x, final_params)\\n\\n # show cost function for final parameters\\n print(cost_function(data_x, data_y, final_params))\\n\\n # plot final model\\n plt.subplot(2, 2, 3)\\n plt.title(\\\"final model\\\")\\n plt.scatter(_data_x, data_y)\\n plt.plot(_data_x, final_model, c='r')\\n\\n ##########################\\n ## learning curve ##\\n ##########################\\n # plot Cost history\\n plt.subplot(2, 2, 4)\\n plt.title(\\\"cost tracking\\\")\\n plt.plot(range(number_iterations), cost_tracking)\\n\\n ########################################\\n ## Coefficient of determination ##\\n ########################################\\n print(coefficient_determination(data_y, final_model))\\n\\n plt.show()\",\n \"def train(self,features,y):\\r\\n \\r\\n if self.learn_type == \\\"nn\\\":\\r\\n #generate supervised dataset\\r\\n return(self.learner.train_on_batch(features,y))\\r\\n elif self.learn_type == \\\"linear\\\":\\r\\n grad = 0\\r\\n n = len(features)\\r\\n for i in range(n):\\r\\n #sum over the instances to get an estimate of the gradient\\r\\n print((y[i] - self.learner.activate(features[i])))\\r\\n grad -= (y[i] - self.learner.activate(features[i])) * \\\\\\r\\n self.learner.grad(features[i])\\r\\n grad /= n\\r\\n #update paramter\\r\\n param = np.copy(self.learner.param)\\r\\n self.learner.param = param - self.alpha * grad\\r\\n #print(self.learner.param)\\r\",\n \"def learn(self):\\r\\n \\r\\n # unpack\\r\\n X = self.Train.X\\r\\n Y = self.Train.Y\\r\\n DY = self.Train.DY\\r\\n \\r\\n NX ,ND = X.shape\\r\\n NDY,_ = DY.shape\\r\\n \\r\\n print 'Build Information Matricies ...'\\r\\n \\r\\n # functions\\r\\n ay0 = np.array([[1.]]*NX)\\r\\n ay1 = X\\r\\n ay2 = np.reshape( np.einsum('ij,ik->ijk',X,X) , [-1,ND*ND] )\\r\\n\\r\\n # reduce redundant basis variables\\r\\n i_doub = np.tri(ND,k=-1).T == 1\\r\\n ay2[:,i_doub.ravel()] = ay2[:,i_doub.ravel()] * 2. \\r\\n i_keep = np.tri(ND,k=0).T == 1\\r\\n ay2 = ay2[:,i_keep.ravel()]\\r\\n\\r\\n # basis matrix, functions\\r\\n Ay = np.hstack([ay0,ay1,ay2])\\r\\n \\r\\n # arrays for the least squares regression\\r\\n At = Ay\\r\\n Yt = Y\\r\\n \\r\\n # gradients\\r\\n if NDY:\\r\\n ad0 = np.array([[0.]]*NX*ND)\\r\\n \\r\\n ad1 = np.tile( np.eye(ND) , [NX,1] )\\r\\n \\r\\n ad2a = np.repeat( np.eye(ND)[:,None,:] , ND , 1 )\\r\\n ad2a = np.reshape( ad2a , [-1,ND*ND] ) \\r\\n ad2a = np.repeat( ad2a, NX, axis=0 ) * np.repeat( np.tile( X, [ND,1] ) , ND, axis=1 )\\r\\n \\r\\n ad2b = np.repeat( np.eye(ND)[:,:,None] , ND , 2 )\\r\\n ad2b = np.reshape( ad2b , [-1,ND*ND] ) \\r\\n ad2b = np.repeat( ad2b, NX, axis=0 ) * np.tile( np.tile( X, [ND,1] ) , [1,ND] )\\r\\n \\r\\n ad2 = ad2a + ad2b\\r\\n \\r\\n # reduce redundant bases\\r\\n ad2[:,i_doub.ravel()] = ad2[:,i_doub.ravel()] * 2.\\r\\n ad2 = ad2[:,i_keep.ravel()] \\r\\n \\r\\n Ad = np.hstack([ad0,ad1,ad2])\\r\\n \\r\\n # add to arrays for least squares regression\\r\\n At = np.vstack([At,Ad])\\r\\n Yt = np.vstack([Yt, np.ravel(DY.T)[:,None]])\\r\\n \\r\\n print 'Least Squares Solve ...'\\r\\n B = sp.linalg.lstsq(At,Yt)[0] \\r\\n \\r\\n # unpack data\\r\\n c = B[0,0]\\r\\n b = B[1:ND+1]\\r\\n \\r\\n A = np.zeros([ND,ND])\\r\\n A[i_keep] = B[ND+1:,0]\\r\\n A[i_keep.T] = A.T[i_keep.T]\\r\\n \\r\\n # problem forumulation\\r\\n A = A*2.\\r\\n \\r\\n # store results\\r\\n self.c = c\\r\\n self.b = b\\r\\n self.A = A\\r\\n \\r\\n print ''\",\n \"def __init__(self, hidden_size, num_step=2000, print_interval=1000):\\n self.num_step = num_step\\n self.print_interval = print_interval\\n\\n # Model parameters initialization\\n # Please initiate your network parameters here.\\n self.w1 = np.array([[random.random() for i in range(hidden_size)] for j in range(2)]) #2 * hidden_size matrix\\n self.w2 = np.array([[random.random() for i in range(hidden_size)] for j in range(hidden_size)])\\n self.w3 = np.array([[random.random()] for j in range(hidden_size)])\\n \\n \\n self.learning_rate = 0.05\\n \\n self.A1 = []\\n self.A2 = []\\n self.Y = []\\n \\n ...\",\n \"def plot_learning_curve(model, X_train, X_test, y_train, y_test):\\n\\n m, train_scores, valid_scores = learning_curve(estimator = model, \\n X = X_train, y = y_train.ravel(), train_sizes = np.linspace(0.1,1.0, 80))\\n\\n train_cv_err = np.mean(train_scores, axis=1)\\n test_cv_err = np.mean(valid_scores, axis=1)\\n tr, = plt.plot(m, train_cv_err)\\n ts, = plt.plot(m, test_cv_err)\\n plt.legend((tr, ts), ('training error', 'test error'), loc = 'best')\\n plt.title('Learning Curve')\\n plt.xlabel('Data Points')\\n plt.ylabel('Accuracy')\",\n \"def train_LR(self, X, y, eta=1e-3, batch_size=1, num_iters=1000) :\\n loss_history = []\\n N,d = X.shape\\n for t in np.arange(num_iters):\\n X_batch = None\\n y_batch = None\\n # ================================================================ #\\n # YOUR CODE HERE:\\n # Sample batch_size elements from the training data for use in gradient descent. \\n # After sampling, X_batch should have shape: (batch_size,1), y_batch should have shape: (batch_size,)\\n # The indices should be randomly generated to reduce correlations in the dataset. \\n # Use np.random.choice. It is better to user WITHOUT replacement.\\n # ================================================================ #\\n \\n # sample indices without replacement\\n batch_idx = np.random.choice(N, batch_size, replace = False)\\n X_batch = X[batch_idx]\\n y_batch = y[batch_idx]\\n \\n \\n # ================================================================ #\\n # END YOUR CODE HERE\\n # ================================================================ #\\n loss = 0.0\\n grad = np.zeros_like(self.w)\\n # ================================================================ #\\n # YOUR CODE HERE: \\n # evaluate loss and gradient for batch data\\n # save loss as loss and gradient as grad\\n # update the weights self.w\\n # ================================================================ #\\n \\n # compute the loss and gradient\\n # loss_and_grad will take responsible for these\\n \\n loss, grad = self.loss_and_grad(X_batch, y_batch)\\n \\n self.w = self.w - eta * grad\\n \\n # ================================================================ #\\n # END YOUR CODE HERE\\n # ================================================================ #\\n loss_history.append(loss)\\n return loss_history, self.w\",\n \"def run():\\n trials = 100\\n\\n multipliers = [0.25, 0.3, 0.35, 0.5, 0.75, 1, 1.25, 1.45, 1.5, 1.55, 1.6] # Coefficients for learning rate\\n\\n mean_penalty = []\\n median_penalty = []\\n std_penalty = []\\n\\n mean_trial_time = []\\n median_trial_time = []\\n std_trial_time = []\\n\\n mean_success_rate = []\\n median_success_rate = []\\n std_success_rate = []\\n\\n for m in multipliers:\\n all_penalties = [] # All penalties from trail sets\\n all_average_trial_time = []\\n all_success_rates = []\\n\\n for i in range(0, 20):\\n # print \\\"Trial set:\\\", i\\n # Set up environment and agent\\n e = Environment() # create environment (also adds some dummy traffic)\\n agent = e.create_agent(LearnerAgent) # create agent\\n agent.mult = m\\n e.set_primary_agent(agent, enforce_deadline=True) # specify agent to track\\n\\n # Now simulate it\\n sim = Simulator(e, update_delay=0.0, display=False) # create simulator (uses pygame when display=True, if available)\\n\\n sim.run(n_trials=trials) # run for a specified number of trials\\n\\n all_penalties.append(agent.all_trails_penalties)\\n all_average_trial_time.append(agent.time/float(trials))\\n all_success_rates.append(float(trials-agent.aborted_trials)/trials)\\n\\n mean_penalty.append(np.mean(all_penalties))\\n median_penalty.append(np.median(all_penalties))\\n std_penalty.append(np.std(all_penalties))\\n\\n mean_trial_time.append(np.mean(all_average_trial_time))\\n median_trial_time.append(np.median(all_average_trial_time))\\n std_trial_time.append(np.std(all_average_trial_time))\\n\\n mean_success_rate.append(np.mean(all_success_rates))\\n median_success_rate.append(np.median(all_success_rates))\\n std_success_rate.append(np.std(all_success_rates))\\n\\n for i in range(0, len(multipliers)):\\n print \\\"\\\"\\n print \\\"Multiplier:\\\", multipliers[i]\\n print \\\"\\\"\\n print \\\"Mean penalty per {} trials:\\\".format(trials), mean_penalty[i]\\n print \\\"Median penalty per {} trials:\\\".format(trials), median_penalty[i]\\n print \\\"Std.Dev. penalty per {} trials:\\\".format(trials), std_penalty[i]\\n\\n print \\\"\\\"\\n print \\\"Mean trial time:\\\", mean_trial_time[i]\\n print \\\"Median trial time:\\\", median_trial_time[i]\\n print \\\"Std.Dev. trial time:\\\", std_trial_time[i]\\n\\n print \\\"\\\"\\n print \\\"Mean success rate per {} trials:\\\".format(trials), mean_success_rate[i]\\n print \\\"Median success rate per {} trials:\\\".format(trials), median_success_rate[i]\\n print \\\"Std.Dev. success rate per {} trials:\\\".format(trials), std_success_rate[i]\",\n \"def ytrain(self,)->list:\",\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 get_learning_curve(estimator, X, y, ylim=None, cv=None, n_jobs=4, train_sizes=np.linspace(.125, 1.0, 8)):\\n if ylim is not None:\\n plt.ylim(*ylim)\\n train_sizes, train_scores, test_scores = learning_curve(\\n estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes)\\n train_scores_mean = np.mean(train_scores, axis=1)\\n train_scores_std = np.std(train_scores, axis=1)\\n test_scores_mean = np.mean(test_scores, axis=1)\\n test_scores_std = np.std(test_scores, axis=1)\\n\\n return train_sizes, train_scores_mean, test_scores_mean, train_scores_std, test_scores_std\",\n \"def train(self, trainingData, trainingLabels, validationData, validationLabels ):\\n\\n self.setWeights(trainingData.shape[1])\\n # DO NOT ZERO OUT YOUR WEIGHTS BEFORE STARTING TRAINING, OR\\n # THE AUTOGRADER WILL LIKELY DEDUCT POINTS.\\n \\n # Hyper-parameters. Your can reset them. Default batchSize = 100, weight_decay = 1e-3, learningRate = 1e-2\\n \\\"*** YOU CODE HERE ***\\\"\\n self.batchSize = 100\\n self.weight_decay = 1e-3\\n self.learningRate = 0.1\\n\\n def Softmax(x):\\n x_max = np.max(x, axis=0)\\n x_exp = np.exp(x - x_max)\\n x_exp_sum = np.sum(x_exp, axis=0)\\n return x_exp / x_exp_sum\\n\\n for iteration in range(self.max_iterations):\\n if iteration % 10 == 0:\\n print(\\\"Starting iteration \\\", iteration, \\\"...\\\")\\n self.learningRate *= 0.9\\n dataBatches = self.prepareDataBatches(trainingData, trainingLabels)\\n for batchData, batchLabel in dataBatches:\\n \\\"*** YOUR CODE HERE ***\\\"\\n Y = np.zeros((len(self.legalLabels), self.batchSize))\\n for i in range(self.batchSize):\\n Y[batchLabel[i]][i] = 1\\n Y_pred = Softmax((batchData @ self.weights + self.bias).T)\\n d_weight = ((Y_pred - Y) @ batchData / batchData.shape[0]).T + self.weight_decay * sum(self.weights)\\n d_bias = np.mean(Y_pred - Y, axis=1) + self.weight_decay * sum(self.bias)\\n self.weights -= d_weight * self.learningRate\\n self.bias -= d_bias * self.learningRate\",\n \"def train_model(self, \\n num_epochs, \\n learning_rate, \\n momentum, \\n num_iters,\\n report_pseudo_cost,\\n save_every_epoch,\\n report_step,\\n report_p_tilda,\\n report_w_norm,\\n exp_path,\\n test_gradients = False):\\n \\n if report_p_tilda:\\n \\n p_t_i = 0\\n \\n p_tilda_all = np.zeros(\\n [num_epochs*num_iters//report_step,self.batch_size]\\n )\\n \\n else:\\n \\n p_tilda_all = []\\n \\n pseudo_losses = []\\n \\n if report_w_norm:\\n \\n w_norms = np.zeros(num_epochs*num_iters//report_step)\\n \\n w_i = 0\\n \\n else:\\n \\n w_norms = []\\n \\n start_train_time = timeit.default_timer()\\n \\n for epoch_index in range(num_epochs):\\n \\n epoch_time0 = timeit.default_timer()\\n \\n perm_inds = self.np_rand_gen.permutation(self.N_train)\\n \\n #put different learning_rate rules (per epoch) for now here:\\n \\n #lrate_epoch = learning_rate\\n \\n if self.mixture:\\n \\n lrate_epoch =\\\\\\n (1.0/(1+epoch_index/10000.0))*learning_rate/self.batch_size\\n \\n else:\\n lrate_epoch =\\\\\\n (1.0/(1+epoch_index/100.0))*learning_rate/self.batch_size\\n \\n # lrate_epoch = (0.9**epoch_index)*learning_rate # 0.99\\n \\n # lrate_epoch = learning_rate\\n \\n if self.use_momentum:\\n \\n momentum_epoch = momentum\\n \\n print(\\\"Learning rate for epoch %d --- %f\\\"%\\n (epoch_index,lrate_epoch))\\n \\n if report_pseudo_cost:\\n \\n avg_pseudo_cost_val = []\\n \\n for i in range(num_iters):\\n \\n iter_start_time = timeit.default_timer()\\n \\n minibatch_inds =\\\\\\n perm_inds[self.batch_size*i:self.batch_size*(i+1)]\\n \\n if \\\"CSS\\\" in self.algorithm:\\n \\n assert self.num_samples > 0 \\n \\n is_samples, is_probs =\\\\\\n self.is_sampler(minibatch_set =list(minibatch_inds),\\n t = epoch_index)\\n \\n is_samples = np.asarray(is_samples, \\n dtype = theano.config.floatX)\\n if test_gradients:\\n \\n t0 = timeit.default_timer()\\n \\n approx_cost, p_tilda =\\\\\\n self.optimize(is_samples, \\n list(minibatch_inds),\\n lrate_epoch)\\n \\n t1 = timeit.default_timer() \\n print(\\\"Gradient computation with implementation 1 took\\\"+\\\\\\n \\\" --- %f minutes\\\"%((t1 - t0)/60.0))\\n W_implicit = np.asarray(self.W.get_value())\\n b_implicit = np.asarray(self.b.get_value())\\n t0 = timeit.default_timer()\\n self.test_grad_computations(is_samples, list(minibatch_inds))\\n t1 = timeit.default_timer()\\n print(\\\"Gradient computation with implementation 2 took \\\"+\\\\\\n \\\"--- %f minutes\\\"%((t1 - t0)/60.0))\\n W_explicit = np.asarray(self.W.get_value())\\n b_explicit = np.asarray(self.b.get_value())\\n print(\\\"Equivalence of W updates in two implementations:\\\")\\n print((np.round(W_implicit,12) == np.round(W_explicit,12)).all())\\n print(\\\"Equivalence of b updates in two implementations:\\\")\\n print((np.round(b_implicit,12) == np.round(b_explicit,12)).all())\\n sys.exit()\\n \\n if ((self.mf_steps > 0) and (self.alpha >0)): \\n \\n if self.use_momentum:\\n \\n approx_cost, p_tilda =\\\\\\n self.optimize(is_samples, \\n list(minibatch_inds),\\n is_probs,\\n lrate_epoch,\\n momentum_epoch)\\n \\n elif (not self.use_momentum):\\n \\n approx_cost, p_tilda =\\\\\\n self.optimize(is_samples, \\n list(minibatch_inds),\\n is_probs,\\n lrate_epoch)\\n \\n elif ((self.alpha ==0) or (self.mf_steps ==0) or\\\\\\n self.mixture) and self.gibbs_steps ==0:\\n \\n if self.use_momentum:\\n \\n approx_cost, p_tilda =\\\\\\n self.optimize(is_samples, \\n list(minibatch_inds),\\n lrate_epoch,\\n momentum_epoch)\\n \\n elif (not self.use_momentum):\\n \\n approx_cost, p_tilda =\\\\\\n self.optimize(is_samples, \\n list(minibatch_inds),\\n lrate_epoch)\\n \\n elif self.gibbs_steps > 0:\\n \\n if self.use_momentum:\\n \\n approx_cost, p_tilda =\\\\\\n self.optimize(is_samples, \\n list(minibatch_inds),\\n is_probs,\\n lrate_epoch,\\n momentum_epoch)\\n \\n elif (not self.use_momentum):\\n \\n approx_cost, p_tilda =\\\\\\n self.optimize(is_samples, \\n list(minibatch_inds),\\n is_probs,\\n lrate_epoch)\\n \\n elif \\\"CD\\\" in self.algorithm:\\n \\n if self.num_hidden ==0:\\n \\n if \\\"PCD\\\" in self.algorithm:\\n \\n mf_sample, cd_sample = self.cd_sampling()\\n \\n self.x_gibbs.set_value(np.transpose(cd_sample))\\n \\n else:\\n ### \\\"CD\\\" \\n mf_sample, cd_sample =\\\\\\n self.cd_sampling(list(minibatch_inds))\\n \\n self.x_gibbs.set_value(np.transpose(cd_sample))\\n \\n if self.use_momentum:\\n \\n approx_cost, p_tilda = self.optimize(list(minibatch_inds),\\n lrate_epoch,\\n momentum_epoch)\\n \\n else:\\n \\n approx_cost, p_tilda = self.optimize(list(minibatch_inds),\\n lrate_epoch)\\n \\n avg_pseudo_cost_val.append(approx_cost)\\n \\n if report_pseudo_cost:\\n \\n if i % report_step ==0:\\n \\n print('Training epoch %d ---- Iter %d ----'%\\n (epoch_index, i)+' pseudo cost value: %f'%approx_cost)\\n \\n if report_p_tilda:\\n \\n if i % report_step == 0:\\n print(\\\"p_tilda values for training examples:\\\")\\n if self.batch_size >=20:\\n print_inds = range(0,20)\\n print(p_tilda[print_inds])\\n else:\\n print(p_tilda[0:self.batch_size])\\n print(\\\"sum of these values:\\\")\\n if self.batch_size >= 20:\\n print_inds = range(0,20)\\n print(p_tilda[print_inds])\\n else:\\n print(np.sum(p_tilda[0:self.batch_size])) \\n \\n p_tilda_all[p_t_i,:] = p_tilda[0:self.batch_size]\\n \\n p_t_i +=1\\n \\n if report_w_norm: \\n \\n curr_w = self.W.get_value() \\n \\n w_norms[w_i] = np.sum(np.multiply(curr_w, curr_w))\\n \\n w_i +=1\\n \\n iter_end_time = timeit.default_timer()\\n \\n print('Training iteration took %f minutes'%\\n ((iter_end_time - iter_start_time) / 60.))\\n \\n if report_pseudo_cost:\\n \\n avg_pseudo_cost_val = np.mean(avg_pseudo_cost_val)\\n \\n pseudo_losses.append(avg_pseudo_cost_val)\\n \\n print('Training epoch %d ---- average pseudo cost value: %f'\\n %(epoch_index, avg_pseudo_cost_val))\\n \\n epoch_time1 = timeit.default_timer()\\n \\n print ('Training epoch took %f minutes'%\\n ((epoch_time1 - epoch_time0)/60.))\\n \\n if save_every_epoch:\\n \\n params_to = os.path.join(exp_path,\\\"TRAINED_PARAMS_END.model\\\")\\n \\n self.save_model_params(params_to)\\n \\n end_train_time = timeit.default_timer()\\n \\n training_time = (end_train_time - start_train_time)/60.0\\n\\n print('Training process took %f minutes'%training_time)\\n \\n params_to = os.path.join(exp_path,\\\"TRAINED_PARAMS_END.model\\\")\\n \\n self.save_model_params(params_to)\\n \\n return p_tilda_all, pseudo_losses, training_time, w_norms\",\n \"def SGD(epochs, eta):\\n # print([[[k] for k in i] for i in self.x])\\n # print([[j] for j in self.y])\\n # print([i] for)\\n\\n # if test_data: n_test = len(test_data)\\n for j in xrange(epochs):\\n # mini_batches = [training_data[k:k + mini_batch_size] for k in xrange(0, n, mini_batch_size)]\\n # for mini_batch in mini_batches:\\n # update_mini_batch(mini_batch, eta)\\n nabla_b = [np.zeros(b.shape) for b in self.biases]\\n nabla_w = [np.zeros(w.shape) for w in self.weights]\\n for x, y in training_data:\\n delta_nabla_b, delta_nabla_w = backprop(x, y)\\n nabla_b = [nb + dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]\\n nabla_w = [nw + dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]\\n # for x, y in training_data:\\n # delta_nabla_b, delta_nabla_w = backprop(x, y)\\n # nabla_b = [nb + dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]\\n # nabla_w = [nw + dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]\\n self.weights = [w - (eta ) * nw\\n for w, nw in zip(self.weights, nabla_w)]\\n self.biases = [b - (eta ) * nb\\n for b, nb in zip(self.biases, nabla_b)]\\n\\n # print 'Epoch {0}'.format(j)\\n # print self.weights\\n # print self.biases\\n\\n # if test_data:\\n # print \\\"Epoch {0}: {1} / {2}\\\".format(\\n # j, evaluate(test_data), n_test)\\n # else:\\n # print \\\"Epoch {0} complete\\\".format(j)\",\n \"def learn(self):\\n metrics_hist = dict()\\n max_runs = 3\\n for run in range(max_runs):\\n all_indices, initial_indices = self._init_al_dataset()\\n\\n metrics_hist[str(run)] = dict()\\n\\n current_indices = list(initial_indices)\\n \\n for split in self.data_splits_frac:\\n print(f'\\\\nRUN {run} - SPLIT - {split*100:0.0f}%')\\n\\n # Initialise models\\n self._init_models(mode='svaal')\\n\\n # Do some label stuff\\n unlabelled_indices = np.setdiff1d(list(all_indices), current_indices)\\n unlabelled_sampler = data.sampler.SubsetRandomSampler(unlabelled_indices)\\n unlabelled_dataloader = data.DataLoader(self.datasets['train'],\\n sampler=unlabelled_sampler,\\n batch_size=64,\\n drop_last=False)\\n\\n print(f'Labelled: {len(current_indices)} Unlabelled: {len(unlabelled_indices)} Total: {len(all_indices)}')\\n\\n # TODO: Make the SVAAL allow 100% labelled and 0% unlabelled to pass through it. Breaking out of loop for now when data hits 100% labelled.\\n if len(unlabelled_indices) == 0:\\n break\\n\\n metrics, svae, discriminator = self.train(dataloader_l=self.labelled_dataloader,\\n dataloader_u=unlabelled_dataloader,\\n dataloader_v=self.val_dataloader,\\n dataloader_t=self.test_dataloader,\\n mode='svaal') \\n print(f'Test Eval.: F1 Scores - Macro {metrics[0]*100:0.2f}% Micro {metrics[1]*100:0.2f}%') \\n \\n # Record performance at each split\\n metrics_hist[str(run)][str(split)] = metrics\\n\\n \\n sampled_indices = self.sample_adversarial(svae, discriminator, unlabelled_dataloader, indices=unlabelled_indices, cuda=True) # TODO: review usage of indices arg\\n current_indices = list(current_indices) + list(sampled_indices)\\n sampler = data.sampler.SubsetRandomSampler(current_indices)\\n self.labelled_dataloader = data.DataLoader(self.datasets['train'], sampler=sampler, batch_size=self.batch_size, drop_last=True)\\n \\n # write results to disk\\n with open('results.json', 'w') as fj:\\n json.dump(metrics_hist, fj, indent=4)\",\n \"def learn(self):\\n pass\",\n \"def learn(self):\\n pass\",\n \"def train(self, training_steps=10):\",\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 bonus(l, m, n):\\n # initialize variables\\n lrs = [1.5, 0.25, 0.03, 0.005, 0.001]\\n (y, x) = gen(l, m, n, 10000, True) \\n # placeholder \\n (y_train, x_train) = gen(l, m, n, 1, True)\\n (y_test, x_test) = gen(l, m, n, 1, False)\\n size, samples, loops, R = 10000, 10000, 50, None\\n \\n # build online learning algorithms\\n adagrad = AdaGrad(R, x, x_train, x_test, y, y_train, y_test, n, samples, size, loops, lrs)\\n \\n # draw plots\\n draw_bonus_error(adagrad.error)\\n draw_bonus_loss(adagrad.loss)\",\n \"def train(self, X, Y, num_iterations = 1000, learning_rate = 0.01, print_cost = False, plot_cost = False):\\n costs = []\\n \\n for i in range(num_iterations + 1):\\n grads, cost = self.propagate(X,Y)\\n \\n # Retrieve derivatives from grads\\n dw = grads[\\\"dw\\\"]\\n db = grads[\\\"db\\\"]\\n \\n # Update rule\\n self.weight = self.weight - learning_rate * dw\\n self.bias = self.bias - learning_rate * db\\n \\n # Record the costs\\n if i % 100 == 0:\\n costs.append(cost)\\n \\n # Print the cost every 100 training examples\\n if print_cost and i % 100 == 0:\\n print(f\\\"cost after iteration: {i} is {np.round(cost, 4)}\\\")\\n \\n grads = {\\\"dw\\\": dw,\\n \\\"db\\\": db}\\n\\n if plot_cost:\\n plt.plot(np.arange(len(costs)) * 100, costs)\\n plt.xlabel(\\\"epoch\\\")\\n plt.ylabel(\\\"cost\\\")\\n plt.title(f\\\"Logistic curve fitting loss function (learning rate={learning_rate})\\\")\\n plt.show()\\n \\n return grads, costs\",\n \"def learn(self):\\n total_error = 0\\n threshold = 0.05\\n\\n counter = len(self._training_set)*len(self._perceptrons)\\n total_error+=self.learning_step()\\n\\n while total_error/counter > threshold:\\n counter += len(self._training_set)*len(self._perceptrons)\\n total_error +=self.learning_step()\",\n \"def stochastic_fit(self):\\r\\n self.init_plot(self.FEATURES)\\r\\n\\r\\n # YOUR CODE HERE\\r\\n\\r\\n while self.training_iteration == 0 or self.training_iteration < self.MAX_ITERATIONS*self.DATAPOINTS:\\r\\n print('Iteration: ', self.training_iteration)\\r\\n datapoint = np.random.randint(0, self.DATAPOINTS)\\r\\n\\r\\n self.compute_gradient(datapoint)\\r\\n self.upd_theta()\\r\\n\\r\\n # plot every 100th iteration\\r\\n if not self.training_iteration % 100:\\r\\n self.update_plot(np.sum(np.square(self.gradient)))\\r\\n\\r\\n self.training_iteration += 1\",\n \"def main():\\n \\n # The following 5 command lines can be outcommented if the features are already created.\\n # There is no need to process the data every single time.\\n # Fine tuning the learning algorythm is much faster without that extra step.\\n \\n # by reading the train dataset the feature index is created.\\n # First calling of the processdata function\\n # Data limited to 300000\\n featureIndexes = processData(os.path.join(dataFolder,\\\"avito_train.tsv\\\"), itemsLimit=600000)\\n print \\\"featureIndex generated!\\\"\\n print len(featureIndexes)\\n\\n # Trainfeature is created using the indexfeatures...\\n # Second calling of the processdata function\\n trainFeatures, trainTargets, trainItemIds, trainPrices, trainUrls, trainPhones, trainEmails, trainLength = processData(os.path.join(dataFolder,\\\"avito_train.tsv\\\"), itemsLimit=600000) # Original itemsLimit=300000\\n\\n # Building the test dataset... just like the training...\\n testFeatures, testItemIds, testPrices, testUrls, testPhones, testEmails, testLength = processData(os.path.join(dataFolder,\\\"avito_test.tsv\\\"), featureIndexes)\\n\\n # Dumping data into file...\\n # joblib.dump((trainFeatures, trainTargets, trainItemIds, testFeatures, testItemIds), os.path.join(dataFolder,\\\"train_data.pkl\\\"))\\n joblib.dump((trainFeatures,trainTargets,trainItemIds,trainPrices,trainUrls,trainPhones,trainEmails,trainLength,\\n testFeatures, testItemIds,testPrices,testUrls,testPhones,testEmails,testLength), os.path.join(dataFolder,\\\"SeparatedByCategory.pkl\\\"))\\n\\n\\n # loading data pack...\\n # trainFeatures, trainTargets, trainItemIds, testFeatures, testItemIds = joblib.load(os.path.join(dataFolder,\\\"train_data.pkl\\\"))\\n\\n #logging.info(\\\"Feature preparation done, fitting model...\\\")\\n\\n # Stochastic gradient model\",\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 main():\\n # Initializing learning rate\\n learning_rate = 0.0005\\n # Initializing stopping criteria\\n stopping_criteria = 0.01\\n # load the data training data from a csv file with an url\\n training_x,testing_x, training_y, testing_y,mean,sd= ai.store_data(\\\"https://github.com/santiagocantu98/K-Nearest-Neightbours/raw/master/diabetes.csv\\\",\\\"training\\\")\\n normal_testing = np.copy(testing_x)\\n\\n # scalates the features of the testing data\\n testing_data_scaled,mean,sd = ai.scale_features(testing_x,mean,sd)\\n ai.print_scaled_data(testing_data_scaled,\\\"testing\\\")\\n ai.calculate_euclidean_distance(training_x, training_y , testing_data_scaled, testing_y,normal_testing)\",\n \"def test_learning_curves():\\n\\n p = pipeline.Pipeline(\\n FX_TRAIN,\\n FX_TEST,\\n FX_LOOKUP,\\n RESULTS_DIR\\n )\\n\\n data = p.learning_curves()\",\n \"def train(self, iterations = 100):\\n arguments = ()\\n print(\\\"training...\\\")\\n results = optimize.minimize(self.CostFunction,x0 = self.Thetas, args = arguments, options = {'disp':True, 'maxiter': iterations}, method = \\\"L-BFGS-B\\\", jac = True)\\n self.Thetas = results['x']\\n FinalCost, _ = self.CostFunction(self.Thetas)\\n print(\\\"successfully trained the model\\\") \\n print(\\\"Final Cost for this model is:\\\", FinalCost)\",\n \"def learn(self):\\n Qsa = self.evalQsa(self.features)[self.chosenA]\\n print Qsa\\n dQ = self.alpha*(self.reward + self.gamma * self.maxQsa(self.next_features) - Qsa)\\n self.thetas += dQ*self.features[:,self.chosenA]\\n print self.thetas\\n # self.thetas /= np.sqrt(np.sum(np.power(self.thetas,2)))\",\n \"def sgd_optimization(data_type, target, model_dir, learning_rate=0.1, n_epochs=10, batch_size=100):\\r\\n\\r\\n test_fold = 1 #xxxxxxxxxxxx TEMP XXXXXXXXXXXXXXXX\\r\\n write_model_file = model_dir + '/model.' + target + '.' + str(test_fold) +'.pkl'\\r\\n fold_path = helpers.get_fold_path(data_type)\\r\\n targets = helpers.build_targets(fold_path, data_type)\\r\\n fnames = targets[target]\\r\\n\\r\\n fold_accuracies = {}\\r\\n did_something = False\\r\\n\\r\\n # pct_ct = []\\r\\n # roc_auc = []\\r\\n # run 4 folds vs 1 fold with each possible scenario\\r\\n # for curr_fl in range(5):\\r\\n # print 'Building data for target: ' + target + ', fold: ' + str(curr_fl)\\r\\n\\r\\n # loop through all folds, for now just do 1!\\r\\n datasets, test_set_labels = helpers.th_load_data(data_type, fold_path, target, fnames, 0, test_fold)\\r\\n\\r\\n train_set_x, train_set_y = datasets[0]\\r\\n test_set_x, test_set_y = datasets[1]\\r\\n valid_set_x = train_set_x\\r\\n valid_set_y = train_set_y\\r\\n\\r\\n # compute number of rows for training, validation and testing\\r\\n rows_train = train_set_x.get_value(borrow=True).shape[0]\\r\\n rows_valid = valid_set_x.get_value(borrow=True).shape[0]\\r\\n rows_test = test_set_x.get_value(borrow=True).shape[0]\\r\\n\\r\\n # compute number of minibatches for training, validation and testing\\r\\n n_train_batches = rows_train / batch_size\\r\\n n_valid_batches = rows_valid / batch_size\\r\\n n_test_batches = rows_test / batch_size\\r\\n\\r\\n ####################### BUILD ACTUAL MODEL #######################\\r\\n # allocate symbolic variables for the data\\r\\n index = T.lscalar() # index to a [mini]batch\\r\\n\\r\\n # generate symbolic variables for input (x and y represent a minibatch)\\r\\n x = T.matrix('x') # data, presented as rasterized images\\r\\n y = T.ivector('y') # labels, presented as 1D vector of [int] labels\\r\\n\\r\\n # construct the logistic regression class\\r\\n # n_in: Each MNIST image has size 32*32 = 1024\\r\\n # n_out: 10 different digits - multi-task LR\\r\\n classifier = LogisticRegression(input=x, n_in=32 * 32, n_out=2)\\r\\n\\r\\n # the cost we minimize during training is the negative log likelihood of the model in symbolic format\\r\\n cost = classifier.negative_log_likelihood(y)\\r\\n\\r\\n # compiling a Theano function that computes the mistakes that are made by the model on a minibatch\\r\\n test_model = theano.function( inputs=[index], outputs=classifier.errors(y),\\r\\n givens={\\r\\n x: test_set_x[index * batch_size: (index + 1) * batch_size],\\r\\n y: test_set_y[index * batch_size: (index + 1) * batch_size]\\r\\n }\\r\\n )\\r\\n\\r\\n validate_model = theano.function(\\r\\n inputs=[index],\\r\\n outputs=classifier.errors(y),\\r\\n givens={\\r\\n x: valid_set_x[index * batch_size: (index + 1) * batch_size],\\r\\n y: valid_set_y[index * batch_size: (index + 1) * batch_size]\\r\\n }\\r\\n )\\r\\n\\r\\n # compute the gradient of cost with respect to theta = (W,b)\\r\\n g_W = T.grad(cost=cost, wrt=classifier.W)\\r\\n g_b = T.grad(cost=cost, wrt=classifier.b)\\r\\n\\r\\n # start-snippet-3\\r\\n # specify how to update the parameters of the model as a list of\\r\\n # (variable, update expression) pairs.\\r\\n updates = [(classifier.W, classifier.W - learning_rate * g_W),\\r\\n (classifier.b, classifier.b - learning_rate * g_b)]\\r\\n\\r\\n # compiling a Theano function `train_model` that returns the cost, but in\\r\\n # the same time updates the parameter of the model based on the rules\\r\\n # defined in `updates`\\r\\n train_model = theano.function( inputs=[index], outputs=cost, updates=updates,\\r\\n givens={\\r\\n x: train_set_x[index * batch_size: (index + 1) * batch_size],\\r\\n y: train_set_y[index * batch_size: (index + 1) * batch_size]\\r\\n }\\r\\n )\\r\\n # end-snippet-3\\r\\n\\r\\n ################ TRAIN MODEL ################\\r\\n # early-stopping parameters\\r\\n patience = 5000 # look as this many examples regardless\\r\\n patience_increase = 2 # wait this much longer when a new best is found\\r\\n improvement_threshold = 0.995 # a relative improvement of this much is considered significant\\r\\n validation_frequency = min(n_train_batches, patience / 2)\\r\\n # go through this many minibatches before checking the network on the validation set; in this case we check every epoch\\r\\n\\r\\n best_validation_loss = numpy.inf\\r\\n test_score = 0.\\r\\n start_time = time.clock()\\r\\n\\r\\n done_looping = False\\r\\n epoch = 0\\r\\n while (epoch < n_epochs) and (not done_looping):\\r\\n epoch = epoch + 1\\r\\n for minibatch_index in xrange(n_train_batches):\\r\\n\\r\\n minibatch_avg_cost = train_model(minibatch_index)\\r\\n\\r\\n # iteration number\\r\\n iter = (epoch - 1) * n_train_batches + minibatch_index\\r\\n\\r\\n if (iter + 1) % validation_frequency == 0:\\r\\n # compute zero-one loss on validation set\\r\\n validation_losses = [validate_model(i)\\r\\n for i in xrange(n_valid_batches)]\\r\\n this_validation_loss = numpy.mean(validation_losses)\\r\\n\\r\\n # print( 'epoch %i, minibatch %i/%i, validation error %f %%' %\\r\\n # (epoch, minibatch_index + 1, n_train_batches, this_validation_loss * 100.) )\\r\\n\\r\\n # if we got the best validation score until now\\r\\n if this_validation_loss < best_validation_loss:\\r\\n #improve patience if loss improvement is good enough\\r\\n if this_validation_loss < best_validation_loss * \\\\\\r\\n improvement_threshold:\\r\\n patience = max(patience, iter * patience_increase)\\r\\n\\r\\n best_validation_loss = this_validation_loss\\r\\n # test it on the test set\\r\\n\\r\\n test_losses = [test_model(i)\\r\\n for i in xrange(n_test_batches)]\\r\\n test_score = numpy.mean(test_losses)\\r\\n\\r\\n # print( (' epoch %i, minibatch %i/%i, test error of best model %f %%' ) %\\r\\n # ( epoch, minibatch_index + 1, n_train_batches, test_score * 100. ) )\\r\\n\\r\\n # save the best model\\r\\n with open(write_model_file, 'w') as f:\\r\\n cPickle.dump(classifier, f)\\r\\n\\r\\n if patience <= iter:\\r\\n done_looping = True\\r\\n break\\r\\n\\r\\n end_time = time.clock()\\r\\n\\r\\n print( ('Optimization complete for %d with best validation score of %f %% with test performance %f %%')\\r\\n % (test_fold, best_validation_loss * 100., test_score * 100.) )\\r\\n print 'The code ran for %d epochs, with %f epochs/sec' % (epoch, 1. * epoch / (end_time - start_time))\\r\\n # print >> sys.stderr, ('The code for file ' + os.path.split(__file__)[1] + ' ran for %.1fs' % ((end_time - start_time)))\\r\\n\\r\\n # end-snippet-4\\r\\n # Now we do the predictions\\r\\n\\r\\n # load the saved best model for this fold\\r\\n classifier = cPickle.load(open(write_model_file))\\r\\n\\r\\n # compile a predictor function\\r\\n predict_model = theano.function(inputs=[classifier.input], outputs=[classifier.y_pred,classifier.p_y_given_x])\\r\\n # compile a confidence predictor function\\r\\n # predict_conf_model = theano.function( inputs=[classifier.input], outputs=classifier.p_y_given_x)\\r\\n # We can test it on some examples from test test\\r\\n\\r\\n \\\"\\\"\\\" *************** build AUC curve *************** \\\"\\\"\\\"\\r\\n # get the probability of our predictions\\r\\n test_set = test_set_x.get_value()\\r\\n predicted_values, conf_preds = predict_model(test_set[:(rows_test)])\\r\\n\\r\\n conf_predictions = []\\r\\n for i in range(len(conf_preds)):\\r\\n # ignore the first column; this gives a lower score that seems wrong.\\r\\n conf_predictions.append(conf_preds[i][1])\\r\\n\\r\\n # determine ROC / AUC\\r\\n fpr, tpr, thresholds = metrics.roc_curve(test_set_labels, conf_predictions)\\r\\n auc = metrics.auc(fpr, tpr) # e.g. 0.855\\r\\n \\\"\\\"\\\" *********************************************** \\\"\\\"\\\"\\r\\n\\r\\n num_correct = 0\\r\\n num_false = 0\\r\\n for i in range(len(predicted_values)):\\r\\n if predicted_values[i] == test_set_labels[i]:\\r\\n num_correct += 1\\r\\n else:\\r\\n num_false += 1\\r\\n\\r\\n total = len(predicted_values)\\r\\n percent_correct = num_correct / float(total)\\r\\n\\r\\n fold_results = ''\\r\\n fold_results += '#################### Results for ' + data_type + ' ####################' + '\\\\n'\\r\\n fold_results += 'target:' + target + ' fold:' + str(test_fold) + ' predicted: ' + \\\\\\r\\n str(total) + ' wrong: ' + \\\\\\r\\n str(num_false) + ' pct correct: ' + str(percent_correct) + ', auc: ' + str(auc)\\r\\n\\r\\n print fold_results\\r\\n\\r\\n write_predictions_file = model_dir + '/predictions.' + target + '.' + str(test_fold) +'.txt'\\r\\n with open(write_predictions_file, 'w') as f:\\r\\n f.write(fold_results + \\\"\\\\n\\\")\\r\\n\\r\\n\\r\\n\\r\\n# def run_predictions(data_type, curr_target):\\r\\n\\r\\n# fold_path = get_fold_path(data_type)\\r\\n# targets = build_targets(fold_path, data_type)\\r\\n# # print \\\"Found \\\" + str(len(targets)) + \\\" targets for \\\" + data_type\\r\\n\\r\\n# fold_accuracies = {}\\r\\n# did_something = False\\r\\n# for target, fnames in targets.iteritems():\\r\\n# if (target != curr_target):\\r\\n# continue\\r\\n# else:\\r\\n# did_something = True\\r\\n\\r\\n# # retrieve our stratified folds\\r\\n# folds = get_folds(data_type, fold_path, target, fnames)\\r\\n\\r\\n# pct_ct = []\\r\\n# roc_auc = []\\r\\n# # run 4 folds vs 1 fold with each possible scenario\\r\\n# for curr_fl in range(5):\\r\\n# print 'Building data for target: ' + target + ', fold: ' + str(curr_fl)\\r\\n\\r\\n# # folds 1-4\\r\\n# temp_data = []\\r\\n# for i in range(len(folds)):\\r\\n# if(i == curr_fl):\\r\\n# # don't include the test fold\\r\\n# continue\\r\\n# else:\\r\\n# temp_data += folds[i]\\r\\n\\r\\n# # vs current 5th test fold\\r\\n# test_data = folds[curr_fl]\\r\\n \\r\\n# \\\"\\\"\\\" Turning 1024 bits into features is a slow process \\\"\\\"\\\"\\r\\n# # build training data\\r\\n# X = []\\r\\n# Y = []\\r\\n# for i in range(len(temp_data)):\\r\\n# row = []\\r\\n# for bit in temp_data[i][0]:\\r\\n# row.append(int(bit))\\r\\n# X.append(row)\\r\\n# Y.append(int(temp_data[i][1]))\\r\\n\\r\\n# X = np.array(X)\\r\\n# Y = np.array(Y)\\r\\n\\r\\n# # build test data\\r\\n# X_test = []\\r\\n# Y_test = []\\r\\n# for i in range(len(test_data)):\\r\\n# row = []\\r\\n# for bit in test_data[i][0]:\\r\\n# row.append(int(bit))\\r\\n# X_test.append(row)\\r\\n# Y_test.append(int(test_data[i][1]))\\r\\n\\r\\n# X_test = np.array(X_test)\\r\\n# Y_test = np.array(Y_test)\\r\\n\\r\\n# percent_correct, auc = random_forest(target, X, Y, X_test, Y_test, curr_fl)\\r\\n# pct_ct.append(percent_correct)\\r\\n# roc_auc.append(auc)\\r\\n\\r\\n\\r\\n# # now get the average fold results for this target\\r\\n# accuracy = sum(pct_ct) / float(len(pct_ct))\\r\\n# all_auc = sum(roc_auc) / float(len(roc_auc))\\r\\n# print 'Results for '+ target + ': accuracy: ' + str(accuracy) + ', auc: ' + str(all_auc)\\r\\n# # update fold accuracies\\r\\n# fold_accuracies[target] = (accuracy, all_auc)\\r\\n\\r\\n\\r\\n if(did_something == False):\\r\\n print curr_target + ' not found in ' + data_type + '!'\\r\\n exit(0)\\r\\n \\r\\n print '#################### Results for ' + data_type + ' ####################'\\r\\n # output results\\r\\n accuracies = 0.00\\r\\n aucs = 0.00\\r\\n num_targets = 0.00\\r\\n for target, obj in fold_accuracies.iteritems():\\r\\n acc = obj[0]\\r\\n auc = obj[1]\\r\\n print target + ' accuracy: ' + str(acc) + ', auc:' + str(auc)\\r\\n accuracies += acc\\r\\n aucs += auc\\r\\n num_targets += 1\\r\\n\\r\\n # overall_acc = accuracies / num_targets\\r\\n # overall_auc = aucs / num_targets\\r\\n # print ' overall accuracy: ' + str(overall_acc) + ', overall auc: ' + str(overall_auc)\\r\\n print '############################################################'\",\n \"def draw_learning_curve(self, estimator, cvs=5, n_jobs=5, space_size=10,\\n **kwargs):\\n train_sizes, train_scores, test_scores = learning_curve(\\n estimator=estimator, X=self.x_matrix, y=self.y_vector,\\n train_sizes=numpy.linspace(.1, 1., space_size), cv=cvs,\\n n_jobs=n_jobs, **kwargs\\n )\\n\\n train_scores_mean = numpy.mean(train_scores, axis=1)\\n train_scores_std = numpy.std(train_scores, axis=1)\\n test_scores_mean = numpy.mean(test_scores, axis=1)\\n test_scores_std = numpy.std(test_scores, axis=1)\\n\\n fig, ax_learning = pyplot.subplots(figsize=(10, 10))\\n\\n ax_learning.fill_between(\\n train_sizes,\\n train_scores_mean + train_scores_std,\\n train_scores_mean - train_scores_std,\\n alpha=0.1\\n )\\n ax_learning.plot(\\n train_sizes, train_scores_mean, color='r',\\n label='Training score'\\n )\\n\\n ax_learning.fill_between(\\n train_sizes,\\n test_scores_mean + test_scores_std,\\n test_scores_mean - test_scores_std,\\n alpha=0.1\\n )\\n ax_learning.plot(\\n train_sizes, test_scores_mean, color='g',\\n label='Cross-validation score'\\n )\\n\\n ax_learning.set(\\n title='Learning curve',\\n xlabel='Training examples', ylabel='Score'\\n )\\n ax_learning.legend(loc='best')\\n\\n self.learning_line = (fig, ax_learning)\",\n \"def sgd(self, lr=0.01, decay=0.5, max_iters=1000,\\n batch_size=128, early_stop=150, decay_intval=50, decay_lim=9):\\n np.set_printoptions(precision=4)\\n w = self.weights[0]\\n loss = self.compute_loss(self.train_y, self.train_x, w)\\n best_loss = loss\\n best_counter = 0\\n decay_counter = 0\\n # print(\\\"initial loss is {} \\\".format(loss))\\n for epoch in range(max_iters):\\n\\n for batch_y, batch_x in batch_iter(self.train_y, self.train_x, batch_size):\\n grad = self.get_gradient(batch_y, batch_x, w)\\n w = w - lr * grad\\n loss = self.compute_loss(self.train_y, self.train_x, w)\\n mis_class = self.compute_metrics(self.train_y, self.train_x, w)\\n\\n self.weights.append(w)\\n self.losses.append(loss)\\n self.misclass_rate.append(mis_class)\\n if self.validation is True:\\n valid_loss = self.compute_loss(self.valid_y, self.valid_x, w)\\n valid_mis_class = self.compute_metrics(self.valid_y, self.valid_x, w)\\n self.valid_losses.append(valid_loss)\\n self.valid_misclass_rate.append(valid_mis_class)\\n # Display every 25 epoch\\n if (epoch + 1) % 25 == 0:\\n print('Epoch {e} in {m}'.format(e=epoch + 1, m=max_iters), end=\\\"\\\\t\\\")\\n if self.validation is True:\\n # print('\\\\tTrain Loss {0:0.4f}, \\\\tTrain mis-class {0:0.4f}, '\\n # '\\\\tvalid loss {0:0.4f}, \\\\tvalid mis-class {0:0.4f}'.\\n # format(loss, mis_class, valid_loss, valid_mis_class))\\n print('\\\\tTrain Loss {}, \\\\tTrain mis-class {}, '\\n '\\\\tvalid loss {}, \\\\tvalid mis-class {}'.\\n format(loss, mis_class, valid_loss, valid_mis_class))\\n else:\\n print('\\\\tTrain Loss {}, \\\\tTrain mis-class {}'.\\n format(loss, mis_class))\\n # judge the performance\\n if best_loss - loss > 0.000001:\\n best_loss = loss\\n best_counter = 0\\n else:\\n best_counter += 1\\n if best_counter > early_stop:\\n print(\\\"Learning early stop since loss not improving for {} epoch.\\\".format(best_counter))\\n break\\n if best_counter % decay_intval == 0:\\n print(\\\"weight decay by {}\\\".format(decay))\\n lr *= decay\\n decay_counter += 1\\n if decay_counter > decay_lim:\\n print(\\\"decay {} times, stop\\\".format(decay_lim))\\n break\\n return self.weights[-1]\",\n \"def plot_learning_curve(X_train_all, X_val_all, y_train_all, y_val_all, train_sizes, title):\\n\\n errors_df = pd.DataFrame(columns = ['train_size', 'train_acc', 'val_acc'])\\n\\n # Loop through example sizes and get the training and validation error\\n for train_size in train_sizes:\\n # Select Subset of Data\\n X_train = X_train_all[:train_size]\\n X_val = X_val_all[:train_size]\\n y_train = y_train_all[:train_size]\\n y_val = y_val_all[:train_size]\\n\\n # Initialize Model\\n model = svm.SVC(kernel='linear')\\n\\n # Fit model\\n print(f\\\"Training {title} using {train_size} examples\\\")\\n model.fit(X_train, y_train)\\n\\n # Get Predictions \\n train_pred = model.predict(X_train)\\n val_pred = model.predict(X_val)\\n\\n # Get Accuracy Score for X_Train and X_Val\\n errors = pd.DataFrame({\\n 'train_size': [train_size],\\n 'train_acc': [accuracy_score(y_train, train_pred)],\\n 'val_acc': [accuracy_score(y_val, val_pred)]\\n })\\n \\n # Concatenate Dataframes\\n errors_df = pd.concat([errors_df, errors])\\n\\n # Plot Learning Curve\\n fig, ax = plt.subplots()\\n\\n errors_df.plot(x='train_size', y='train_acc',kind='line', ax=ax)\\n errors_df.plot(x='train_size', y='val_acc',kind='line', color='red', ax=ax)\\n\\n ax.set_xlabel(\\\"Training Size\\\")\\n ax.set_ylabel(\\\"Accuracy\\\")\\n ax.set_title(title)\\n\\n # Save Figure\\n plt.savefig('figs/' + title + '_learning_curve.png')\",\n \"def learnign_rate_examples():\\n #######\\n bad_larning_rate = 0.1\\n not_bad_learning_rate = 1e-4\\n good_learning_rate = 1e-3\\n #######\\n return bad_larning_rate, not_bad_learning_rate, good_learning_rate\",\n \"def train2(self):\\n for epoch in range(self.epochs):\\n print \\\"epoch: \\\", epoch\\n self.train(self.D)\\n self.alpha -= 0.002 # decrease the learning rate\\n self.min_alpha = model.alpha # fix the learning rate, no decay\",\n \"def plot_learning_curve(X, y, maxdepth, estimator, plt):\\n # create cv training and test scores for various training set sizes\\n train_sizes, train_scores, test_scores = learning_curve(estimator,\\n X, # feature matrix\\n y, # target vector\\n cv=10, # number of folds in cross-validation\\n scoring='neg_mean_squared_error', # metric\\n n_jobs=-1, # use all computer cores,\\n train_sizes=np.linspace(0.01, 1.0, 30) # 30 different sizes of the training set\\n )\\n # create means and standart deviations of training set scores\\n train_mean = np.mean(train_scores, axis=1)\\n train_std = np.std(train_scores, axis=1)\\n\\n # create means and standart deviations of test set scores\\n test_mean = np.mean(test_scores, axis=1)\\n test_std = np.std(test_scores, axis=1)\\n\\n # draw lines\\n plt.plot(train_sizes, train_mean, '--', color='#111111', label=\\\"Training score\\\")\\n plt.plot(train_sizes, test_mean, color='#111111', label=\\\"Cross-validation score\\\")\\n\\n # draw bands\\n plt.fill_between(train_sizes, train_mean - train_std, train_mean + train_std, color=\\\"#DDDDDD\\\")\\n plt.fill_between(train_sizes, test_mean - test_std, test_mean + test_std, color=\\\"#f4d0d7\\\")\\n \\n # create plot \\n plt.title(\\\"Learning curve\\\")\\n plt.xlabel(\\\"Training set size\\\", fontsize=18)\\n plt.ylabel(\\\"mse\\\", fontsize=18)\\n plt.legend(loc=\\\"best\\\")\\n plt.tight_layout()\",\n \"def train(self, i):\\n\\t\\tlearningRate = self.learningRateFn(i)\\n\\t\\tdiscountFactor = self.discountFactorFn(i)\\n\\t\\ttrainingTuples = []\\n\\t\\twhile self.currentSAVRSAVIndex < len(self.SAVRSAV):\\n\\t\\t\\tcurrentSAVRSAV = self.SAVRSAV[self.currentSAVRSAVIndex]\\n\\t\\t\\tvalue = currentSAVRSAV['predictedValueOfAction'] + learningRate * (currentSAVRSAV['reward'] + discountFactor*currentSAVRSAV['predictedValueOfNewAction'] - currentSAVRSAV['predictedValueOfAction'])\\n\\t\\t\\ttrainingTuples.append((currentSAVRSAV['state'],currentSAVRSAV['action'],value))\\n\\t\\t\\tself.currentSAVRSAVIndex += 1\\n\\t\\treturn self.neuralNet.train(trainingTuples)\",\n \"def train(self, iterations: int):\\n\\n s = \\\"{:3d} reward {:6.2f}/{:6.2f}/{:6.2f} len {:6.2f} epsilon {:1.3f} {}\\\"\\n s_check = \\\"{:3d} reward {:6.2f}/{:6.2f}/{:6.2f} len {:6.2f} epsilon {:1.3f} saved {} \\\"\\n total_steps = 0\\n iter_metrics = []\\n for n in range(iterations):\\n r_min, r_mean, r_max, iter_steps = self.train_iter()\\n iter_metrics.append((r_min, r_mean, r_max))\\n total_steps += iter_steps\\n\\n if n == int(iterations / 2):\\n self.steps_to_update_target_model = int(self.steps_to_update_target_model / 2)\\n\\n # checkpointing & logging\\n s_print = s\\n file_name = \\\"\\\"\\n if n % self.checkpoint_freq == 0:\\n file_name = f'my_dqn_{n}.pth'\\n torch.save(self.target_dqn.state_dict(), os.path.join(self.checkpoint_path, file_name))\\n s_print = s_check\\n\\n if self.verbose:\\n print(s_print.format(\\n n + 1,\\n r_min,\\n r_mean,\\n r_max,\\n total_steps,\\n self.e_greedy,\\n file_name\\n ))\\n iter_min = np.mean([x[0] for x in iter_metrics])\\n iter_mean = np.mean([x[1] for x in iter_metrics])\\n iter_max = np.mean([x[2] for x in iter_metrics])\\n return iter_min, iter_mean, iter_max\",\n \"def learning_curve(dataframe:object, analysis_type:str, loss_skip_15pct:bool=False):\\n\\n\\t\\t# Spline seems to crash with too many points.\\n\\t\\tif (dataframe.shape[0] >= 400):\\n\\t\\t\\tline_shape = 'linear'\\n\\t\\telif (dataframe.shape[0] < 400):\\n\\t\\t\\tline_shape = 'spline'\\n\\n\\t\\tdf_loss = dataframe[['loss','val_loss']]\\n\\t\\tdf_loss = df_loss.rename(columns={\\\"loss\\\": \\\"train_loss\\\", \\\"val_loss\\\": \\\"validation_loss\\\"})\\n\\t\\tdf_loss = df_loss.round(3)\\n\\n\\t\\tif loss_skip_15pct:\\n\\t\\t\\tdf_loss = df_loss.tail(round(df_loss.shape[0]*.85))\\n\\n\\t\\tfig_loss = px.line(\\n\\t\\t\\tdf_loss\\n\\t\\t\\t, title = '<i>Training History: Loss</i>'\\n\\t\\t\\t, line_shape = line_shape\\n\\t\\t)\\n\\t\\tfig_loss.update_layout(\\n\\t\\t\\txaxis_title = \\\"Epochs\\\"\\n\\t\\t\\t, yaxis_title = \\\"Loss\\\"\\n\\t\\t\\t, legend_title = None\\n\\t\\t\\t, font_family = \\\"Avenir\\\"\\n\\t\\t\\t, font_color = \\\"#FAFAFA\\\"\\n\\t\\t\\t, plot_bgcolor = \\\"#181B1E\\\"\\n\\t\\t\\t, paper_bgcolor = \\\"#181B1E\\\"\\n\\t\\t\\t, height = 400\\n\\t\\t\\t, hoverlabel = dict(\\n\\t\\t\\t\\tbgcolor = \\\"#0F0F0F\\\"\\n\\t\\t\\t\\t, font_size = 15\\n\\t\\t\\t\\t, font_family = \\\"Avenir\\\"\\n\\t\\t\\t)\\n\\t\\t\\t, yaxis = dict(\\n\\t\\t\\t\\tside = \\\"right\\\"\\n\\t\\t\\t\\t, tickmode = 'auto'# When loss is initially high, the 0.1 tickmarks are overwhelming.\\n\\t\\t\\t\\t, tick0 = -1\\n\\t\\t\\t\\t, nticks = 9\\n\\t\\t\\t)\\n\\t\\t\\t, legend = dict(\\n\\t\\t\\t\\torientation=\\\"h\\\"\\n\\t\\t\\t\\t, yanchor=\\\"bottom\\\"\\n\\t\\t\\t\\t, y=1.02\\n\\t\\t\\t\\t, xanchor=\\\"right\\\"\\n\\t\\t\\t\\t, x=1\\n\\t\\t\\t)\\n\\t\\t\\t, margin = dict(\\n\\t\\t\\t\\tt = 5\\n\\t\\t\\t\\t, b = 0\\n\\t\\t\\t),\\n\\t\\t)\\n\\t\\tfig_loss.update_xaxes(zeroline=False, gridcolor='#262B2F', tickfont=dict(color='#818487'))\\n\\t\\tfig_loss.update_yaxes(zeroline=False, gridcolor='#262B2F', tickfont=dict(color='#818487'))\\n\\n\\t\\tif (\\\"classification\\\" in analysis_type):\\n\\t\\t\\tdf_acc = dataframe[['accuracy', 'val_accuracy']]\\n\\t\\t\\tdf_acc = df_acc.rename(columns={\\\"accuracy\\\": \\\"train_accuracy\\\", \\\"val_accuracy\\\": \\\"validation_accuracy\\\"})\\n\\t\\t\\tdf_acc = df_acc.round(3)\\n\\n\\t\\t\\tfig_acc = px.line(\\n\\t\\t\\tdf_acc\\n\\t\\t\\t\\t, title = '<i>Training History: Accuracy</i>'\\n\\t\\t\\t\\t, line_shape = line_shape\\n\\t\\t\\t)\\n\\t\\t\\tfig_acc.update_layout(\\n\\t\\t\\t\\txaxis_title = \\\"epochs\\\"\\n\\t\\t\\t\\t, yaxis_title = \\\"accuracy\\\"\\n\\t\\t\\t\\t, legend_title = None\\n\\t\\t\\t\\t, font_family = \\\"Avenir\\\"\\n\\t\\t\\t\\t, font_color = \\\"#FAFAFA\\\"\\n\\t\\t\\t\\t, plot_bgcolor = \\\"#181B1E\\\"\\n\\t\\t\\t\\t, paper_bgcolor = \\\"#181B1E\\\"\\n\\t\\t\\t\\t, height = 400\\n\\t\\t\\t\\t, hoverlabel = dict(\\n\\t\\t\\t\\t\\tbgcolor = \\\"#0F0F0F\\\"\\n\\t\\t\\t\\t\\t, font_size = 15\\n\\t\\t\\t\\t\\t, font_family = \\\"Avenir\\\"\\n\\t\\t\\t\\t)\\n\\t\\t\\t\\t, yaxis = dict(\\n\\t\\t\\t\\tside = \\\"right\\\"\\n\\t\\t\\t\\t, tickmode = 'linear'\\n\\t\\t\\t\\t, tick0 = 0.0\\n\\t\\t\\t\\t, dtick = 0.05\\n\\t\\t\\t\\t)\\n\\t\\t\\t\\t, legend = dict(\\n\\t\\t\\t\\t\\torientation=\\\"h\\\"\\n\\t\\t\\t\\t\\t, yanchor=\\\"bottom\\\"\\n\\t\\t\\t\\t\\t, y=1.02\\n\\t\\t\\t\\t\\t, xanchor=\\\"right\\\"\\n\\t\\t\\t\\t\\t, x=1\\n\\t\\t\\t\\t)\\n\\t\\t\\t\\t, margin = dict(\\n\\t\\t\\t\\t\\tt = 5\\n\\t\\t\\t\\t),\\n\\t\\t\\t)\\n\\t\\t\\tfig_acc.update_xaxes(zeroline=False, gridcolor='#262B2F', tickfont=dict(color='#818487'))\\n\\t\\t\\tfig_acc.update_yaxes(zeroline=False, gridcolor='#262B2F', tickfont=dict(color='#818487'))\\n\\t\\t\\tfig_acc.show()\\n\\t\\tfig_loss.show()\",\n \"def learn(self):\\r\\n \\r\\n # take a mini-batch from replay experience\\r\\n cur_batch_size = min(len(self.replay_exp), self.batch_size)\\r\\n mini_batch = random.sample(self.replay_exp, cur_batch_size)\\r\\n \\r\\n # batch data\\r\\n sample_states = np.ndarray(shape = (cur_batch_size, self.state_size)) # replace 128 with cur_batch_size\\r\\n sample_actions = np.ndarray(shape = (cur_batch_size, 1))\\r\\n sample_rewards = np.ndarray(shape = (cur_batch_size, 1))\\r\\n sample_next_states = np.ndarray(shape = (cur_batch_size, self.state_size))\\r\\n sample_dones = np.ndarray(shape = (cur_batch_size, 1))\\r\\n\\r\\n temp=0\\r\\n for exp in mini_batch:\\r\\n sample_states[temp] = exp[0]\\r\\n sample_actions[temp] = exp[1]\\r\\n sample_rewards[temp] = exp[2]\\r\\n sample_next_states[temp] = exp[3]\\r\\n sample_dones[temp] = exp[4]\\r\\n temp += 1\\r\\n \\r\\n \\r\\n sample_qhat_next = self.brain_target.predict(sample_next_states)\\r\\n \\r\\n # set all Q values terminal states to 0\\r\\n sample_qhat_next = sample_qhat_next * (np.ones(shape = sample_dones.shape) - sample_dones)\\r\\n # choose max action for each state\\r\\n sample_qhat_next = np.max(sample_qhat_next, axis=1)\\r\\n \\r\\n sample_qhat = self.brain_policy.predict(sample_states)\\r\\n \\r\\n for i in range(cur_batch_size):\\r\\n a = sample_actions[i,0]\\r\\n sample_qhat[i,int(a)] = sample_rewards[i] + self.gamma * sample_qhat_next[i]\\r\\n \\r\\n q_target = sample_qhat\\r\\n \\r\\n self.brain_policy.fit(sample_states, q_target, epochs = 1, verbose = 0)\\r\\n \\r\\n \\r\\n \\r\\n \\\"\\\"\\\"\\r\\n \\r\\n for state, action, reward, next_state, done in mini_batch:\\r\\n target_Q_s_a = 0 # new target for Q(s,a)\\r\\n state = np.reshape(state, [1, state_size])\\r\\n next_state = np.reshape(next_state, [1, state_size])\\r\\n \\r\\n # if it is not the terminal state\\r\\n if not done:\\r\\n qhat_next = self.brain_target.predict(next_state) # estimate Q(s',a')\\r\\n target_Q_s_a = reward + self.gamma * np.amax(qhat_next[0]) # because the output is m * n, so we need to consider the dimension [0]\\r\\n else:\\r\\n target_Q_s_a = reward\\r\\n \\r\\n target_output = self.brain_policy.predict(state) # we will replace target of Q(s,a) for specific a later\\r\\n target_output[0][action] = target_Q_s_a # new target for state s and action a\\r\\n \\r\\n self.brain_policy.fit(state, target_output, epochs = 1, verbose = 0)\\r\\n \\r\\n \\\"\\\"\\\"\",\n \"def train( self, trainingData, trainingLabels, validationData, validationLabels ):\\n\\n self.features = trainingData[0].keys() # could be useful later\\n # DO NOT ZERO OUT YOUR WEIGHTS BEFORE STARTING TRAINING, OR\\n # THE AUTOGRADER WILL LIKELY DEDUCT POINTS.\\n for iteration in range(self.max_iterations):\\n #pdb.set_trace() # esto es un break point para que puedas comprobar el formato de los datos\\n print (\\\"Starting iteration \\\", iteration, \\\"...\\\")\\n for i in range(len(trainingData)):#training data\\n max = -10000000\\n for j in range(len(self.weights)):\\n prod = np.dot(self.weights[j], trainingData[i]) #este sería x0 (en la primera vuelta) (xj)\\n if (prod > max):\\n max=prod #en max guardamos la distancia a la instancia que más cerca está de la que estamos recorriendo\\n indclase=j #guardas el índice de la clase a la que predices que pertenece\\n\\n if(indclase != trainingLabels[i]):\\n # recalcular pesos\\n self.weights[trainingLabels[i]].__radd__(trainingData[i]) #honek jarraian egiten du gehiketa pisu guztientzat\\n #pdb.set_trace() # esto es un break point para que puedas comprobar el formato de los datos\\n self.weights[indclase].__sub__(trainingData[i]) #honek jarraian egiten du kenketa pisu guztientzat\\n\\n\\n\\n\\n\\n ########################################################################################\\n # 1. i es el indice de un ejemplo (un item, f(x) de un ejemplo) del conjunto de entrenamiento.\\n # 2. Asi pues, en cada vuelta de este loop se trata un solo ejemplo\\n # por cada ejemplo calculareis el producto punto (dotProduct) w*item\\n # NOTAS: Recordad que cada ejemplo viene representado por varios rasgos (o features), es decir, es un vector de rasgos, tantos como nos marca el atributo self.features.\\n # Asi cada ejemplo es de dimension 1 filas y self.features).\\n # La dimension del vector w tambien es self.features, es decir, habra tantos pesos en w_rasgo dentro de w como rasgos haya en cada item de ejemplo\\n # Recordad tambien que es una clasificacion multiclase en este caso. Hay tantas clases como nos marca el atributo self.legalLabels\\n #########################################################################################\",\n \"def learn(self):\\n raise NotImplementedError\",\n \"def generate(self):\\r\\n \\r\\n components = []\\r\\n components.append(nn.Linear(self.n_features,self.hidden_sizes[0]))\\r\\n self._activation(components,self.activation)\\r\\n self._dropout(components,self.dropout)\\r\\n \\r\\n for i in range(1,len(self.hidden_sizes)):\\r\\n components.append(nn.Linear(self.hidden_sizes[i-1],self.hidden_sizes[i]))\\r\\n self._activation(components,self.activation)\\r\\n self._dropout(components,self.dropout)\\r\\n \\r\\n components.append(nn.Linear(self.hidden_sizes[-1],self.n_classes))\\r\\n\\r\\n mlp = nn.Sequential(*components)\\r\\n \\r\\n num_params = sum(p.numel() for p in mlp.parameters() if p.requires_grad)\\r\\n print(\\\"Created MLP with \\\"+str(num_params)+\\\" learnable params\\\")\\r\\n \\r\\n return mlp\",\n \"def train(epoch, model, loss_fn, optimizer, dataloder,pair_generation_tnf):\\n model.train()\\n train_loss =0\\n for batch_idx, batch in enumerate(tqdm(dataloder, desc='Epoch {}'.format(epoch))):\\n optimizer.zero_grad()\\n #batch = pair_generation_tnf(batch)\\n \\n theta = model(batch)\\n print()\\n loss= loss_fn(theta, batch['theta'])\\n \\n \\n \\n loss.backward()\\n optimizer.step()\\n train_loss += loss.data.cpu().numpy().item()\\n train_loss /= len(dataloader)\\n print('Train set: Average loss: {:.4f}'.format(train_loss))\\n return train_loss\",\n \"def finetune_n_estimators_createData():\\n acc, auc = [], []\\n for i in tqdm([j*10 for j in range(1,31)],desc='Progress(n_estimators)',ncols=70,smoothing=0.5):\\n X_train, X_test, y_train, y_test, X, y_binary = initializing()\\n XGBCla = get_XGBmodel(n_est=i)\\n XGBCla = XGBCla.fit(X_train, y_train)\\n acc.append(accuracy_score(XGBCla.predict(X_test),y_test))\\n auc.append(roc_auc_score(XGBCla.predict(X_test),y_test))\\n np.save(\\\"npy-data/result_n_estimators_tuning_acc_auc_crossval_train\\\",acc+auc)\",\n \"def train(self, game_life):\\n rewards = [obs.get('reward') for obs in game_life]\\n cum_rewards = sum(rewards)\\n\\n # manage the graphics\\n self.reward_graph.append(cum_rewards)\\n plt.plot(self.reward_graph)\\n x, y, z = peri_bounding_box\\n\\n # The amound of nudge\\n if cum_rewards:\\n displacement = cum_rewards * self.displacement\\n else:\\n displacement = 0 - self.displacement\\n\\n # Store observations and perturbed predictions\\n data, targets = [], []\\n\\n for obs in game_life:\\n\\n # Perturb action\\n action, prediction = obs.get('action')\\n if self.epsilon and (random.uniform(0, 1.0) < self.epsilon):\\n action = random.randrange(18)\\n\\n # Copy\\n update = list(prediction)\\n\\n # Update only the target action\\n update[0][action] = update[0][action] + displacement\\n\\n\\n data.append(\\n # Apply bounding box before appending\\n np.array(obs.get('observation')[x[0]:x[1], y[0]:y[1], :])\\n )\\n\\n\\n update = np.array(update).reshape(1,18),\\n targets.append(update)\\n\\n if data and len(data) > 15:\\n # Image processing\\n datagen = preprocessing.image.ImageDataGenerator(\\n featurewise_center=True,\\n featurewise_std_normalization=True,\\n rotation_range=20,\\n width_shift_range=0.2,\\n height_shift_range=0.2,\\n horizontal_flip=True)\\n datagen.fit(data)\\n\\n # Training data generator\\n train = datagen.flow(np.array(data), np.squeeze(np.array(targets)),\\n batch_size=16)\\n\\n # Finally train\\n self.graph.fit_generator(train, steps_per_epoch=len(data)/16,\\n epochs=30, verbose=0,\\n callbacks=[\\n callbacks.EarlyStopping(monitor='acc'),\\n # callbacks.ModelCheckpoint() ?\\n ]\\n )\",\n \"def train():\\n pass\",\n \"def plot_learning_curve(self, estimators, title, labels, colors, X, y, \\n ylim=None, cv=None, n_jobs=1, train_sizes=np.linspace(.1, 1.0, 10)):\\n plt.figure(figsize = (6,8))\\n plt.title(title)\\n if ylim is not None:\\n plt.ylim(*ylim)\\n plt.xlabel(\\\"Training examples\\\")\\n plt.ylabel(\\\"Accuracy\\\")\\n for i in range(len(estimators)): \\n estimator = estimators[i]\\n line_label = labels[i]\\n line_color = colors[i]\\n train_sizes, train_scores, test_scores = learning_curve(\\n estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes)\\n train_scores_mean = np.mean(train_scores, axis=1)\\n train_scores_std = np.std(train_scores, axis=1)\\n test_scores_mean = np.mean(test_scores, axis=1)\\n test_scores_std = np.std(test_scores, axis=1)\\n\\n plt.fill_between(train_sizes, train_scores_mean - train_scores_std,\\n train_scores_mean + train_scores_std, alpha=0.1,\\n color=line_color[0])\\n plt.fill_between(train_sizes, test_scores_mean - test_scores_std,\\n test_scores_mean + test_scores_std, alpha=0.1, color=line_color[1])\\n plt.plot(train_sizes, train_scores_mean, \\\"o-\\\", color=line_color[0],\\n label=line_label[0])#\\\"Training accuracy\\\"\\n plt.plot(train_sizes, test_scores_mean, \\\"o-\\\", color=line_color[1],\\n label=line_label[1]) #\\\"Cross-validation accuracy\\\"\\n\\n plt.grid() \\n plt.legend(bbox_to_anchor=(0., 1.05, 1., .105),loc=3, mode=\\\"expand\\\",\\n borderaxespad=0.)\\n plt.savefig(\\\"../Figures/\\\" + title + \\\".png\\\", bbox_inches=\\\"tight\\\")\\n return plt\",\n \"def train (self, data, targets, epochs = 100, etaDataLayer = 0.2, etaHiddenLayer = 0.2, hiddenLayers = 1, hiddenNeurons = 200, dataWeightsLimit = 0.05, hiddenWeightsLimit = 0.5, regression = True, backPropagate = False, verbose = False):\\n\\t\\tself.data[\\\"input\\\"] \\t\\t= numpy.array(data)\\n\\t\\tself.data[\\\"rows\\\"] \\t\\t= len(data)\\n\\t\\tself.data[\\\"cols\\\"] \\t\\t= len(data[0])\\n\\t\\tself.targets \\t\\t\\t= targets\\n\\t\\tself.classCount \\t\\t= len(set(targets))\\n\\t\\tself.epochs \\t\\t\\t= epochs\\n\\t\\tself.etaDataLayer \\t\\t= float(etaDataLayer)\\n\\t\\tself.etaHiddenLayer \\t= float(etaHiddenLayer)\\n\\t\\tself.hiddenLayers \\t\\t= hiddenLayers\\n\\t\\tself.hiddenNeurons \\t\\t= hiddenNeurons\\n\\t\\tself.dataWeightsLimit \\t= float(dataWeightsLimit)\\n\\t\\tself.hiddenWeightsLimit\\t= float(hiddenWeightsLimit)\\n\\t\\tself.regression \\t\\t= regression\\n\\t\\tself.backPropagate \\t\\t= backPropagate\\n\\t\\tself.verbose \\t\\t\\t= verbose\\n\\t\\tself.report \\t\\t\\t= {}\\n\\t\\tself.report[\\\"total\\\"] \\t= self.epochs * len(data)\\n\\t\\tself.dataWeights \\t\\t= self.dataWeightsLimit * numpy.random.random_sample((self.data[\\\"cols\\\"], self.hiddenNeurons))\\n\\t\\tself.hiddenWeights \\t\\t= self.hiddenWeightsLimit * numpy.random.random_sample((self.hiddenNeurons + 1, 1))\\n\\t\\tprint \\\"========================================\\\"\\n\\t\\tprint \\\"--- Training . . . ---------------------\\\"\\n\\t\\tprint \\\"========================================\\\"\\n\\t\\tfor epoch in range(self.epochs):\\n\\t\\t\\thits \\t\\t\\t\\t= 0\\n\\t\\t\\tmisses \\t\\t\\t\\t= 0\\n\\t\\t\\tprocessed \\t\\t\\t= 0\\n\\t\\t\\tdistances \\t\\t\\t= []\\n\\t\\t\\tpredictedClass \\t\\t= None\\n\\t\\t\\tsampleIndices \\t\\t= sorted(range(len(self.data[\\\"input\\\"])), key = lambda k: random.random())\\n\\t\\t\\tif self.verbose == True:\\n\\t\\t\\t\\tprint \\\"----------------------------------------\\\"\\n\\t\\t\\t\\tprint \\\"--- Epoch\\\", epoch\\n\\t\\t\\t\\tprint \\\"----------------------------------------\\\"\\n\\t\\t\\tfor sampleIndex in sampleIndices:\\n\\t\\t\\t\\tprint self.dataWeights\\n\\t\\t\\t\\tsample \\t\\t\\t= self.data[\\\"input\\\"][sampleIndex]\\n\\t\\t\\t\\ttarget \\t\\t\\t= self.targets[sampleIndex]\\n\\t\\t\\t\\tif self.verbose == True:\\n\\t\\t\\t\\t\\tprint \\\"--- Feeding Forward . . . --------------\\\"\\n\\t\\t\\t\\t\\tprint \\\" Sample\\\", sampleIndex + 1, \\\"of Epoch\\\", epoch + 1\\n\\t\\t\\t\\t# Forward Propagation\\n\\t\\t\\t\\ta \\t\\t\\t\\t= 1.0 / (1.0 + numpy.exp(- numpy.dot(sample, self.dataWeights)))\\n\\t\\t\\t\\tb \\t\\t\\t\\t= numpy.concatenate([[1], a])\\n\\t\\t\\t\\toutput \\t\\t\\t= 1.0 / (1.0 + numpy.exp(- numpy.dot(b, self.hiddenWeights)))[0]\\n\\t\\t\\t\\t# Metric Computation & Communication\\n\\t\\t\\t\\tif self.regression == False:\\n\\t\\t\\t\\t\\terror \\t\\t\\t= 0.5 * (((target / (self.classCount - 1)) - output) ** 2)\\n\\t\\t\\t\\t\\tdistance \\t\\t= abs(target - (output * (self.classCount - 1)))\\n\\t\\t\\t\\t\\tpredictedClass \\t= round(self.classCount * output) - 1\\n\\t\\t\\t\\t\\tif predictedClass == target:\\n\\t\\t\\t\\t\\t\\thits += 1\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tmisses += 1\\n\\t\\t\\t\\t\\tif self.verbose == True:\\n\\t\\t\\t\\t\\t\\tprint \\\" Annotated Class: \\\\t\\\", target\\n\\t\\t\\t\\t\\t\\tprint \\\" Computed Class: \\\\t\\\", predictedClass\\n\\t\\t\\t\\t\\t\\tprint \\\" Computed SSE: \\\\t\\\\t%0.4f\\\" % error\\n\\t\\t\\t\\t\\t\\tprint \\\" Raw Distance: \\\\t\\\\t%0.4f\\\" % distance\\n\\t\\t\\t\\t\\t\\tif predictedClass == target:\\n\\t\\t\\t\\t\\t\\t\\tprint \\\" Prediction Status: \\\\tHit! :)\\\"\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tprint \\\" Prediction Status: \\\\tOops! :(\\\"\\n\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\terror \\t\\t\\t= 0.5 * ((target - output) ** 2)\\n\\t\\t\\t\\t\\tdistance \\t\\t= abs(target - output)\\n\\t\\t\\t\\t\\tif self.verbose == True:\\n\\t\\t\\t\\t\\t\\tprint \\\" Annotated Value: \\\\t\\\", target\\n\\t\\t\\t\\t\\t\\tprint \\\" Computed Value: \\\\t%0.4f\\\" % output\\n\\t\\t\\t\\t\\t\\tprint \\\" Computed SSE: \\\\t\\\\t%0.4f\\\" % error\\n\\t\\t\\t\\t\\t\\tprint \\\" Raw Distance: \\\\t\\\\t%0.4f\\\" % distance\\n\\t\\t\\t\\tprocessed += 1\\n\\t\\t\\t\\tdistances.append(distance)\\n\\t\\t\\t\\t# Back Propagation\\n\\t\\t\\t\\tif self.verbose == True:\\n\\t\\t\\t\\t\\tprint \\\"--- Back Propagating . . . -------------\\\"\\n\\t\\t\\t\\tdeltaDataWeights \\t= ((target / self.classCount - 1) - output) * output * (1 - output)\\n\\t\\t\\t\\tdeltaHiddenWeights \\t= numpy.delete((b * (1 - b) * self.hiddenWeights * deltaDataWeights)[0], 0.0)\\n\\t\\t\\t\\tupdateHiddenWeights = etaHiddenLayer * b * deltaDataWeights\\n\\t\\t\\t\\tupdatedHiddenLayer \\t= b + updateHiddenWeights\\n\\t\\t\\t\\tself.hiddenWeights \\t= numpy.transpose(numpy.atleast_2d(updatedHiddenLayer))\\n\\t\\t\\t\\tupdateDataWeights \\t= etaDataLayer * numpy.outer(sample, deltaHiddenWeights)\\n\\t\\t\\t\\tself.dataWeights \\t= self.dataWeights + updateDataWeights\\n\\t\\t\\t\\tprint self.dataWeights\\n\\t\\t\\t\\tif self.verbose == True:\\n\\t\\t\\t\\t\\tprint \\\"--- Sample Processed -------------------\\\\n\\\"\\n\\n\\t\\t\\t\\t# updateDataWeights \\t= etaDataLayer * numpy.array(sample) * deltaHiddenWeights\\n\\n\\t\\t\\t\\t# # Multiple Hidden Layer Routine\\n\\t\\t\\t\\t# for hiddenLayer in range(hiddenLayers):\\n\\t\\t\\tif self.verbose == True:\\n\\t\\t\\t\\tprint \\\"----------------------------------------\\\"\\n\\t\\t\\t\\tprint \\\"--- Epoch\\\", epoch, \\\"Complete\\\"\\n\\t\\t\\t\\tprint \\\"----------------------------------------\\\"\\n\\t\\t\\t\\tif self.regression == False:\\n\\t\\t\\t\\t\\taccuracy \\t\\t= (hits/processed) * 100\\n\\t\\t\\t\\t\\tprint \\\" \\tEpoch Hits / Total:\\\\t\\\", hits, \\\"/\\\", processed\\n\\t\\t\\t\\t\\tprint \\\" \\tEpoch Hit Percent:\\\\t%0.2f\\\" % (float(hits) / processed * 100), \\\"\\\\n\\\"\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tprint \\\"\\\\n\\\"\\n\\t\\tprint \\\"========================================\\\"\\n\\t\\tprint \\\"--- Training Complete ------------------\\\"\\n\\t\\tprint \\\"========================================\\\"\",\n \"def Q_learning_test(env,alpha,gamma,episodes, q_table):\\n %time\\n \\n # For plotting metrics\\n all_epochs = []\\n all_penalties = []\\n rewards = []\\n \\n total_reward = 0\\n \\n for i in range(1, episodes+1):\\n state = env.reset()\\n episode_rewards = []\\n\\n epochs, penalties, reward, = 0, 0, 0\\n done = False\\n\\n while not done:\\n \\n action = np.argmax(q_table[state]) # Exploit learned values by choosing optimal values\\n next_state, reward, done, info = env.step(action) \\n\\n\\n if reward == -10:\\n penalties += 1\\n \\n state = next_state\\n episode_rewards.append(reward)\\n epochs += 1\\n \\n if done == True:\\n break \\n if epochs == 1000:\\n break \\n \\n total_reward += reward\\n rewards.append(np.sum(episode_rewards))\\n \\n if i % 1000 == 0:\\n clear_output(wait=True)\\n print(f\\\"Episode: {i}\\\")\\n\\n \\n print(\\\"Training finished.\\\\n\\\")\\n \\n \\n plt.plot(savgol_filter(rewards, 1001, 3, mode = \\\"interp\\\"))\\n plt.title(\\\"Smoothened testing reward per episode\\\", pad = 30 , size = BIGGER_SIZE)\\n plt.xlabel('Episodes', labelpad = 20);\\n plt.ylabel('Total Reward', labelpad = 20);\\n plt.tick_params(axis='both', which='major', labelsize=16);\\n plt.tick_params(axis='both', which='minor', labelsize=16);\\n #plt.xlim(100000, 200000);\\n #plt.ylim(0,50)\\n # plt.xticks(np.arange(0, episodes+1, 5000));\\n # plt.yticks(np.arange(min(rewards), max(rewards)+1, 1000));\",\n \"def part_1(l, m, n, size, noise):\\n # initilize variables\\n (y, x) = gen(l, m, n, size, noise)\\n samples, loops, R = size / 10, 20, None\\n lrs = [1.5, 0.25, 0.03, 0.005, 0.001]\\n alphas = [1.1, 1.01, 1.005, 1.0005, 1.0001]\\n gammas = [2.0, 0.3, 0.04, 0.006, 0.001]\\n \\n # divide dataset: 10% - training, 10% - test.\\n left, right = random.sample(range(10),2)\\n x_train, x_test = x[left*samples:(left+1)*samples], x[right*samples:(right+1)*samples]\\n y_train, y_test = y[left*samples:(left+1)*samples], y[right*samples:(right+1)*samples]\\n \\n # build online learning algorithms\\n perceptron = Perceptron(R, x_train, x_test, y_train, y_test, n, samples, size)\\n perceptron_margin = Perceptron_Margin(R, x, x_train, x_test, y, y_train, y_test, n, samples, size, loops, lrs)\\n winnon = Winnon(R, x, x_train, x_test, y, y_train, y_test, n, samples, size, loops, alphas)\\n winnon_margin = Winnon_Margin(R, x, x_train, x_test, y, y_train, y_test, n, samples, size, loops, alphas, gammas)\\n adagrad = AdaGrad(R, x, x_train, x_test, y, y_train, y_test, n, samples, size, loops, lrs)\\n \\n # draw plots\\n draw_1(size, l, m, n, perceptron.error, perceptron_margin.error, winnon.error, winnon_margin.error, adagrad.error)\",\n \"def createModel(data, eta, epoch, file_name, plot_name, no_of_input=2):\\n logging.info(f\\\"\\\\n\\\\n>>>>>>>>>>Starting training>>>>>>>>>>>>>>>>{file_name}\\\")\\n logging.info(f\\\"eta = {str(eta)} epochs ={str(epoch)}\\\\n\\\")\\n\\n df = pd.DataFrame(data)\\n\\n X,y = prepare_data(df)\\n logging.info(f\\\"X={X}\\\")\\n logging.info(f\\\"Y={y}\\\") \\n\\n model = Perceptron(eta, epoch, no_of_input)\\n\\n model.fit(X, y)\\n\\n model.predict(X)\\n\\n model.total_loss()\\n\\n save_model(model, file_name)\\n\\n \\n logging.info(f\\\">>>>>>>>>>>>>>>>>>>>>>>>>>>>>\\\")\\n\\n if no_of_input == 2:\\n save_plot(df, plot_name, model)\",\n \"def Q_learning_train(env,alpha,gamma,epsilon,episodes):\\n %time\\n # For plotting metrics\\n all_epochs = []\\n all_penalties = []\\n rewards = []\\n \\n #Initialize Q table of 22500 x 8 size (22500 states and 8 actions) with all zeroes\\n q_table = np.zeros([env.observation_space.n, env.action_space.n]) \\n \\n for i in range(1, episodes+1):\\n state = env.reset()\\n episode_rewards = []\\n\\n epochs, penalties, reward, = 0, 0, 0\\n done = False\\n\\n while not done:\\n if random.uniform(0, 1) < epsilon:\\n action = env.action_space.sample() # Explore action space randomly\\n else:\\n action = np.argmax(q_table[state]) # Exploit learned values by choosing optimal values\\n\\n next_state, reward, done, info = env.step(action) \\n\\n old_value = q_table[state, action]\\n next_max = np.max(q_table[next_state])\\n\\n new_value = (1 - alpha) * old_value + alpha * (reward + gamma * next_max)\\n q_table[state, action] = new_value\\n\\n if reward == -10:\\n penalties += 1\\n \\n\\n state = next_state\\n episode_rewards.append(reward)\\n epochs += 1\\n \\n if done == True:\\n break \\n if epochs == 1000:\\n break \\n rewards.append(np.sum(episode_rewards))\\n \\n if i % 1000 == 0:\\n clear_output(wait=True)\\n print(f\\\"Episode: {i}\\\")\\n \\n \\n print(\\\"Training finished.\\\\n\\\")\\n \\n plt.plot(savgol_filter(rewards, 1001, 3, mode = \\\"interp\\\"))\\n plt.title(\\\"Smoothened training reward per episode\\\", pad = 30, size = BIGGER_SIZE)\\n plt.legend()\\n plt.xlabel('Episodes', labelpad = 20);\\n plt.ylabel('Total Reward', labelpad = 20);\\n plt.tick_params(axis='both', which='major');\\n plt.tick_params(axis='both', which='minor');\\n #plt.xlim(0, 60000);\\n #plt.ylim(0,50)\\n #plt.xticks(np.arange(0, episodes+1, 5000));\\n #plt.yticks(np.arange(min(rewards), max(rewards)+1, 1000));\",\n \"def generate(self):\\n self.training_data.gen_x(self.x_func)\\n self.training_data.gen_a(self.a_func)\\n self.training_data.gen_y(self.y_func)\\n \\n self.testing_data.gen_x(self.x_func)\\n self.testing_data.gen_ys(self.y_func)\\n self.testing_data.gen_azero(self.ytotal_func)\",\n \"def __init__(\\n self,\\n n = 2,\\n learning_rate = 0.0001,\\n early_stop = 1e-4,\\n steps = 100000,\\n ):\\n self.n = n\\n self.learning_rate = learning_rate\\n self.early_stop = early_stop\\n self.steps = steps\\n self.coefficients = self.random_coefficients(n)\\n self.loss = np.array([])\\n self.x_values = np.array([])\\n self.y_values = np.array([])\\n self.old_loss = 0\",\n \"def train(self, X, y, batch_size=8, learning_rate=1, n_steps=100):\\n self.training_w = np.zeros((n_steps, self.n_in+1))\\n self.training_loss = np.zeros(n_steps)\\n for s in tqdm(range(n_steps)):\\n # draw a random batch\\n batch_idx = np.random.choice(X.shape[0], batch_size, replace=False)\\n # compute and store mean loss\\n self.training_loss[s] = np.mean(self.loss(y[batch_idx], self.predict(X[batch_idx])))\\n # store current weights\\n self.training_w[s,:self.n_in] = self.w\\n self.training_w[s,-1] = self.b\\n # perform a gradient descent step\\n self.gradient_descent_step(X[batch_idx], y[batch_idx], learning_rate)\",\n \"def learn_offline(self, dataset, sparsity_coeff, learning_rate,\\n max_steps, base_norm_coeff, precision):\\n # The list of all data processed per layer devided for sublayer \\n # input_data[sublayer][actual_recording][events, timestamp if 0 or xy coordinates if 1]\\n input_data = []\\n # In the first layer the input_data is the input dataset given by the user\\n input_data.append(dataset)\\n \\n for layer in range(self.layers):\\n # now let's generate the surfaces and train the layers\\n single_layer_surfaces = []\\n single_layer_errors = []\\n # The result of a single layer learning that will serve as input for the \\n # next one\\n outrecordings = []\\n for sublayer in range(len(self.basis[layer])):\\n sub_layer_surfaces = []\\n sub_layer_errors = []\\n sub_layer_outevents_on = []\\n sub_layer_outevents_off = []\\n # A single array containing all the generated surfaces \\n # for a single sublayer used for full offline learning \\n all_surfaces = []\\n all_reference_events = []\\n # Generate and allocate plots for online plotting\\n if self.verbose is True:\\n plot_names = []\\n # Building a list to contain the basis at each run\\n for i in range(len(self.basis[layer][sublayer])):\\n plot_names.append(\\\"Base N: \\\"+str(i))\\n live_figures, live_axes = surface_live_plot(surfaces=self.basis[layer][sublayer], fig_names=plot_names)\\n for recording in range(len(input_data[sublayer])):\\n recording_surfaces = []\\n for k in range(len(input_data[sublayer][recording][0])):\\n single_event = [input_data[sublayer][recording][0][k], input_data[sublayer][recording][1][k]]\\n tsurface = Time_Surface_event(xdim = self.surfaces_dimensions[layer][0],\\n ydim = self.surfaces_dimensions[layer][1],\\n event=single_event,\\n timecoeff=self.taus[layer],\\n dataset=input_data[sublayer][recording],\\n num_polarities=self.polarities[layer],\\n verbose=False)\\n recording_surfaces.append(tsurface)\\n # A single array containing all the generated surfaces \\n # for a single sublayer used for full recording learning\\n all_surfaces.append(tsurface) \\n all_reference_events.append(single_event)\\n sub_layer_surfaces.append(recording_surfaces)\\n \\n # Learning time\\n n_steps = 0 \\n previous_err = 0\\n err = precision + 1\\n while (abs(err-previous_err)>precision) & (n_steps<max_steps):\\n #Let's compute the activations\\n sub_layer_activations = []\\n for i in range(len(all_surfaces)):\\n self.sublayer_response_CG(layer, sublayer, all_surfaces[i], sparsity_coeff, 0)\\n sub_layer_activations.append(self.activations[layer][sublayer].copy()) \\n #Let's compute the basis\\n opt_res = update_basis_offline_CG(self.basis[layer][sublayer],\\n self.surfaces_dimensions[layer][0]*self.polarities[layer],\\n self.surfaces_dimensions[layer][1], \\n self.features_number[layer], sub_layer_activations,\\n all_surfaces, base_norm_coeff)\\n \\n self.basis[layer][sublayer] = opt_res.x.reshape(self.features_number[layer],\\n self.surfaces_dimensions[layer][1], self.surfaces_dimensions[layer][0]*self.polarities[layer])\\n sub_layer_errors.append(opt_res.fun)\\n n_steps += 1\\n previous_err = err\\n err = sub_layer_errors[-1]\\n # Update plots\\n if self.verbose is True: \\n live_figures, live_axes = surface_live_plot(surfaces=self.basis[layer][sublayer], figures=live_figures, axes=live_axes)\\n print(\\\"Layer:\\\"+np.str(layer)+\\\" Sublayer:\\\"+np.str(sublayer)+\\\" Base optimization process:\\\"+np.str((n_steps/max_steps)*100)+\\\"%\\\")\\n if (n_steps<max_steps):\\n print(\\\"Execution stopped, requested precision reached\\\")\\n else:\\n print(\\\"Maximum number of step reached, last delta error was :\\\" + np.str(abs(err-previous_err)))\\n \\n #Let's compute again the activations after defining the set of basis\\n sub_layer_activations = []\\n for i in range(len(all_surfaces)):\\n self.sublayer_response_CG(layer, sublayer, all_surfaces[i], sparsity_coeff, 0)\\n sub_layer_activations.append(self.activations[layer][sublayer].copy()) \\n # sub_layer_activations contains all the activations to all the time surfaces\\n # of different recordings, in order to build the next layer input data \\n # I need to redefine the original ordering of the data\\n current_position = 0\\n for recording in range(len(input_data[sublayer])):\\n current_recording_length = len(input_data[sublayer][recording][0]) \\n # Obtaining the events resulting from the activations in a single recording\\n outevents = events_from_activations(sub_layer_activations[current_position:(current_position+current_recording_length)],\\n all_reference_events[current_position:(current_position+current_recording_length)],\\n self.delay_coeff)\\n sub_layer_outevents_on.append(outevents[0])\\n sub_layer_outevents_off.append(outevents[1])\\n current_position += current_recording_length\\n \\n single_layer_surfaces.append(sub_layer_surfaces)\\n single_layer_errors.append(sub_layer_errors)\\n # Saving each sub layer events deviding between negative and positive\\n # activations, they will be used to optimize the consequent of \\n # sublayers in the next layer\\n outrecordings.append(sub_layer_outevents_on) \\n outrecordings.append(sub_layer_outevents_off)\\n # Close plots before displaying next set of basis\\n if self.verbose is True:\\n for i in range(len(live_figures)):\\n plt.close(fig=live_figures[i])\\n live_axes.clear()\\n live_figures.clear()\\n input_data = outrecordings.copy()\\n self.surfaces.append(single_layer_surfaces)\\n self.errors.append(single_layer_errors)\",\n \"def train(self, adata, num_epochs = 2000, batch_size = 64, val_split = 0.1, lr = 1e-03, decay_factor = 1/3,\\n patience_LR = 3, patience_ES = 9):\\n \\n tf.keras.backend.clear_session()\\n \\n loss = NBloss\\n \\n dataset = self.makegenerators(adata, val_split = 0.1, batch_size = batch_size, splitseed = self.splitseed)\\n \\n counter_LR = 0\\n counter_ES = 0\\n best_loss = np.inf\\n \\n self.optimizer.lr = lr\\n \\n total_start = time()\\n \\n for epoch in range(num_epochs):\\n epoch_start = time()\\n \\n epoch_loss_avg = tf.keras.metrics.Mean()\\n epoch_loss_avg_val = tf.keras.metrics.Mean()\\n \\n # Training loop - using batches of batch_size\\n for x, target in dataset(val = False):\\n loss_value, grads = grad(self, x, target, loss)\\n self.optimizer.apply_gradients(zip(grads, self.trainable_variables))\\n epoch_loss_avg(loss_value) # Add current batch loss\\n \\n # Validation Loop\\n for x, target in dataset(val = True):\\n output = self(*x)\\n loss_value = loss(target, output)\\n epoch_loss_avg_val(loss_value)\\n \\n current_loss_val = epoch_loss_avg_val.result()\\n\\n epoch_time = round(time() - epoch_start, 1)\\n \\n print(\\\"Epoch {:03d}: Training Loss: {:.3f}, Validation Loss: {:.3f}, Time: {:.1f} s\\\".format(epoch, epoch_loss_avg.result().numpy(), epoch_loss_avg_val.result().numpy(), epoch_time))\\n \\n if(current_loss_val + 10**(-3) < best_loss):\\n counter_LR = 0\\n counter_ES = 0\\n best_loss = current_loss_val\\n else:\\n counter_LR = counter_LR + 1\\n counter_ES = counter_ES + 1\\n\\n if patience_ES <= counter_ES:\\n break\\n\\n if patience_LR <= counter_LR:\\n self.optimizer.lr = self.optimizer.lr * decay_factor\\n counter_LR = 0\\n print(\\\"\\\\nDecaying Learning Rate to: \\\" + str(self.optimizer.lr.numpy()))\\n \\n # End epoch\\n \\n total_time = round(time() - total_start, 2)\\n \\n if not os.path.isdir(\\\"./\\\" + self.weights_dir):\\n os.mkdir(\\\"./\\\" + self.weights_dir)\\n \\n self.save_weights(os.path.join(self.weights_dir, \\\"countmodel_weights_\\\" + self.name_), save_format='tf')\\n \\n print('\\\\nTraining Completed')\\n print(\\\"Total training time: \\\" + str(total_time) + \\\" seconds\\\")\",\n \"def __init__(self, hidden_size, num_step=2000, print_interval=100, af=relu, lr=0.1):\\n np.random.seed(3023)\\n self.num_step = num_step\\n self.print_interval = print_interval\\n self.af = af # activation function\\n self.lr = lr # learning rate\\n self.accuracy_box = []\\n\\n # Model parameters initialization\\n # Please initiate your network parameters here.\\n self.hidden1_weights = np.random.randn(2, hidden_size) # The dimension of the dataset is 2, so the initial dimension of the hidden weights is 2 x hidden size\\n self.hidden2_weights = np.random.randn(hidden_size, hidden_size)\\n self.output3_weights = np.random.randn(hidden_size, 1) # output is binary, so the output size is 1\",\n \"def train_naive(): # add arguments as needed\\n pass\",\n \"def train(self, X, y, lr, epoch, method='adam', quit=1e-4):\\n if len(y.shape) == 1:\\n y = y.reshape((-1, 1))\\n if not (0 < lr < 1):\\n raise self.ANNException('learning rate cannot be negative or exceeds 1')\\n if epoch <= 0:\\n raise self.ANNException('epoch must be postitive integer')\\n if method == 'gd':\\n for _ in range(epoch):\\n nodes = self._forward(X)\\n self._backpropagate(y, nodes, lr)\\n elif method == 'adam':\\n alpha = 0.1\\n beta1 = 0.5\\n beta2 = 0.999\\n epsilon = 1e-8\\n mt = np.zeros(shape=self.weight.shape)\\n vt = np.zeros(shape=self.weight.shape)\\n before_err = self._energy(X, y)\\n for t in range(1, epoch+1):\\n nodes = self._forward(X)\\n gt = self._backpropagate(y, nodes, alpha, ret=True)\\n mt = beta1*mt + (1-beta1)*gt\\n vt = beta2*vt + (1-beta2)*gt**2\\n mthat = mt / (1-np.power(beta1, t))\\n vthat = vt / (1-np.power(beta2, t))\\n self.weight -= alpha * mthat/(np.sqrt(vthat)+epsilon)\\n after_err = self._energy(X, y)\\n if 0 < after_err-before_err < quit:\\n return\\n else:\\n before_err = after_err\\n else:\\n raise self.ANNException('only gd and adam optimizer are supported')\",\n \"def SGD(self, X_train, Y_train, X_validation, Y_validation, epochs, mini_batch_size, learning_rate, decay):\\n \\n training_data = zip(X_train, Y_train)\\n validation_data = zip(X_validation, Y_validation)\\n\\n \\n \\\"\\\"\\\"Take the training data and make a list out of it\\\"\\\"\\\"\\n training_data = list(training_data)\\n \\n \\\"\\\"\\\"Check if there is data in the test_data\\\"\\\"\\\"\\n if validation_data:\\n validation_data = list(validation_data)\\n n_validation_data = len(validation_data)\\n \\n \\\"\\\"\\\"\\n Mini-batches: Each mini-batch contains mini_batch_size elements from the training set.\\n \\n Splits the training data into mini-bachtes, and for each mini-batches we train the network. \\n \\n \\\"\\\"\\\" \\n\\n# Updated for the testing\\n# ========================\\n mini_batches = []\\n high_score = [0,0]\\n for j in range(epochs):\\n random.shuffle(training_data)\\n for k in range(0, len(training_data), mini_batch_size):\\n mini_batches.append(training_data[k:k+mini_batch_size])\\n for mini_batch in mini_batches:\\n self.update_mini_batch(mini_batch, learning_rate)\\n if validation_data:\\n new_score = self.evaluate(X_validation, Y_validation)\\n if high_score[0] < new_score:\\n high_score[0] = new_score\\n high_score[1] = j + 1\\n learning_rate = learning_rate * (1-decay)\\n \\n return high_score[0], high_score[1]\\n# ========================\\n\\n\\n \\\"\\\"\\\"\\n Update the network's weights and biases by applying\\n gradient descent using backpropagation to a single mini batch.\\n The ``mini_batch`` is a list of tuples ``(x, y)``, and ``eta``\\n is the learning rate.\\\"\\\"\\\"\",\n \"def train():\\n # YOUR TRAINING CODE GOES HERE\",\n \"def fit(self, w):\\n w_former = w\\n w_next = w\\n w_t = w\\n w_t_100 = w\\n w_diff = 10000\\n i = 0\\n #tim_beg = t.time()\\n # use two part to calculate the a(w,w0):calculate the gradient using regular or SDG, batch = 10\\n # calculate the gradient and update the w,w0\\n while i < 10000 and np.abs(w_diff) > 0.00001:\\n loss_func = self.lost\\n grads = self.gradient(loss_func)\\n # calculate the y_pred(eta)\\n w_next = w_former - grads(w_former) / (10000)\\n k =self.lost(w_next) - self.lost(w_former)\\n m = np.dot(w_next-w_former, grads(w_former).T)\\n if i != 0 and i % 100 == 0:\\n w_t = w_t_100\\n w_t_100 = w_next\\n w_diff = 1 / len(w) * (np.sum(np.abs(w_t_100 - w_t)))\\n i_loss = self.lost(w_next)\\n print(\\\"Iteration < %d > with loss < %f >\\\" % (i, i_loss))\\n #self.los_plt.append(i_loss)\\n #tim = t.time() - tim_beg\\n #self.tim.append(tim)\\n i += 1\\n w_former = w_next\\n #plt.plot(self.tim, self.los_plt)\\n #plt.xlabel(\\\"time\\\")\\n #plt.ylabel('loss')\\n #plt.show()\\n if i >= 10000:\\n print(\\\"~Optimization stops because finishing iteration~\\\")\\n if np.abs(w_diff) <= 0.00001:\\n print(\\\"~Optimization stops because of difference between weights are less than 0.00001~\\\")\\n self.w_result = w_next\",\n \"def train_dynamic(batch_size=10):\\n \\n return\",\n \"def sgd(self, training_data, epochs, batch_size, eta=0.01, lambda_r=0.2, verbose=False, test_data=None):\\n stagnation_epochs = 5\\n eta_divide_factor = 4\\n eta_decrease_available = 4\\n\\n self.accuracies = np.zeros(epochs)\\n self.costs = np.zeros(epochs)\\n self.eta = eta\\n self.lambda_r = lambda_r\\n\\n n = len(training_data)\\n curr_stagnation = stagnation_epochs\\n min_cost = float('inf')\\n\\n for idx, e in enumerate(range(epochs)):\\n np.random.shuffle(training_data)\\n batches = [np.array(training_data[k:k + batch_size], dtype=object)\\n for k in range(0, len(training_data), batch_size)]\\n\\n for batch in batches:\\n self.gradient_descent_step(batch, eta, lambda_r, n)\\n\\n self.costs[idx] = self.cost_func.prediction_cost(self.feed_forward([x_ for x_, y_ in training_data])[2],\\n np.array([y_ for x_, y_ in training_data])) + \\\\\\n self.weights_cost(n, self.lambda_r)\\n\\n if verbose:\\n print('Epoch {} ended with cost {:.3f}'.format(e + 1, self.costs[idx]))\\n\\n min_cost = min(min_cost, self.costs[idx])\\n\\n if idx != 0:\\n curr_stagnation = curr_stagnation - 1 if self.costs[idx] != min_cost else stagnation_epochs\\n\\n if curr_stagnation == 0:\\n curr_stagnation = stagnation_epochs\\n eta /= eta_divide_factor\\n eta_decrease_available -= 1\\n min_cost = float('inf')\\n\\n if eta_decrease_available < 0:\\n if verbose:\\n print('Eta decreased maximum available times, terminating')\\n break\\n\\n if verbose:\\n print('Decreasing eta to {:.5f}'.format(eta))\\n\\n if test_data:\\n self.accuracies[idx] = self.metric.metric_value(self.predict([x_ for x_, y_ in test_data]),\\n [y_ for x_, y_ in test_data])\\n\\n if verbose:\\n self.plot_costs()\\n\\n if test_data:\\n self.plot_metric_values()\",\n \"def run_learning_curve_experiment(X, y, dataset_name, train_ratio=0.7):\\n gkr_cv, tau_opt, s2_opt = pick_optimal_params_using_cv(X, y)\\n K, K_mmd = create_krr_mmd_kernel_matrices(X, s2_opt)\\n n = K.shape[0]\\n train_indices, test_indices = train_test_indices(\\n n, train_ratio=train_ratio)\\n\\n learning_curves_mc_train, learning_curves_mc_test = sample_mc_learning_curves_train_test(\\n K, y, train_indices, test_indices, tau_opt, num_trajectories=10)\\n\\n K_train = K[np.ix_(train_indices, train_indices)]\\n fw = alg.FrankWolfe(K_train)\\n fw.run_frank_wolfe()\\n learning_curve_fw_train, learning_curve_fw_test = calculate_learning_curves_train_test(K, y,\\n train_indices,\\n test_indices,\\n fw.sampled_order,\\n tau_opt)\\n\\n save_dir = 'learning_curves-{}'.format(dataset_name)\\n save_dir = Path(data_experiments_dir) / save_dir\\n print(save_dir)\\n save_dir.mkdir(parents=True, exist_ok=False)\\n\\n # Save all of the learning curves\\n np.save(save_dir / 'learning_curve_fw_train', learning_curve_fw_train)\\n np.save(save_dir / 'learning_curve_fw_test', learning_curve_fw_test)\\n np.save(save_dir / 'learning_curves_mc_train', learning_curves_mc_train)\\n np.save(save_dir / 'learning_curves_mc_test', learning_curves_mc_test)\\n\\n # Save json file of interesting information for this particular run\\n euclidean_dist_q05 = kernel_quantile_heuristic(X, q=0.05)\\n euclidean_dist_q95 = kernel_quantile_heuristic(X, q=0.95)\\n\\n param_config = {\\n 'n': X.shape[0],\\n 'd': X.shape[1],\\n 'tau_opt_KRR': tau_opt,\\n 's2_opt_KRR': s2_opt,\\n 'train_ratio': train_ratio,\\n 'euclidean_dist_q05': euclidean_dist_q05,\\n 'euclidean_dist_q95': euclidean_dist_q95,\\n 'time_created': str(datetime.now().strftime('%Y-%m-%d_%H:%M:%S'))\\n }\\n\\n with open(save_dir / 'experiment_config.json', 'w') as json_file:\\n json.dump(param_config, json_file)\",\n \"def learn(self):\\n\\n for i in range(self.args.n_iters):\\n diff = self.iteration()\\n\\n if diff < self.args.epsilon:\\n self.save(self.save_path, i)\\n break\\n elif (i + 1) % self.args.save_frequency == 0:\\n self.save(self.save_path, i)\",\n \"def show_learning_curve(self):\\n\\n # Loop output classes\\n for c in range(1,self.n_output_classes):\\n # Get data\\n x_values = np.array(self.n_class_samples_list[c])\\n accuracy = np.array(self.accuracy_list[c])\\n precision = np.array(self.precision_list[c])\\n recall = np.array(self.recall_list[c])\\n F1 = np.array(self.F1_list[c])\\n\\n # Make plot\\n with sns.axes_style(\\\"ticks\\\"):\\n fig,ax = plt.subplots()\\n plt.plot([np.min(x_values),np.max(x_values)],[0.5,0.5],\\n color='#777777',linestyle='--')\\n plt.plot([np.min(x_values),np.max(x_values)],[0.66,0.66],\\n color='#777777',linestyle=':')\\n plt.plot([np.min(x_values),np.max(x_values)],[0.8,0.8],\\n color='#777777',linestyle=':')\\n plt.plot([np.min(x_values),np.max(x_values)],[0.9,0.9],\\n color='#777777',linestyle=':')\\n\\n plt.plot( x_values, accuracy, color='#000000',\\n linewidth=1, label='Accuracy' )\\n plt.plot( x_values, precision, color='#0000aa',\\n linewidth=1, label='Precision' )\\n plt.plot( x_values, recall, color='#00aa00',\\n linewidth=1, label='Recall' )\\n plt.plot( x_values, F1, color='#aa0000',\\n linewidth=2, label='F1' )\\n\\n plt.yticks( [0, 0.5, 0.66, 0.8, 0.9, 1.0],\\n ['0','0.5','0.66','0.8','0.9','1.0'], ha='right' )\\n plt.xlim(np.max(x_values)*-0.02,np.max(x_values)*1.02)\\n plt.ylim(-0.02,1.02)\\n plt.xlabel('Number of training samples')\\n plt.ylabel('Performance')\\n plt.title('Learning curve, class {}'.format(c))\\n sns.despine(ax=ax, offset=0, trim=True)\\n lgnd = plt.legend(loc=4, ncol=1, frameon=True, fontsize=9)\\n lgnd.get_frame().set_facecolor('#ffffff')\\n ax.spines['left'].set_bounds(0,1)\\n ax.spines['bottom'].set_bounds(np.min(x_values),np.max(x_values))\",\n \"def learn_online(self, dataset, method=\\\"Exp distance\\\", base_norm=\\\"Thresh\\\", \\n noise_ratio=[0,0,1], sparsity_coeff=[0,0,1], sensitivity=[0,0,1],\\n learning_rate=[0,0,1], base_norm_coeff=0):\\n # The list of all data processed per layer devided for sublayer \\n # input_data[sublayer][actual_recording][events, timestamp if 0 or xy coordinates if 1]\\n input_data = []\\n # In the first layer the input_data is the input dataset given by the user\\n input_data.append(dataset)\\n\\n # Preallocating evolution methods, for plotting the network evolution.\\n self.evolution_pre_allocation(len(dataset))\\n \\n for layer in range(self.layers):\\n # now let's generate the surfaces and train the layers\\n single_layer_surfaces = []\\n single_layer_errors = []\\n # The result of a single layer learning that will serve as input for the \\n # next one\\n outrecordings = []\\n \\n for sublayer in range(len(self.basis[layer])):\\n \\n # Create network evolution parameters, at the moment I'm using \\n # an exponential decay kernel as a function, it can be changed in the code pretty\\n # easly\\n \\n # end_time: how many time surfaces will be generated in the learing \\n # process for this sublayer\\n end_time = 0\\n for i in range(len(input_data[sublayer])):\\n end_time += len(input_data[sublayer][i][0])\\n time = np.arange(end_time)\\n \\n noise_evolution = exp_decay(noise_ratio[0], noise_ratio[1], noise_ratio[2], time)\\n learning_evolution = exp_decay(learning_rate[0], learning_rate[1], learning_rate[2], time)\\n sparsity_evolution = exp_decay(sparsity_coeff[0], sparsity_coeff[1], sparsity_coeff[2], time) \\n sensitivity_evolution = exp_decay(sensitivity[0], sensitivity[1], sensitivity[2], time)\\n \\n # Generate and allocate plots for online plotting\\n if self.verbose is True and layer==1:\\n # Building a list to contain the basis at each run and the original timesurface (the whole picture)\\n # at the position 0\\n timesurfaces_list = [Time_Surface_all(xdim=35, ydim=35, timestamp=dataset[0][0][-1], timecoeff=self.taus[0], dataset=dataset[0], num_polarities=1, minv=0.1, verbose=False)]\\n plot_names = [\\\"Original Time Surface\\\"]\\n for i in range(len(self.basis[layer][sublayer])):\\n timesurfaces_list.append(self.basis[layer][sublayer][i])\\n plot_names.append(\\\"Base N: \\\"+str(i))\\n live_figures, live_axes = surface_live_plot(surfaces=timesurfaces_list, fig_names=plot_names)\\n\\n\\n \\n # Counter of surfaces that will be used to update evolution parameters\\n time = 0\\n sub_layer_surfaces = []\\n sub_layer_reference_events = []\\n sub_layer_errors = [] \\n \\n for recording in range(len(input_data[sublayer])):\\n recording_surfaces = []\\n recording_reference_events = []\\n for k in range(len(input_data[sublayer][recording][0])):\\n single_event = [input_data[sublayer][recording][0][k], input_data[sublayer][recording][1][k]]\\n tsurface = Time_Surface_event(xdim = self.surfaces_dimensions[layer][0],\\n ydim = self.surfaces_dimensions[layer][1],\\n event=single_event,\\n timecoeff=self.taus[layer],\\n dataset=input_data[sublayer][recording],\\n num_polarities=self.polarities[layer],\\n verbose=False)\\n if method==\\\"CG\\\" :\\n sub_layer_errors.append(self.sublayer_response_CG(layer, sublayer,\\n tsurface,\\n sparsity_evolution[time], \\n noise_evolution[time]))\\n if method==\\\"Exp distance\\\" :\\n sub_layer_errors.append(self.sublayer_response_exp_distance(layer, sublayer,\\n tsurface,\\n sparsity_evolution[time], \\n noise_evolution[time], \\n sensitivity_evolution[time]))\\n if method==\\\"Dot product\\\":\\n sub_layer_errors.append(self.sublayer_response_dot_product(layer, sublayer,\\n tsurface,\\n sparsity_evolution[time], \\n noise_evolution[time], \\n sensitivity_evolution[time]))\\n recording_surfaces.append(tsurface)\\n recording_reference_events.append(single_event)\\n # Run a single step of the gradient descent\\n if base_norm==\\\"L2\\\":\\n update_basis_online(self.basis[layer][sublayer], self.activations[layer][sublayer],\\n learning_evolution[time], tsurface, base_norm_coeff, 1, 0)\\n if base_norm==\\\"Thresh\\\":\\n update_basis_online_hard_treshold(self.basis[layer][sublayer], self.activations[layer][sublayer],\\n learning_evolution[time], tsurface, 1, 0)\\n \\n time += 1\\n if time!=0: \\n self.evolution_save_point(layer, sublayer, recording, noise_evolution[time-1], sparsity_evolution[time-1], sensitivity_evolution[time-1], learning_evolution[time-1])\\n # Update plots\\n if self.verbose is True and layer==1: \\n timesurfaces_list[0]=Time_Surface_all(xdim=35, ydim=35, timestamp=dataset[recording][0][-1], timecoeff=self.taus[0], dataset=dataset[recording], num_polarities=1, minv=0.1, verbose=False)\\n for i in range(len(self.basis[layer][sublayer])):\\n timesurfaces_list[i+1]=self.basis[layer][sublayer][i]\\n live_figures, live_axes = surface_live_plot(surfaces=timesurfaces_list, figures=live_figures, axes=live_axes)\\n print(\\\"Layer:\\\"+np.str(layer)+\\\" Sublayer:\\\"+np.str(sublayer)+\\\" Base optimization process per recording:\\\"+np.str(((recording+1)/len(input_data[sublayer]))*100)+\\\"%\\\")\\n sub_layer_surfaces.append(recording_surfaces)\\n sub_layer_reference_events.append(recording_reference_events)\\n # Close plots before displaying next set of basis\\n if self.verbose is True and layer==1:\\n for i in range(len(live_figures)):\\n plt.close(fig=live_figures[i])\\n live_axes.clear()\\n live_figures.clear()\\n \\n \\n # Check if we are at the last layer or we need to recompute the activations\\n # to train the next layer\\n if layer+1 != self.layers:\\n # Let's compute again the activations after defining the set of basis!\\n \\n # I use the evolution parameters at the steady state\\n time = time - 1\\n # Where I store all the events computed in a sublayer\\n # on and off activations originate two batches out of a single one\\n sub_layer_outevents_on = []\\n sub_layer_outevents_off = []\\n for recording in range(len(input_data[sublayer])):\\n recording_activations = []\\n for k in range(len(input_data[sublayer][recording][0])):\\n if method==\\\"CG\\\" :\\n self.sublayer_response_CG(layer, sublayer,\\n sub_layer_surfaces[recording][k],\\n sparsity_evolution[time], \\n noise_evolution[time])\\n if method==\\\"Exp distance\\\" :\\n self.sublayer_response_exp_distance(layer, sublayer,\\n sub_layer_surfaces[recording][k],\\n sparsity_evolution[time], \\n noise_evolution[time], \\n sensitivity_evolution[time])\\n if method==\\\"Dot product\\\":\\n sub_layer_errors.append(self.sublayer_response_dot_product(layer, sublayer,\\n sub_layer_surfaces[recording][k],\\n sparsity_evolution[time], \\n noise_evolution[time], \\n sensitivity_evolution[time]))\\n recording_activations.append(self.activations[layer][sublayer].copy())\\n\\n # Obtaining the events resulting from the activations in a single recording\\n outevents = events_from_activations(recording_activations,\\n sub_layer_reference_events[recording],\\n self.delay_coeff)\\n \\n sub_layer_outevents_on.append(outevents[0])\\n sub_layer_outevents_off.append(outevents[1])\\n \\n \\n # They will be used to optimize the consequent of sublayers\\n # in the next layer\\n outrecordings.append(sub_layer_outevents_on) \\n outrecordings.append(sub_layer_outevents_off) \\n \\n single_layer_surfaces.append(sub_layer_surfaces)\\n single_layer_errors.append(sub_layer_errors)\\n input_data = outrecordings.copy()\\n self.surfaces.append(single_layer_surfaces)\\n self.errors.append(single_layer_errors)\",\n \"def trainNet():\",\n \"def learner(self):\\n for N in range(self.N_learn):\\n trajectories = self.sample_trajectories()\\n\\n # TODO: Both these methods take the full trajectories at the moment, a speedup could be achieved here\\n self.qmodel.train(trajectories)\\n self.amodel.train(trajectories)\",\n \"def plot_learning(self):\\n plt.plot([i for i in range(len(self.fitness_list))], self.fitness_list)\\n plt.ylabel(\\\"Fitness\\\")\\n plt.xlabel(\\\"Iteration\\\")\\n plt.show()\",\n \"def train_model(self):\\r\\n alpha, accuracy_rate = self.select_model()\\r\\n # Initialize logistic regression with alpha(learning rate)\\r\\n lg = logisticregression(C=alpha)\\r\\n # Train the model.\\r\\n lg.fit(self.training_data, self.target_data)\\r\\n # Save the trained model as .pkl file.\\r\\n joblib.dump(value=lg, filename=self.intention_id+'.pkl', compress=1)\\r\\n print \\\"Estimated Parameters of Logistic Regression\\\"\\r\\n # Estimated parameters of logistic regression.\\r\\n print lg.get_params()\",\n \"def test_learning_rate(lrmin=0.1,lrmax=1,lrstep=0.2):\\n for lrate in np.arange(lrmin,lrmax,lrstep):\\n print(\\\"learning rate: %s\\\" % lrate)\\n get_nn_parameters(epochs=1, learning_rate=lrate)\",\n \"def train(self, batch_size=None, alpha=0.1, epochs=100, verbose=False, save_cost_hist=False):\\n cost_hist = []\\n nexamples = self.X_train.shape[1]\\n batch_size = nexamples if batch_size is None else batch_size\\n number_batches = int(np.floor(nexamples / batch_size))\\n for epoch in range(epochs):\\n X_batch, y_batch = self.shuffle_dataset()\\n for batch in range(number_batches):\\n if batch % 10 == 0:\\n print(f\\\"training batch {batch} for epoch {epoch} of size {batch_size}\\\", end=\\\"\\\\r\\\")\\n # Correction factor if training dataset is not evenly divisible\\n fact = 0 if number_batches - 1 != batch else nexamples % batch_size\\n columns = range(batch * batch_size,\\n (batch + 1) * batch_size + fact)\\n X_batch_train = X_batch[:, columns]\\n y_batch_train = y_batch[:, columns]\\n grads = self.compute_grads(X_batch_train, y_batch_train)\\n self.theta = self.theta - alpha * grads\\n\\n if save_cost_hist:\\n cost = self.cost()\\n cost_hist.append(cost)\\n\\n if verbose and epoch % 10 == 0:\\n cost = self.cost()\\n print(f\\\"Total cost after epoch {epoch + 1}: {cost}\\\")\\n\\n if save_cost_hist:\\n self.cost_hist = cost_hist\",\n \"def learn(self, Xtrain, ytrain):\\n pass\\n self.weights = np.zeros(Xtrain.shape[1],)\\n\\n ### YOUR CODE HERE\\n \\n lmbd = self.params['lamb']\\n \\n numsamples = Xtrain.shape[0]\\n # Xless = Xtrain[:,self.params['features']]\\n Xless = Xtrain\\n self.weights = np.random.rand(Xless.shape[1])\\n err = 10000;\\n #cw =0;\\n tolerance = 10*np.exp(-4)\\n i=0;\\n \\n \\n w1 = self.weights\\n # cw_v =(np.dot(Xless, self.weights)-ytrain)\\n #cw = (np.linalg.norm(cw_v)**2)/(2*numsamples)\\n cw_v = np.dot(Xless, self.weights.T)\\n cw = self.logit_cost(cw_v, Xless, ytrain) + lmbd * self.regularizer[0](self.weights)\\n # print(cw)\\n errors = []\\n runtm = []\\n epch = []\\n \\n err = 1\\n iteration= 1000\\n #tm= time.time()\\n while (abs(cw-err)>tolerance) and (i <iteration):\\n err = cw\\n g = self.logit_cost_grad(cw_v, Xless, ytrain)\\n obj = cw\\n j=0\\n ita = -1* self.params['stepsize']\\n w = self.weights\\n # w1 = np.add(w,np.dot(ita,g))\\n while(j<iteration):\\n w1 = np.add(w,np.dot(ita,g))\\n # cw_v =(np.dot(Xless, w1)-ytrain)\\n # cw = (np.linalg.norm(cw_v)**2)/(2*numsamples)\\n cw_v = np.dot(Xless, w1.T)\\n cw = self.logit_cost(cw_v, Xless, ytrain)+lmbd * self.regularizer[0](w1)\\n ## print (cw)\\n \\n if(cw<np.absolute(obj-tolerance)): ############################################\\n break\\n ita = 0.7*ita\\n j=j+1\\n \\n if(j==iteration):\\n self.weights=w\\n ita =0\\n else:\\n self.weights = w1\\n \\n # cw_v =(np.dot(Xless, self.weights)-ytrain)\\n #cw = (np.linalg.norm(cw_v)**2)/(2*numsamples)\\n cw_v = np.dot(Xless, self.weights.T)\\n cw = self.logit_cost(cw_v, Xless, ytrain)\\n #tm1 = time.time()-tm\\n #runtm.append(tm1)\\n #err = cw\\n errors.append(err)\\n i=i+1\\n epch.append(i)\",\n \"def nnRegression(data):\",\n \"def learn(self, D, **kwargs):\\n pass\",\n \"def get_sgd_solution(TRAINING_PHI, TEST_PHI, VAL_PHI, W_Now, TrainingData,\\n TrainingTarget, TestData, ValData):\\n # Gradient Descent Solution for Linear Regression\\n La = 2\\n # learningRate = 0.01\\n L_Erms_Val, L_Erms_TR, L_Erms_Test, L_Accuracy_Test, W_Mat = [], [], [], [], []\\n\\n for i in range(0, 400):\\n\\n # print (f'---------Iteration: {i} M{M} LR {learningRate} L :{C_Lambda}--------------')\\n Delta_E_D = -np.dot(\\n (TrainingTarget[i] - np.dot(np.transpose(W_Now), TRAINING_PHI[i])),\\n TRAINING_PHI[i])\\n La_Delta_E_W = np.dot(La, W_Now)\\n Delta_E = np.add(Delta_E_D, La_Delta_E_W)\\n Delta_W = -np.dot(learningRate, Delta_E)\\n W_T_Next = W_Now + Delta_W\\n W_Now = W_T_Next\\n\\n #-----------------TrainingData Accuracy---------------------#\\n TR_TEST_OUT = GetValTest(TRAINING_PHI, W_T_Next)\\n Erms_TR = GetErms(TR_TEST_OUT, TrainingTarget)\\n L_Erms_TR.append(float(Erms_TR.split(',')[1]))\\n\\n #-----------------ValidationData Accuracy---------------------#\\n VAL_TEST_OUT = GetValTest(VAL_PHI, W_T_Next)\\n Erms_Val = GetErms(VAL_TEST_OUT, ValDataAct)\\n L_Erms_Val.append(float(Erms_Val.split(',')[1]))\\n\\n #-----------------TestingData Accuracy---------------------#\\n TEST_OUT = GetValTest(TEST_PHI, W_T_Next)\\n Erms_Test = GetErms(TEST_OUT, TestDataAct)\\n L_Erms_Test.append(float(Erms_Test.split(',')[1]))\\n L_Accuracy_Test.append(float(Erms_Test.split(',')[0]))\\n\\n return ([L_Erms_TR, L_Erms_Val, L_Erms_Test, L_Accuracy_Test])\",\n \"def train(features, targets, weights, bias):\\n # see gradient_descent for explanation\\n epochs = 100\\n learning_rate = 0.1\\n\\n picture_nb = 2\\n\\n # Print current accuracy. How many people have been classified as sick/healthy correctly?\\n predictions = predict(features, weights, bias)\\n print(\\\"Accuracy: \\\", np.mean(predictions == targets))\\n\\n for epoch in range(epochs):\\n if epoch % 10 == 0:\\n # get normalized scores\\n predictions = activation(pre_activation(features, weights, bias))\\n # compare with targets to see how bad our algorithm is\\n print(\\\"Cost = %s\\\" % cost(predictions, targets))\\n # Replot graph. Check in create_dataset for explanation of parameters\\n if picture_nb == 2:\\n plt.plot(features[:, 0], (weights[0] * features[:, 0] + bias) / -weights[1], color='red')\\n elif picture_nb == 11:\\n plt.plot(features[:, 0], (weights[0] * features[:, 0] + bias) / -weights[1], color='green')\\n else:\\n plt.plot(features[:, 0], (weights[0] * features[:, 0] + bias) / -weights[1], color='orange')\\n picture_nb+=1\\n\\n # Initialize gradients\\n # weights_gradients is 2D array with 2 values\\n weights_gradients = np.zeros(weights.shape)\\n bias_gradient = 0\\n # Go through each row\\n for feature, target in zip(features, targets):\\n # Compute prediction\\n z = pre_activation(feature, weights, bias)\\n # Get normalized score\\n y = activation(z)\\n # Update gradients based on formulas established before. Look at gradient_descent to understand what we\\n # are doing. Also, the formulas are below, just before the call of the function train.\\n weights_gradients += (y - target) * derivative_activation(z) * feature\\n # no multiplication of feature because it does not depend on some coordinates.\\n bias_gradient += (y - target) * derivative_activation(z)\\n\\n # Update variables. These are the lines that result the cost to get reduced.\\n weights = weights - learning_rate * weights_gradients\\n bias = bias - learning_rate * bias_gradient\\n\\n # Print final accuracy. How many people have been classified as sick/healthy correctly?\\n predictions = predict(features, weights, bias)\\n print(\\\"Accuracy: \\\", np.mean(predictions == targets))\\n\\n plt.scatter(features[:, 0], features[:, 1], s=40, c=targets, cmap=plt.cm.Spectral)\\n plt.savefig(\\\"DataPointsLineEvolution.png\\\")\\n # legend for understanding\\n plt.legend(['Original division', 'New division', 'New division', 'New division', 'New division', 'New division',\\n 'New division', 'New division', 'New division', 'Final division'], loc='upper left')\\n # save picture of data points drawn.\\n plt.savefig(\\\"DataPointsLineEvolutionLegend.png\\\")\",\n \"def fit(self, X, y, X_validate, y_validate):\\n \\n iterate = 800\\n \\n self.SGD_theta_list = [0]*len(X[0])\\n self.SGD_bias = 0\\n\\n SGD_cost_history = []\\n SGD_validate_cost_history = []\\n\\n for i in range(iterate):\\n if(i%100==0):\\n print(i,\\\" iterations\\\")\\n selection = random.randint(0, len(X)-1) #selecting one random row for SGD\\n temp_X = []\\n temp_X.append(X[selection])\\n temp_y = []\\n temp_y.append(y[selection])\\n self.SGD_bias, self.SGD_theta_list = self.update_thetas(np.array(temp_X), np.array(temp_y), self.SGD_theta_list, self.SGD_bias,self.training_rate)\\n SGD_cost = self.cost_function(X, y, self.SGD_theta_list, self.SGD_bias)\\n SGD_cost_history.append(SGD_cost)\\n SGD_validate_cost = self.cost_function(X_validate, y_validate,self.SGD_theta_list, self.SGD_bias)\\n SGD_validate_cost_history.append(SGD_validate_cost)\\n\\n self.FINAL_SGD_TRAIN_LOSS.append(SGD_cost_history[-1])\\n self.FINAL_SGD_VALIDATE_LOSS.append(SGD_validate_cost_history[-1])\\n\\n plt.plot(list(range(iterate)), SGD_cost_history)\\n plt.plot(list(range(iterate)), SGD_validate_cost_history)\\n plt.xlabel(\\\"Iterations\\\")\\n plt.ylabel(\\\"Loss SGD\\\")\\n plt.show()\\n \\n \\n self.BGD_theta_list = [0]*len(X[0])\\n self.BGD_bias = 0\\n\\n BGD_cost_history = []\\n BGD_validate_cost_history = []\\n\\n for i in range(iterate):\\n if(i%100==0):\\n print(i,\\\" iterations\\\")\\n selection = random.randint(0, len(X)-1)\\n \\n self.BGD_bias, self.BGD_theta_list = self.update_thetas(X, y, self.BGD_theta_list, self.BGD_bias,self.training_rate)\\n\\n BGD_cost = self.cost_function(X, y, self.BGD_theta_list, self.BGD_bias)\\n BGD_cost_history.append(BGD_cost)\\n BGD_validate_cost = self.cost_function(X_validate, y_validate,self.BGD_theta_list, self.BGD_bias)\\n BGD_validate_cost_history.append(BGD_validate_cost)\\n\\n self.FINAL_BGD_TRAIN_LOSS.append(BGD_cost_history[-1])\\n self.FINAL_BGD_VALIDATE_LOSS.append(BGD_validate_cost_history[-1])\\n\\n plt.plot(list(range(iterate)), BGD_cost_history)\\n plt.plot(list(range(iterate)), BGD_validate_cost_history)\\n plt.xlabel(\\\"Iterations\\\")\\n plt.ylabel(\\\"Loss BGD\\\")\\n plt.show()\\n\\n print(\\\"FINAL_SGD_TRAIN_LOSS\\\\n\\\",self.FINAL_SGD_TRAIN_LOSS)\\n print(\\\"FINAL_SGD_VALIDATE_LOSS\\\\n\\\",self.FINAL_SGD_VALIDATE_LOSS)\\n print(\\\"FINAL_BGD_TRAIN_LOSS\\\\n\\\",self.FINAL_BGD_TRAIN_LOSS)\\n print(\\\"FINAL_BGD_VALIDATE_LOSS\\\\n\\\",self.FINAL_BGD_VALIDATE_LOSS)\\n\\n \\n return self\",\n \"def online_dictionary_learning(self, dinit, tinit, winit, pars, trainingdata, HMat, QMat):\\n num_images = trainingdata.shape[1]\\n # n0 = num_images/10\\n n0 = num_images/(pars['batchSize']*10)\\n model = dict(\\n D=dinit, # dictionary\\n A=tinit, # transform matrix\\n W=winit, # classifier\\n )\\n\\n param = {\\n 'lambda1': pars['lambda_'],\\n 'lambda2': 0,\\n 'mode': 2\\n }\\n\\n # crf iterations\\n fobj_avg = dict()\\n\\n if not os.path.isdir(settings.GENERATED_DATA_DIRECTORY):\\n os.mkdir(settings.GENERATED_DATA_DIRECTORY)\\n\\n for iter_ in range(pars['maxIters']):\\n tic = time.time()\\n # Take a random permutation of the samples\\n filename = 'permute_{}_{}_{}.npy'.format(iter_, pars['numBases'], pars['dataset'])\\n full_path = os.path.join(settings.GENERATED_DATA_DIRECTORY, filename)\\n\\n if os.path.isfile(full_path):\\n ind_rnd = np.load(full_path, allow_pickle=False, fix_imports=False)\\n else:\\n ind_rnd = np.random.permutation(num_images)\\n np.save(full_path, ind_rnd, allow_pickle=False, fix_imports=False)\\n\\n for batch in range(num_images//pars['batchSize']):\\n # load the dataset\\n # we only loads one sample or a small batch at each iteration\\n # batch_idx = ind_rnd((1:pars.batchSize)+pars.batchSize*(batch-1));\\n lower_index = pars['batchSize'] * batch\\n upper_index = lower_index + pars['batchSize']\\n batch_idx = ind_rnd[lower_index:upper_index]\\n yt = trainingdata[:, batch_idx]\\n ht = HMat[:, batch_idx]\\n qt = QMat[:, batch_idx]\\n # TODO: Review if in these cases it's mandatory to assign copies\\n D = model['D']\\n W = model['W']\\n A = model['A']\\n # sparse coding\\n # S = L1QP_FeatureSign_Set(yt, D, gamma, lambda);\\n\\n S = lasso(\\n yt,\\n D if np.isfortran(D) else np.asfortranarray(D),\\n **param\\n )\\n\\n # compute the gradient of crf parameters\\n grad_W = (1-pars['mu'])*(W@S - ht)@S.T + pars['nu2']*W\\n grad_A = pars['mu']*(A@S - qt)@S.T + pars['nu1']*A\\n grad_S1 = W.T @ (W@S - ht) # gradient w.r.t S for 0.5*||H-WS||_2^2\\n grad_S2 = A.T @ (A@S - qt) # gradient w.r.t S for 0.5*||Q-AS||_2^2\\n\\n # compute the gradient of dictionary\\n # find the active set and compute beta\\n B1 = np.zeros((pars['numBases'], pars['batchSize']), dtype=np.int)\\n B2 = np.zeros((pars['numBases'], pars['batchSize']), dtype=np.int)\\n DtD = D.T@D\\n for j in range(pars['batchSize']):\\n active_set = np.array(np.nonzero(S[:, j] != 0)).ravel()\\n # DtD = D(:,active_set)'*D(:,active_set) + gamma*eye(length(active_set));\\n DtD_hat = DtD[active_set, active_set] + pars['gamma']*np.eye(active_set.shape[0])\\n\\n # DtD_inv = DtD\\\\eye(length(active_set));\\n DtD_inv = np.linalg.solve(DtD_hat, np.eye(active_set.shape[0]))\\n\\n B1[active_set, j] = (DtD_inv @ grad_S1[active_set, j]).T\\n\\n B2[active_set, j] = (DtD_inv @ grad_S2[active_set, j]).T\\n\\n grad_D = (1-pars['mu'])*(-D@B1@S.T + (yt - D@S)@B1.T) + pars['mu'] * \\\\\\n (-D@B2@S.T + (yt - D@S)@B2.T) # dD = -D*B*S' + (X - D*S)*B';\\n\\n # use yang's method\\n # gfullMat = zeros([size(D),size(D,2)]);\\n # [gMat, IDX] = sparseDerivative(D, full(S), yt);\\n # gfullMat(:,IDX,IDX) = gMat;\\n # gradSmat = repmat(reshape(grad_S1,[1 1 length(grad_S1)]),size(D));\\n # grad_D = sum(gfullMat.*gradSmat,3);\\n\\n # update the learning rate\\n rho_i = min(pars['rho'], pars['rho']*n0/(batch+1))\\n\\n # update model parameters\\n D = D - rho_i*grad_D\\n D = D / np.tile(np.linalg.norm(D, axis=0), (D.shape[0], 1))\\n model['D'] = D\\n\\n W = W - rho_i*grad_W\\n model['W'] = W\\n\\n A = A - rho_i*grad_A\\n model['A'] = A\\n\\n # get statistics\\n S = lasso(\\n trainingdata,\\n D if np.isfortran(D) else np.asfortranarray(D),\\n **param\\n )\\n fobj = self.get_objective_lc(D, S, trainingdata, W, HMat, A, QMat, pars['lambda_'], pars['mu'])[0]\\n # *** numpy.linalg.LinAlgError: Last 2 dimensions of the array must be square\\n # stat['fobj_avg'][iter_] = fobj + 0.5*nu1*np.sum(W**2) + 0.5*nu2*np.sum(A**2)\\n fobj_avg[iter_] = fobj + 0.5*pars['nu1']*np.sum(np.multiply(W, W)) + 0.5*pars['nu2']*np.sum(A**2)\\n # filename = 'model_{}_{}_{}.npy'.format(iter_, num_bases, pars['dataset'])\\n # full_path = os.path.join(generated_data_directory, filename)\\n # ValueError: Object arrays cannot be saved when allow_pickle=False\\n # the model is being saved in three different files to avoid\\n # setting allow_pickle=True when trying to save the whole model\\n # np.save(full_path, model, allow_pickle=True, fix_imports=False)\\n for key, value in model.items():\\n filename = '{}_{}_{}_{}.npy'.format(key, iter_, pars['numBases'], pars['dataset'])\\n full_path = os.path.join(settings.GENERATED_DATA_DIRECTORY, filename)\\n np.save(full_path, value, allow_pickle=False, fix_imports=False)\\n\\n toc = time.time()\\n print('Iter = {}, Elapsed Time = {}'.format(iter_, toc-tic))\\n\\n stat_filename = 'stat_{}_{}.json'.format(pars['numBases'], pars['dataset'])\\n stat_full_path = os.path.join(settings.GENERATED_DATA_DIRECTORY, stat_filename)\\n # saving as JSON to avoid using pickle\\n with open(stat_full_path, 'w') as file_:\\n json.dump(fobj_avg, file_)\\n\\n return model, fobj_avg\",\n \"def RatingsGradientDescent(params, Y, R, num_users, num_movies, num_features, lbd, alpha, num_iters):\\n J_history = np.zeros(num_iters)\\n for i in range(num_iters):\\n J_history[i], grad = cofiCostFunc(params, Y, R, num_users, num_movies, num_features, lbd)\\n params = params-alpha*grad\\n if i % 100 == 99:\\n print('Step %i, cost=%f' % (i+1, J_history[i]))\\n return params, J_history\",\n \"def model(X_train, Y_train, X_test, Y_test, num_iterations, learning_rate, print_cost):\\n\\n\\n # initialize parameters with zeros\\n w, b = initialize_with_zeros(X_train.shape[0]);\\n\\n print(\\\"w.shape() = \\\" +str(w.shape)+ \\\", b = \\\" +str(b));\\n\\n # Gradient descent\\n parameters, grads, costs = optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost);\\n \\n # Retrieve parameters w and b from dictionary \\\"parameters\\\"\\n w = parameters[\\\"w\\\"]\\n b = parameters[\\\"b\\\"]\\n \\n # Predict test/train set examples \\n Y_prediction_test = predict(w, b, X_test)\\n Y_prediction_train = predict(w, b, X_train)\\n\\n # Print train/test Errors\\n print(\\\"train accuracy: {} %\\\".format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100))\\n print(\\\"test accuracy: {} %\\\".format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100))\\n \\n d = {\\\"costs\\\": costs,\\n \\\"Y_prediction_test\\\": Y_prediction_test, \\n \\\"Y_prediction_train\\\" : Y_prediction_train, \\n \\\"w\\\" : w,\\n \\\"b\\\" : b,\\n \\\"learning_rate\\\" : learning_rate,\\n \\\"num_iterations\\\": num_iterations}\\n \\n return d\",\n \"def increase_learning(self, factor):\\n pass\",\n \"def batchlearn(self, final_state=False):\\n # what to do anyway with finals states in batch learning ???\\n\\n TDe = self.estimate_TDioa() \\n self.actQoa += self.alpha * TDe\\n self.X = self.policy_func(self.actQoa)\\n \\n \\n print(\\\"\\\\r>> batchlearn at {}\\\".format(self.total_step), \\n end='', flush=True) if self.verbose else None\\n print() if self.verbose else None\\n print('actQ:\\\\n', self.actQoa) if self.verbose else None\\n print('TDe:\\\\n', TDe) if self.verbose else None\\n print() if self.verbose else None\\n\\n\\n #re-init\\n self.count_oa.fill(0)\\n self.count_oao.fill(0)\\n self.reward_oa.fill(0)\\n # self.valQoa = self.actQoa.copy() # may not be needed\\n self.batch_step = 0\",\n \"def learn(self, purge_memory=True):\\n observed_inputs, observed_reward, predicted_outputs, distance_from_reward = self._preprocess_experience()\\n # now train. DataFeeder automatically reshuffles data.\\n self.dataset_feeder = DataFeeder(\\n [observed_inputs, predicted_outputs, observed_reward],\\n batch_size=self.batch_size)\\n # determine number of iterations:\\n self.iterations = int(self.epochs * len(observed_inputs) / self.batch_size)\\n for _ in range(self.iterations):\\n self._batch()\\n # TODO: write a method that computes and prints training stats\\n # if _ % 1000:\\n # self._train_stats(_)\\n if purge_memory:\\n self.purge_memory()\",\n \"def learn(filePath):\\n filename = filePath.stem\\n processedJAFFE = load(str(filePath))\\n processedDF = pd.DataFrame(processedJAFFE)\\n processedDF.columns = ['name', 'data', 'emotion']\\n processedDF = processedDF.sort_values(by=['name', 'emotion'])\\n grouped = processedDF.groupby(['name', 'emotion'])\\n train = grouped.nth([0, 1])\\n test = grouped.nth([2, 3, 4])\\n\\n yTrain = train.index.get_level_values(1).tolist()\\n xTrain = train.values.ravel().tolist()\\n yTest = test.index.get_level_values(1).tolist()\\n xTest = test.values.ravel().tolist()\\n\\n parameters = {\\n 'C': [\\n 1.00E-12, 1.00E-11, 1.00E-10, 1.00E-09, 1.00E-08, 1.00E-07, 1.00E-06,\\n 1.00E-05, 1.00E-04, 1.00E-03, 2.00E-03, 1.00E-02, 1.00E-01, 1.00,\\n 1.00E+01, 1.00E+02, 1.00E+03, 1.00E+04, 1.00E+05\\n ],\\n 'gamma': [\\n 1.00E00,\\n 1.00E-01,\\n 1.00E-02,\\n 1.00E-03,\\n 5.00E-04, 2.00E-04, 1.50E-04, 1.10E-04, 1.05E-04, 1.00E-04,\\n 9.50E-05, 9.00E-05, 7.00E-05, 5.00E-05, 1.90E-05, 1.00E-05,\\n 1.00E-06,\\n 1.00E-07,\\n ],\\n }\\n\\n models = []\\n models.append(['gamma \\\\\\\\ C', 1.00E-12, 1.00E-11, 1.00E-10, 1.00E-09, 1.00E-08,\\n 1.00E-07, 1.00E-06, 1.00E-05, 1.00E-04, 1.00E-03, 2.00E-03, 1.00E-02,\\n 1.00E-01, 1.00, 1.00E+01, 1.00E+02, 1.00E+03, 1.00E+04, 1.00E+05 ])\\n gridTimeStart = time()\\n numIteration = len(parameters['gamma']) * len(parameters['C'])\\n iteration = 0\\n meanTime = 0\\n for gamma in parameters['gamma']:\\n row = [gamma]\\n for C in parameters['C']:\\n print('C = %s \\\\t gamma = %s'%(C, gamma))\\n timeStart = time()\\n svc = OneVsRestClassifier(SVC(random_state=0, decision_function_shape='ovr',\\n C=C, kernel='rbf', gamma=gamma), n_jobs=4)\\n svc.fit(xTrain, yTrain)\\n yTrue, yPred = yTest, svc.predict(xTest)\\n yTrue = np.array(yTrue, dtype=np.unicode_)\\n yPred = np.array(yPred, dtype=np.unicode_)\\n correct = np.sum(yTrue == yPred)\\n \\n print(\\\"accuracy: %d/%d = \\\"%(correct, len(yTrue)),\\n D('%.2f'%(correct/len(yTrue)*100)))\\n row.append(D('%.2f'%(correct/len(yTrue)*100)))\\n \\n iterTime = time()-timeStart\\n iteration = iteration + 1\\n meanTime = meanTime * (iteration-1)/iteration + iterTime/iteration\\n remainingTime = (numIteration-iteration)*meanTime\\n print('--------------------------(%d sec)--remaining: %s'%\\n (iterTime, str(timedelta(seconds=int(remainingTime)))))\\n models.append(row)\\n gridTime = time() - gridTimeStart\\n gridTime = timedelta(seconds=int(gridTime))\\n print('time: %s'%str(gridTime))\\n print('saving file: %s.csv'%filename)\\n with open('../csv/%s.csv'%filename, 'w') as csvFile:\\n writer = csv.writer(csvFile)\\n writer.writerows(models)\",\n \"def learn(self, Xtrain, ytrain):\\n\\n ### YOUR CODE HERE\\n \\n self.numfeatures = Xtrain.shape[1]\\n numsamples = Xtrain.shape[0]\\n #print (self.numfeatures)\\n count = 0\\n for i in ytrain:\\n if (i>count):\\n count+=1\\n self.numclasses = count + 1\\n \\n if(self.params['usecolumnones']==False):\\n b = np.ones((numsamples, self.numfeatures-1))\\n b = Xtrain[:,:-1]\\n Xtrain = b\\n self.numfeatures -= 1\\n # print(Xtrain.shape[1])\\n\\n ### END YOUR CODE\\n\\n origin_shape = (self.numclasses, self.numfeatures)\\n self.means = np.zeros(origin_shape)\\n self.stds = np.zeros(origin_shape)\\n\\n ### YOUR CODE HERE\\n countclass = np.zeros(self.numclasses)\\n for i in range (0, numsamples):\\n k = int(ytrain[i])\\n countclass[k] += 1\\n for j in range (0, self.numfeatures):\\n self.means[k][j]+=Xtrain[i][j]\\n \\n for i in range (0, self.numclasses):\\n #np.true_divide(self.means[i], countclass[i])\\n for j in range (0, self.numfeatures):\\n self.means[i][j] = self.means[i][j]/(countclass[i]+1e-8)\\n \\n self.yprob = np.true_divide(countclass, numsamples)\\n \\n for i in range (0, numsamples):\\n k = int(ytrain[i])\\n for j in range (0, self.numfeatures):\\n self.stds[k][j]+= (Xtrain[i][j] - self.means[k][j])**2\\n # print (self.stds)\\n \\n for i in range (0, self.numclasses):\\n #np.true_divide(self.stds[i], countclass[i])\\n for j in range (0, self.numfeatures):\\n self.stds[i][j] = self.stds[i][j]/(countclass[i]+1e-8)\\n \\n # print (self.means)\\n # print (self.stds)\\n ### END YOUR CODE\\n\\n assert self.means.shape == origin_shape\\n assert self.stds.shape == origin_shape\",\n \"def plot_learning_curve(estimator, title, X, y, ylim=None, cv=None,\\n n_jobs=None, train_sizes=np.linspace(.1, 1.0, 5)):\\n \\n \\n\\n \\n font = {'family': 'serif',\\n 'color': 'black',\\n 'weight': 'bold',\\n 'size': 10,\\n }\\n \\n fig=plt.figure(figsize=(5,3))\\n\\n plt.title(title, fontdict= font)\\n if ylim is not None:\\n plt.ylim(*ylim)\\n plt.xlabel(\\\"Training examples\\\", fontdict=font)\\n plt.ylabel(\\\"Score\\\", fontdict=font)\\n train_sizes, train_scores, test_scores = learning_curve(\\n estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes)\\n train_scores_mean = np.mean(train_scores, axis=1)\\n train_scores_std = np.std(train_scores, axis=1)\\n test_scores_mean = np.mean(test_scores, axis=1)\\n test_scores_std = np.std(test_scores, axis=1)\\n \\n plt.grid(b=True, which='both', color='w', linewidth=1.0) \\n# \\n\\n plt.fill_between(train_sizes, train_scores_mean - train_scores_std,\\n train_scores_mean + train_scores_std, alpha=0.1,\\n color=\\\"blue\\\")\\n plt.fill_between(train_sizes, test_scores_mean - test_scores_std,\\n test_scores_mean + test_scores_std, alpha=0.1, color=\\\"orange\\\")\\n plt.plot(train_sizes, train_scores_mean, 'o--', color=\\\"blue\\\",\\n label=\\\"Training score\\\")\\n plt.plot(train_sizes, test_scores_mean, '--o', color=\\\"orange\\\",\\n label=\\\"Cross-validation score\\\")\\n \\n plt.legend(facecolor='white',loc=\\\"best\\\")\\n\\n fig.savefig(\\\"learning_Curve.pdf\\\", dpi=300,bbox_inches='tight')\\n plt.close(fig)\\n\\n return plt\",\n \"def train_logisticRegression(data: np.array, labels: np.array)->None:\\n\\n n_examples = np.size(data, 0)\\n n_features = np.size(data, 1)\\n n_categories = np.size(labels, 1)\\n\\n data = np.hstack((np.ones((n_examples, 1)), data))\\n\\n print(data[0:5, :])\\n\\n X_train, X_test, y_train, y_test, idx_test = split_data(data, labels, 0.7)\\n\\n convergence_goal = 1e-3\\n learning_rate = 0.01\\n\\n theta = np.random.uniform(size=((n_features+1, n_categories)))\\n\\n for i in range(n_categories):\\n\\n cost_var = 1\\n\\n previous_cost = 1e6\\n iterations = 0\\n cost_to_plot = []\\n\\n while cost_var > convergence_goal:\\n iterations += 1\\n cost, grad = costFunction(X_train, y_train[:, i], theta[:, i])\\n theta[:, i] = update_theta(theta[:, i], grad, learning_rate)\\n cost_var = previous_cost - cost\\n previous_cost = cost\\n if iterations == 1: cost_var = 1\\n cost_to_plot.append(cost)\\n # print(cost)\\n\\n plt.plot(range(iterations), cost_to_plot, 'g-', label = 'cost')\\n plt.xlabel('iterations')\\n plt.ylabel('cost')\\n # plt.show()\\n\\n predictions = lrPredict(theta, X_test)\\n\\n print(predictions[0:5, :])\\n print(y_test[0:5, :])\\n\\n accuracy = np.mean([p == l for p, l in zip(predictions, y_test)])\\n print(\\\"Accuracy = {}\\\".format(accuracy))\\n\\n pass\",\n \"def plot_learning_curve(estimator, title, X, y, ylim=None, cv=None,\\n n_jobs=-1, train_sizes=np.linspace(.1, 1.0, 5),color1 = \\\"g\\\",color2 = \\\"r\\\",\\n plotmedian=True, includebasetext=False, baselinepos=[180,0.9]):\\n fig,ax = plt.subplots(1,1,figsize=(10,7))\\n plt.title(title, color=\\\"dimgray\\\", loc=\\\"left\\\", size=20)\\n plt.xlabel(\\\"Training sample size\\\", color=\\\"dimgrey\\\",size=15)\\n plt.ylabel(\\\"Accuracy score\\\", color=\\\"dimgrey\\\",size=15)\\n train_sizes, train_scores, test_scores = learning_curve(\\n estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes)\\n print (\\\"number of element in train sample = \\\", train_sizes)\\n\\n \\n \\n train_scores_mean = np.mean(train_scores, axis=1)\\n train_scores_median = np.median(train_scores, axis=1)\\n\\n train_scores_std = np.std(train_scores, axis=1)\\n test_scores_mean = np.mean(test_scores, axis=1)\\n if plotmedian:\\n test_scores_median = np.median(test_scores, axis=1)\\n test_scores_std = np.std(test_scores, axis=1)\\n #plt.grid()\\n plt.plot(train_sizes[:], np.zeros(len(train_sizes))+0.889, ls=\\\"--\\\", color = \\\"dimgrey\\\", lw=2)\\n if includebasetext:\\n plt.text(baselinepos[0], baselinepos[1], \\\"baseline prediction\\\",color=\\\"dimgrey\\\",size=15)\\n\\n plt.fill_between(train_sizes, train_scores_mean - train_scores_std,\\n train_scores_mean + train_scores_std, alpha=0.3,\\n color=color2)\\n plt.fill_between(train_sizes, test_scores_mean - test_scores_std,\\n test_scores_mean + test_scores_std, alpha=0.3, color=color1)\\n plt.plot(train_sizes, train_scores_mean, 'o-', color=color2, lw=2,\\n label=\\\"Training\\\")\\n if plotmedian:\\n plt.plot(train_sizes, train_scores_median, 'x:', color=color2,alpha=0.3,\\n label=\\\"Training\\\")\\n plt.plot(train_sizes, test_scores_mean, 'o-', color=color1,\\n label=\\\"Cross-validation\\\", lw=3)\\n if plotmedian:\\n plt.plot(train_sizes, test_scores_median, 'x:', color=color1, alpha=0.3,\\n label=\\\"Cross-validation\\\")\\n plt.ylim([0.8,1.05])\\n\\n legend=plt.legend(loc=\\\"best\\\")\\n plt.setp(legend.get_texts(), color='dimgray', size=15)\\n\\n ax.spines['bottom'].set_color('dimgray')\\n ax.spines['top'].set_visible(False)\\n ax.spines['right'].set_visible(False)\\n ax.spines['left'].set_color('dimgray')\\n ax.tick_params(axis='x', colors='dimgray')\\n ax.tick_params(axis='y', colors='dimgray', size=3)\\n ax.get_yaxis().set_ticks([0.8,0.9,1.0])\\n\\n ax.tick_params(labelsize=14)\\n\\n return plt\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65476876","0.652535","0.63539034","0.63355064","0.62676394","0.6246775","0.61720693","0.6154492","0.61399","0.6103736","0.60872924","0.60743475","0.6020889","0.60129255","0.6007138","0.59935564","0.59641993","0.5947333","0.5942775","0.59299177","0.5904586","0.589832","0.58923537","0.58923537","0.5888531","0.5882838","0.58712965","0.5852597","0.58449614","0.58282423","0.58084184","0.5791307","0.5787087","0.57815874","0.57795805","0.577066","0.577041","0.57652074","0.5758767","0.57530737","0.5745968","0.57432276","0.5732301","0.57240456","0.57228094","0.57208806","0.57114464","0.5707685","0.56961495","0.5694872","0.569327","0.56886065","0.56826603","0.5682169","0.5681635","0.5681419","0.56814015","0.5670079","0.5664344","0.56612784","0.5659331","0.56494445","0.5647269","0.56421244","0.5641537","0.5632938","0.56285226","0.5628479","0.56274927","0.56254315","0.5622793","0.5621616","0.5616078","0.56126964","0.56095874","0.5604967","0.56021106","0.5597396","0.55957556","0.5592528","0.5586756","0.55841744","0.5582733","0.55737144","0.55701154","0.55675507","0.5558895","0.5557123","0.5550006","0.5549016","0.5540089","0.5537978","0.55326205","0.55278736","0.552377","0.5522408","0.5521384","0.55205303","0.55119884","0.55073804"],"string":"[\n \"0.65476876\",\n \"0.652535\",\n \"0.63539034\",\n \"0.63355064\",\n \"0.62676394\",\n \"0.6246775\",\n \"0.61720693\",\n \"0.6154492\",\n \"0.61399\",\n \"0.6103736\",\n \"0.60872924\",\n \"0.60743475\",\n \"0.6020889\",\n \"0.60129255\",\n \"0.6007138\",\n \"0.59935564\",\n \"0.59641993\",\n \"0.5947333\",\n \"0.5942775\",\n \"0.59299177\",\n \"0.5904586\",\n \"0.589832\",\n \"0.58923537\",\n \"0.58923537\",\n \"0.5888531\",\n \"0.5882838\",\n \"0.58712965\",\n \"0.5852597\",\n \"0.58449614\",\n \"0.58282423\",\n \"0.58084184\",\n \"0.5791307\",\n \"0.5787087\",\n \"0.57815874\",\n \"0.57795805\",\n \"0.577066\",\n \"0.577041\",\n \"0.57652074\",\n \"0.5758767\",\n \"0.57530737\",\n \"0.5745968\",\n \"0.57432276\",\n \"0.5732301\",\n \"0.57240456\",\n \"0.57228094\",\n \"0.57208806\",\n \"0.57114464\",\n \"0.5707685\",\n \"0.56961495\",\n \"0.5694872\",\n \"0.569327\",\n \"0.56886065\",\n \"0.56826603\",\n \"0.5682169\",\n \"0.5681635\",\n \"0.5681419\",\n \"0.56814015\",\n \"0.5670079\",\n \"0.5664344\",\n \"0.56612784\",\n \"0.5659331\",\n \"0.56494445\",\n \"0.5647269\",\n \"0.56421244\",\n \"0.5641537\",\n \"0.5632938\",\n \"0.56285226\",\n \"0.5628479\",\n \"0.56274927\",\n \"0.56254315\",\n \"0.5622793\",\n \"0.5621616\",\n \"0.5616078\",\n \"0.56126964\",\n \"0.56095874\",\n \"0.5604967\",\n \"0.56021106\",\n \"0.5597396\",\n \"0.55957556\",\n \"0.5592528\",\n \"0.5586756\",\n \"0.55841744\",\n \"0.5582733\",\n \"0.55737144\",\n \"0.55701154\",\n \"0.55675507\",\n \"0.5558895\",\n \"0.5557123\",\n \"0.5550006\",\n \"0.5549016\",\n \"0.5540089\",\n \"0.5537978\",\n \"0.55326205\",\n \"0.55278736\",\n \"0.552377\",\n \"0.5522408\",\n \"0.5521384\",\n \"0.55205303\",\n \"0.55119884\",\n \"0.55073804\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.66602564"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":78587,"cells":{"query":{"kind":"string","value":"Function finds entropy of a given set of class labels"},"document":{"kind":"string","value":"def entropy ( target_array ):\n return -1 * sum (\n [\n pipe ( np.sum ( target_array == value ) / len ( target_array ), lambda ratio: ratio * np.log ( ratio ) )\n for value in set ( target_array )\n ]\n ) # End entropy()"},"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 __entropy(self, labels):\n class_probs = np.unique(labels, return_counts=True)[1] / labels.size\n class_prob_logs = np.log2(class_probs)\n entropy = -np.sum(class_probs * class_prob_logs)\n return entropy","def get_entropy(*labels):\n entropies = [] #list of entropy values from each subset\n total = 0 #total number of datapoints\n for subset in labels:\n n = len(subset)\n total += n\n counts = np.unique(subset, return_counts=True)[1] #frequency of unique values\n entropy = np.sum([-(i/n) * np.log2(i/n) for i in counts]) #subset entropy calcuation\n entropies.append((entropy, n))\n return np.sum([(n/total) * ent for n, ent in iter(entropies)])","def calculate_entropy(dataset) :\n\n num_entries = len(dataset)\n label_counts = {}\n for vector in dataset :\n # the label is at the last index of the data set\n current_label = vector[-1]\n if current_label not in label_counts :\n label_counts[current_label] = 0\n label_counts[current_label] += 1\n # Calculate the entropy\n entropy = 0.0\n for label in label_counts :\n # Calculate probability of each label within the dataset\n prob_of_label = label_counts[label]/num_entries\n # Since the entropy is the negative of the sum of all probability,\n # simply subtract it\n entropy -= prob_of_label * log(prob_of_label, 2)\n return entropy","def entropyOnSubset(data, class_label, indices=None):\n\tsubset = []\n\tif indices == None:\n\t\tsubset = data[:]\n\telse: \n\t\tsubset = data.loc[indices]\n\t\n\tsubset = subset[class_label].tolist()\n\tvalues = list(set(subset))\n\tentropy = 0\n\t\n\tfor i in values:\n\t\tpV = subset.count(i)/len(subset)\n\t\tentropy -= pV * np.log2(pV)\n\t\n\treturn entropy","def calc_entropy(data_set):\n size = len(data_set)\n label_counts = {}\n for feat_vector in data_set:\n label = feat_vector[-1]\n label_counts.setdefault(label, 0)\n label_counts[label] += 1\n\n entropy = 0.0\n for key, count in label_counts.iteritems():\n prob = float(count) / size\n entropy -= prob * log(prob, 2)\n\n return entropy","def get_entropy_of_labels(labels, base=None):\n\n n_labels = len(labels)\n\n if n_labels <= 1:\n return 0\n\n value,counts = np.unique(labels, return_counts=True)\n probs = counts / n_labels\n n_classes = np.count_nonzero(probs)\n\n if n_classes <= 1:\n return 0\n\n ent = 0.\n\n # Compute entropy\n base = e if base is None else base\n for i in probs:\n ent -= i * log(i, base)\n\n return ent","def condentropy(truelabels, labels):\n labels=array(labels)\n truelabels=array(truelabels)\n \n condent=0.\n for l in xrange(min(labels),max(labels)+1):\n sublabels = truelabels[ labels==l ]\n condent += len(sublabels)*chl_entropy( sublabels )\n return condent/float(len(labels))","def entropy(class_probabilities):\n return sum(-p * math.log(p, 2)\n for p in class_probabilities\n if p) #ignore 0's","def entropy(class_probabilities):\n return sum(-p * math.log(p,2)\n for p in class_probabilities\n if p)","def get_entropy(self, rows):\n label_count = defaultdict(int)\n total_count = 0\n for row in rows:\n label = row[self.target_attribute]\n label_count[label] += 1\n total_count += 1\n return sum([-(float(label_count[label]) /\n total_count) * np.log2(float(label_count[label]) / total_count)\n for label in label_count.keys()])","def _entropy2(labels, base=None):\n\n n_labels = len(labels)\n\n if n_labels <= 1:\n return 0\n\n value,counts = np.unique(labels, return_counts=True)\n probs = counts / n_labels\n n_classes = np.count_nonzero(probs)\n\n if n_classes <= 1:\n return 0\n\n ent = 0.\n\n # Compute entropy\n base = e if base is None else base\n for i in probs:\n ent -= i * log(i, base)\n\n # quick observation shows ent between 0.0 and 4.0.\n return ent","def calculate_entropy(y):\n\tlog2 = lambda x: math.log(x) / math.log(2)\n\tunique_labels = np.unique(y)\n\tentropy = 0\n\tfor label in unique_labels:\n\t\tcount = len(y[y == label])\n\t\tp = count / len(y)\n\t\tentropy += -p * log2(p)\n\treturn entropy","def entropy(self,classData):\n\n\t\t###### your implementation below ######\n\t\ttotalEntropy = 0\n\t\ttempSet = {}\n\t\tfor i in range(len(classData)):\n\t\t\ttempSet[classData[i]] = (classData.count(classData[i]))\n\t\ttotal = sum(tempSet.values())\n\t\tfor x in tempSet:\n\t\t\ttotalEntropy += -(tempSet[x]/total * math.log(tempSet[x]/total, 2))\n\t\treturn totalEntropy","def find_entropy(examples_set):\n pk = find_probabilities_of_labels(examples_set)\n result = 0\n for p in pk:\n if p != 0:\n result = result + (p * math.log(p, 2.0))\n\n result = -result\n return result","def calculate_entropy(self, tags):\n tags_counter = Counter()\n\n if not tags:\n return 0\n\n for tag in tags:\n tags_counter[tag] += 1\n classes_probs = [tags_counter[tag] / float(len(tags)) for tag in tags_counter]\n if 0.0 in classes_probs:\n return 0\n\n entropy = 0\n for prob in classes_probs:\n entropy -= prob * math.log(prob, 2)\n\n return entropy","def get_entropy(self, documents):\n entropy = 0\n for c in self.classes:\n count = 0\n for document in documents:\n if document.c == c:\n count += 1\n if count != 0 and len(documents) != 0:\n ratio = count / len(documents)\n entropy -= ratio * log(ratio, 2)\n return entropy","def entropy(group_counts):\n total = sum(group_counts)\n entro = 0\n for item_count in group_counts:\n entro += item_entropy(item_count, total)\n return entro","def _entropy(self, feature, node):\n entropy = 0\n categories = np.unique(feature)\n num_point = len(feature)\n for category in categories:\n # for each category in that feature\n num_category = len(feature[feature == category])\n for c in self.num_class:\n # count the number of each class\n num_category_class = len(feature[np.logical_and(feature == category, node.y == c)])\n if num_category_class == 0:\n continue\n # compute entropy/information gain or classification error\n entropy += num_category / num_point * (\n -num_category_class / num_category * log2(num_category_class / num_category))\n return entropy","def entropy(Y):\n\n temp = np.unique(Y, return_counts=True)\n uniq_Y = list(temp[0])\n Y_count = list(temp[1])\n \n total = sum(Y_count)\n\n ent = 0\n for elem in uniq_Y:\n prob = Y_count[uniq_Y.index(elem)] / total\n # print(\"prob:\", prob)\n ent -= (prob * (math.log2(prob)))\n # print(\"ent:\",ent)\n\n return ent","def entropy(self, dataset, target_attr):\n freq = {} #A dictionary to counts how many samples for each target classification \n data_entropy = 0.0\n samplenumbers = len(dataset) #Total number of samplers in data set\n \n #Calculate the frequency of each of the values in the target attribute\n for record in dataset:\n if (record[target_attr] in freq):\n freq[record[target_attr]] += 1.0\n else:\n freq[record[target_attr]] = 1.0\n \n # Calculate the entropy of the data for the target attribute\n for freq in list(freq.values()):\n data_entropy += (-freq/samplenumbers) * math.log(freq/samplenumbers, 2) \n \n return data_entropy","def entropy(data):\n strings, lens = Counter(data), np.float(len(data))\n return -sum(count / lens * np.log2(count / lens) for count in strings.values())","def GetEntropy(flanks):\n countA = 0\n countT = 0\n countG = 0\n countC = 0\n for i in flanks:\n if i == \"A\":\n countA += 1\n elif i == \"T\":\n countT += 1\n elif i == \"C\":\n countC += 1\n elif i == \"G\":\n countG += 1\n else: pass\n total = countA+countT+countG+countC\n fractions = [item*1.0/total for item in [countA,countT,countG,countC]]\n entropy = sum([-1.0*item*math.log(item,2) for item in fractions if item != 0])\n return entropy","def entropy(self, **kwargs) -> TensorType:","def entropy(self, **kwargs) -> TensorType:","def compute_class_freqs(gen):\r\n labels = gen.labels\r\n N = labels.shape[0]\r\n positive_frequencies = np.sum(labels, axis=0) / N\r\n negative_frequencies = np.sum(1 - labels, axis=0) / N\r\n return positive_frequencies, negative_frequencies","def entropy(y):\n EPS = 0.0005\n\n # YOUR CODE HERE\n if len(y) == 0:\n return 0.\n \n pk = np.mean(y, axis=0)\n \n return - np.sum(pk * np.log(pk + EPS))","def compute_class_freqs(labels):\n ### START CODE HERE (REPLACE INSTANCES OF 'None' with your code) ###\n \n # total number of patients (rows)\n N = len(labels)\n \n positive_frequencies = np.sum(labels,axis=0)/N\n negative_frequencies = 1-positive_frequencies\n\n ### END CODE HERE ###\n return positive_frequencies, negative_frequencies","def entropy(Y):\n unique, count = np.unique(Y, return_counts=True, axis=0)\n prob = count/len(Y)\n en = np.sum((-1)*prob*np.log2(prob))\n return en","def entropy(self, y):\n n = y.size\n if n <= 1:\n return 0\n\n labels, counts = unique(y, return_counts=True)\n\n if counts.size <= 1:\n return 0\n\n probs = counts / n\n entropy = -sum([p * log(p, 2) for p in probs])\n return entropy","def ig(X, y):\n\n # binarization: from counts to presence/abscence\n binarize(X, threshold=0.0, copy=False)\n\n # una columna por cada clase\n Y = LabelBinarizer().fit_transform(y)\n if Y.shape[1] == 1: # binary problem case\n Y = np.append(1-Y, Y, axis=1)\n\n Y_prob = (np.sum(Y, axis=0, dtype=np.float64) / len(Y)).reshape(-1, 1)\n\n # calculate the class entropy H(Y)\n class_entropy = _entropy(Y_prob)\n\n X_y_count = safe_sparse_dot(Y.T, X)\n # TODO XXX FIXME ver si estoy calculando bien esta probabilidad\n X_y_prob = \\\n X_y_count / np.sum(X_y_count, axis=0, dtype=np.float64)\n\n # calculate the conditional entropy of the class given the feature H(y|f_i)\n cond_entropy = _entropy(X_y_prob) # TODO XXX FIXME ver si estoy calculando bien la entropia condicional\n print \"class:\", class_entropy\n print \"cond_entropy:\", cond_entropy\n\n infogain = class_entropy - cond_entropy\n\n return infogain, None","def entropy(data):\n\n freqs = {}\n suma = len(data)\n\n for i in range(0, len(data)):\n freqs[data[i]] = 1.0 + freqs.get(data[i], 0)\n\n res = 0.0\n for i in freqs:\n res += (freqs[i] / suma) * log((freqs[i] / suma), 2)\n return -res","def entropy(y):\n return -1 * sum(\n [\n pipe(np.sum(y == value) / len(y), lambda ratio: ratio * np.log(ratio))\n for value in set(y)\n ]\n )","def calculate_cross_entropy(self, output, flat_labels): #completed, expensive, should be compiled\n return -np.sum(np.log(np.clip(output, a_min=1E-12, a_max=1.0))[np.arange(flat_labels.shape[0]), flat_labels[:,1]])","def entropy(y):\r\n\r\n # INSERT YOUR CODE HERE\r\n value, count = np.unique(y,return_counts = True)\r\n Hy = 0.0\r\n prob = count.astype(float)/len(y)\r\n for p in prob:\r\n Hy += -(p)*(np.log2(p))\r\n return Hy\r\n raise Exception('Function not yet implemented!')","def entropy(rows, resCol = None):\n from math import log\n if not resCol: #create the dictionary of counts for each class using pure python\n total = len(rows)\n counts = __uniqueCounts(rows)\n else: #Create the dictionary of counts for each class using pandas.\n assert 'index' in dir(rows)\n total = len(rows.index)\n counts = __uniqueCountsPandas(rows, resCol)\n log2 = lambda x:log(x)/log(2) #Create a function to take log-base 2 of a number\n ent = 0 #Initialize the entropy at zero\n #Implement the formula for entropy, using log-base2\n fracs = [float(x)/total for x in counts.values()]\n for x in fracs:\n ent += -x*log2(x)\n return ent","def convert_logits_to_class_distribution(inputs: Tensor, n_classes: int) -> Tensor:\n\n # FIXME: This method is quite slow.\n output = torch.zeros((inputs.shape[0], n_classes))\n for idx, row in enumerate(inputs):\n values, counts = torch.unique(row, return_counts=True)\n output[idx, values.int().numpy()] = counts.float()\n return output / inputs.shape[1]","def entropyCategorical(attr, X, y):\n uniques = X[attr].unique().tolist()\n idxLists = []\n entropies = []\n weights = []\n for u in uniques:\n idxLists.append(X.index[X[attr] == u].tolist())\n entropies.append(entropy(y, idxLists[-1]))\n weights.append(len(idxLists[-1]))\n\n entropies = np.array(entropies).reshape(1, -1)\n weights = np.array(weights).reshape(-1, 1).astype(np.float32)\n weights /= np.sum(weights)\n\n return (uniques, idxLists, (entropies @ weights)[0, 0])","def entropy(y):\n total = y.size\n value_counts = np.bincount(y).astype(\"float\")\n proportions = value_counts / y.size\n\n return sum(-i * np.log(i) for i in proportions if i)","def entropy(*args):\n\n\n values = []\n leaf = -1\n\n for i, val in enumerate(args):\n if(val != 0):\n values.append(val * math.log(val, len(args)))\n if(val == 1):\n leaf = i\n \n return -sum(values), leaf","def categorical_crossentropy(predictions, targets):\n return theano.tensor.nnet.categorical_crossentropy(predictions, targets)","def categorical_crossentropy(predictions, targets):\n return theano.tensor.nnet.categorical_crossentropy(predictions, targets)","def encode_labels(labels, nclass=5):\n y = np.zeros((len(labels), nclass)).astype('float32')\n for j, yj in enumerate(labels):\n for i in range(nclass):\n if i+1 == np.floor(yj) + 1:\n y[j, i] = yj - np.floor(yj)\n if i+1 == np.floor(yj):\n y[j, i] = np.floor(yj) - yj + 1\n return y","def loss(labels, logits):\n return sparse_categorical_crossentropy(labels, logits, from_logits=True)","def my_softmax_cross_entropy(preds, labels):\n loss = tf.nn.softmax_cross_entropy_with_logits(logits=preds, labels=labels)\n # loss = tf.nn.weighted_cross_entropy_with_logits(logits=preds, targets=labels, pos_weight=0.1)\n return tf.reduce_mean(loss)","def class_distribution(y): \n # ===================== PLEASE WRITE HERE =====================\n \n bin_array = np.bincount(y)\n n_class1 = bin_array[1]\n n_class2 = bin_array[2]\n n_class3 = bin_array[3]\n \n # ===================== PLEASE WRITE HERE =====================\n \n print('Number of samples in class_1:', n_class1)\n print('Number of samples in class_2:', n_class2)\n print('Number of samples in class_3:', n_class3)","def classification_loss(self, classes_true, classes_logits):\n entropy_fn = tf.nn.sparse_softmax_cross_entropy_with_logits\n\n classes_max = tf.argmax(classes_true, axis=1)\n class_loss = entropy_fn(\n labels=classes_max,\n logits=classes_logits)\n return class_loss","def compute_entropy(bincounts, include_zeros):\n num_total = tf.cast(tf.reduce_sum(bincounts), tf.float64)\n if not include_zeros:\n bincounts = bincounts[1:]\n mask = tf.greater(bincounts, 0)\n nonzero_bincounts = tf.cast(\n tf.boolean_mask(bincounts, mask), tf.float64)\n num_nonzero = tf.cast(tf.reduce_sum(nonzero_bincounts), tf.float64)\n log_nonzero_bincounts = tf.math.log(nonzero_bincounts)\n log_prob = log_nonzero_bincounts - tf.reduce_logsumexp(\n log_nonzero_bincounts)\n entropy = tf.math.reduce_sum(\n log_prob * tf.exp(log_prob)) / -tf.math.log(tf.cast(2, tf.float64))\n return entropy * num_nonzero / num_total","def entropy(self):\n raise NotImplementedError","def encode_labels(labels, nclass=5):\n Y = np.zeros((len(labels), nclass)).astype('float32')\n for j, y in enumerate(labels):\n for i in range(nclass):\n if i+1 == np.floor(y) + 1:\n Y[j,i] = y - np.floor(y)\n if i+1 == np.floor(y):\n Y[j,i] = np.floor(y) - y + 1\n return Y","def get_entropy(distribution, samples):\n entropy = -tf.reduce_sum(distribution.log_prob(samples), axis=1)\n return entropy","def entropy(s):\n p, lns = Counter(s), float(len(s))\n return -sum( count/lns * math.log(count/lns, 2) for count in p.values())","def entropy(counts):\n assert (counts >= 0).all()\n probs = counts / counts.sum()\n probs = probs[probs > 0] # Avoid log(0)\n return - np.sum(probs * np.log2(probs))","def calcDataEntropy(self, data, structure):\n classIndex, entropy = structure['class']['index'], 0\n for value in structure['class']['values']:\n newData = list(filter(lambda y: y[classIndex] == value, data))\n p = len(newData) / len(data) if len(data) > 0 else 1\n entropy += (-1) * (p * log2(p)) if p > 0 else 0\n return round(entropy, 3)","def compute_entropy(sampled, dataset, model, train_args):\n all_entropy = None\n data = Subset(dataset, sampled)\n sampler = SequentialSampler(data)\n dataloader = DataLoader(data, sampler=sampler, batch_size=train_args.per_gpu_eval_batch_size)\n for batch in tqdm(dataloader, desc=\"Computing entropy\"):\n batch = tuple(t.to(train_args.device) for t in batch)\n with torch.no_grad():\n inputs = {\"input_ids\": batch[0], \"attention_mask\": batch[1]}\n if train_args.model_type != \"distilbert\":\n inputs[\"token_type_ids\"] = (\n batch[2] if train_args.model_type in [\"bert\", \"xlnet\", \"albert\"] else None\n ) # XLM, DistilBERT, RoBERTa, and XLM-RoBERTa don't use segment_ids\n outputs = model(**inputs)\n logits = outputs[0]\n categorical = Categorical(logits = logits)\n entropy = categorical.entropy()\n if all_entropy is None:\n all_entropy = entropy.detach().cpu().numpy()\n else:\n all_entropy = np.append(all_entropy, entropy.detach().cpu().numpy(), axis=0)\n avg_entropy = all_entropy.mean()\n return avg_entropy","def entropy(d, total, word_count):\n\t# Entropie je - Sum_morf p(morf) * log_2 p(morf)\n\t# p(morf) = c(morf) / c(all)\n\te = 0\n\tfor count in d.values():\n\t\tp = count/total\n\t\ttype_e = - p * log2(p)\n\t\te += type_e * count\n\treturn e / word_count","def _class_distribution(y):\n unique, counts = np.unique(y, return_counts = True)\n\n percentages = counts / np.sum(counts)\n\n return unique, counts, percentages","def entropy(l):\n\n probabilities = np.bincount(l) / len(l)\n with np.errstate(divide='ignore'): # ignore log(0) errors, we'll handle\n log_probabilities = np.log2(probabilities)\n log_probabilities[~np.isfinite(log_probabilities)] = 0\n return -np.sum(probabilities * log_probabilities)","def _entropy(self, y):\n # Get size\n n = y.shape[0]\n summation = 0\n\n # Summatory\n for c_i in np.unique(y):\n prob = sum(y == c_i) / float(n)\n summation += prob * np.log2(prob)\n\n return -summation","def calculate_entropy(eval_token_count, training_model):\n sum_of_counts = sum(eval_token_count.values())\n cross_entropy = 0\n mis = []\n for ngram in eval_token_count:\n if training_model.score(ngram[-1], list(ngram[0:3])) == 0 or sum_of_counts == 0:\n mi = np.mean(mis) if len(mis) > 0 else np.log2(0.287)\n else:\n mi = training_model.logscore(ngram[-1], list(ngram[0:3]))\n pi = eval_token_count[ngram] / sum_of_counts\n mis.append(mi)\n cross_entropy -= pi * mi\n return cross_entropy","def __entropy(self, data_set, target_feature):\n frequencies = self.__calculate_frequency(data_set, target_feature)\n feature_entropy = 0.0\n number_of_values = len(data_set)\n\n # Add entropy for each value in frequencies.\n for frequency in frequencies:\n probability = frequencies[frequency] / number_of_values\n feature_entropy += (probability * math.log(probability, 2))\n\n return feature_entropy * -1","def entropy(self, text):\n\n# text = self.myReplacer.replace(text)\n# text = self.tokenizer.tokenize(text)\n new_text = []\n for word in text:\n if word.count('\\'') > 0:\n words = word.split('\\'')\n for w in words:\n new_text.append(w)\n else:\n new_text.append(word)\n text = new_text\n \n e = 0.0\n lenth = len(text)\n if lenth == 0:\n return 0\n elif lenth < self._n:\n current_n = lenth\n else:\n current_n = self._n\n \n for i in range(current_n - 1, len(text)):\n context = tuple(text[(i - current_n + 1) : i])\n token = text[i]\n e += self.logprob(token, context)\n return e","def labels_to_labels(class_labels, num_classes =4):\n levels = []\n for label in class_labels:\n levels_from_label = label_to_levels(int(label), num_classes=num_classes)\n levels.append(levels_from_label)\n return torch.stack(levels).cuda()","def loss(logits, labels):\n labels = tf.to_int64(labels)\n# labels = tf.to_float(labels)\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=labels, logits=logits, name='xentropy')\n# y_conv = tf.nn.softmax(logits)\n# cross_entropy = -tf.reduce_sum(labels*tf.log(y_conv))\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')","def entropy(data, idxList):\n df = data.loc[idxList]\n counts = df.value_counts().to_numpy()\n counts = counts.reshape(1, -1).astype(np.float32)\n counts /= np.sum(counts)\n log_sum = counts @ np.log2(counts.T)\n return -log_sum[0, 0]","def cross_entropy_loss(outputs, labels): \n# works properly\n \n m = labels.shape[0]\n p = outputs\n log_likelihood = -1*torch.log(p[range(m),labels])\n loss = torch.sum(log_likelihood) / m\n return loss.item()","def entropy(x):\n nz = np.nonzero(x)[0]\n return -np.sum(x[nz]*np.log2(x[nz]))","def predictive_entropy(mc_preds):\n return entropy(np.mean(mc_preds, axis=0))","def calc_entropy_classification(dataset_entropies, max_thresh_value, num_outlier_threshs=50):\n\n dataset_outliers = []\n threshs = []\n\n total_dataset = float(len(dataset_entropies))\n\n # loop through each rejection prior value and evaluate the percentage of the dataset being considered as\n # statistical outliers, i.e. each data point's outlier probability > rejection prior.\n for i in range(num_outlier_threshs - 1):\n outlier_threshold = (i + 1) * (max_thresh_value / num_outlier_threshs)\n threshs.append(outlier_threshold)\n\n dataset_outliers.append(0)\n\n for k in range(len(dataset_entropies)):\n if dataset_entropies[k] > outlier_threshold:\n dataset_outliers[i] += 1\n\n dataset_outliers[i] = dataset_outliers[i] / total_dataset\n\n return {\"entropy_thresholds\": threshs, \"entropy_outlier_percentage\": dataset_outliers}","def entropy(data):\n e = 0\n\n counter = collections.Counter(data)\n l = len(data)\n for count in counter.values():\n p_x = count / l\n e += - p_x * math.log2(p_x)\n\n return e","def entropy(dist):\n #dist = array([max(d,1e-100) for d in dist])\n dist = dist + 1e-20\n return dot(dist,(log(1.0/dist) * (1.0/log(2.0))).T)","def entropy_fn(args: StepFunctionArgs) -> SingleScorePerStepTensor:\n logits = args.attribution_model.output2logits(args.forward_output)\n out = torch.distributions.Categorical(logits=logits).entropy()\n if out.ndim > 1:\n out = out.squeeze(-1)\n return out","def entropy(target_col):\n elements,counts = np.unique(target_col,return_counts = True)\n entropy = np.sum([(-counts[i]/np.sum(counts))*np.log2(counts[i]/np.sum(counts)) for i in range(len(elements))])\n return entropy","def entropy(probabilities):\n return -(sum([p * log(p, 2) if p > 0 else 0 for p in probabilities]))","def mean_ent(cluster_assignments):\n nrow, ncol, nrun = cluster_assignments.shape\n csum = cluster_assignments.sum(axis=2)\n m = numpy.mean([scipy.stats.entropy(row) for row in csum])\n return m","def entropy(a):\n a = a.upper()\n\n freq = collections.defaultdict(int) # int() is the default constructor for non existent item, and returns 0\n for c in a:\n freq[c] = freq[c] + 1\n\n e = 0.0\n for f in freq.values():\n if f:\n p = f / len(a)\n e += p * math.log(p)\n\n return -e","def loss(self, logits, labels):\n loss = tf.keras.losses.sparse_categorical_crossentropy(labels, logits)\n return tf.reduce_mean(loss)","def entropy( freq ):\n N = 0.0\n entropy = 0.0\n for x, v in freq.items( ):\n N += v\n entropy -= v * math.log( v, 2 )\n return (N * math.log( N, 2 ) + entropy) / N","def entropy(self, unlabeled_sequence):\n unlabeled_sequence = self._transform(unlabeled_sequence)\n\n T = len(unlabeled_sequence)\n N = len(self._states)\n\n alpha = self._forward_probability(unlabeled_sequence)\n beta = self._backward_probability(unlabeled_sequence)\n normalisation = logsumexp2(alpha[T - 1])\n\n entropy = normalisation\n\n # starting state, t = 0\n for i, state in enumerate(self._states):\n p = 2 ** (alpha[0, i] + beta[0, i] - normalisation)\n entropy -= p * self._priors.logprob(state)\n # print('p(s_0 = %s) =' % state, p)\n\n # state transitions\n for t0 in range(T - 1):\n t1 = t0 + 1\n for i0, s0 in enumerate(self._states):\n for i1, s1 in enumerate(self._states):\n p = 2 ** (\n alpha[t0, i0]\n + self._transitions[s0].logprob(s1)\n + self._outputs[s1].logprob(unlabeled_sequence[t1][_TEXT])\n + beta[t1, i1]\n - normalisation\n )\n entropy -= p * self._transitions[s0].logprob(s1)\n # print('p(s_%d = %s, s_%d = %s) =' % (t0, s0, t1, s1), p)\n\n # symbol emissions\n for t in range(T):\n for i, state in enumerate(self._states):\n p = 2 ** (alpha[t, i] + beta[t, i] - normalisation)\n entropy -= p * self._outputs[state].logprob(\n unlabeled_sequence[t][_TEXT]\n )\n # print('p(s_%d = %s) =' % (t, state), p)\n\n return entropy","def cross_entropy(X, y, using_onehot=True):\n\tM = y.shape[0]\n\tif using_onehot :\n\t\tlog_likelihood = -np.log(np.max(X * y, -1))\n\telse:\n\t\tlog_likelihood = -np.log(X[range(M), y]) # 找到y对应的那个类别所对应的logit\n\tloss = np.sum(log_likelihood) / M\n\treturn loss","def softmax_cross_entropy(y, label):\r\n losses = np.sum((- np.log(y + g_epsilon) * label), axis=1)\r\n return losses\r\n pass","def calc_entropy(data_set): #calculates total entropy of the dataset\r\n republicans = 0\r\n democrats = 0\r\n total = 0\r\n for data_point in data_set:\r\n party = data_point.dat_party\r\n if party == \"R\":\r\n republicans+=1\r\n elif party == \"D\":\r\n democrats+=1\r\n total+=1\r\n\r\n if total == 0: return 0\r\n prob_dem = democrats/total\r\n prob_rep = republicans/total\r\n if prob_dem == 0: return -(prob_rep * math.log(prob_rep, 2))\r\n if prob_rep == 0: return -(prob_dem * math.log(prob_dem, 2))\r\n\r\n entropy = (-prob_dem * math.log(prob_dem, 2)) -(prob_rep * math.log(prob_rep, 2))\r\n return entropy","def cross_entropy_loss(logits, labels, label_smoothing=0., dtype=jnp.float32):\n num_classes = logits.shape[-1]\n labels = jax.nn.one_hot(labels, num_classes, dtype=dtype)\n if label_smoothing > 0:\n labels = labels * (1 - label_smoothing) + label_smoothing / num_classes\n logp = jax.nn.log_softmax(logits.astype(dtype))\n return -jnp.mean(jnp.sum(logp * labels, axis=-1))","def entropy(string):\n p, lns = Counter(string), float(len(string))\n return -sum(count/lns * math.log(count/lns, 2) for count in p.values())","def _entropy(data):\n hist = np.array(PIL.Image.fromarray(data).histogram())\n hist = hist / hist.sum()\n hist = hist[hist != 0]\n return -np.sum(hist * np.log2(hist))","def count_classes(labels):\n class_dict = {}\n for image in labels:\n for row in image:\n for label in row:\n if label not in class_dict:\n class_dict[label] = 1\n else:\n class_dict[label] += 1\n return class_dict","def calculate_class_weights(labels):\n class_counts = sorted(Counter(labels).items())\n num_items = [x[1] for x in class_counts]\n weights = [min(num_items)/x for x in num_items]\n\n return torch.tensor(weights)","def calc_conditional_entropy(map,data_stat,attribute):\n #acquire the data info of the attribute stored in data_stat\n data_info = data_stat[attribute]\n #acquire the label info\n # label_col = len(data_stat)-1\n label_col = data_stat.keys()[-1]\n # print(data_stat.keys())\n label_info = data_stat[label_col]\n #acquire the data \n data = map[attribute]\n labels = map[label_col]\n conditional_entropy =0\n for data_type in data_info:\n specific_entropy = 0\n for label_type in label_info: \n #attribute data indices where all data entries are equal to a speicifc value\n data_with_spec_val_idx = data_info[data_type]\n #label indices where all labels are of same value\n spec_label_idx = label_info[label_type]\n #the intersection of the two indices above\n intersect_idx = np.intersect1d(data_with_spec_val_idx,spec_label_idx)\n #conditional probability of label being of specific value given speicific data value\n temp_prob = len(intersect_idx)/float(len(data_with_spec_val_idx))\n if temp_prob!=0:\n specific_entropy += temp_prob*math.log(temp_prob,2)\n specific_entropy = -specific_entropy\n prob = len(data_with_spec_val_idx)/float(len(data))\n conditional_entropy += prob * specific_entropy\n return conditional_entropy","def cross_entropy(\n **kwargs\n) -> Callable:\n return categorical_crossentropy","def get_class_weights(img_paths: List[str], class_to_idx: Dict[str, int], label_names: List[str]):\n labels = list()\n for img_path in img_paths:\n label = os.path.basename(os.path.dirname(img_path))\n labels.append(class_to_idx[label]) \n\n counts = Counter(labels) + Counter([class_to_idx[name] for name in label_names])\n counts = np.array(sorted(counts.items()))[:,1]\n \n return counts.max()/counts","def cross_entropy_loss(self, logits, labels):\n return F.cross_entropy(logits, labels)","def softmax_cross_entropy_loss(logit, labels):\n p = softmax(logit)\n loss_i = - labels * np.log(p + 1e-8)\n return np.mean(loss_i)","def entropy(message):\n n = len(message)\n message = letter_freq(message)\n h = 0\n for n_i in message.values():\n p_i = n_i/n\n h += -p_i*(log2(p_i))\n return h","def find_entropy(less_than_threshold,more_than_threshold):\n\n ''' Storing total number of records '''\n total_records = len(less_than_threshold) + len(more_than_threshold)\n\n ''' Calculating the probability '''\n less_than_probability = len(less_than_threshold) / total_records\n more_than_probability = len(more_than_threshold) / total_records\n\n ''' Converting the dataframe to numpy arrays '''\n less_than_threshold_values = less_than_threshold.values\n more_than_threshold_values = more_than_threshold.values\n\n ''' Storing the target attribute values (Muffin or Cupcake) for threshold values '''\n target_for_less_than = less_than_threshold_values[:, -1]\n target_for_more_than = more_than_threshold_values[:, -1]\n\n ''' Finding the counts of muffin and cupcake for values lower than and greater than threshold value '''\n recipe_type, less_than_cupcake_muffin_count = np.unique(target_for_less_than, return_counts=True)\n recipe_type, more_than_cupcake_muffin_count = np.unique(target_for_more_than, return_counts=True)\n\n # print(recipe_type, more_than_cupcake_muffin_count, len(more_than_cupcake_muffin_count))\n ''' To ensure there are at least 5 records in each node '''\n if less_than_cupcake_muffin_count.sum() < 5 or more_than_cupcake_muffin_count.sum() < 5:\n ''' Return horrible badness '''\n return math.inf\n else:\n ''' Find the entropies for less than threshold values and more than threshold values '''\n less_than_entropy = sum((less_than_cupcake_muffin_count / less_than_cupcake_muffin_count.sum()) * - np.log2(\n less_than_cupcake_muffin_count / less_than_cupcake_muffin_count.sum()))\n more_than_entropy = sum((more_than_cupcake_muffin_count / more_than_cupcake_muffin_count.sum()) * - np.log2(\n more_than_cupcake_muffin_count / more_than_cupcake_muffin_count.sum()))\n\n ''' Calculate the total weighted entropy '''\n total_weighted_entropy = less_than_probability * less_than_entropy + more_than_probability * more_than_entropy\n\n return total_weighted_entropy","def entropy(y):\n p = _proba(y)\n return (-p * np.log2(p)).sum()","def classes_calculations(input):\n counts, _ = np.histogram(input, bins=int(\n input.max() + 1), range=(0, int(input.max())))\n return np.nonzero(counts)[0]","def loss(logits, labels):\n labels = tf.to_int64(labels)\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\n logits, labels, name='xentropy')\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')","def loss(logits, labels):\r\n labels = tf.to_int64(labels)\r\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\r\n labels=labels, logits=logits, name='xentropy')\r\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')","def loss(logits, labels):\r\n labels = tf.to_int64(labels)\r\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\r\n labels=labels, logits=logits, name='xentropy')\r\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')","def get_class_labels(self):\r\n \r\n y = self.get_data()['y']\r\n if type(y) == torch.Tensor:\r\n return y.unique().numpy()\r\n else:\r\n return sorted(list(set(y)))","def classify(self, features):\n\n # TODO: finish this.\n class_labels = []\n # TODO: finish this.\n features = np.array(features)\n feat_shape = features.shape\n for i in range(feat_shape[0]):\n vote = np.zeros((self.num_trees))\n for j in range(self.num_trees):\n #print self.trees[j].classify(feat)\n vote[j] = self.trees[j].classify(features[i,self.attr_track[j]].reshape(1,-1))[0]\n counts = np.bincount(vote.astype(int))\n class_labels.append(np.argmax(counts))\n return class_labels"],"string":"[\n \"def __entropy(self, labels):\\n class_probs = np.unique(labels, return_counts=True)[1] / labels.size\\n class_prob_logs = np.log2(class_probs)\\n entropy = -np.sum(class_probs * class_prob_logs)\\n return entropy\",\n \"def get_entropy(*labels):\\n entropies = [] #list of entropy values from each subset\\n total = 0 #total number of datapoints\\n for subset in labels:\\n n = len(subset)\\n total += n\\n counts = np.unique(subset, return_counts=True)[1] #frequency of unique values\\n entropy = np.sum([-(i/n) * np.log2(i/n) for i in counts]) #subset entropy calcuation\\n entropies.append((entropy, n))\\n return np.sum([(n/total) * ent for n, ent in iter(entropies)])\",\n \"def calculate_entropy(dataset) :\\n\\n num_entries = len(dataset)\\n label_counts = {}\\n for vector in dataset :\\n # the label is at the last index of the data set\\n current_label = vector[-1]\\n if current_label not in label_counts :\\n label_counts[current_label] = 0\\n label_counts[current_label] += 1\\n # Calculate the entropy\\n entropy = 0.0\\n for label in label_counts :\\n # Calculate probability of each label within the dataset\\n prob_of_label = label_counts[label]/num_entries\\n # Since the entropy is the negative of the sum of all probability,\\n # simply subtract it\\n entropy -= prob_of_label * log(prob_of_label, 2)\\n return entropy\",\n \"def entropyOnSubset(data, class_label, indices=None):\\n\\tsubset = []\\n\\tif indices == None:\\n\\t\\tsubset = data[:]\\n\\telse: \\n\\t\\tsubset = data.loc[indices]\\n\\t\\n\\tsubset = subset[class_label].tolist()\\n\\tvalues = list(set(subset))\\n\\tentropy = 0\\n\\t\\n\\tfor i in values:\\n\\t\\tpV = subset.count(i)/len(subset)\\n\\t\\tentropy -= pV * np.log2(pV)\\n\\t\\n\\treturn entropy\",\n \"def calc_entropy(data_set):\\n size = len(data_set)\\n label_counts = {}\\n for feat_vector in data_set:\\n label = feat_vector[-1]\\n label_counts.setdefault(label, 0)\\n label_counts[label] += 1\\n\\n entropy = 0.0\\n for key, count in label_counts.iteritems():\\n prob = float(count) / size\\n entropy -= prob * log(prob, 2)\\n\\n return entropy\",\n \"def get_entropy_of_labels(labels, base=None):\\n\\n n_labels = len(labels)\\n\\n if n_labels <= 1:\\n return 0\\n\\n value,counts = np.unique(labels, return_counts=True)\\n probs = counts / n_labels\\n n_classes = np.count_nonzero(probs)\\n\\n if n_classes <= 1:\\n return 0\\n\\n ent = 0.\\n\\n # Compute entropy\\n base = e if base is None else base\\n for i in probs:\\n ent -= i * log(i, base)\\n\\n return ent\",\n \"def condentropy(truelabels, labels):\\n labels=array(labels)\\n truelabels=array(truelabels)\\n \\n condent=0.\\n for l in xrange(min(labels),max(labels)+1):\\n sublabels = truelabels[ labels==l ]\\n condent += len(sublabels)*chl_entropy( sublabels )\\n return condent/float(len(labels))\",\n \"def entropy(class_probabilities):\\n return sum(-p * math.log(p, 2)\\n for p in class_probabilities\\n if p) #ignore 0's\",\n \"def entropy(class_probabilities):\\n return sum(-p * math.log(p,2)\\n for p in class_probabilities\\n if p)\",\n \"def get_entropy(self, rows):\\n label_count = defaultdict(int)\\n total_count = 0\\n for row in rows:\\n label = row[self.target_attribute]\\n label_count[label] += 1\\n total_count += 1\\n return sum([-(float(label_count[label]) /\\n total_count) * np.log2(float(label_count[label]) / total_count)\\n for label in label_count.keys()])\",\n \"def _entropy2(labels, base=None):\\n\\n n_labels = len(labels)\\n\\n if n_labels <= 1:\\n return 0\\n\\n value,counts = np.unique(labels, return_counts=True)\\n probs = counts / n_labels\\n n_classes = np.count_nonzero(probs)\\n\\n if n_classes <= 1:\\n return 0\\n\\n ent = 0.\\n\\n # Compute entropy\\n base = e if base is None else base\\n for i in probs:\\n ent -= i * log(i, base)\\n\\n # quick observation shows ent between 0.0 and 4.0.\\n return ent\",\n \"def calculate_entropy(y):\\n\\tlog2 = lambda x: math.log(x) / math.log(2)\\n\\tunique_labels = np.unique(y)\\n\\tentropy = 0\\n\\tfor label in unique_labels:\\n\\t\\tcount = len(y[y == label])\\n\\t\\tp = count / len(y)\\n\\t\\tentropy += -p * log2(p)\\n\\treturn entropy\",\n \"def entropy(self,classData):\\n\\n\\t\\t###### your implementation below ######\\n\\t\\ttotalEntropy = 0\\n\\t\\ttempSet = {}\\n\\t\\tfor i in range(len(classData)):\\n\\t\\t\\ttempSet[classData[i]] = (classData.count(classData[i]))\\n\\t\\ttotal = sum(tempSet.values())\\n\\t\\tfor x in tempSet:\\n\\t\\t\\ttotalEntropy += -(tempSet[x]/total * math.log(tempSet[x]/total, 2))\\n\\t\\treturn totalEntropy\",\n \"def find_entropy(examples_set):\\n pk = find_probabilities_of_labels(examples_set)\\n result = 0\\n for p in pk:\\n if p != 0:\\n result = result + (p * math.log(p, 2.0))\\n\\n result = -result\\n return result\",\n \"def calculate_entropy(self, tags):\\n tags_counter = Counter()\\n\\n if not tags:\\n return 0\\n\\n for tag in tags:\\n tags_counter[tag] += 1\\n classes_probs = [tags_counter[tag] / float(len(tags)) for tag in tags_counter]\\n if 0.0 in classes_probs:\\n return 0\\n\\n entropy = 0\\n for prob in classes_probs:\\n entropy -= prob * math.log(prob, 2)\\n\\n return entropy\",\n \"def get_entropy(self, documents):\\n entropy = 0\\n for c in self.classes:\\n count = 0\\n for document in documents:\\n if document.c == c:\\n count += 1\\n if count != 0 and len(documents) != 0:\\n ratio = count / len(documents)\\n entropy -= ratio * log(ratio, 2)\\n return entropy\",\n \"def entropy(group_counts):\\n total = sum(group_counts)\\n entro = 0\\n for item_count in group_counts:\\n entro += item_entropy(item_count, total)\\n return entro\",\n \"def _entropy(self, feature, node):\\n entropy = 0\\n categories = np.unique(feature)\\n num_point = len(feature)\\n for category in categories:\\n # for each category in that feature\\n num_category = len(feature[feature == category])\\n for c in self.num_class:\\n # count the number of each class\\n num_category_class = len(feature[np.logical_and(feature == category, node.y == c)])\\n if num_category_class == 0:\\n continue\\n # compute entropy/information gain or classification error\\n entropy += num_category / num_point * (\\n -num_category_class / num_category * log2(num_category_class / num_category))\\n return entropy\",\n \"def entropy(Y):\\n\\n temp = np.unique(Y, return_counts=True)\\n uniq_Y = list(temp[0])\\n Y_count = list(temp[1])\\n \\n total = sum(Y_count)\\n\\n ent = 0\\n for elem in uniq_Y:\\n prob = Y_count[uniq_Y.index(elem)] / total\\n # print(\\\"prob:\\\", prob)\\n ent -= (prob * (math.log2(prob)))\\n # print(\\\"ent:\\\",ent)\\n\\n return ent\",\n \"def entropy(self, dataset, target_attr):\\n freq = {} #A dictionary to counts how many samples for each target classification \\n data_entropy = 0.0\\n samplenumbers = len(dataset) #Total number of samplers in data set\\n \\n #Calculate the frequency of each of the values in the target attribute\\n for record in dataset:\\n if (record[target_attr] in freq):\\n freq[record[target_attr]] += 1.0\\n else:\\n freq[record[target_attr]] = 1.0\\n \\n # Calculate the entropy of the data for the target attribute\\n for freq in list(freq.values()):\\n data_entropy += (-freq/samplenumbers) * math.log(freq/samplenumbers, 2) \\n \\n return data_entropy\",\n \"def entropy(data):\\n strings, lens = Counter(data), np.float(len(data))\\n return -sum(count / lens * np.log2(count / lens) for count in strings.values())\",\n \"def GetEntropy(flanks):\\n countA = 0\\n countT = 0\\n countG = 0\\n countC = 0\\n for i in flanks:\\n if i == \\\"A\\\":\\n countA += 1\\n elif i == \\\"T\\\":\\n countT += 1\\n elif i == \\\"C\\\":\\n countC += 1\\n elif i == \\\"G\\\":\\n countG += 1\\n else: pass\\n total = countA+countT+countG+countC\\n fractions = [item*1.0/total for item in [countA,countT,countG,countC]]\\n entropy = sum([-1.0*item*math.log(item,2) for item in fractions if item != 0])\\n return entropy\",\n \"def entropy(self, **kwargs) -> TensorType:\",\n \"def entropy(self, **kwargs) -> TensorType:\",\n \"def compute_class_freqs(gen):\\r\\n labels = gen.labels\\r\\n N = labels.shape[0]\\r\\n positive_frequencies = np.sum(labels, axis=0) / N\\r\\n negative_frequencies = np.sum(1 - labels, axis=0) / N\\r\\n return positive_frequencies, negative_frequencies\",\n \"def entropy(y):\\n EPS = 0.0005\\n\\n # YOUR CODE HERE\\n if len(y) == 0:\\n return 0.\\n \\n pk = np.mean(y, axis=0)\\n \\n return - np.sum(pk * np.log(pk + EPS))\",\n \"def compute_class_freqs(labels):\\n ### START CODE HERE (REPLACE INSTANCES OF 'None' with your code) ###\\n \\n # total number of patients (rows)\\n N = len(labels)\\n \\n positive_frequencies = np.sum(labels,axis=0)/N\\n negative_frequencies = 1-positive_frequencies\\n\\n ### END CODE HERE ###\\n return positive_frequencies, negative_frequencies\",\n \"def entropy(Y):\\n unique, count = np.unique(Y, return_counts=True, axis=0)\\n prob = count/len(Y)\\n en = np.sum((-1)*prob*np.log2(prob))\\n return en\",\n \"def entropy(self, y):\\n n = y.size\\n if n <= 1:\\n return 0\\n\\n labels, counts = unique(y, return_counts=True)\\n\\n if counts.size <= 1:\\n return 0\\n\\n probs = counts / n\\n entropy = -sum([p * log(p, 2) for p in probs])\\n return entropy\",\n \"def ig(X, y):\\n\\n # binarization: from counts to presence/abscence\\n binarize(X, threshold=0.0, copy=False)\\n\\n # una columna por cada clase\\n Y = LabelBinarizer().fit_transform(y)\\n if Y.shape[1] == 1: # binary problem case\\n Y = np.append(1-Y, Y, axis=1)\\n\\n Y_prob = (np.sum(Y, axis=0, dtype=np.float64) / len(Y)).reshape(-1, 1)\\n\\n # calculate the class entropy H(Y)\\n class_entropy = _entropy(Y_prob)\\n\\n X_y_count = safe_sparse_dot(Y.T, X)\\n # TODO XXX FIXME ver si estoy calculando bien esta probabilidad\\n X_y_prob = \\\\\\n X_y_count / np.sum(X_y_count, axis=0, dtype=np.float64)\\n\\n # calculate the conditional entropy of the class given the feature H(y|f_i)\\n cond_entropy = _entropy(X_y_prob) # TODO XXX FIXME ver si estoy calculando bien la entropia condicional\\n print \\\"class:\\\", class_entropy\\n print \\\"cond_entropy:\\\", cond_entropy\\n\\n infogain = class_entropy - cond_entropy\\n\\n return infogain, None\",\n \"def entropy(data):\\n\\n freqs = {}\\n suma = len(data)\\n\\n for i in range(0, len(data)):\\n freqs[data[i]] = 1.0 + freqs.get(data[i], 0)\\n\\n res = 0.0\\n for i in freqs:\\n res += (freqs[i] / suma) * log((freqs[i] / suma), 2)\\n return -res\",\n \"def entropy(y):\\n return -1 * sum(\\n [\\n pipe(np.sum(y == value) / len(y), lambda ratio: ratio * np.log(ratio))\\n for value in set(y)\\n ]\\n )\",\n \"def calculate_cross_entropy(self, output, flat_labels): #completed, expensive, should be compiled\\n return -np.sum(np.log(np.clip(output, a_min=1E-12, a_max=1.0))[np.arange(flat_labels.shape[0]), flat_labels[:,1]])\",\n \"def entropy(y):\\r\\n\\r\\n # INSERT YOUR CODE HERE\\r\\n value, count = np.unique(y,return_counts = True)\\r\\n Hy = 0.0\\r\\n prob = count.astype(float)/len(y)\\r\\n for p in prob:\\r\\n Hy += -(p)*(np.log2(p))\\r\\n return Hy\\r\\n raise Exception('Function not yet implemented!')\",\n \"def entropy(rows, resCol = None):\\n from math import log\\n if not resCol: #create the dictionary of counts for each class using pure python\\n total = len(rows)\\n counts = __uniqueCounts(rows)\\n else: #Create the dictionary of counts for each class using pandas.\\n assert 'index' in dir(rows)\\n total = len(rows.index)\\n counts = __uniqueCountsPandas(rows, resCol)\\n log2 = lambda x:log(x)/log(2) #Create a function to take log-base 2 of a number\\n ent = 0 #Initialize the entropy at zero\\n #Implement the formula for entropy, using log-base2\\n fracs = [float(x)/total for x in counts.values()]\\n for x in fracs:\\n ent += -x*log2(x)\\n return ent\",\n \"def convert_logits_to_class_distribution(inputs: Tensor, n_classes: int) -> Tensor:\\n\\n # FIXME: This method is quite slow.\\n output = torch.zeros((inputs.shape[0], n_classes))\\n for idx, row in enumerate(inputs):\\n values, counts = torch.unique(row, return_counts=True)\\n output[idx, values.int().numpy()] = counts.float()\\n return output / inputs.shape[1]\",\n \"def entropyCategorical(attr, X, y):\\n uniques = X[attr].unique().tolist()\\n idxLists = []\\n entropies = []\\n weights = []\\n for u in uniques:\\n idxLists.append(X.index[X[attr] == u].tolist())\\n entropies.append(entropy(y, idxLists[-1]))\\n weights.append(len(idxLists[-1]))\\n\\n entropies = np.array(entropies).reshape(1, -1)\\n weights = np.array(weights).reshape(-1, 1).astype(np.float32)\\n weights /= np.sum(weights)\\n\\n return (uniques, idxLists, (entropies @ weights)[0, 0])\",\n \"def entropy(y):\\n total = y.size\\n value_counts = np.bincount(y).astype(\\\"float\\\")\\n proportions = value_counts / y.size\\n\\n return sum(-i * np.log(i) for i in proportions if i)\",\n \"def entropy(*args):\\n\\n\\n values = []\\n leaf = -1\\n\\n for i, val in enumerate(args):\\n if(val != 0):\\n values.append(val * math.log(val, len(args)))\\n if(val == 1):\\n leaf = i\\n \\n return -sum(values), leaf\",\n \"def categorical_crossentropy(predictions, targets):\\n return theano.tensor.nnet.categorical_crossentropy(predictions, targets)\",\n \"def categorical_crossentropy(predictions, targets):\\n return theano.tensor.nnet.categorical_crossentropy(predictions, targets)\",\n \"def encode_labels(labels, nclass=5):\\n y = np.zeros((len(labels), nclass)).astype('float32')\\n for j, yj in enumerate(labels):\\n for i in range(nclass):\\n if i+1 == np.floor(yj) + 1:\\n y[j, i] = yj - np.floor(yj)\\n if i+1 == np.floor(yj):\\n y[j, i] = np.floor(yj) - yj + 1\\n return y\",\n \"def loss(labels, logits):\\n return sparse_categorical_crossentropy(labels, logits, from_logits=True)\",\n \"def my_softmax_cross_entropy(preds, labels):\\n loss = tf.nn.softmax_cross_entropy_with_logits(logits=preds, labels=labels)\\n # loss = tf.nn.weighted_cross_entropy_with_logits(logits=preds, targets=labels, pos_weight=0.1)\\n return tf.reduce_mean(loss)\",\n \"def class_distribution(y): \\n # ===================== PLEASE WRITE HERE =====================\\n \\n bin_array = np.bincount(y)\\n n_class1 = bin_array[1]\\n n_class2 = bin_array[2]\\n n_class3 = bin_array[3]\\n \\n # ===================== PLEASE WRITE HERE =====================\\n \\n print('Number of samples in class_1:', n_class1)\\n print('Number of samples in class_2:', n_class2)\\n print('Number of samples in class_3:', n_class3)\",\n \"def classification_loss(self, classes_true, classes_logits):\\n entropy_fn = tf.nn.sparse_softmax_cross_entropy_with_logits\\n\\n classes_max = tf.argmax(classes_true, axis=1)\\n class_loss = entropy_fn(\\n labels=classes_max,\\n logits=classes_logits)\\n return class_loss\",\n \"def compute_entropy(bincounts, include_zeros):\\n num_total = tf.cast(tf.reduce_sum(bincounts), tf.float64)\\n if not include_zeros:\\n bincounts = bincounts[1:]\\n mask = tf.greater(bincounts, 0)\\n nonzero_bincounts = tf.cast(\\n tf.boolean_mask(bincounts, mask), tf.float64)\\n num_nonzero = tf.cast(tf.reduce_sum(nonzero_bincounts), tf.float64)\\n log_nonzero_bincounts = tf.math.log(nonzero_bincounts)\\n log_prob = log_nonzero_bincounts - tf.reduce_logsumexp(\\n log_nonzero_bincounts)\\n entropy = tf.math.reduce_sum(\\n log_prob * tf.exp(log_prob)) / -tf.math.log(tf.cast(2, tf.float64))\\n return entropy * num_nonzero / num_total\",\n \"def entropy(self):\\n raise NotImplementedError\",\n \"def encode_labels(labels, nclass=5):\\n Y = np.zeros((len(labels), nclass)).astype('float32')\\n for j, y in enumerate(labels):\\n for i in range(nclass):\\n if i+1 == np.floor(y) + 1:\\n Y[j,i] = y - np.floor(y)\\n if i+1 == np.floor(y):\\n Y[j,i] = np.floor(y) - y + 1\\n return Y\",\n \"def get_entropy(distribution, samples):\\n entropy = -tf.reduce_sum(distribution.log_prob(samples), axis=1)\\n return entropy\",\n \"def entropy(s):\\n p, lns = Counter(s), float(len(s))\\n return -sum( count/lns * math.log(count/lns, 2) for count in p.values())\",\n \"def entropy(counts):\\n assert (counts >= 0).all()\\n probs = counts / counts.sum()\\n probs = probs[probs > 0] # Avoid log(0)\\n return - np.sum(probs * np.log2(probs))\",\n \"def calcDataEntropy(self, data, structure):\\n classIndex, entropy = structure['class']['index'], 0\\n for value in structure['class']['values']:\\n newData = list(filter(lambda y: y[classIndex] == value, data))\\n p = len(newData) / len(data) if len(data) > 0 else 1\\n entropy += (-1) * (p * log2(p)) if p > 0 else 0\\n return round(entropy, 3)\",\n \"def compute_entropy(sampled, dataset, model, train_args):\\n all_entropy = None\\n data = Subset(dataset, sampled)\\n sampler = SequentialSampler(data)\\n dataloader = DataLoader(data, sampler=sampler, batch_size=train_args.per_gpu_eval_batch_size)\\n for batch in tqdm(dataloader, desc=\\\"Computing entropy\\\"):\\n batch = tuple(t.to(train_args.device) for t in batch)\\n with torch.no_grad():\\n inputs = {\\\"input_ids\\\": batch[0], \\\"attention_mask\\\": batch[1]}\\n if train_args.model_type != \\\"distilbert\\\":\\n inputs[\\\"token_type_ids\\\"] = (\\n batch[2] if train_args.model_type in [\\\"bert\\\", \\\"xlnet\\\", \\\"albert\\\"] else None\\n ) # XLM, DistilBERT, RoBERTa, and XLM-RoBERTa don't use segment_ids\\n outputs = model(**inputs)\\n logits = outputs[0]\\n categorical = Categorical(logits = logits)\\n entropy = categorical.entropy()\\n if all_entropy is None:\\n all_entropy = entropy.detach().cpu().numpy()\\n else:\\n all_entropy = np.append(all_entropy, entropy.detach().cpu().numpy(), axis=0)\\n avg_entropy = all_entropy.mean()\\n return avg_entropy\",\n \"def entropy(d, total, word_count):\\n\\t# Entropie je - Sum_morf p(morf) * log_2 p(morf)\\n\\t# p(morf) = c(morf) / c(all)\\n\\te = 0\\n\\tfor count in d.values():\\n\\t\\tp = count/total\\n\\t\\ttype_e = - p * log2(p)\\n\\t\\te += type_e * count\\n\\treturn e / word_count\",\n \"def _class_distribution(y):\\n unique, counts = np.unique(y, return_counts = True)\\n\\n percentages = counts / np.sum(counts)\\n\\n return unique, counts, percentages\",\n \"def entropy(l):\\n\\n probabilities = np.bincount(l) / len(l)\\n with np.errstate(divide='ignore'): # ignore log(0) errors, we'll handle\\n log_probabilities = np.log2(probabilities)\\n log_probabilities[~np.isfinite(log_probabilities)] = 0\\n return -np.sum(probabilities * log_probabilities)\",\n \"def _entropy(self, y):\\n # Get size\\n n = y.shape[0]\\n summation = 0\\n\\n # Summatory\\n for c_i in np.unique(y):\\n prob = sum(y == c_i) / float(n)\\n summation += prob * np.log2(prob)\\n\\n return -summation\",\n \"def calculate_entropy(eval_token_count, training_model):\\n sum_of_counts = sum(eval_token_count.values())\\n cross_entropy = 0\\n mis = []\\n for ngram in eval_token_count:\\n if training_model.score(ngram[-1], list(ngram[0:3])) == 0 or sum_of_counts == 0:\\n mi = np.mean(mis) if len(mis) > 0 else np.log2(0.287)\\n else:\\n mi = training_model.logscore(ngram[-1], list(ngram[0:3]))\\n pi = eval_token_count[ngram] / sum_of_counts\\n mis.append(mi)\\n cross_entropy -= pi * mi\\n return cross_entropy\",\n \"def __entropy(self, data_set, target_feature):\\n frequencies = self.__calculate_frequency(data_set, target_feature)\\n feature_entropy = 0.0\\n number_of_values = len(data_set)\\n\\n # Add entropy for each value in frequencies.\\n for frequency in frequencies:\\n probability = frequencies[frequency] / number_of_values\\n feature_entropy += (probability * math.log(probability, 2))\\n\\n return feature_entropy * -1\",\n \"def entropy(self, text):\\n\\n# text = self.myReplacer.replace(text)\\n# text = self.tokenizer.tokenize(text)\\n new_text = []\\n for word in text:\\n if word.count('\\\\'') > 0:\\n words = word.split('\\\\'')\\n for w in words:\\n new_text.append(w)\\n else:\\n new_text.append(word)\\n text = new_text\\n \\n e = 0.0\\n lenth = len(text)\\n if lenth == 0:\\n return 0\\n elif lenth < self._n:\\n current_n = lenth\\n else:\\n current_n = self._n\\n \\n for i in range(current_n - 1, len(text)):\\n context = tuple(text[(i - current_n + 1) : i])\\n token = text[i]\\n e += self.logprob(token, context)\\n return e\",\n \"def labels_to_labels(class_labels, num_classes =4):\\n levels = []\\n for label in class_labels:\\n levels_from_label = label_to_levels(int(label), num_classes=num_classes)\\n levels.append(levels_from_label)\\n return torch.stack(levels).cuda()\",\n \"def loss(logits, labels):\\n labels = tf.to_int64(labels)\\n# labels = tf.to_float(labels)\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=labels, logits=logits, name='xentropy')\\n# y_conv = tf.nn.softmax(logits)\\n# cross_entropy = -tf.reduce_sum(labels*tf.log(y_conv))\\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')\",\n \"def entropy(data, idxList):\\n df = data.loc[idxList]\\n counts = df.value_counts().to_numpy()\\n counts = counts.reshape(1, -1).astype(np.float32)\\n counts /= np.sum(counts)\\n log_sum = counts @ np.log2(counts.T)\\n return -log_sum[0, 0]\",\n \"def cross_entropy_loss(outputs, labels): \\n# works properly\\n \\n m = labels.shape[0]\\n p = outputs\\n log_likelihood = -1*torch.log(p[range(m),labels])\\n loss = torch.sum(log_likelihood) / m\\n return loss.item()\",\n \"def entropy(x):\\n nz = np.nonzero(x)[0]\\n return -np.sum(x[nz]*np.log2(x[nz]))\",\n \"def predictive_entropy(mc_preds):\\n return entropy(np.mean(mc_preds, axis=0))\",\n \"def calc_entropy_classification(dataset_entropies, max_thresh_value, num_outlier_threshs=50):\\n\\n dataset_outliers = []\\n threshs = []\\n\\n total_dataset = float(len(dataset_entropies))\\n\\n # loop through each rejection prior value and evaluate the percentage of the dataset being considered as\\n # statistical outliers, i.e. each data point's outlier probability > rejection prior.\\n for i in range(num_outlier_threshs - 1):\\n outlier_threshold = (i + 1) * (max_thresh_value / num_outlier_threshs)\\n threshs.append(outlier_threshold)\\n\\n dataset_outliers.append(0)\\n\\n for k in range(len(dataset_entropies)):\\n if dataset_entropies[k] > outlier_threshold:\\n dataset_outliers[i] += 1\\n\\n dataset_outliers[i] = dataset_outliers[i] / total_dataset\\n\\n return {\\\"entropy_thresholds\\\": threshs, \\\"entropy_outlier_percentage\\\": dataset_outliers}\",\n \"def entropy(data):\\n e = 0\\n\\n counter = collections.Counter(data)\\n l = len(data)\\n for count in counter.values():\\n p_x = count / l\\n e += - p_x * math.log2(p_x)\\n\\n return e\",\n \"def entropy(dist):\\n #dist = array([max(d,1e-100) for d in dist])\\n dist = dist + 1e-20\\n return dot(dist,(log(1.0/dist) * (1.0/log(2.0))).T)\",\n \"def entropy_fn(args: StepFunctionArgs) -> SingleScorePerStepTensor:\\n logits = args.attribution_model.output2logits(args.forward_output)\\n out = torch.distributions.Categorical(logits=logits).entropy()\\n if out.ndim > 1:\\n out = out.squeeze(-1)\\n return out\",\n \"def entropy(target_col):\\n elements,counts = np.unique(target_col,return_counts = True)\\n entropy = np.sum([(-counts[i]/np.sum(counts))*np.log2(counts[i]/np.sum(counts)) for i in range(len(elements))])\\n return entropy\",\n \"def entropy(probabilities):\\n return -(sum([p * log(p, 2) if p > 0 else 0 for p in probabilities]))\",\n \"def mean_ent(cluster_assignments):\\n nrow, ncol, nrun = cluster_assignments.shape\\n csum = cluster_assignments.sum(axis=2)\\n m = numpy.mean([scipy.stats.entropy(row) for row in csum])\\n return m\",\n \"def entropy(a):\\n a = a.upper()\\n\\n freq = collections.defaultdict(int) # int() is the default constructor for non existent item, and returns 0\\n for c in a:\\n freq[c] = freq[c] + 1\\n\\n e = 0.0\\n for f in freq.values():\\n if f:\\n p = f / len(a)\\n e += p * math.log(p)\\n\\n return -e\",\n \"def loss(self, logits, labels):\\n loss = tf.keras.losses.sparse_categorical_crossentropy(labels, logits)\\n return tf.reduce_mean(loss)\",\n \"def entropy( freq ):\\n N = 0.0\\n entropy = 0.0\\n for x, v in freq.items( ):\\n N += v\\n entropy -= v * math.log( v, 2 )\\n return (N * math.log( N, 2 ) + entropy) / N\",\n \"def entropy(self, unlabeled_sequence):\\n unlabeled_sequence = self._transform(unlabeled_sequence)\\n\\n T = len(unlabeled_sequence)\\n N = len(self._states)\\n\\n alpha = self._forward_probability(unlabeled_sequence)\\n beta = self._backward_probability(unlabeled_sequence)\\n normalisation = logsumexp2(alpha[T - 1])\\n\\n entropy = normalisation\\n\\n # starting state, t = 0\\n for i, state in enumerate(self._states):\\n p = 2 ** (alpha[0, i] + beta[0, i] - normalisation)\\n entropy -= p * self._priors.logprob(state)\\n # print('p(s_0 = %s) =' % state, p)\\n\\n # state transitions\\n for t0 in range(T - 1):\\n t1 = t0 + 1\\n for i0, s0 in enumerate(self._states):\\n for i1, s1 in enumerate(self._states):\\n p = 2 ** (\\n alpha[t0, i0]\\n + self._transitions[s0].logprob(s1)\\n + self._outputs[s1].logprob(unlabeled_sequence[t1][_TEXT])\\n + beta[t1, i1]\\n - normalisation\\n )\\n entropy -= p * self._transitions[s0].logprob(s1)\\n # print('p(s_%d = %s, s_%d = %s) =' % (t0, s0, t1, s1), p)\\n\\n # symbol emissions\\n for t in range(T):\\n for i, state in enumerate(self._states):\\n p = 2 ** (alpha[t, i] + beta[t, i] - normalisation)\\n entropy -= p * self._outputs[state].logprob(\\n unlabeled_sequence[t][_TEXT]\\n )\\n # print('p(s_%d = %s) =' % (t, state), p)\\n\\n return entropy\",\n \"def cross_entropy(X, y, using_onehot=True):\\n\\tM = y.shape[0]\\n\\tif using_onehot :\\n\\t\\tlog_likelihood = -np.log(np.max(X * y, -1))\\n\\telse:\\n\\t\\tlog_likelihood = -np.log(X[range(M), y]) # 找到y对应的那个类别所对应的logit\\n\\tloss = np.sum(log_likelihood) / M\\n\\treturn loss\",\n \"def softmax_cross_entropy(y, label):\\r\\n losses = np.sum((- np.log(y + g_epsilon) * label), axis=1)\\r\\n return losses\\r\\n pass\",\n \"def calc_entropy(data_set): #calculates total entropy of the dataset\\r\\n republicans = 0\\r\\n democrats = 0\\r\\n total = 0\\r\\n for data_point in data_set:\\r\\n party = data_point.dat_party\\r\\n if party == \\\"R\\\":\\r\\n republicans+=1\\r\\n elif party == \\\"D\\\":\\r\\n democrats+=1\\r\\n total+=1\\r\\n\\r\\n if total == 0: return 0\\r\\n prob_dem = democrats/total\\r\\n prob_rep = republicans/total\\r\\n if prob_dem == 0: return -(prob_rep * math.log(prob_rep, 2))\\r\\n if prob_rep == 0: return -(prob_dem * math.log(prob_dem, 2))\\r\\n\\r\\n entropy = (-prob_dem * math.log(prob_dem, 2)) -(prob_rep * math.log(prob_rep, 2))\\r\\n return entropy\",\n \"def cross_entropy_loss(logits, labels, label_smoothing=0., dtype=jnp.float32):\\n num_classes = logits.shape[-1]\\n labels = jax.nn.one_hot(labels, num_classes, dtype=dtype)\\n if label_smoothing > 0:\\n labels = labels * (1 - label_smoothing) + label_smoothing / num_classes\\n logp = jax.nn.log_softmax(logits.astype(dtype))\\n return -jnp.mean(jnp.sum(logp * labels, axis=-1))\",\n \"def entropy(string):\\n p, lns = Counter(string), float(len(string))\\n return -sum(count/lns * math.log(count/lns, 2) for count in p.values())\",\n \"def _entropy(data):\\n hist = np.array(PIL.Image.fromarray(data).histogram())\\n hist = hist / hist.sum()\\n hist = hist[hist != 0]\\n return -np.sum(hist * np.log2(hist))\",\n \"def count_classes(labels):\\n class_dict = {}\\n for image in labels:\\n for row in image:\\n for label in row:\\n if label not in class_dict:\\n class_dict[label] = 1\\n else:\\n class_dict[label] += 1\\n return class_dict\",\n \"def calculate_class_weights(labels):\\n class_counts = sorted(Counter(labels).items())\\n num_items = [x[1] for x in class_counts]\\n weights = [min(num_items)/x for x in num_items]\\n\\n return torch.tensor(weights)\",\n \"def calc_conditional_entropy(map,data_stat,attribute):\\n #acquire the data info of the attribute stored in data_stat\\n data_info = data_stat[attribute]\\n #acquire the label info\\n # label_col = len(data_stat)-1\\n label_col = data_stat.keys()[-1]\\n # print(data_stat.keys())\\n label_info = data_stat[label_col]\\n #acquire the data \\n data = map[attribute]\\n labels = map[label_col]\\n conditional_entropy =0\\n for data_type in data_info:\\n specific_entropy = 0\\n for label_type in label_info: \\n #attribute data indices where all data entries are equal to a speicifc value\\n data_with_spec_val_idx = data_info[data_type]\\n #label indices where all labels are of same value\\n spec_label_idx = label_info[label_type]\\n #the intersection of the two indices above\\n intersect_idx = np.intersect1d(data_with_spec_val_idx,spec_label_idx)\\n #conditional probability of label being of specific value given speicific data value\\n temp_prob = len(intersect_idx)/float(len(data_with_spec_val_idx))\\n if temp_prob!=0:\\n specific_entropy += temp_prob*math.log(temp_prob,2)\\n specific_entropy = -specific_entropy\\n prob = len(data_with_spec_val_idx)/float(len(data))\\n conditional_entropy += prob * specific_entropy\\n return conditional_entropy\",\n \"def cross_entropy(\\n **kwargs\\n) -> Callable:\\n return categorical_crossentropy\",\n \"def get_class_weights(img_paths: List[str], class_to_idx: Dict[str, int], label_names: List[str]):\\n labels = list()\\n for img_path in img_paths:\\n label = os.path.basename(os.path.dirname(img_path))\\n labels.append(class_to_idx[label]) \\n\\n counts = Counter(labels) + Counter([class_to_idx[name] for name in label_names])\\n counts = np.array(sorted(counts.items()))[:,1]\\n \\n return counts.max()/counts\",\n \"def cross_entropy_loss(self, logits, labels):\\n return F.cross_entropy(logits, labels)\",\n \"def softmax_cross_entropy_loss(logit, labels):\\n p = softmax(logit)\\n loss_i = - labels * np.log(p + 1e-8)\\n return np.mean(loss_i)\",\n \"def entropy(message):\\n n = len(message)\\n message = letter_freq(message)\\n h = 0\\n for n_i in message.values():\\n p_i = n_i/n\\n h += -p_i*(log2(p_i))\\n return h\",\n \"def find_entropy(less_than_threshold,more_than_threshold):\\n\\n ''' Storing total number of records '''\\n total_records = len(less_than_threshold) + len(more_than_threshold)\\n\\n ''' Calculating the probability '''\\n less_than_probability = len(less_than_threshold) / total_records\\n more_than_probability = len(more_than_threshold) / total_records\\n\\n ''' Converting the dataframe to numpy arrays '''\\n less_than_threshold_values = less_than_threshold.values\\n more_than_threshold_values = more_than_threshold.values\\n\\n ''' Storing the target attribute values (Muffin or Cupcake) for threshold values '''\\n target_for_less_than = less_than_threshold_values[:, -1]\\n target_for_more_than = more_than_threshold_values[:, -1]\\n\\n ''' Finding the counts of muffin and cupcake for values lower than and greater than threshold value '''\\n recipe_type, less_than_cupcake_muffin_count = np.unique(target_for_less_than, return_counts=True)\\n recipe_type, more_than_cupcake_muffin_count = np.unique(target_for_more_than, return_counts=True)\\n\\n # print(recipe_type, more_than_cupcake_muffin_count, len(more_than_cupcake_muffin_count))\\n ''' To ensure there are at least 5 records in each node '''\\n if less_than_cupcake_muffin_count.sum() < 5 or more_than_cupcake_muffin_count.sum() < 5:\\n ''' Return horrible badness '''\\n return math.inf\\n else:\\n ''' Find the entropies for less than threshold values and more than threshold values '''\\n less_than_entropy = sum((less_than_cupcake_muffin_count / less_than_cupcake_muffin_count.sum()) * - np.log2(\\n less_than_cupcake_muffin_count / less_than_cupcake_muffin_count.sum()))\\n more_than_entropy = sum((more_than_cupcake_muffin_count / more_than_cupcake_muffin_count.sum()) * - np.log2(\\n more_than_cupcake_muffin_count / more_than_cupcake_muffin_count.sum()))\\n\\n ''' Calculate the total weighted entropy '''\\n total_weighted_entropy = less_than_probability * less_than_entropy + more_than_probability * more_than_entropy\\n\\n return total_weighted_entropy\",\n \"def entropy(y):\\n p = _proba(y)\\n return (-p * np.log2(p)).sum()\",\n \"def classes_calculations(input):\\n counts, _ = np.histogram(input, bins=int(\\n input.max() + 1), range=(0, int(input.max())))\\n return np.nonzero(counts)[0]\",\n \"def loss(logits, labels):\\n labels = tf.to_int64(labels)\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\\n logits, labels, name='xentropy')\\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')\",\n \"def loss(logits, labels):\\r\\n labels = tf.to_int64(labels)\\r\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\\r\\n labels=labels, logits=logits, name='xentropy')\\r\\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')\",\n \"def loss(logits, labels):\\r\\n labels = tf.to_int64(labels)\\r\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\\r\\n labels=labels, logits=logits, name='xentropy')\\r\\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')\",\n \"def get_class_labels(self):\\r\\n \\r\\n y = self.get_data()['y']\\r\\n if type(y) == torch.Tensor:\\r\\n return y.unique().numpy()\\r\\n else:\\r\\n return sorted(list(set(y)))\",\n \"def classify(self, features):\\n\\n # TODO: finish this.\\n class_labels = []\\n # TODO: finish this.\\n features = np.array(features)\\n feat_shape = features.shape\\n for i in range(feat_shape[0]):\\n vote = np.zeros((self.num_trees))\\n for j in range(self.num_trees):\\n #print self.trees[j].classify(feat)\\n vote[j] = self.trees[j].classify(features[i,self.attr_track[j]].reshape(1,-1))[0]\\n counts = np.bincount(vote.astype(int))\\n class_labels.append(np.argmax(counts))\\n return class_labels\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.81865084","0.80822265","0.77153903","0.7669256","0.75980985","0.75456953","0.7508981","0.7403374","0.73444664","0.73422587","0.71964747","0.7112142","0.7071382","0.70541775","0.7049735","0.6889866","0.6841053","0.6830166","0.6794126","0.67489135","0.67384094","0.6696681","0.66725016","0.66725016","0.6626664","0.6620464","0.65594697","0.6559406","0.6548044","0.65069276","0.64983153","0.64782894","0.64650524","0.64292467","0.6424856","0.64209974","0.6410198","0.6407456","0.6396782","0.6382889","0.6382889","0.6367221","0.6342167","0.6328642","0.63243467","0.6318887","0.63148725","0.63132185","0.6312702","0.630946","0.630415","0.62860626","0.6275465","0.6264609","0.6259715","0.6251364","0.6229696","0.6228887","0.62288046","0.6220279","0.6207711","0.6187316","0.6183145","0.6173455","0.6169881","0.61695606","0.6165996","0.6158242","0.61433125","0.6143281","0.6143236","0.6141783","0.6135489","0.61272687","0.6114977","0.6108171","0.6103914","0.61020255","0.6100103","0.60990953","0.6093608","0.60860413","0.6085947","0.6083149","0.6073534","0.6066318","0.6061464","0.60596806","0.60471904","0.6020585","0.6009599","0.6004958","0.6002024","0.59953934","0.59948987","0.5991962","0.5978903","0.5978903","0.5970294","0.5966419"],"string":"[\n \"0.81865084\",\n \"0.80822265\",\n \"0.77153903\",\n \"0.7669256\",\n \"0.75980985\",\n \"0.75456953\",\n \"0.7508981\",\n \"0.7403374\",\n \"0.73444664\",\n \"0.73422587\",\n \"0.71964747\",\n \"0.7112142\",\n \"0.7071382\",\n \"0.70541775\",\n \"0.7049735\",\n \"0.6889866\",\n \"0.6841053\",\n \"0.6830166\",\n \"0.6794126\",\n \"0.67489135\",\n \"0.67384094\",\n \"0.6696681\",\n \"0.66725016\",\n \"0.66725016\",\n \"0.6626664\",\n \"0.6620464\",\n \"0.65594697\",\n \"0.6559406\",\n \"0.6548044\",\n \"0.65069276\",\n \"0.64983153\",\n \"0.64782894\",\n \"0.64650524\",\n \"0.64292467\",\n \"0.6424856\",\n \"0.64209974\",\n \"0.6410198\",\n \"0.6407456\",\n \"0.6396782\",\n \"0.6382889\",\n \"0.6382889\",\n \"0.6367221\",\n \"0.6342167\",\n \"0.6328642\",\n \"0.63243467\",\n \"0.6318887\",\n \"0.63148725\",\n \"0.63132185\",\n \"0.6312702\",\n \"0.630946\",\n \"0.630415\",\n \"0.62860626\",\n \"0.6275465\",\n \"0.6264609\",\n \"0.6259715\",\n \"0.6251364\",\n \"0.6229696\",\n \"0.6228887\",\n \"0.62288046\",\n \"0.6220279\",\n \"0.6207711\",\n \"0.6187316\",\n \"0.6183145\",\n \"0.6173455\",\n \"0.6169881\",\n \"0.61695606\",\n \"0.6165996\",\n \"0.6158242\",\n \"0.61433125\",\n \"0.6143281\",\n \"0.6143236\",\n \"0.6141783\",\n \"0.6135489\",\n \"0.61272687\",\n \"0.6114977\",\n \"0.6108171\",\n \"0.6103914\",\n \"0.61020255\",\n \"0.6100103\",\n \"0.60990953\",\n \"0.6093608\",\n \"0.60860413\",\n \"0.6085947\",\n \"0.6083149\",\n \"0.6073534\",\n \"0.6066318\",\n \"0.6061464\",\n \"0.60596806\",\n \"0.60471904\",\n \"0.6020585\",\n \"0.6009599\",\n \"0.6004958\",\n \"0.6002024\",\n \"0.59953934\",\n \"0.59948987\",\n \"0.5991962\",\n \"0.5978903\",\n \"0.5978903\",\n \"0.5970294\",\n \"0.5966419\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6390812"},"document_rank":{"kind":"string","value":"39"}}},{"rowIdx":78588,"cells":{"query":{"kind":"string","value":"Function finds the negative mean squared distance from mean for point in Y (variance)"},"document":{"kind":"string","value":"def negative_mse ( target_array ):\n return -1 * mse ( target_array )\n # End negative_mse()"},"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 mse(x, y):\n\n return (x - y).pow(2).sum(dim=1, keepdim=True).mean() / x.size(1)","def rmse(x: np.ndarray, y: np.ndarray):\n x, y = np.copy(x), np.copy(y)\n if x.ndim > 1:\n return np.sqrt(np.nanmean((x-y)**2, axis=1))\n return np.sqrt(np.nanmean((x-y)**2))","def d_mse(x, y):\n\n return 2 * (x - y) / x.size(0) / x.size(1)","def calc_rmse(y: np.ndarray, y_hat: np.ndarray) -> float:\n return np.sqrt(np.mean((y - y_hat)**2))","def calculate_mean_squared_error(self, X, y):\r\n mean_squared_error = np.square(np.subtract(y,self.predict(X))).mean()\r\n return mean_squared_error","def calculate_variance(X):\n\tmean = np.ones(np.shape(X)) * X.mean(0)\n\tn_samples = np.shape(X)[0]\n\tvariance = (1 / n_samples) * np.diag((X - mean).T.dot(X - mean))\n\treturn variance","def get_stdev(self):\n if self._y.mean() == 0:\n raise ValueError('invalid value of mean of y, the ratio is not computable')\n\n var = numpy.mean(self._x ** 2) * numpy.mean(1.0 / self._y ** 2) - \\\n (numpy.mean(self._x) ** 2) * (numpy.mean(1.0 / self._y) ** 2)\n return numpy.sqrt(var)","def _mean_diff(x, y):\n return np.mean(x) - np.mean(y)","def calc_mse(data, ax=0):\n return ((data[:, 0] - data[:, 1]) ** 2).mean(axis=ax)","def mse(y_true: np.ndarray, y_pred: np.ndarray) -> float:\n return np.mean(np.power(y_true - y_pred, 2))","def mse(datax,datay,w):\n return np.mean((datax.dot(w.T)-datay)**2)","def calculate_std_dev(X):\n\tstd_dev = np.sqrt(calculate_variance(X))\n\treturn std_dev","def rmse(y_true: np.ndarray, y_pred: np.ndarray):\n return np.sqrt(np.mean(np.power(y_true - y_pred, 2)))","def estimateCovariance(df):\n import numpy as np\n m = df.select(df['scaledFeatures']).map(lambda x: x[0]).mean()\n dfZeroMean = df.select(df['scaledFeatures']).map(lambda x: x[0]).map(lambda x: x-m) # subtract the mean\n\n return dfZeroMean.map(lambda x: np.outer(x,x)).sum()/df.count()","def diffSquaredSum(classObj ,dataSet, mean):\r\n return np.sum((dataSet - mean)**2)","def compute_mean_squared_error(self, X_data, y_data):\n #assert isinstance(X_data, np.ndarray)\n #assert isinstance(y_data, np.ndarray)\n #assert X_data.shape[0] == y_data.shape[0]\n \n return np.square(np.subtract(X_data, y_data)).mean()","def stdev_from_mean(x):\r\n x = array(x)\r\n return (x - mean(x)) / std(x)","def calculate_mean_squared_error(self, X, y):\n mserror = 0\n results = self.predict(X)\n \n mserror = mean_squared_error(results,y)\n #print(error)\n return mserror","def calc_mae(y: np.ndarray, y_hat: np.ndarray) -> float:\n return np.mean(np.abs(y - y_hat))","def standard_deviation(data):\n\n return np.sqrt(variance(data))","def standard_deviation(data):\n\n return np.sqrt(variance(data))","def mean_absolute_error(w, X, y):\n #####################################################\n # TODO 1: Fill in your code here #\n #####################################################\n if w is None:\n return None\n\n err = None\n yhat = np.dot(X , w)\n err = np.abs(np.subtract(yhat,y)).mean()\n return err","def standard_deviation(xs: List[float]) -> float:\n return math.sqrt(variance(xs))","def standard_deviation(xs: List[float]) -> float:\n return math.sqrt(variance(xs))","def normalDist(x, mean, var):\n\n if (var != 0):\n return -(x - mean)**2/(2*var) - 0.5*np.log(2*np.pi*var)\n else:\n return 0","def rmse(self, X, y) -> float:\n return np.sqrt(np.sum(self.l2_error(X, y)))","def rmse_calc(arr1, arr2):\n assert arr1.shape==arr2.shape\n \n return np.sqrt(np.mean((arr2-arr1)**2))","def mean_absolute_error(w, X, y):\n #####################################################\n # TODO 1: Fill in your code here #\n #####################################################\n err = None\n temp = np.dot(X, w)\n err = np.mean(np.abs(_error(y, temp)))\n return err","def d_mean(x, y):\n return (x + y) / 2","def mean_absolute_error(y, y_pred, w):\n return np.average(np.abs(y_pred - y), weights=w)","def mean_deviation(self):\r\n\t\t_mean = sum(self.sample)/len(self.sample)\r\n\t\treturn sum(map(lambda x: abs(x - _mean), self.sample))/len(self.sample)","def mse(A, B):\n return ((A - B) ** 2).mean(axis=0)","def rmse(X, Y):\n\n assert X.shape == Y.shape\n\n N = X.shape[0]\n\n if N < 9:\n print(\"Not enough points. {} datapoints given. At least 9 is required\".format(N))\n return\n\n diff = X - Y\n diff = diff**2\n rmse = np.sqrt(diff.mean())\n\n le = rmse * (1.0 - np.sqrt(1-1.96*np.sqrt(2.0)/np.sqrt(N-1)))\n ue = rmse * (np.sqrt(1 + 1.96*np.sqrt(2.0)/np.sqrt(N-1))-1)\n\n return rmse, le, ue","def mse ( target_array ):\n return np.mean ( ( target_array - np.mean ( target_array ) ) ** 2 )\n # End mse()","def nmse(actual: np.ndarray, predicted: np.ndarray):\n return np.mean(np.square(actual - predicted)) / (np.mean(actual) * np.mean(predicted) + np.finfo(float).eps)","def linear_error(X, y, w):\n\n return np.where(y != np.sign(np.dot(X, w)), 1.0, 0.0).mean()","def rmse(y_preds: ndarray, y_actual: ndarray) -> float:\n\n return np.sqrt(np.mean(np.power(y_preds - y_actual, 2)))","def _variance(mean_variance, samples):\n mean = mean_variance[0] / samples\n variance = mean_variance[1]\n variance /= samples\n variance -= mean * mean\n return variance","def measure(self, X, Y, index):\n X = np.array(X)\n Y = np.array(Y)\n length = len(X)\n score = 0\n if length != 0:\n for i in range(length):\n sigma = self.votility[index + i]\n if sigma != 0:\n score += abs(X[i]-Y[i])/sigma\n \n score = score/length \n return score","def variance(x):\n \"\"\" note - why n-1?: since we are likely looking at a sample, x_bar is only an\n estimate of the actual mean, which means that on average (x_i - x_bar) ** 2\n is an underestimate of x_i's squared deviation from the mean, which is why\n we divide by n-1 instead of n (see bit.ly/lL2EapI)\"\"\"\n n = len(x)\n deviations = deviations_from_mean(x)\n return sum_of_squares(deviations) / (n - 1)","def calc_nrmse(y: np.ndarray, y_hat: np.ndarray) -> float:\n pass","def rmse(y_hat, y):\n\tif type(y) == list:\n\t\tpass\n\telse:\n\t\ty = y.values.tolist()\n\tm = len(y)\n\tsum = 0\n\tfor i in range(m):\n\t\tsum += ((y_hat[i] - y[i]) ** 2 / m)\n\terror = np.sqrt(sum)\n\treturn error","def variance(y, w):\n # w = clip_normalize(w)\n # Compute the expectance (d_y, n_q)\n y_q_exp = np.dot(y.T, w)\n\n # Compute the expectance of squares (d_y, n_q)\n y_q_exp_sq = np.dot((y ** 2).T, w)\n\n # Compute the variance (d_y, n_q)\n return y_q_exp_sq - (y_q_exp ** 2)","def mse(X, Y, W):\n\n # TODO\n mse = np.sum((X@W-Y)**2)/(2*X.shape[0])\n # END TODO\n\n return mse","def mean_squared_error(self, y_out, y):\n loss = np.sum((y - y_out)**2)\n return loss","def mse_loss(self, x, y):\n loss = tf.reduce_mean(tf.square(x - y))\n return loss","def mse(y, yhat):\n return 0.5 * jnp.mean((y - yhat)**2)","def mse(gt, pred):\n return np.mean((gt - pred) ** 2)","def mse(gt, pred):\n return np.mean((gt - pred) ** 2)","def get_mle_variance(series, mean=None):\n\n if mean is None:\n\n mean = series.mean()\n\n return 1 / series.size * ((series - mean)**2).sum()","def SST(Y):\n\tsummation = 0\n\taverage = mean(Y)\n\tfor i in range(len(Y)):\n\t\tsummation += (Y[i]-average)**2\n\treturn summation","def get_stdev(self):\n var_x = numpy.var(self._x)\n var_y = numpy.var(self._y)\n return numpy.sqrt(var_x + var_y)","def unexplained_variance(x, x_proj):\n res = poincare.distance(x, x_proj) ** 2\n return torch.mean(res).item()","def mean_square_error(y, y_pred, w):\n return np.average(((y_pred - y) ** 2), weights=w)","def moments(self, x, y):\n # Let's attempt to remove noise by axing points\n # below 5% of the peak\n threshold = y.max() * 0.05\n clean = np.array(y)\n clean[clean < threshold] = 0\n zero = clean.sum()\n one = np.sum(x * clean)\n two = np.sum(x * x * clean)\n mean = one / zero\n var = two / zero - mean**2\n stdev = np.sqrt(var)\n return (mean, stdev)","def std(mean, vals):\n return sqrt(sum([(i-mean)**2 for i in vals])/len(vals))","def minimum_mean_square_error(x, y):\n x_pseudoinv = np.linalg.pinv(x)\n return x_pseudoinv * x.T * y","def mystd(x, pX):\n mu_x = mean(x)\n var_x_l = [(x[i] - mu_x) ** 2 * pX[i] for i in range(len(x))]\n var_x = sum(var_x_l)\n return sqrt(var_x)","def normal_density(mean, variance, X):\n Z = np.sqrt(2.0*np.pi*variance)\n unden = np.exp(old_div(-np.sum((X-mean)**2.0, 1),(2.0*variance)) )\n den = old_div(unden,Z)\n assert len(den) == X.shape[0]\n return den","def demeaned(self):\n return self.data - self.mean","def stdDev(data):\r\n sum = 0\r\n ave = average(data)\r\n for i in data:\r\n sum += (i-ave)**2\r\n return math.sqrt(sum/len(data))","def MSE(actual, noisy):\n mean_squared_error(actual, noisy)","def mse(x1, x2, axis=0):\n x1 = np.asanyarray(x1)\n x2 = np.asanyarray(x2)\n return np.mean((x1 - x2) ** 2, axis=axis)","def mean_squared_error(y_true, y_pred):\n mse = np.mean(np.power(y_true - y_pred, 2))\n return mse","def clipped_mse(self, y_true, y_pred):\r\n return tf.keras.backend.mean(tf.keras.backend.square(tf.keras.backend.clip(y_pred - y_true, -1., 1.)), axis=-1)","def variance(xs: List[float]) -> float:\n assert len(xs) >= 2, \"variance requires at least two elements\"\n\n n = len(xs)\n deviations = de_mean(xs)\n return sum_of_squares(deviations) / (n - 1)","def variance(xs: List[float]) -> float:\n assert len(xs) >= 2, \"variance requires at least two elements\"\n\n n = len(xs)\n deviations = de_mean(xs)\n return sum_of_squares(deviations) / (n - 1)","def test_stdev_from_mean(self):\r\n x = [2.1, 4.2, 5.9, 8.4, 9.6]\r\n result = stdev_from_mean(x)\r\n self.assertFloatEqual(\r\n result,\r\n [-1.292463399014413,\r\n -0.60358696806764478,\r\n -0.045925095396451399,\r\n 0.77416589382589174,\r\n 1.1678095686526162])","def deviation(xs):\n\ta = avg(xs)\n\treturn sqrt(sum([(x - a) ** 2 for x in xs]) / (len(xs) - 1))","def variance(x):\r\n n = len(x)\r\n deviations = dev_mean(x)\r\n return sum_of_squares(deviations) / (n-1)","def get_mse(data, yhat, mode=\"train\"):\n y = getattr(data, mode + \"Yref\")\n mse = mean_squared_error(y, data.revert(yhat, mode))\n return np.sqrt(mse)","def mean_squared_error(y_true, y_pred):\n\tmse = np.mean(np.power(y_true, y_pred, 2))\n\treturn mse","def value(a, y):\n\t\treturn 0.5*np.linalg.norm(a-y)**2","def sd(x):\n x_mean = mean(x)\n return (\n sum((x_i - x_mean) ** 2 for x_i in x) / (len(x) - 1)\n ) ** 0.5","def mean_squared_error(y_true, y_pred):\n mse = np.mean((y_true - y_pred)**2)\n return mse","def error(self, y_predicted, y):\n errors = []\n for i in range(y.size): \n errors.append((y[i]-y_predicted[i]) ** 2)\n return mean(errors)","def root_mean_square_error(y, y_pred, w):\n return np.sqrt(np.average(((y_pred - y) ** 2), weights=w))","def mae(y_true: np.ndarray, y_pred: np.ndarray):\n return np.mean(np.abs(y_true - y_pred))","def rmse(x, y):\n return mse(x, y) ** .5","def std_deviation(array):\n if not array or len(array) == 1:\n return 0\n\n average = AGGREGATES['mean_arithmetic'](array)\n variance = map(lambda x: (x-average)**2,array)\n stdev = AGGREGATES['mean_arithmetic'](variance)\n return math.sqrt(stdev)","def variance(x):\n n = len(x)\n deviations = de_mean(x)\n return sum_of_squares(deviations) / (n - 1)","def variance(x):\n n = len(x)\n deviations = de_mean(x)\n return sum_of_squares(deviations) / (n - 1)","def variance(x):\n n = len(x)\n deviations = de_mean(x)\n return sum_of_squares(deviations) / (n - 1)","def covariance(x, y):\n x_mean = mean(x)\n y_mean = mean(y)\n diff_x_mean = (x_i - x_mean for x_i in x)\n diff_y_mean = (y_i - y_mean for y_i in y)\n sum_xy_diff = sum(a * b for a, b in zip(diff_x_mean, diff_y_mean))\n return sum_xy_diff / (len(x) - 1)","def calc_standard_deviation(data: list) -> float:\n mean = calc_mean(data)\n acc = 0.0\n for n in data:\n acc += (n - mean) ** 2\n acc /= len(data) - 1\n return math.sqrt(acc)","def variance(self):\r\n\t\t_mean = sum(self.sample)/len(self.sample)\r\n\t\treturn sum(map(lambda x: (x - _mean)**2, self.sample))/(len(self.sample) - 1)","def covariance (x, y):\n n = len(x)\n return dot(de_mean(x), de_mean(y))/(n-1)","def MSE(a,b,axis):\n return ((a-b)**2).mean(axis=axis)","def adstatistic(self, X):\n n = len(X)\n Y = X[:]\n ybar = mean(Y)\n yvar = var(Y)\n ysd = sqrt(yvar)\n Y = [(y- ybar)/ysd for y in Y]\n A2 = -n\n S =0.0 \n Y.sort() # don't forget this!!!\n for i, y in enumerate(Y):\n j = i+1\n p = self.pnorm(y)\n q = 1- p\n S += (j+j - 1)*log(p)+ (2 *(n-j)+1)* log(q)\n A2 -= S/n\n \n \n A2 *= (1.0 + 4.0/n - 25.0/n**2)\n return A2","def rmse(actual: np.ndarray, predicted: np.ndarray):\n return np.sqrt(np.mean(np.square(_error(actual, predicted))))","def getL(y):\n\n x = np.array(range(0,len(y)))\n b = cov(x,y) / cov(x,x)\n a = np.mean(y) - b * np.mean(x)\n \n return b * len(y) + a","def mse(observed, predicted):\n return np.sqrt(np.mean((observed - predicted)**2))","def SSD(x,y):\n return np.sum((x-y)**2)","def mse(actual,expected):\n return np.mean(se(actual,expected))","def std_deviation_of_mean_value(x):\n\n import numpy as np\n x = np.array(x)\n M = np.size(x)\n\n if M == 1: return 0\n\n return empirical_std_deviation(x)/np.sqrt(M)","def covariance(x, y):\n n = len(x)\n return dot(de_mean(x), de_mean(y)) / (n - 1)","def mse(predicted, actual):\n diff = predicted - actual\n return np.average(diff * diff, axis=0)","def mean_stddev(self):\n if len(self.vs) == 0:\n raise StdDevFilterException\n\n mx = self.mean()\n # compute variance\n variance = sum([(x - mx)**2 for x in self.vs])/len(self.vs)\n # return mean value and standard deviation (square root of variance)\n return mx,math.sqrt(variance)","def rmse_over_stdev(y_true, y_pred, train_y=None):\n if train_y is not None:\n stdev = np.std(train_y)\n else:\n stdev = np.std(y_true)\n rmse = root_mean_squared_error(y_true, y_pred)\n return rmse / stdev","def mad(v):\n return np.mean(np.abs(v - np.mean(v)))","def MeanSqError(self):\r\n\t\treturn self.mse"],"string":"[\n \"def mse(x, y):\\n\\n return (x - y).pow(2).sum(dim=1, keepdim=True).mean() / x.size(1)\",\n \"def rmse(x: np.ndarray, y: np.ndarray):\\n x, y = np.copy(x), np.copy(y)\\n if x.ndim > 1:\\n return np.sqrt(np.nanmean((x-y)**2, axis=1))\\n return np.sqrt(np.nanmean((x-y)**2))\",\n \"def d_mse(x, y):\\n\\n return 2 * (x - y) / x.size(0) / x.size(1)\",\n \"def calc_rmse(y: np.ndarray, y_hat: np.ndarray) -> float:\\n return np.sqrt(np.mean((y - y_hat)**2))\",\n \"def calculate_mean_squared_error(self, X, y):\\r\\n mean_squared_error = np.square(np.subtract(y,self.predict(X))).mean()\\r\\n return mean_squared_error\",\n \"def calculate_variance(X):\\n\\tmean = np.ones(np.shape(X)) * X.mean(0)\\n\\tn_samples = np.shape(X)[0]\\n\\tvariance = (1 / n_samples) * np.diag((X - mean).T.dot(X - mean))\\n\\treturn variance\",\n \"def get_stdev(self):\\n if self._y.mean() == 0:\\n raise ValueError('invalid value of mean of y, the ratio is not computable')\\n\\n var = numpy.mean(self._x ** 2) * numpy.mean(1.0 / self._y ** 2) - \\\\\\n (numpy.mean(self._x) ** 2) * (numpy.mean(1.0 / self._y) ** 2)\\n return numpy.sqrt(var)\",\n \"def _mean_diff(x, y):\\n return np.mean(x) - np.mean(y)\",\n \"def calc_mse(data, ax=0):\\n return ((data[:, 0] - data[:, 1]) ** 2).mean(axis=ax)\",\n \"def mse(y_true: np.ndarray, y_pred: np.ndarray) -> float:\\n return np.mean(np.power(y_true - y_pred, 2))\",\n \"def mse(datax,datay,w):\\n return np.mean((datax.dot(w.T)-datay)**2)\",\n \"def calculate_std_dev(X):\\n\\tstd_dev = np.sqrt(calculate_variance(X))\\n\\treturn std_dev\",\n \"def rmse(y_true: np.ndarray, y_pred: np.ndarray):\\n return np.sqrt(np.mean(np.power(y_true - y_pred, 2)))\",\n \"def estimateCovariance(df):\\n import numpy as np\\n m = df.select(df['scaledFeatures']).map(lambda x: x[0]).mean()\\n dfZeroMean = df.select(df['scaledFeatures']).map(lambda x: x[0]).map(lambda x: x-m) # subtract the mean\\n\\n return dfZeroMean.map(lambda x: np.outer(x,x)).sum()/df.count()\",\n \"def diffSquaredSum(classObj ,dataSet, mean):\\r\\n return np.sum((dataSet - mean)**2)\",\n \"def compute_mean_squared_error(self, X_data, y_data):\\n #assert isinstance(X_data, np.ndarray)\\n #assert isinstance(y_data, np.ndarray)\\n #assert X_data.shape[0] == y_data.shape[0]\\n \\n return np.square(np.subtract(X_data, y_data)).mean()\",\n \"def stdev_from_mean(x):\\r\\n x = array(x)\\r\\n return (x - mean(x)) / std(x)\",\n \"def calculate_mean_squared_error(self, X, y):\\n mserror = 0\\n results = self.predict(X)\\n \\n mserror = mean_squared_error(results,y)\\n #print(error)\\n return mserror\",\n \"def calc_mae(y: np.ndarray, y_hat: np.ndarray) -> float:\\n return np.mean(np.abs(y - y_hat))\",\n \"def standard_deviation(data):\\n\\n return np.sqrt(variance(data))\",\n \"def standard_deviation(data):\\n\\n return np.sqrt(variance(data))\",\n \"def mean_absolute_error(w, X, y):\\n #####################################################\\n # TODO 1: Fill in your code here #\\n #####################################################\\n if w is None:\\n return None\\n\\n err = None\\n yhat = np.dot(X , w)\\n err = np.abs(np.subtract(yhat,y)).mean()\\n return err\",\n \"def standard_deviation(xs: List[float]) -> float:\\n return math.sqrt(variance(xs))\",\n \"def standard_deviation(xs: List[float]) -> float:\\n return math.sqrt(variance(xs))\",\n \"def normalDist(x, mean, var):\\n\\n if (var != 0):\\n return -(x - mean)**2/(2*var) - 0.5*np.log(2*np.pi*var)\\n else:\\n return 0\",\n \"def rmse(self, X, y) -> float:\\n return np.sqrt(np.sum(self.l2_error(X, y)))\",\n \"def rmse_calc(arr1, arr2):\\n assert arr1.shape==arr2.shape\\n \\n return np.sqrt(np.mean((arr2-arr1)**2))\",\n \"def mean_absolute_error(w, X, y):\\n #####################################################\\n # TODO 1: Fill in your code here #\\n #####################################################\\n err = None\\n temp = np.dot(X, w)\\n err = np.mean(np.abs(_error(y, temp)))\\n return err\",\n \"def d_mean(x, y):\\n return (x + y) / 2\",\n \"def mean_absolute_error(y, y_pred, w):\\n return np.average(np.abs(y_pred - y), weights=w)\",\n \"def mean_deviation(self):\\r\\n\\t\\t_mean = sum(self.sample)/len(self.sample)\\r\\n\\t\\treturn sum(map(lambda x: abs(x - _mean), self.sample))/len(self.sample)\",\n \"def mse(A, B):\\n return ((A - B) ** 2).mean(axis=0)\",\n \"def rmse(X, Y):\\n\\n assert X.shape == Y.shape\\n\\n N = X.shape[0]\\n\\n if N < 9:\\n print(\\\"Not enough points. {} datapoints given. At least 9 is required\\\".format(N))\\n return\\n\\n diff = X - Y\\n diff = diff**2\\n rmse = np.sqrt(diff.mean())\\n\\n le = rmse * (1.0 - np.sqrt(1-1.96*np.sqrt(2.0)/np.sqrt(N-1)))\\n ue = rmse * (np.sqrt(1 + 1.96*np.sqrt(2.0)/np.sqrt(N-1))-1)\\n\\n return rmse, le, ue\",\n \"def mse ( target_array ):\\n return np.mean ( ( target_array - np.mean ( target_array ) ) ** 2 )\\n # End mse()\",\n \"def nmse(actual: np.ndarray, predicted: np.ndarray):\\n return np.mean(np.square(actual - predicted)) / (np.mean(actual) * np.mean(predicted) + np.finfo(float).eps)\",\n \"def linear_error(X, y, w):\\n\\n return np.where(y != np.sign(np.dot(X, w)), 1.0, 0.0).mean()\",\n \"def rmse(y_preds: ndarray, y_actual: ndarray) -> float:\\n\\n return np.sqrt(np.mean(np.power(y_preds - y_actual, 2)))\",\n \"def _variance(mean_variance, samples):\\n mean = mean_variance[0] / samples\\n variance = mean_variance[1]\\n variance /= samples\\n variance -= mean * mean\\n return variance\",\n \"def measure(self, X, Y, index):\\n X = np.array(X)\\n Y = np.array(Y)\\n length = len(X)\\n score = 0\\n if length != 0:\\n for i in range(length):\\n sigma = self.votility[index + i]\\n if sigma != 0:\\n score += abs(X[i]-Y[i])/sigma\\n \\n score = score/length \\n return score\",\n \"def variance(x):\\n \\\"\\\"\\\" note - why n-1?: since we are likely looking at a sample, x_bar is only an\\n estimate of the actual mean, which means that on average (x_i - x_bar) ** 2\\n is an underestimate of x_i's squared deviation from the mean, which is why\\n we divide by n-1 instead of n (see bit.ly/lL2EapI)\\\"\\\"\\\"\\n n = len(x)\\n deviations = deviations_from_mean(x)\\n return sum_of_squares(deviations) / (n - 1)\",\n \"def calc_nrmse(y: np.ndarray, y_hat: np.ndarray) -> float:\\n pass\",\n \"def rmse(y_hat, y):\\n\\tif type(y) == list:\\n\\t\\tpass\\n\\telse:\\n\\t\\ty = y.values.tolist()\\n\\tm = len(y)\\n\\tsum = 0\\n\\tfor i in range(m):\\n\\t\\tsum += ((y_hat[i] - y[i]) ** 2 / m)\\n\\terror = np.sqrt(sum)\\n\\treturn error\",\n \"def variance(y, w):\\n # w = clip_normalize(w)\\n # Compute the expectance (d_y, n_q)\\n y_q_exp = np.dot(y.T, w)\\n\\n # Compute the expectance of squares (d_y, n_q)\\n y_q_exp_sq = np.dot((y ** 2).T, w)\\n\\n # Compute the variance (d_y, n_q)\\n return y_q_exp_sq - (y_q_exp ** 2)\",\n \"def mse(X, Y, W):\\n\\n # TODO\\n mse = np.sum((X@W-Y)**2)/(2*X.shape[0])\\n # END TODO\\n\\n return mse\",\n \"def mean_squared_error(self, y_out, y):\\n loss = np.sum((y - y_out)**2)\\n return loss\",\n \"def mse_loss(self, x, y):\\n loss = tf.reduce_mean(tf.square(x - y))\\n return loss\",\n \"def mse(y, yhat):\\n return 0.5 * jnp.mean((y - yhat)**2)\",\n \"def mse(gt, pred):\\n return np.mean((gt - pred) ** 2)\",\n \"def mse(gt, pred):\\n return np.mean((gt - pred) ** 2)\",\n \"def get_mle_variance(series, mean=None):\\n\\n if mean is None:\\n\\n mean = series.mean()\\n\\n return 1 / series.size * ((series - mean)**2).sum()\",\n \"def SST(Y):\\n\\tsummation = 0\\n\\taverage = mean(Y)\\n\\tfor i in range(len(Y)):\\n\\t\\tsummation += (Y[i]-average)**2\\n\\treturn summation\",\n \"def get_stdev(self):\\n var_x = numpy.var(self._x)\\n var_y = numpy.var(self._y)\\n return numpy.sqrt(var_x + var_y)\",\n \"def unexplained_variance(x, x_proj):\\n res = poincare.distance(x, x_proj) ** 2\\n return torch.mean(res).item()\",\n \"def mean_square_error(y, y_pred, w):\\n return np.average(((y_pred - y) ** 2), weights=w)\",\n \"def moments(self, x, y):\\n # Let's attempt to remove noise by axing points\\n # below 5% of the peak\\n threshold = y.max() * 0.05\\n clean = np.array(y)\\n clean[clean < threshold] = 0\\n zero = clean.sum()\\n one = np.sum(x * clean)\\n two = np.sum(x * x * clean)\\n mean = one / zero\\n var = two / zero - mean**2\\n stdev = np.sqrt(var)\\n return (mean, stdev)\",\n \"def std(mean, vals):\\n return sqrt(sum([(i-mean)**2 for i in vals])/len(vals))\",\n \"def minimum_mean_square_error(x, y):\\n x_pseudoinv = np.linalg.pinv(x)\\n return x_pseudoinv * x.T * y\",\n \"def mystd(x, pX):\\n mu_x = mean(x)\\n var_x_l = [(x[i] - mu_x) ** 2 * pX[i] for i in range(len(x))]\\n var_x = sum(var_x_l)\\n return sqrt(var_x)\",\n \"def normal_density(mean, variance, X):\\n Z = np.sqrt(2.0*np.pi*variance)\\n unden = np.exp(old_div(-np.sum((X-mean)**2.0, 1),(2.0*variance)) )\\n den = old_div(unden,Z)\\n assert len(den) == X.shape[0]\\n return den\",\n \"def demeaned(self):\\n return self.data - self.mean\",\n \"def stdDev(data):\\r\\n sum = 0\\r\\n ave = average(data)\\r\\n for i in data:\\r\\n sum += (i-ave)**2\\r\\n return math.sqrt(sum/len(data))\",\n \"def MSE(actual, noisy):\\n mean_squared_error(actual, noisy)\",\n \"def mse(x1, x2, axis=0):\\n x1 = np.asanyarray(x1)\\n x2 = np.asanyarray(x2)\\n return np.mean((x1 - x2) ** 2, axis=axis)\",\n \"def mean_squared_error(y_true, y_pred):\\n mse = np.mean(np.power(y_true - y_pred, 2))\\n return mse\",\n \"def clipped_mse(self, y_true, y_pred):\\r\\n return tf.keras.backend.mean(tf.keras.backend.square(tf.keras.backend.clip(y_pred - y_true, -1., 1.)), axis=-1)\",\n \"def variance(xs: List[float]) -> float:\\n assert len(xs) >= 2, \\\"variance requires at least two elements\\\"\\n\\n n = len(xs)\\n deviations = de_mean(xs)\\n return sum_of_squares(deviations) / (n - 1)\",\n \"def variance(xs: List[float]) -> float:\\n assert len(xs) >= 2, \\\"variance requires at least two elements\\\"\\n\\n n = len(xs)\\n deviations = de_mean(xs)\\n return sum_of_squares(deviations) / (n - 1)\",\n \"def test_stdev_from_mean(self):\\r\\n x = [2.1, 4.2, 5.9, 8.4, 9.6]\\r\\n result = stdev_from_mean(x)\\r\\n self.assertFloatEqual(\\r\\n result,\\r\\n [-1.292463399014413,\\r\\n -0.60358696806764478,\\r\\n -0.045925095396451399,\\r\\n 0.77416589382589174,\\r\\n 1.1678095686526162])\",\n \"def deviation(xs):\\n\\ta = avg(xs)\\n\\treturn sqrt(sum([(x - a) ** 2 for x in xs]) / (len(xs) - 1))\",\n \"def variance(x):\\r\\n n = len(x)\\r\\n deviations = dev_mean(x)\\r\\n return sum_of_squares(deviations) / (n-1)\",\n \"def get_mse(data, yhat, mode=\\\"train\\\"):\\n y = getattr(data, mode + \\\"Yref\\\")\\n mse = mean_squared_error(y, data.revert(yhat, mode))\\n return np.sqrt(mse)\",\n \"def mean_squared_error(y_true, y_pred):\\n\\tmse = np.mean(np.power(y_true, y_pred, 2))\\n\\treturn mse\",\n \"def value(a, y):\\n\\t\\treturn 0.5*np.linalg.norm(a-y)**2\",\n \"def sd(x):\\n x_mean = mean(x)\\n return (\\n sum((x_i - x_mean) ** 2 for x_i in x) / (len(x) - 1)\\n ) ** 0.5\",\n \"def mean_squared_error(y_true, y_pred):\\n mse = np.mean((y_true - y_pred)**2)\\n return mse\",\n \"def error(self, y_predicted, y):\\n errors = []\\n for i in range(y.size): \\n errors.append((y[i]-y_predicted[i]) ** 2)\\n return mean(errors)\",\n \"def root_mean_square_error(y, y_pred, w):\\n return np.sqrt(np.average(((y_pred - y) ** 2), weights=w))\",\n \"def mae(y_true: np.ndarray, y_pred: np.ndarray):\\n return np.mean(np.abs(y_true - y_pred))\",\n \"def rmse(x, y):\\n return mse(x, y) ** .5\",\n \"def std_deviation(array):\\n if not array or len(array) == 1:\\n return 0\\n\\n average = AGGREGATES['mean_arithmetic'](array)\\n variance = map(lambda x: (x-average)**2,array)\\n stdev = AGGREGATES['mean_arithmetic'](variance)\\n return math.sqrt(stdev)\",\n \"def variance(x):\\n n = len(x)\\n deviations = de_mean(x)\\n return sum_of_squares(deviations) / (n - 1)\",\n \"def variance(x):\\n n = len(x)\\n deviations = de_mean(x)\\n return sum_of_squares(deviations) / (n - 1)\",\n \"def variance(x):\\n n = len(x)\\n deviations = de_mean(x)\\n return sum_of_squares(deviations) / (n - 1)\",\n \"def covariance(x, y):\\n x_mean = mean(x)\\n y_mean = mean(y)\\n diff_x_mean = (x_i - x_mean for x_i in x)\\n diff_y_mean = (y_i - y_mean for y_i in y)\\n sum_xy_diff = sum(a * b for a, b in zip(diff_x_mean, diff_y_mean))\\n return sum_xy_diff / (len(x) - 1)\",\n \"def calc_standard_deviation(data: list) -> float:\\n mean = calc_mean(data)\\n acc = 0.0\\n for n in data:\\n acc += (n - mean) ** 2\\n acc /= len(data) - 1\\n return math.sqrt(acc)\",\n \"def variance(self):\\r\\n\\t\\t_mean = sum(self.sample)/len(self.sample)\\r\\n\\t\\treturn sum(map(lambda x: (x - _mean)**2, self.sample))/(len(self.sample) - 1)\",\n \"def covariance (x, y):\\n n = len(x)\\n return dot(de_mean(x), de_mean(y))/(n-1)\",\n \"def MSE(a,b,axis):\\n return ((a-b)**2).mean(axis=axis)\",\n \"def adstatistic(self, X):\\n n = len(X)\\n Y = X[:]\\n ybar = mean(Y)\\n yvar = var(Y)\\n ysd = sqrt(yvar)\\n Y = [(y- ybar)/ysd for y in Y]\\n A2 = -n\\n S =0.0 \\n Y.sort() # don't forget this!!!\\n for i, y in enumerate(Y):\\n j = i+1\\n p = self.pnorm(y)\\n q = 1- p\\n S += (j+j - 1)*log(p)+ (2 *(n-j)+1)* log(q)\\n A2 -= S/n\\n \\n \\n A2 *= (1.0 + 4.0/n - 25.0/n**2)\\n return A2\",\n \"def rmse(actual: np.ndarray, predicted: np.ndarray):\\n return np.sqrt(np.mean(np.square(_error(actual, predicted))))\",\n \"def getL(y):\\n\\n x = np.array(range(0,len(y)))\\n b = cov(x,y) / cov(x,x)\\n a = np.mean(y) - b * np.mean(x)\\n \\n return b * len(y) + a\",\n \"def mse(observed, predicted):\\n return np.sqrt(np.mean((observed - predicted)**2))\",\n \"def SSD(x,y):\\n return np.sum((x-y)**2)\",\n \"def mse(actual,expected):\\n return np.mean(se(actual,expected))\",\n \"def std_deviation_of_mean_value(x):\\n\\n import numpy as np\\n x = np.array(x)\\n M = np.size(x)\\n\\n if M == 1: return 0\\n\\n return empirical_std_deviation(x)/np.sqrt(M)\",\n \"def covariance(x, y):\\n n = len(x)\\n return dot(de_mean(x), de_mean(y)) / (n - 1)\",\n \"def mse(predicted, actual):\\n diff = predicted - actual\\n return np.average(diff * diff, axis=0)\",\n \"def mean_stddev(self):\\n if len(self.vs) == 0:\\n raise StdDevFilterException\\n\\n mx = self.mean()\\n # compute variance\\n variance = sum([(x - mx)**2 for x in self.vs])/len(self.vs)\\n # return mean value and standard deviation (square root of variance)\\n return mx,math.sqrt(variance)\",\n \"def rmse_over_stdev(y_true, y_pred, train_y=None):\\n if train_y is not None:\\n stdev = np.std(train_y)\\n else:\\n stdev = np.std(y_true)\\n rmse = root_mean_squared_error(y_true, y_pred)\\n return rmse / stdev\",\n \"def mad(v):\\n return np.mean(np.abs(v - np.mean(v)))\",\n \"def MeanSqError(self):\\r\\n\\t\\treturn self.mse\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69241166","0.69005483","0.6845944","0.67627764","0.67190903","0.66590434","0.6627769","0.6610583","0.6524916","0.65237314","0.65040076","0.64928967","0.64775354","0.64648354","0.6457528","0.6452227","0.6450612","0.6444482","0.64413154","0.64091843","0.64091843","0.64056325","0.6370795","0.6370795","0.63657796","0.63634485","0.6354784","0.63502234","0.6349613","0.63392794","0.6335988","0.63284326","0.6313229","0.6307151","0.62958854","0.62779105","0.62687695","0.6268122","0.62671274","0.62612724","0.6260414","0.62545484","0.62506104","0.6236993","0.6230789","0.62291086","0.6215553","0.6211394","0.6211394","0.6209531","0.6207457","0.62032956","0.6195418","0.6192891","0.6185262","0.6181171","0.6179662","0.6179413","0.61769056","0.6175509","0.6159757","0.61587703","0.6153015","0.6151526","0.6148318","0.6144913","0.6144913","0.6144701","0.61374235","0.6132212","0.6131614","0.6126801","0.6123359","0.6118048","0.61156076","0.61140317","0.61133635","0.61085224","0.61048007","0.60877705","0.6084409","0.6084409","0.6084409","0.6071556","0.60689986","0.6065231","0.60648096","0.60645026","0.6058646","0.60538614","0.60535824","0.6049686","0.604946","0.6048542","0.6046317","0.6042934","0.6038654","0.6034047","0.60336107","0.60292244","0.6026122"],"string":"[\n \"0.69241166\",\n \"0.69005483\",\n \"0.6845944\",\n \"0.67627764\",\n \"0.67190903\",\n \"0.66590434\",\n \"0.6627769\",\n \"0.6610583\",\n \"0.6524916\",\n \"0.65237314\",\n \"0.65040076\",\n \"0.64928967\",\n \"0.64775354\",\n \"0.64648354\",\n \"0.6457528\",\n \"0.6452227\",\n \"0.6450612\",\n \"0.6444482\",\n \"0.64413154\",\n \"0.64091843\",\n \"0.64091843\",\n \"0.64056325\",\n \"0.6370795\",\n \"0.6370795\",\n \"0.63657796\",\n \"0.63634485\",\n \"0.6354784\",\n \"0.63502234\",\n \"0.6349613\",\n \"0.63392794\",\n \"0.6335988\",\n \"0.63284326\",\n \"0.6313229\",\n \"0.6307151\",\n \"0.62958854\",\n \"0.62779105\",\n \"0.62687695\",\n \"0.6268122\",\n \"0.62671274\",\n \"0.62612724\",\n \"0.6260414\",\n \"0.62545484\",\n \"0.62506104\",\n \"0.6236993\",\n \"0.6230789\",\n \"0.62291086\",\n \"0.6215553\",\n \"0.6211394\",\n \"0.6211394\",\n \"0.6209531\",\n \"0.6207457\",\n \"0.62032956\",\n \"0.6195418\",\n \"0.6192891\",\n \"0.6185262\",\n \"0.6181171\",\n \"0.6179662\",\n \"0.6179413\",\n \"0.61769056\",\n \"0.6175509\",\n \"0.6159757\",\n \"0.61587703\",\n \"0.6153015\",\n \"0.6151526\",\n \"0.6148318\",\n \"0.6144913\",\n \"0.6144913\",\n \"0.6144701\",\n \"0.61374235\",\n \"0.6132212\",\n \"0.6131614\",\n \"0.6126801\",\n \"0.6123359\",\n \"0.6118048\",\n \"0.61156076\",\n \"0.61140317\",\n \"0.61133635\",\n \"0.61085224\",\n \"0.61048007\",\n \"0.60877705\",\n \"0.6084409\",\n \"0.6084409\",\n \"0.6084409\",\n \"0.6071556\",\n \"0.60689986\",\n \"0.6065231\",\n \"0.60648096\",\n \"0.60645026\",\n \"0.6058646\",\n \"0.60538614\",\n \"0.60535824\",\n \"0.6049686\",\n \"0.604946\",\n \"0.6048542\",\n \"0.6046317\",\n \"0.6042934\",\n \"0.6038654\",\n \"0.6034047\",\n \"0.60336107\",\n \"0.60292244\",\n \"0.6026122\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":78589,"cells":{"query":{"kind":"string","value":"Function finds mean squared distance from mean for point in Y (variance)"},"document":{"kind":"string","value":"def mse ( target_array ):\n return np.mean ( ( target_array - np.mean ( target_array ) ) ** 2 )\n # End mse()"},"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 mse(x, y):\n\n return (x - y).pow(2).sum(dim=1, keepdim=True).mean() / x.size(1)","def rmse(x: np.ndarray, y: np.ndarray):\n x, y = np.copy(x), np.copy(y)\n if x.ndim > 1:\n return np.sqrt(np.nanmean((x-y)**2, axis=1))\n return np.sqrt(np.nanmean((x-y)**2))","def d_mean(x, y):\n return (x + y) / 2","def calculate_mean_squared_error(self, X, y):\r\n mean_squared_error = np.square(np.subtract(y,self.predict(X))).mean()\r\n return mean_squared_error","def diffSquaredSum(classObj ,dataSet, mean):\r\n return np.sum((dataSet - mean)**2)","def d_mse(x, y):\n\n return 2 * (x - y) / x.size(0) / x.size(1)","def calculate_mean_squared_error(self, X, y):\n mserror = 0\n results = self.predict(X)\n \n mserror = mean_squared_error(results,y)\n #print(error)\n return mserror","def compute_mean_squared_error(self, X_data, y_data):\n #assert isinstance(X_data, np.ndarray)\n #assert isinstance(y_data, np.ndarray)\n #assert X_data.shape[0] == y_data.shape[0]\n \n return np.square(np.subtract(X_data, y_data)).mean()","def _mean_diff(x, y):\n return np.mean(x) - np.mean(y)","def mean_deviation(self):\r\n\t\t_mean = sum(self.sample)/len(self.sample)\r\n\t\treturn sum(map(lambda x: abs(x - _mean), self.sample))/len(self.sample)","def calc_rmse(y: np.ndarray, y_hat: np.ndarray) -> float:\n return np.sqrt(np.mean((y - y_hat)**2))","def stdev_from_mean(x):\r\n x = array(x)\r\n return (x - mean(x)) / std(x)","def mse(datax,datay,w):\n return np.mean((datax.dot(w.T)-datay)**2)","def get_stdev(self):\n if self._y.mean() == 0:\n raise ValueError('invalid value of mean of y, the ratio is not computable')\n\n var = numpy.mean(self._x ** 2) * numpy.mean(1.0 / self._y ** 2) - \\\n (numpy.mean(self._x) ** 2) * (numpy.mean(1.0 / self._y) ** 2)\n return numpy.sqrt(var)","def standard_deviation(xs: List[float]) -> float:\n return math.sqrt(variance(xs))","def standard_deviation(xs: List[float]) -> float:\n return math.sqrt(variance(xs))","def calculate_std_dev(X):\n\tstd_dev = np.sqrt(calculate_variance(X))\n\treturn std_dev","def calculate_variance(X):\n\tmean = np.ones(np.shape(X)) * X.mean(0)\n\tn_samples = np.shape(X)[0]\n\tvariance = (1 / n_samples) * np.diag((X - mean).T.dot(X - mean))\n\treturn variance","def mystd(x, pX):\n mu_x = mean(x)\n var_x_l = [(x[i] - mu_x) ** 2 * pX[i] for i in range(len(x))]\n var_x = sum(var_x_l)\n return sqrt(var_x)","def std_deviation_of_mean_value(x):\n\n import numpy as np\n x = np.array(x)\n M = np.size(x)\n\n if M == 1: return 0\n\n return empirical_std_deviation(x)/np.sqrt(M)","def rmse_calc(arr1, arr2):\n assert arr1.shape==arr2.shape\n \n return np.sqrt(np.mean((arr2-arr1)**2))","def calc_mse(data, ax=0):\n return ((data[:, 0] - data[:, 1]) ** 2).mean(axis=ax)","def minimum_mean_square_error(x, y):\n x_pseudoinv = np.linalg.pinv(x)\n return x_pseudoinv * x.T * y","def mape(x, y):\n return statistics.mean(ape(x, y))","def rmsd(x, y):\n\n # get the length of the dataset\n n, = x.shape\n\n return np.sqrt(np.sum((x-y)**2)/n)","def calc_standard_deviation(data: list) -> float:\n mean = calc_mean(data)\n acc = 0.0\n for n in data:\n acc += (n - mean) ** 2\n acc /= len(data) - 1\n return math.sqrt(acc)","def mean_squared_error(self, y_out, y):\n loss = np.sum((y - y_out)**2)\n return loss","def mse(y_true: np.ndarray, y_pred: np.ndarray) -> float:\n return np.mean(np.power(y_true - y_pred, 2))","def standard_deviation(data):\n\n return np.sqrt(variance(data))","def standard_deviation(data):\n\n return np.sqrt(variance(data))","def mean_square_error(y, y_pred, w):\n return np.average(((y_pred - y) ** 2), weights=w)","def rmse(y_true: np.ndarray, y_pred: np.ndarray):\n return np.sqrt(np.mean(np.power(y_true - y_pred, 2)))","def dist(mean, example):\n return np.linalg.norm(example.row - mean)","def deviation(xs):\n\ta = avg(xs)\n\treturn sqrt(sum([(x - a) ** 2 for x in xs]) / (len(xs) - 1))","def mse(X, Y, W):\n\n # TODO\n mse = np.sum((X@W-Y)**2)/(2*X.shape[0])\n # END TODO\n\n return mse","def deviationAvg(xs):\n\treturn deviation(xs) / sqrt(len(xs))","def mahalanobis_distance(self, x: np.ndarray) -> float:\n # this method could be vectorized for efficient calls\n error = x - self.mean\n mahalanobis_distance = error.T @ nla.solve(self.cov, error)\n return mahalanobis_distance","def _dist(x, y):\n return np.sqrt(np.mean(np.square(x - y)))","def stdDev(data):\r\n sum = 0\r\n ave = average(data)\r\n for i in data:\r\n sum += (i-ave)**2\r\n return math.sqrt(sum/len(data))","def moments(self, x, y):\n # Let's attempt to remove noise by axing points\n # below 5% of the peak\n threshold = y.max() * 0.05\n clean = np.array(y)\n clean[clean < threshold] = 0\n zero = clean.sum()\n one = np.sum(x * clean)\n two = np.sum(x * x * clean)\n mean = one / zero\n var = two / zero - mean**2\n stdev = np.sqrt(var)\n return (mean, stdev)","def variance(xs: List[float]) -> float:\n assert len(xs) >= 2, \"variance requires at least two elements\"\n\n n = len(xs)\n deviations = de_mean(xs)\n return sum_of_squares(deviations) / (n - 1)","def variance(xs: List[float]) -> float:\n assert len(xs) >= 2, \"variance requires at least two elements\"\n\n n = len(xs)\n deviations = de_mean(xs)\n return sum_of_squares(deviations) / (n - 1)","def SSD(x,y):\n return np.sum((x-y)**2)","def mean_squared_error(Y, Y_hat):\n \n m = Y.shape[0]\n \n # calc cost\n cost = (1 / (2 * m)) * np.sum(np.square(Y - Y_hat))\n cost = np.squeeze(cost)\n \n # calc gradient\n dY_hat = - (1 / m) * (Y - Y_hat)\n \n return cost, dY_hat","def SST(Y):\n\tsummation = 0\n\taverage = mean(Y)\n\tfor i in range(len(Y)):\n\t\tsummation += (Y[i]-average)**2\n\treturn summation","def std(mean, vals):\n return sqrt(sum([(i-mean)**2 for i in vals])/len(vals))","def mahalanobis_distance(x, y):\r\n diff = x - np.mean(y, axis=0)\r\n cov = np.cov(y.T) # Covariance matrix\r\n inv_cov = np.linalg.inv(cov)\r\n return np.dot(np.dot(diff, inv_cov), diff.T) + np.log(np.linalg.det(cov))","def covariance(x, y):\n x_mean = mean(x)\n y_mean = mean(y)\n diff_x_mean = (x_i - x_mean for x_i in x)\n diff_y_mean = (y_i - y_mean for y_i in y)\n sum_xy_diff = sum(a * b for a, b in zip(diff_x_mean, diff_y_mean))\n return sum_xy_diff / (len(x) - 1)","def mse(x1, x2, axis=0):\n x1 = np.asanyarray(x1)\n x2 = np.asanyarray(x2)\n return np.mean((x1 - x2) ** 2, axis=axis)","def adstatistic(self, X):\n n = len(X)\n Y = X[:]\n ybar = mean(Y)\n yvar = var(Y)\n ysd = sqrt(yvar)\n Y = [(y- ybar)/ysd for y in Y]\n A2 = -n\n S =0.0 \n Y.sort() # don't forget this!!!\n for i, y in enumerate(Y):\n j = i+1\n p = self.pnorm(y)\n q = 1- p\n S += (j+j - 1)*log(p)+ (2 *(n-j)+1)* log(q)\n A2 -= S/n\n \n \n A2 *= (1.0 + 4.0/n - 25.0/n**2)\n return A2","def mean_squared_error(y_true, y_pred):\n mse = np.mean(np.power(y_true - y_pred, 2))\n return mse","def get_mle_variance(series, mean=None):\n\n if mean is None:\n\n mean = series.mean()\n\n return 1 / series.size * ((series - mean)**2).sum()","def mean_squared_error(y_true, y_pred):\n \n # initialize error at 0\n error = 0\n \n # loop over all samples in the true and predicted list\n for yt, yp in zip(y_true, y_pred):\n # calculate squared error\n # and add to error\n error += (yt - yp) ** 2 \n # return mean error\n return error / len(y_true)","def covariance(x, y):\n n = len(x)\n return dot(deviations_from_mean(x), deviations_from_mean(y))/ (n - 1)","def root_mean_square_error(y, y_pred, w):\n return np.sqrt(np.average(((y_pred - y) ** 2), weights=w))","def calc_mae(y: np.ndarray, y_hat: np.ndarray) -> float:\n return np.mean(np.abs(y - y_hat))","def mean_cov(X):\n if not isinstance(X, np.ndarray) or len(X.shape) != 2:\n raise TypeError('X must be a 2D numpy.ndarray')\n\n n, d = X.shape\n\n if n < 2:\n raise ValueError('X must contain multiple data points')\n\n # mean\n mean = np.mean(X, axis=0).reshape(1, d)\n\n # derivative\n dev = X - mean\n\n # covariance\n cov = np.matmul(dev.T, dev) / (n - 1)\n\n return mean, cov","def variance(x):\n \"\"\" note - why n-1?: since we are likely looking at a sample, x_bar is only an\n estimate of the actual mean, which means that on average (x_i - x_bar) ** 2\n is an underestimate of x_i's squared deviation from the mean, which is why\n we divide by n-1 instead of n (see bit.ly/lL2EapI)\"\"\"\n n = len(x)\n deviations = deviations_from_mean(x)\n return sum_of_squares(deviations) / (n - 1)","def mean_squared_error(y_true, y_pred):\n mse = np.mean((y_true - y_pred)**2)\n return mse","def rmse(self, X, y) -> float:\n return np.sqrt(np.sum(self.l2_error(X, y)))","def covariance(x, y):\n n = len(x)\n return dot(de_mean(x), de_mean(y)) / (n - 1)","def mean_squared_error(y_true, y_pred):\n\tmse = np.mean(np.power(y_true, y_pred, 2))\n\treturn mse","def covariance (x, y):\n n = len(x)\n return dot(de_mean(x), de_mean(y))/(n-1)","def get_stdev(self):\n var_x = numpy.var(self._x)\n var_y = numpy.var(self._y)\n return numpy.sqrt(var_x + var_y)","def variance(x):\r\n n = len(x)\r\n deviations = dev_mean(x)\r\n return sum_of_squares(deviations) / (n-1)","def normal_density(mean, variance, X):\n Z = np.sqrt(2.0*np.pi*variance)\n unden = np.exp(old_div(-np.sum((X-mean)**2.0, 1),(2.0*variance)) )\n den = old_div(unden,Z)\n assert len(den) == X.shape[0]\n return den","def test_stdev_from_mean(self):\r\n x = [2.1, 4.2, 5.9, 8.4, 9.6]\r\n result = stdev_from_mean(x)\r\n self.assertFloatEqual(\r\n result,\r\n [-1.292463399014413,\r\n -0.60358696806764478,\r\n -0.045925095396451399,\r\n 0.77416589382589174,\r\n 1.1678095686526162])","def calculate_mahalanobis_distance(point, centroid, sd, dimension):\n x = 0 # initialize\n for i in range(dimension):\n x += ((point[i]-centroid[i]) / sd[i]) ** 2 # calculate sum of squares\n\n return x ** 0.5 # return mahalanobis distance","def estimateCovariance(df):\n import numpy as np\n m = df.select(df['scaledFeatures']).map(lambda x: x[0]).mean()\n dfZeroMean = df.select(df['scaledFeatures']).map(lambda x: x[0]).map(lambda x: x-m) # subtract the mean\n\n return dfZeroMean.map(lambda x: np.outer(x,x)).sum()/df.count()","def dev_mean(x):\r\n x_bar = mean(x)\r\n return [x_i - x_bar for x_i in x]","def SSE(y, yhat):\n\n return np.sum(np.power(yhat - y, 2))","def std_deviation(array):\n if not array or len(array) == 1:\n return 0\n\n average = AGGREGATES['mean_arithmetic'](array)\n variance = map(lambda x: (x-average)**2,array)\n stdev = AGGREGATES['mean_arithmetic'](variance)\n return math.sqrt(stdev)","def measure(self, X, Y, index):\n X = np.array(X)\n Y = np.array(Y)\n length = len(X)\n score = 0\n if length != 0:\n for i in range(length):\n sigma = self.votility[index + i]\n if sigma != 0:\n score += abs(X[i]-Y[i])/sigma\n \n score = score/length \n return score","def rmse(y_hat, y):\n\tif type(y) == list:\n\t\tpass\n\telse:\n\t\ty = y.values.tolist()\n\tm = len(y)\n\tsum = 0\n\tfor i in range(m):\n\t\tsum += ((y_hat[i] - y[i]) ** 2 / m)\n\terror = np.sqrt(sum)\n\treturn error","def mse(A, B):\n return ((A - B) ** 2).mean(axis=0)","def nmse(actual: np.ndarray, predicted: np.ndarray):\n return np.mean(np.square(actual - predicted)) / (np.mean(actual) * np.mean(predicted) + np.finfo(float).eps)","def rmse(X, Y):\n\n assert X.shape == Y.shape\n\n N = X.shape[0]\n\n if N < 9:\n print(\"Not enough points. {} datapoints given. At least 9 is required\".format(N))\n return\n\n diff = X - Y\n diff = diff**2\n rmse = np.sqrt(diff.mean())\n\n le = rmse * (1.0 - np.sqrt(1-1.96*np.sqrt(2.0)/np.sqrt(N-1)))\n ue = rmse * (np.sqrt(1 + 1.96*np.sqrt(2.0)/np.sqrt(N-1))-1)\n\n return rmse, le, ue","def sd(x):\n x_mean = mean(x)\n return (\n sum((x_i - x_mean) ** 2 for x_i in x) / (len(x) - 1)\n ) ** 0.5","def variance(x):\n n = len(x)\n deviations = de_mean(x)\n return sum_of_squares(deviations) / (n - 1)","def variance(x):\n n = len(x)\n deviations = de_mean(x)\n return sum_of_squares(deviations) / (n - 1)","def variance(x):\n n = len(x)\n deviations = de_mean(x)\n return sum_of_squares(deviations) / (n - 1)","def rmse(y_preds: ndarray, y_actual: ndarray) -> float:\n\n return np.sqrt(np.mean(np.power(y_preds - y_actual, 2)))","def GetStandardDeviation(vals_l, mean):\n\n\n sum_deviations_squared = 0\n\n for x in vals_l:\n sum_deviations_squared += (x - mean)**2\n\n return math.sqrt(float(sum_deviations_squared)/float(len(vals_l)))","def mean_stddev(self):\n if len(self.vs) == 0:\n raise StdDevFilterException\n\n mx = self.mean()\n # compute variance\n variance = sum([(x - mx)**2 for x in self.vs])/len(self.vs)\n # return mean value and standard deviation (square root of variance)\n return mx,math.sqrt(variance)","def sqrtvariance(values, weights=None, axis=0):\n \n return np.sqrt(variance(values, weights=weights, axis=axis))","def computeMse(data_target, Y):\n if data_target.shape != Y.shape:\n print \"the shapes does not correspond\",\n print data_target.shape,\n print Y.shape\n exit(-1)\n return np.sum(np.square(data_target - Y) / Y.shape[0])","def normsq(self):\n return sum(x**2 for x in self.data)","def msd(x, y, frac):\n N = int(len(x) * frac)\n msd = []\n for lag in range(1, N):\n msd.append(\n np.mean(\n [\n SquareDist(x[j], x[j + lag], y[j], y[j + lag])\n for j in range(len(x) - lag)\n ]\n )\n )\n return np.array(msd)","def lsumdiffsquared(x,y):\r\n sds = 0\r\n for i in range(len(x)):\r\n sds = sds + (x[i]-y[i])**2\r\n return sds","def total_sum_of_squares(y: np.ndarray) -> float:\n return np.sum(np.square(y - np.linalg.norm(y)))","def covariance(x, mean_x, y, mean_y):\r\n \r\n covar = 0.0\r\n for i in range(len(x)):\r\n covar += (x[i] - mean_x) * (y[i] - mean_y)\r\n return covar","def get_mse(data, yhat, mode=\"train\"):\n y = getattr(data, mode + \"Yref\")\n mse = mean_squared_error(y, data.revert(yhat, mode))\n return np.sqrt(mse)","def MSE(actual, noisy):\n mean_squared_error(actual, noisy)","def mse(y, yhat):\n return 0.5 * jnp.mean((y - yhat)**2)","def calc_smape(y: np.ndarray, y_hat: np.ndarray) -> float:\n pass","def normalDist(x, mean, var):\n\n if (var != 0):\n return -(x - mean)**2/(2*var) - 0.5*np.log(2*np.pi*var)\n else:\n return 0","def error(self, y_predicted, y):\n errors = []\n for i in range(y.size): \n errors.append((y[i]-y_predicted[i]) ** 2)\n return mean(errors)","def empirical_std_deviation(x):\n import numpy as np\n x = np.array(x)\n M = np.size(x)\n xm = np.mean(x)\n\n #return np.sqrt(1./(M-1.)*np.sum((x-xm)**2))\n return np.sqrt( M/(M-1.) * ( (1./M*np.sum(x**2)) - xm**2 ) )","def minibatch_mean_variance(x):\n mean = tf.reduce_mean(x, 0, keepdims=True)\n vals = tf.sqrt(tf.reduce_mean(tf.squared_difference(x, mean), 0) + 1e-8)\n vals = tf.reduce_mean(vals)\n return vals","def mae(y_true: np.ndarray, y_pred: np.ndarray):\n return np.mean(np.abs(y_true - y_pred))"],"string":"[\n \"def mse(x, y):\\n\\n return (x - y).pow(2).sum(dim=1, keepdim=True).mean() / x.size(1)\",\n \"def rmse(x: np.ndarray, y: np.ndarray):\\n x, y = np.copy(x), np.copy(y)\\n if x.ndim > 1:\\n return np.sqrt(np.nanmean((x-y)**2, axis=1))\\n return np.sqrt(np.nanmean((x-y)**2))\",\n \"def d_mean(x, y):\\n return (x + y) / 2\",\n \"def calculate_mean_squared_error(self, X, y):\\r\\n mean_squared_error = np.square(np.subtract(y,self.predict(X))).mean()\\r\\n return mean_squared_error\",\n \"def diffSquaredSum(classObj ,dataSet, mean):\\r\\n return np.sum((dataSet - mean)**2)\",\n \"def d_mse(x, y):\\n\\n return 2 * (x - y) / x.size(0) / x.size(1)\",\n \"def calculate_mean_squared_error(self, X, y):\\n mserror = 0\\n results = self.predict(X)\\n \\n mserror = mean_squared_error(results,y)\\n #print(error)\\n return mserror\",\n \"def compute_mean_squared_error(self, X_data, y_data):\\n #assert isinstance(X_data, np.ndarray)\\n #assert isinstance(y_data, np.ndarray)\\n #assert X_data.shape[0] == y_data.shape[0]\\n \\n return np.square(np.subtract(X_data, y_data)).mean()\",\n \"def _mean_diff(x, y):\\n return np.mean(x) - np.mean(y)\",\n \"def mean_deviation(self):\\r\\n\\t\\t_mean = sum(self.sample)/len(self.sample)\\r\\n\\t\\treturn sum(map(lambda x: abs(x - _mean), self.sample))/len(self.sample)\",\n \"def calc_rmse(y: np.ndarray, y_hat: np.ndarray) -> float:\\n return np.sqrt(np.mean((y - y_hat)**2))\",\n \"def stdev_from_mean(x):\\r\\n x = array(x)\\r\\n return (x - mean(x)) / std(x)\",\n \"def mse(datax,datay,w):\\n return np.mean((datax.dot(w.T)-datay)**2)\",\n \"def get_stdev(self):\\n if self._y.mean() == 0:\\n raise ValueError('invalid value of mean of y, the ratio is not computable')\\n\\n var = numpy.mean(self._x ** 2) * numpy.mean(1.0 / self._y ** 2) - \\\\\\n (numpy.mean(self._x) ** 2) * (numpy.mean(1.0 / self._y) ** 2)\\n return numpy.sqrt(var)\",\n \"def standard_deviation(xs: List[float]) -> float:\\n return math.sqrt(variance(xs))\",\n \"def standard_deviation(xs: List[float]) -> float:\\n return math.sqrt(variance(xs))\",\n \"def calculate_std_dev(X):\\n\\tstd_dev = np.sqrt(calculate_variance(X))\\n\\treturn std_dev\",\n \"def calculate_variance(X):\\n\\tmean = np.ones(np.shape(X)) * X.mean(0)\\n\\tn_samples = np.shape(X)[0]\\n\\tvariance = (1 / n_samples) * np.diag((X - mean).T.dot(X - mean))\\n\\treturn variance\",\n \"def mystd(x, pX):\\n mu_x = mean(x)\\n var_x_l = [(x[i] - mu_x) ** 2 * pX[i] for i in range(len(x))]\\n var_x = sum(var_x_l)\\n return sqrt(var_x)\",\n \"def std_deviation_of_mean_value(x):\\n\\n import numpy as np\\n x = np.array(x)\\n M = np.size(x)\\n\\n if M == 1: return 0\\n\\n return empirical_std_deviation(x)/np.sqrt(M)\",\n \"def rmse_calc(arr1, arr2):\\n assert arr1.shape==arr2.shape\\n \\n return np.sqrt(np.mean((arr2-arr1)**2))\",\n \"def calc_mse(data, ax=0):\\n return ((data[:, 0] - data[:, 1]) ** 2).mean(axis=ax)\",\n \"def minimum_mean_square_error(x, y):\\n x_pseudoinv = np.linalg.pinv(x)\\n return x_pseudoinv * x.T * y\",\n \"def mape(x, y):\\n return statistics.mean(ape(x, y))\",\n \"def rmsd(x, y):\\n\\n # get the length of the dataset\\n n, = x.shape\\n\\n return np.sqrt(np.sum((x-y)**2)/n)\",\n \"def calc_standard_deviation(data: list) -> float:\\n mean = calc_mean(data)\\n acc = 0.0\\n for n in data:\\n acc += (n - mean) ** 2\\n acc /= len(data) - 1\\n return math.sqrt(acc)\",\n \"def mean_squared_error(self, y_out, y):\\n loss = np.sum((y - y_out)**2)\\n return loss\",\n \"def mse(y_true: np.ndarray, y_pred: np.ndarray) -> float:\\n return np.mean(np.power(y_true - y_pred, 2))\",\n \"def standard_deviation(data):\\n\\n return np.sqrt(variance(data))\",\n \"def standard_deviation(data):\\n\\n return np.sqrt(variance(data))\",\n \"def mean_square_error(y, y_pred, w):\\n return np.average(((y_pred - y) ** 2), weights=w)\",\n \"def rmse(y_true: np.ndarray, y_pred: np.ndarray):\\n return np.sqrt(np.mean(np.power(y_true - y_pred, 2)))\",\n \"def dist(mean, example):\\n return np.linalg.norm(example.row - mean)\",\n \"def deviation(xs):\\n\\ta = avg(xs)\\n\\treturn sqrt(sum([(x - a) ** 2 for x in xs]) / (len(xs) - 1))\",\n \"def mse(X, Y, W):\\n\\n # TODO\\n mse = np.sum((X@W-Y)**2)/(2*X.shape[0])\\n # END TODO\\n\\n return mse\",\n \"def deviationAvg(xs):\\n\\treturn deviation(xs) / sqrt(len(xs))\",\n \"def mahalanobis_distance(self, x: np.ndarray) -> float:\\n # this method could be vectorized for efficient calls\\n error = x - self.mean\\n mahalanobis_distance = error.T @ nla.solve(self.cov, error)\\n return mahalanobis_distance\",\n \"def _dist(x, y):\\n return np.sqrt(np.mean(np.square(x - y)))\",\n \"def stdDev(data):\\r\\n sum = 0\\r\\n ave = average(data)\\r\\n for i in data:\\r\\n sum += (i-ave)**2\\r\\n return math.sqrt(sum/len(data))\",\n \"def moments(self, x, y):\\n # Let's attempt to remove noise by axing points\\n # below 5% of the peak\\n threshold = y.max() * 0.05\\n clean = np.array(y)\\n clean[clean < threshold] = 0\\n zero = clean.sum()\\n one = np.sum(x * clean)\\n two = np.sum(x * x * clean)\\n mean = one / zero\\n var = two / zero - mean**2\\n stdev = np.sqrt(var)\\n return (mean, stdev)\",\n \"def variance(xs: List[float]) -> float:\\n assert len(xs) >= 2, \\\"variance requires at least two elements\\\"\\n\\n n = len(xs)\\n deviations = de_mean(xs)\\n return sum_of_squares(deviations) / (n - 1)\",\n \"def variance(xs: List[float]) -> float:\\n assert len(xs) >= 2, \\\"variance requires at least two elements\\\"\\n\\n n = len(xs)\\n deviations = de_mean(xs)\\n return sum_of_squares(deviations) / (n - 1)\",\n \"def SSD(x,y):\\n return np.sum((x-y)**2)\",\n \"def mean_squared_error(Y, Y_hat):\\n \\n m = Y.shape[0]\\n \\n # calc cost\\n cost = (1 / (2 * m)) * np.sum(np.square(Y - Y_hat))\\n cost = np.squeeze(cost)\\n \\n # calc gradient\\n dY_hat = - (1 / m) * (Y - Y_hat)\\n \\n return cost, dY_hat\",\n \"def SST(Y):\\n\\tsummation = 0\\n\\taverage = mean(Y)\\n\\tfor i in range(len(Y)):\\n\\t\\tsummation += (Y[i]-average)**2\\n\\treturn summation\",\n \"def std(mean, vals):\\n return sqrt(sum([(i-mean)**2 for i in vals])/len(vals))\",\n \"def mahalanobis_distance(x, y):\\r\\n diff = x - np.mean(y, axis=0)\\r\\n cov = np.cov(y.T) # Covariance matrix\\r\\n inv_cov = np.linalg.inv(cov)\\r\\n return np.dot(np.dot(diff, inv_cov), diff.T) + np.log(np.linalg.det(cov))\",\n \"def covariance(x, y):\\n x_mean = mean(x)\\n y_mean = mean(y)\\n diff_x_mean = (x_i - x_mean for x_i in x)\\n diff_y_mean = (y_i - y_mean for y_i in y)\\n sum_xy_diff = sum(a * b for a, b in zip(diff_x_mean, diff_y_mean))\\n return sum_xy_diff / (len(x) - 1)\",\n \"def mse(x1, x2, axis=0):\\n x1 = np.asanyarray(x1)\\n x2 = np.asanyarray(x2)\\n return np.mean((x1 - x2) ** 2, axis=axis)\",\n \"def adstatistic(self, X):\\n n = len(X)\\n Y = X[:]\\n ybar = mean(Y)\\n yvar = var(Y)\\n ysd = sqrt(yvar)\\n Y = [(y- ybar)/ysd for y in Y]\\n A2 = -n\\n S =0.0 \\n Y.sort() # don't forget this!!!\\n for i, y in enumerate(Y):\\n j = i+1\\n p = self.pnorm(y)\\n q = 1- p\\n S += (j+j - 1)*log(p)+ (2 *(n-j)+1)* log(q)\\n A2 -= S/n\\n \\n \\n A2 *= (1.0 + 4.0/n - 25.0/n**2)\\n return A2\",\n \"def mean_squared_error(y_true, y_pred):\\n mse = np.mean(np.power(y_true - y_pred, 2))\\n return mse\",\n \"def get_mle_variance(series, mean=None):\\n\\n if mean is None:\\n\\n mean = series.mean()\\n\\n return 1 / series.size * ((series - mean)**2).sum()\",\n \"def mean_squared_error(y_true, y_pred):\\n \\n # initialize error at 0\\n error = 0\\n \\n # loop over all samples in the true and predicted list\\n for yt, yp in zip(y_true, y_pred):\\n # calculate squared error\\n # and add to error\\n error += (yt - yp) ** 2 \\n # return mean error\\n return error / len(y_true)\",\n \"def covariance(x, y):\\n n = len(x)\\n return dot(deviations_from_mean(x), deviations_from_mean(y))/ (n - 1)\",\n \"def root_mean_square_error(y, y_pred, w):\\n return np.sqrt(np.average(((y_pred - y) ** 2), weights=w))\",\n \"def calc_mae(y: np.ndarray, y_hat: np.ndarray) -> float:\\n return np.mean(np.abs(y - y_hat))\",\n \"def mean_cov(X):\\n if not isinstance(X, np.ndarray) or len(X.shape) != 2:\\n raise TypeError('X must be a 2D numpy.ndarray')\\n\\n n, d = X.shape\\n\\n if n < 2:\\n raise ValueError('X must contain multiple data points')\\n\\n # mean\\n mean = np.mean(X, axis=0).reshape(1, d)\\n\\n # derivative\\n dev = X - mean\\n\\n # covariance\\n cov = np.matmul(dev.T, dev) / (n - 1)\\n\\n return mean, cov\",\n \"def variance(x):\\n \\\"\\\"\\\" note - why n-1?: since we are likely looking at a sample, x_bar is only an\\n estimate of the actual mean, which means that on average (x_i - x_bar) ** 2\\n is an underestimate of x_i's squared deviation from the mean, which is why\\n we divide by n-1 instead of n (see bit.ly/lL2EapI)\\\"\\\"\\\"\\n n = len(x)\\n deviations = deviations_from_mean(x)\\n return sum_of_squares(deviations) / (n - 1)\",\n \"def mean_squared_error(y_true, y_pred):\\n mse = np.mean((y_true - y_pred)**2)\\n return mse\",\n \"def rmse(self, X, y) -> float:\\n return np.sqrt(np.sum(self.l2_error(X, y)))\",\n \"def covariance(x, y):\\n n = len(x)\\n return dot(de_mean(x), de_mean(y)) / (n - 1)\",\n \"def mean_squared_error(y_true, y_pred):\\n\\tmse = np.mean(np.power(y_true, y_pred, 2))\\n\\treturn mse\",\n \"def covariance (x, y):\\n n = len(x)\\n return dot(de_mean(x), de_mean(y))/(n-1)\",\n \"def get_stdev(self):\\n var_x = numpy.var(self._x)\\n var_y = numpy.var(self._y)\\n return numpy.sqrt(var_x + var_y)\",\n \"def variance(x):\\r\\n n = len(x)\\r\\n deviations = dev_mean(x)\\r\\n return sum_of_squares(deviations) / (n-1)\",\n \"def normal_density(mean, variance, X):\\n Z = np.sqrt(2.0*np.pi*variance)\\n unden = np.exp(old_div(-np.sum((X-mean)**2.0, 1),(2.0*variance)) )\\n den = old_div(unden,Z)\\n assert len(den) == X.shape[0]\\n return den\",\n \"def test_stdev_from_mean(self):\\r\\n x = [2.1, 4.2, 5.9, 8.4, 9.6]\\r\\n result = stdev_from_mean(x)\\r\\n self.assertFloatEqual(\\r\\n result,\\r\\n [-1.292463399014413,\\r\\n -0.60358696806764478,\\r\\n -0.045925095396451399,\\r\\n 0.77416589382589174,\\r\\n 1.1678095686526162])\",\n \"def calculate_mahalanobis_distance(point, centroid, sd, dimension):\\n x = 0 # initialize\\n for i in range(dimension):\\n x += ((point[i]-centroid[i]) / sd[i]) ** 2 # calculate sum of squares\\n\\n return x ** 0.5 # return mahalanobis distance\",\n \"def estimateCovariance(df):\\n import numpy as np\\n m = df.select(df['scaledFeatures']).map(lambda x: x[0]).mean()\\n dfZeroMean = df.select(df['scaledFeatures']).map(lambda x: x[0]).map(lambda x: x-m) # subtract the mean\\n\\n return dfZeroMean.map(lambda x: np.outer(x,x)).sum()/df.count()\",\n \"def dev_mean(x):\\r\\n x_bar = mean(x)\\r\\n return [x_i - x_bar for x_i in x]\",\n \"def SSE(y, yhat):\\n\\n return np.sum(np.power(yhat - y, 2))\",\n \"def std_deviation(array):\\n if not array or len(array) == 1:\\n return 0\\n\\n average = AGGREGATES['mean_arithmetic'](array)\\n variance = map(lambda x: (x-average)**2,array)\\n stdev = AGGREGATES['mean_arithmetic'](variance)\\n return math.sqrt(stdev)\",\n \"def measure(self, X, Y, index):\\n X = np.array(X)\\n Y = np.array(Y)\\n length = len(X)\\n score = 0\\n if length != 0:\\n for i in range(length):\\n sigma = self.votility[index + i]\\n if sigma != 0:\\n score += abs(X[i]-Y[i])/sigma\\n \\n score = score/length \\n return score\",\n \"def rmse(y_hat, y):\\n\\tif type(y) == list:\\n\\t\\tpass\\n\\telse:\\n\\t\\ty = y.values.tolist()\\n\\tm = len(y)\\n\\tsum = 0\\n\\tfor i in range(m):\\n\\t\\tsum += ((y_hat[i] - y[i]) ** 2 / m)\\n\\terror = np.sqrt(sum)\\n\\treturn error\",\n \"def mse(A, B):\\n return ((A - B) ** 2).mean(axis=0)\",\n \"def nmse(actual: np.ndarray, predicted: np.ndarray):\\n return np.mean(np.square(actual - predicted)) / (np.mean(actual) * np.mean(predicted) + np.finfo(float).eps)\",\n \"def rmse(X, Y):\\n\\n assert X.shape == Y.shape\\n\\n N = X.shape[0]\\n\\n if N < 9:\\n print(\\\"Not enough points. {} datapoints given. At least 9 is required\\\".format(N))\\n return\\n\\n diff = X - Y\\n diff = diff**2\\n rmse = np.sqrt(diff.mean())\\n\\n le = rmse * (1.0 - np.sqrt(1-1.96*np.sqrt(2.0)/np.sqrt(N-1)))\\n ue = rmse * (np.sqrt(1 + 1.96*np.sqrt(2.0)/np.sqrt(N-1))-1)\\n\\n return rmse, le, ue\",\n \"def sd(x):\\n x_mean = mean(x)\\n return (\\n sum((x_i - x_mean) ** 2 for x_i in x) / (len(x) - 1)\\n ) ** 0.5\",\n \"def variance(x):\\n n = len(x)\\n deviations = de_mean(x)\\n return sum_of_squares(deviations) / (n - 1)\",\n \"def variance(x):\\n n = len(x)\\n deviations = de_mean(x)\\n return sum_of_squares(deviations) / (n - 1)\",\n \"def variance(x):\\n n = len(x)\\n deviations = de_mean(x)\\n return sum_of_squares(deviations) / (n - 1)\",\n \"def rmse(y_preds: ndarray, y_actual: ndarray) -> float:\\n\\n return np.sqrt(np.mean(np.power(y_preds - y_actual, 2)))\",\n \"def GetStandardDeviation(vals_l, mean):\\n\\n\\n sum_deviations_squared = 0\\n\\n for x in vals_l:\\n sum_deviations_squared += (x - mean)**2\\n\\n return math.sqrt(float(sum_deviations_squared)/float(len(vals_l)))\",\n \"def mean_stddev(self):\\n if len(self.vs) == 0:\\n raise StdDevFilterException\\n\\n mx = self.mean()\\n # compute variance\\n variance = sum([(x - mx)**2 for x in self.vs])/len(self.vs)\\n # return mean value and standard deviation (square root of variance)\\n return mx,math.sqrt(variance)\",\n \"def sqrtvariance(values, weights=None, axis=0):\\n \\n return np.sqrt(variance(values, weights=weights, axis=axis))\",\n \"def computeMse(data_target, Y):\\n if data_target.shape != Y.shape:\\n print \\\"the shapes does not correspond\\\",\\n print data_target.shape,\\n print Y.shape\\n exit(-1)\\n return np.sum(np.square(data_target - Y) / Y.shape[0])\",\n \"def normsq(self):\\n return sum(x**2 for x in self.data)\",\n \"def msd(x, y, frac):\\n N = int(len(x) * frac)\\n msd = []\\n for lag in range(1, N):\\n msd.append(\\n np.mean(\\n [\\n SquareDist(x[j], x[j + lag], y[j], y[j + lag])\\n for j in range(len(x) - lag)\\n ]\\n )\\n )\\n return np.array(msd)\",\n \"def lsumdiffsquared(x,y):\\r\\n sds = 0\\r\\n for i in range(len(x)):\\r\\n sds = sds + (x[i]-y[i])**2\\r\\n return sds\",\n \"def total_sum_of_squares(y: np.ndarray) -> float:\\n return np.sum(np.square(y - np.linalg.norm(y)))\",\n \"def covariance(x, mean_x, y, mean_y):\\r\\n \\r\\n covar = 0.0\\r\\n for i in range(len(x)):\\r\\n covar += (x[i] - mean_x) * (y[i] - mean_y)\\r\\n return covar\",\n \"def get_mse(data, yhat, mode=\\\"train\\\"):\\n y = getattr(data, mode + \\\"Yref\\\")\\n mse = mean_squared_error(y, data.revert(yhat, mode))\\n return np.sqrt(mse)\",\n \"def MSE(actual, noisy):\\n mean_squared_error(actual, noisy)\",\n \"def mse(y, yhat):\\n return 0.5 * jnp.mean((y - yhat)**2)\",\n \"def calc_smape(y: np.ndarray, y_hat: np.ndarray) -> float:\\n pass\",\n \"def normalDist(x, mean, var):\\n\\n if (var != 0):\\n return -(x - mean)**2/(2*var) - 0.5*np.log(2*np.pi*var)\\n else:\\n return 0\",\n \"def error(self, y_predicted, y):\\n errors = []\\n for i in range(y.size): \\n errors.append((y[i]-y_predicted[i]) ** 2)\\n return mean(errors)\",\n \"def empirical_std_deviation(x):\\n import numpy as np\\n x = np.array(x)\\n M = np.size(x)\\n xm = np.mean(x)\\n\\n #return np.sqrt(1./(M-1.)*np.sum((x-xm)**2))\\n return np.sqrt( M/(M-1.) * ( (1./M*np.sum(x**2)) - xm**2 ) )\",\n \"def minibatch_mean_variance(x):\\n mean = tf.reduce_mean(x, 0, keepdims=True)\\n vals = tf.sqrt(tf.reduce_mean(tf.squared_difference(x, mean), 0) + 1e-8)\\n vals = tf.reduce_mean(vals)\\n return vals\",\n \"def mae(y_true: np.ndarray, y_pred: np.ndarray):\\n return np.mean(np.abs(y_true - y_pred))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6901139","0.6851943","0.6846584","0.68131304","0.67818093","0.6695487","0.66594326","0.6637449","0.6555009","0.65388817","0.65273666","0.65109974","0.65004605","0.6492552","0.64914644","0.64914644","0.6474629","0.64733547","0.64600074","0.638137","0.6363629","0.6362605","0.6355077","0.6345256","0.63270485","0.6318481","0.6308166","0.630808","0.6302818","0.6302818","0.62877023","0.6281065","0.626743","0.6264757","0.62595457","0.6255559","0.62505424","0.62425363","0.6240108","0.62260336","0.62217766","0.62217766","0.6212952","0.62119234","0.6209035","0.6204203","0.620263","0.62000823","0.61932117","0.61897767","0.6186852","0.6186689","0.6169594","0.61599207","0.61578953","0.61472577","0.61469394","0.6146053","0.61456954","0.6140718","0.6138056","0.6137333","0.61363864","0.6135716","0.6134341","0.6128659","0.6122947","0.6121969","0.6112721","0.61103207","0.61081237","0.6106164","0.61058456","0.6102751","0.609478","0.6092885","0.60916966","0.60791594","0.60731816","0.60731816","0.60731816","0.60580724","0.60559374","0.6047343","0.6038961","0.6037875","0.60308355","0.60277194","0.60269547","0.60213083","0.60192937","0.60188514","0.60146564","0.6013125","0.6004812","0.59906083","0.59892476","0.59874684","0.5982687","0.59777695"],"string":"[\n \"0.6901139\",\n \"0.6851943\",\n \"0.6846584\",\n \"0.68131304\",\n \"0.67818093\",\n \"0.6695487\",\n \"0.66594326\",\n \"0.6637449\",\n \"0.6555009\",\n \"0.65388817\",\n \"0.65273666\",\n \"0.65109974\",\n \"0.65004605\",\n \"0.6492552\",\n \"0.64914644\",\n \"0.64914644\",\n \"0.6474629\",\n \"0.64733547\",\n \"0.64600074\",\n \"0.638137\",\n \"0.6363629\",\n \"0.6362605\",\n \"0.6355077\",\n \"0.6345256\",\n \"0.63270485\",\n \"0.6318481\",\n \"0.6308166\",\n \"0.630808\",\n \"0.6302818\",\n \"0.6302818\",\n \"0.62877023\",\n \"0.6281065\",\n \"0.626743\",\n \"0.6264757\",\n \"0.62595457\",\n \"0.6255559\",\n \"0.62505424\",\n \"0.62425363\",\n \"0.6240108\",\n \"0.62260336\",\n \"0.62217766\",\n \"0.62217766\",\n \"0.6212952\",\n \"0.62119234\",\n \"0.6209035\",\n \"0.6204203\",\n \"0.620263\",\n \"0.62000823\",\n \"0.61932117\",\n \"0.61897767\",\n \"0.6186852\",\n \"0.6186689\",\n \"0.6169594\",\n \"0.61599207\",\n \"0.61578953\",\n \"0.61472577\",\n \"0.61469394\",\n \"0.6146053\",\n \"0.61456954\",\n \"0.6140718\",\n \"0.6138056\",\n \"0.6137333\",\n \"0.61363864\",\n \"0.6135716\",\n \"0.6134341\",\n \"0.6128659\",\n \"0.6122947\",\n \"0.6121969\",\n \"0.6112721\",\n \"0.61103207\",\n \"0.61081237\",\n \"0.6106164\",\n \"0.61058456\",\n \"0.6102751\",\n \"0.609478\",\n \"0.6092885\",\n \"0.60916966\",\n \"0.60791594\",\n \"0.60731816\",\n \"0.60731816\",\n \"0.60731816\",\n \"0.60580724\",\n \"0.60559374\",\n \"0.6047343\",\n \"0.6038961\",\n \"0.6037875\",\n \"0.60308355\",\n \"0.60277194\",\n \"0.60269547\",\n \"0.60213083\",\n \"0.60192937\",\n \"0.60188514\",\n \"0.60146564\",\n \"0.6013125\",\n \"0.6004812\",\n \"0.59906083\",\n \"0.59892476\",\n \"0.59874684\",\n \"0.5982687\",\n \"0.59777695\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6005872"},"document_rank":{"kind":"string","value":"94"}}},{"rowIdx":78590,"cells":{"query":{"kind":"string","value":"Function to update the values of a TreeSplits object."},"document":{"kind":"string","value":"def updateTreeValues ( self, feature_column, feature_value, node_type, nodes, children = [ ] ):\n self.feature_column = feature_column\n self.feature_value = feature_value\n self.node_type = node_type\n self.nodes = nodes\n self.children = children\n # End updateTreeValues()"},"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 SetSplitValues(self, *args):\n return _ShapeUpgrade.ShapeUpgrade_SplitCurve_SetSplitValues(self, *args)","def split(self):\n pos_median = len(self.keys)/2\n key_median = self.keys[pos_median]\n value_median = self.values[pos_median]\n keys_left = self.keys[:pos_median]\n keys_right = self.keys[pos_median+1:]\n values_left = self.values[:pos_median]\n values_right = self.values[pos_median+1:]\n if self.is_leaf():\n refs_left = []\n refs_right = []\n else:\n refs_left = self.refs[:pos_median]\n refs_right = self.refs[pos_median+1:]\n\n # Update the current node.\n self.keys = keys_left\n self.values = values_left\n self.refs = refs_left\n\n # Create a new sibling with the right data.\n sibling = BTreeNode(self.m)\n sibling.parent = self.parent\n sibling.keys = keys_right\n sibling.values = values_right\n sibling.refs = refs_right\n for ref in sibling.refs:\n ref.parent = sibling\n\n # If the current node is root, we need to create a new root.\n if self.is_root():\n new_root = BTreeNode(self.m)\n new_root.keys = [key_median]\n new_root.values = [value_median]\n new_root.refs = [self, sibling]\n self.parent = new_root\n sibling.parent = new_root\n else:\n index = self.parent.refs.index(self)\n self.parent.keys.insert(index+1, key_median)\n self.parent.values.insert(index+1, value_median)\n self.parent.refs.insert(index+1, sibling)\n\n if self.parent.is_full():\n self.parent.split()","def AdjustTree(self):\n p = self\n while p != None:\n # If current node's leaves number is more than M, just split and adjust father node MBR\n if len(p.leaves) > p.M:\n p.SplitNode()\n else:\n # Or just adjust father point MBR\n if p.father != None:\n p.father.MBR = merge(p.father.MBR, p.MBR)\n p = p.father","def split(self):\n left = BPlusNode(self.order)\n right = BPlusNode(self.order)\n mid = self.order // 2\n\n left.keys = self.keys[:mid]\n left.values = self.values[:mid]\n\n right.keys = self.keys[mid:]\n right.values = self.values[mid:]\n\n # When the node is split, set the parent key to the left-most key of the right child node.\n self.keys = [right.keys[0]]\n self.values = [left, right]\n self.leaf = False","def set_values(self, new_values):\n for name, value in new_values.items():\n self.nodes_db.loc[name][\"node\"].set_value(value)","def split(self, place_leaf_splitted):\n raise NotImplementedError","def setSplit(self,split):\n self.split=split","def SetVSplitValues(self, *args):\n return _ShapeUpgrade.ShapeUpgrade_SplitSurface_SetVSplitValues(self, *args)","def update(self, tree_path, value):\n\t\traise NotImplementedError","def update(self):\n map(lambda x: x.update(), self._children.values())","def grow(self):\n while self.splittable_nodes:\n self.split_next()","def updateTree(self):\n self.reset()\n self.resetTree() \n self.read()","def addSplitValue(self, split):\n self.balance += split.value","def update(self, probs: torch.Tensor):\n tree, capacity = self._create_tree(probs, self.tree)\n self.tree = tree\n self.capacity = capacity","def update(self,x,y):\n if self.ncores > 1:\n # parallel updates\n pass # FIXME\n else:\n # sequential updates\n for tree in self.forest:\n tree.update(x,y)","def split(self, splits, catchall=False):\r\n raise NotImplementedError()","def updateTree(self, i, val, cur):\n start, end = cur.start, cur.end\n if start == end == i:\n cur.val = val\n return\n mid = start+(end-start)/2\n if i <= mid:\n cur.val -= cur.left.val\n self.updateTree(i, val, cur.left)\n cur.val += cur.left.val\n else:\n cur.val -= cur.right.val\n self.updateTree(i, val, cur.right)\n cur.val += cur.right.val","def update(self) -> None:\n\t\t# Clear attributes that will be updates\n\t\tself.node_names: List[str] = []\n\t\tself.subnode_names: Dict[str, Set[str]] = {}\n\t\t# Iterate over RootNodes\n\t\tname: str\n\t\ts_name: str\n\t\tfor rootnode in self.root_nodes:\n\t\t\t# Iterate over Nodes\n\t\t\tfor node in rootnode.nodes:\n\t\t\t\tself._update_with_node(node)\n\t\t\tif len(rootnode.subnodes):\n\t\t\t\t# Create Set in subnode_names for the RootNode's SubNodes\n\t\t\t\tself.subnode_names[rootnode.name] = set()\n\t\t\t\t# Iterate over SubNodes\n\t\t\t\tfor subnode in rootnode.subnodes:\n\t\t\t\t\tself.subnode_names[rootnode.name].add(subnode.name)","def changeInitValues(self, betas):\n\n for e in self.children:\n e.changeInitValues(betas)","def __setitem__(self, t: Tuple[int, ...], o: 'Tree') -> None:\n ...","def update(self, feature_col, feature_value, node_type, nodes, children=[]):\n self.feature_col = feature_col\n self.feature_value = feature_value\n self.node_type = node_type\n self.nodes = nodes\n self.children = children","def change_node_vals(root, sorted_inorder):\r\n if root is None:\r\n return\r\n\r\n change_node_vals(root.left, sorted_inorder)\r\n\r\n root.val = sorted_inorder[0]\r\n sorted_inorder.pop(0)\r\n\r\n change_node_vals(root.right, sorted_inorder)","def SetUSplitValues(self, *args):\n return _ShapeUpgrade.ShapeUpgrade_SplitSurface_SetUSplitValues(self, *args)","def fillBestSplitsInDataByInfoGainIntoDict(self, data, structure, colName, numOfSplits, splitsList, indexToInsert):\n if len(data) <= 0 or numOfSplits <= 0:\n return []\n colIndex = structure[colName]['index']\n split = self.findBestSplitInDataByInfoGain(data, structure, colName)\n if str(indexToInsert) in splitsList:\n splitsList[str(indexToInsert)] += [split]\n else:\n splitsList[str(indexToInsert)] = [split]\n indexToInsert, numOfSplits = indexToInsert + 1, numOfSplits - 1\n\n if split:\n newDataBellowSplit = list(filter(lambda y: float(y[colIndex]) <= split[0], data))\n newDataAboveSplit = list(filter(lambda y: float(y[colIndex]) > split[0], data))\n self.fillBestSplitsInDataByInfoGainIntoDict(newDataBellowSplit, structure, colName, numOfSplits, splitsList, indexToInsert)\n self.fillBestSplitsInDataByInfoGainIntoDict(newDataAboveSplit, structure, colName, numOfSplits, splitsList, indexToInsert)","def __update(self, idx):\n parent = (idx - 1) // 2\n while parent >= 0:\n left, right = 2 * parent + 1, 2 * parent + 2\n self.__tree[parent] = self.__tree[left] + self.__tree[right]\n parent = (parent - 1) // 2","async def _set_split(self, row, value):\n self.sheet.update_cell(row, 2, value)\n return True","def _setup_splits(self):\n #ntot = self.reredux_conf['nperfile']\n ntot = self.reredux_conf['Ngals']\n npersplit = self.runconf['nper']\n\n self.beglist, self.endlist = get_splits(ntot, npersplit)","def set_datasplits(self, df):\n\t\tdf.to_csv(self.splitsFile)","def fillDictWithBestValueSplitsOfDataByGini(self, data, structure, colIndex, numOfSplits, splitsList, indexToInsert):\n if len(data) <= 0 or numOfSplits <= 0:\n return []\n split = self.findBestValueSplitByGini(data, structure, colIndex)\n if str(indexToInsert) in splitsList:\n splitsList[str(indexToInsert)] += [split]\n else:\n splitsList[str(indexToInsert)] = [split]\n indexToInsert, numOfSplits = indexToInsert + 1, numOfSplits - 1\n\n if split:\n newDataBellowSplit = list(filter(lambda y: float(y[colIndex]) <= split[0], data))\n newDataAboveSplit = list(filter(lambda y: float(y[colIndex]) > split[0], data))\n self.fillDictWithBestValueSplitsOfDataByGini(newDataBellowSplit, structure, colIndex, numOfSplits, splitsList, indexToInsert)\n self.fillDictWithBestValueSplitsOfDataByGini(newDataAboveSplit, structure, colIndex, numOfSplits, splitsList, indexToInsert)","def test_split_adds_children(mock_amg):\n\n mock_amg.cells[0].split()\n assert mock_amg.cells[0].children['bl'] is mock_amg.cells[-4]\n assert mock_amg.cells[0].children['br'] is mock_amg.cells[-3]\n assert mock_amg.cells[0].children['tl'] is mock_amg.cells[-2]\n assert mock_amg.cells[0].children['tr'] is mock_amg.cells[-1]","def split(self, attribute):\n if attribute not in self.attributes:\n raise KeyError('Attribute not present in node')\n \n self.split_attr = attribute\n \n # list() is used to make a copy of the list instead of pointing to the same list\n child_attributes = list(self.attributes)\n child_attributes.remove(attribute)\n \n child1_ancestors = list(self.ancestors)\n child0_ancestors = list(self.ancestors)\n child1_ancestors.append(attribute_value(attribute, 1))\n child0_ancestors.append(attribute_value(attribute, 0))\n \n self.val1 = Node(child_attributes, child1_ancestors, self.data, self.heuristic)\n self.val0 = Node(child_attributes, child0_ancestors, self.data, self.heuristic)","def addSplit(self):\n pass","async def update_split(self, name, delta, items=None):\n\n # Generates list\n splits_list = await self._get_all_splits()\n\n # Gets index of name based on fuzzy search match\n index = await self._get_name_index(name, splits_list)\n\n # If index is valid, adds provided value to splits\n if index == -1:\n return None\n prev_val = int(splits_list[index][1])\n new_val = prev_val + delta\n await self._set_split(index + 1, new_val)\n\n # If item provided, appends item to end of item list\n if items is not None:\n item_list = self.sheet.cell(index + 1, 3).value\n if len(item_list) != 0:\n new_item_list = item_list + \", \" + items\n else: \n new_item_list = items\n self.sheet.update_cell(index + 1, 3, new_item_list)\n\n # Returns both previous and new value\n return prev_val, new_val, splits_list[index][0]","def change_leaf_value(self, place, has_element_new):\n self.has_element = has_element_new","def split(root, Dk, maxDepth, minRows, currDepth):\n \n left, right = root['branches']\n del(root['branches'])\n \n# if not left and not right:\n# return\n \n # Check if the node is a leaf\n if not len(left): \n root['left'] = root['right'] = getLeafClass(right)\n return\n elif not len(right):\n root['left'] = root['right'] = getLeafClass(left)\n return\n \n # Check for max depth\n if(currDepth >= maxDepth):\n root['left'], root['right'] = getLeafClass(left), getLeafClass(right)\n return\n \n # Process left branch\n if(len(left) <= minRows):\n root['left'] = getLeafClass(left)\n else:\n root['left'] = findNextSplit(left, Dk)\n split(root['left'], Dk, maxDepth, minRows, currDepth + 1)\n \n # Process right branch\n if(len(right) <= minRows):\n root['right'] = getLeafClass(right)\n else:\n root['right'] = findNextSplit(right, Dk)\n split(root['right'], Dk, maxDepth, minRows, currDepth + 1)","def place_at_splits(data):\n groups = defaultdict(list)\n for runner_idx, runner in enumerate(data):\n splits = runner['splits']\n for split in splits:\n split['runner_idx'] = runner_idx\n groups[split['split_dist']].append(split)\n\n ranks = []\n srt_keys = sorted(groups, key=groups.get)\n for key in srt_keys:\n group = groups[key]\n srt_group = sorted(group, key=lambda t: t['split_mins'])\n ranked_group = []\n for rank, split in enumerate(srt_group):\n split['rank'] = rank\n ranked_group.append(split)\n ranks.append(ranked_group)\n\n return data, ranks","def update(\n self, index: Union[int, np.ndarray], value: Union[float, np.ndarray]\n ):\n\n tree_index = self.capacity + index\n self._tree[tree_index] = value\n\n # Propagate up the tree.\n parent = tree_index // 2\n while np.any(parent > 0):\n left = self._tree[2 * parent] # Children/sibling.\n right = self._tree[2 * parent + 1]\n # Note: Due to possible floating point error in the sum-tree case,\n # it's safer to recompute the parent nodes directly rather than to\n # accumulate an \"update\" up the tree which could be faster.\n self._tree[parent] = self.operation(left, right)\n parent = parent // 2","def update(self, other):\n b = self.hallucinate_merge(other)\n self.l_child = b.l_child\n self.r_child = b.r_child","def parameter_tree_changed(self, param, changes):\n for param, change, data in changes:\n path = self.settings.childPath(param)\n if path is not None:\n childName = '.'.join(path)\n else:\n childName = param.name()\n if change == 'childAdded':pass\n\n elif change == 'value':\n\n if param.name() == 'Detectors':\n self.update_plot_det_items(param)\n\n elif param.name() == 'scan_average':\n self.show_average_dock(param.value() > 1)\n elif change == 'parent':pass","def _fill_tree(self):\r\n self._tree.delete(*self._tree.get_children())\r\n for point_index, point in enumerate(self._structure.points):\r\n self._tree.insert('', 'end', values=[point_index, round(point[0]), round(point[1])])\r\n if point_index == self._index_of_sel_point:\r\n self._set_selection(point_index)","def updateSubTreesHeight(self):\n \n # Get sons...\n # ---------------------------------------------------- #\n nodeLeftSon = self._leftSon\n nodeRightSon = self._rightSon\n \n # Calc left subtree height...\n # ---------------------------------------------------- #\n if(nodeLeftSon is not None):\n self._leftSubtreeHeight = max(nodeLeftSon._leftSubtreeHeight, nodeLeftSon._rightSubtreeHeight) + 1\n else:\n self._leftSubtreeHeight = 0\n \n # Calc right subtree height...\n # ---------------------------------------------------- #\n if(nodeRightSon is not None):\n self._rightSubtreeHeight = max(nodeRightSon._leftSubtreeHeight, nodeRightSon._rightSubtreeHeight) + 1\n else:\n self._rightSubtreeHeight = 0","def update_many(self, base_tree_path, values, level=NONTRANSACTIONAL):\n\t\tassert transactional == NONTRANSACTIONAL, 'Transactional updates are not supported'\n\n\t\t# The default implementation, if the chosen backend does not provide a more efficient one\n\t\tbase_tree_path = list(base_tree_path)\n\t\tret_values = []\n\t\tfor tree_path, value in values:\n\t\t\tret_values.append(\n\t\t\t\tself.update(base_tree_path + list(tree_path), value)\n\t\t\t)\n\n\t\treturn ret_values","def refresh_tree(self):\n self.process_tree = ProcessNode.objects.get(id=self.process_tree_id)","def update_nodes(self):\n raise NotImplementedError('ERROR: sweeper has to implement update_nodes(self)')","def _synchronize_attributes(self):\n\t\tself._depth = 0\n\t\tself._max_chars = 1\n\t\tself._size = 0\n\t\tif (not self._root):\n\t\t\treturn\n\t\tattrs = [\"_is_balanced\", \"_isvalidBST\", \"_max\", \"_min\"]\n\t\tqueue = c3.Queue()\n\t\tqueue.enqueue((1, self._root))\n\t\twhile queue.peek():\n\t\t\tnodelev, node = queue.dequeue()._data\n\t\t\tself._size += 1\n\t\t\tif (self._treetype and type(node.value()) != self._treetype):\n\t\t\t\t#print \"WARNING: Tree has been corrupted with data of the wrong type. \" \\\n\t\t\t\t#\t+ str(type(node.value())) + \": \" + str(node.value())\n\t\t\t\tpass\n\t\t\tfor attr in attrs:\n\t\t\t\tif hasattr(node, attr):\n\t\t\t\t\tdelattr(node, attr)\n\t\t\tnode.setdepth(nodelev)\n\t\t\tif (nodelev > self._depth):\n\t\t\t\tself._depth = nodelev\n\t\t\tif (len(str(node.value())) > self._max_chars):\n\t\t\t\tself._max_chars = len(str(node.value()))\n\t\t\tif (node.lchild()):\n\t\t\t\tqueue.enqueue((nodelev + 1, node.lchild()))\n\t\t\tif (node.rchild()):\n\t\t\t\tqueue.enqueue((nodelev + 1, node.rchild()))","def _parse_split_dims(tree, split_dims, level=0, parent=None, max_level=7,\n split_positions=None):\n if level == max_level:\n # this is leaf tree, and split_dim=-1.\n return\n\n if tree.lesser is not None:\n _parse_split_dims(tree.lesser, split_dims, level=level+1, parent=tree,\n max_level=max_level, split_positions=split_positions)\n else:\n # This will happen when the point is overlapped and `split_dim==-1`,\n # in this case just use parent `tree`.\n # print('tree.lesser is None, level {}'.format(level))\n _parse_split_dims(tree, split_dims, level=level+1, parent=tree,\n max_level=max_level, split_positions=split_positions)\n if tree.greater is not None:\n _parse_split_dims(tree.greater, split_dims, level=level+1, parent=tree,\n max_level=max_level, split_positions=split_positions)\n else:\n # This will happen when the point is overlapped and `split_dim==-1`,\n # in this case just use parent `tree`.\n # print('[WARNING] tree.greater is None, level {}'.format(level))\n _parse_split_dims(tree, split_dims, level=level+1, parent=tree,\n max_level=max_level, split_positions=split_positions)\n\n if level < max_level:\n split_dim = tree.split_dim\n if split_dim == -1:\n # since we repeated premature leafs, we get invalid splits\n # in this case just use the parents.\n # This case happen when the points are overlapped.\n # print('split_dim is -1 at level', level)\n split_dim = parent.split_dim if (parent.split_dim > -1) else 0\n split_dims[level].append(split_dim)\n if split_positions is not None:\n split = tree.split\n if split_dim == -1:\n split = parent.split if (parent.split_dim > -1) else 0\n split_positions[level].append(split)","def __test_all_segments_with_updates(self, arr, fnc, upd):\n segment_tree = SegmentTree(arr, fnc)\n for index, value in upd.items():\n arr[index] = value\n segment_tree.update(index, value)\n self.__test_segments_helper(segment_tree, fnc, arr)","def set_splits(self, train_E, train_E_false=None, test_E=None, test_E_false=None, directed=False, nw_name='test',\n TG=None, split_id=0, split_alg='spanning_tree', verbose=False):\n # Initialize the training graph\n if TG is None:\n if directed:\n TG = nx.DiGraph()\n else:\n TG = nx.Graph()\n TG.add_edges_from(train_E)\n TG.add_edges_from(train_E_false)\n\n # Set the parameters by calling the parent class private set method\n super(SPEvalSplit, self)._set_splits(train_E=train_E, train_E_false=train_E_false, test_E=test_E,\n test_E_false=test_E_false, directed=directed, nw_name=nw_name,\n TG=TG, split_id=split_id, split_alg=split_alg, verbose=verbose)","def _update_statistics(self):\n\n self._finalize_data()\n if 'z' in self.data.dtype.names:\n self.tree.settings['min_depth'] = np.nanmin(self.node_data['z']).compute()\n self.tree.settings['max_depth'] = np.nanmax(self.node_data['z']).compute()\n if 'tvu' in self.data.dtype.names:\n self.tree.settings['min_tvu'] = np.nanmin(self.node_data['tvu']).compute()\n self.tree.settings['max_tvu'] = np.nanmax(self.node_data['tvu']).compute()","def __setitem__(self, i: int, o: 'Tree') -> None:\n ...","def _do_pytree(array, split_indices, reshape_shape):\n pytree = jnp.split(array, split_indices)\n pytree[0] = pytree[0].reshape(reshape_shape)\n pytree[-1] = {'-1': pytree[-1]}\n return pytree","def _finalize_splittable_nodes(self):\n while len(self.splittable_nodes) > 0:\n node = self.splittable_nodes.pop()\n self._finalize_leaf(node)","def splits(self) -> List[int]:\n if self._splits is None:\n self.RefreshStats()\n return self._splits","def update(self, idx, value):\n idx = self.__capacity - 1 + idx\n self.__tree[idx] = value\n self.__update(idx)","def set_tree(self, new_tree):\n if isinstance(new_tree, BinaryTree):\n self.tree = new_tree","def __set__(self, instance, value):\n # Run process for the nested field type for each value in list\n instance._values[self.name] = [self.field.process(v) for v in value]","def _tree_update(self, new_tree: Tree, event: Event):\n raise NotImplementedError()","def _SetParameters(self, data, setter_name):\n # First, collect all non-terminal paths seen among the judgments:\n self._paths = set()\n for responses, _ in data.itervalues():\n for _, judgment, _ in responses:\n # We want the path minus the last element. For example, if the\n # judgment is ('disk', 'not edge-on', 'spiral'), we need a submodel\n # rooted at the ('disk', 'not edge-on') key.\n self._paths.add(judgment[:-1])\n # Now we make sure we have all the subpaths. In the above example, once we\n # have ('disk', 'not edge-on'), we also need to have ('disk',).\n for path in self._paths.copy():\n self._paths.update((path[:index] for index in range(len(path))))\n\n # Next, create a PathView of the data and iterate over all the slices:\n data_view = PathView(data)\n for path in self._paths:\n data_view.SetPrimaryKey(path)\n # Create the submodel for this key if it doesn't already exist:\n if path not in self.model_tree:\n # Construct a new submodel at this node in the tree:\n self.model_tree[path] = self._CreateSubmodel(path)\n # Set the question weights according to the parent node of path:\n weights = {}\n if path:\n for question, (_, resolution_map) in data.iteritems():\n if path in resolution_map:\n weights[question] = resolution_map[path]\n # Call the appropriate SetXParameters method for the node in model_tree\n # corresponding to the path path:\n getattr(self.model_tree[path], setter_name)(data_view,\n question_weights=weights)","def regenerate_tree(self, newpos):\n self.path = self.tree[newpos][2]\n self.tree = self.get_tree()\n self.pos = self.get_curpos()","def delSplitValue(self, split):\n self.balance -= split.value","def _set_by_path(tree, keys, value):\n _get_by_path(tree, keys[:-1])[keys[-1]] = value","def _set_by_path(tree, keys, value):\n _get_by_path(tree, keys[:-1])[keys[-1]] = value","def update(self, status):\n\n for name, c in self.children.items():\n c.update(status.child(name))","def set_splits(self, train_E, train_E_false=None, test_E=None, test_E_false=None, directed=False, nw_name='test',\n TG=None, split_id=0, split_alg='spanning_tree', owa=True, verbose=False):\n # Set the LP specific parameters\n self._owa = owa\n if train_E_false is not None:\n self._fe_ratio = np.around(len(train_E_false) / len(train_E), 4)\n else:\n self._fe_ratio = 1\n\n # Set the remaining parameters by calling the parent class private set method\n super(LPEvalSplit, self)._set_splits(train_E=train_E, train_E_false=train_E_false, test_E=test_E,\n test_E_false=test_E_false, directed=directed, nw_name=nw_name,\n TG=TG, split_id=split_id, split_alg=split_alg, verbose=verbose)","def reassignWeights(self,weights):\n\t\n\t\tbranches = self.collectAllBranches()\n\n\t\tfor i in range(self.nBranches):\n\n\t\t\tbranches[i].weight = weights[i]","def sync_tree_with_data(self, tree: QTreeView, data: List[DataNode]) -> None:\n tree.setModel(self.create_model_from_nodes(data))\n tree.expandAll()","def split(self, user, number=2, piece='a', comment=None, force_refresh=True):\n if comment is None:\n comment = 'Split sample into {0} pieces'.format(number)\n\n process = Process.objects.create(title='Split Sample',\n comment=comment,\n user=user,\n type_id='split-process')\n nodes = []\n\n branch = self.get_piece(piece)\n for i in range(number):\n if i == 0:\n new_piece = piece\n else:\n new_piece = self._get_next_piece()\n # Note: Issue #248 in django-mptt causes the tree to not be properly\n # updated when inserting objects if parent is set. Workaround\n # is to set parent_id instead. This fixes methods such as\n # MPTTModel.get_descendants(). Since you are referencing an\n # object that has changed in the database (process_tree),\n # the lft and rght items are not updated properly. Workarounds\n # include manually updating the root node or requerying for\n # the sample object which will force a refresh.\n nodes.append(self._insert_node(process, new_piece, i + 1, branch))\n if force_refresh: # workaround to force the root node to update\n self.refresh_tree()\n return nodes","def _tree_update(self, new_tree: Tree, tree_update_time: datetime):\n self.__tree_update_time = tree_update_time\n self.__new_tree = new_tree\n self.__new_event_types_listeners = self._register_event_listeners(self.__new_tree)\n self.__is_simultaneous_state = True","def update(self, initial, follows):","def BCT_operators(self):\n leaves_original = [node for node, degree in self.tree.out_degree().items() if degree == 0]\n\n def split(node):\n # ##\n # Return bin-tuple of the orphaned tree\n #\n # Parameter:\n # node: string\n #\n # Return:\n # (split_node_parent, node)\n # ##\n\n # Trivialize the orphaned subtree and re-allocate the position to\n # the child of the split_node_parent does not be cut.\n split_node_parent = M.tree.predecessors(node)[0]\n\n if M.tree.predecessors(split_node_parent) != []:\n split_node_parent_parent = M.tree.predecessors(split_node_parent)[0]\n else:\n split_node_parent_parent = None\n M.tree.node[node]['position'] = 'trivial'\n the_other_child = [n for n in M.tree.successors(split_node_parent) if n != node][0]\n\n # Shift the child to the position of its parent\n M.tree.node[the_other_child]['position'] = M.tree.node[split_node_parent]['position']\n M.tree.node[split_node_parent]['position'] = 'trivial'\n\n # Cutting the edge which is related to the parent of the split node\n try:\n cutting_edges_list = [(n1, n2) for n1, n2 in M.tree.edges() if\n (n1 == split_node_parent or n2 == split_node_parent) and (n2 != node)]\n\n # Remove edeges\n for i, j in cutting_edges_list:\n M.tree.remove_edge(i, j)\n\n # Establish the edge on the new movement\n if split_node_parent_parent:\n i, j = [n1 for n1, n2 in cutting_edges_list if n1 == split_node_parent_parent][0], \\\n [n2 for n1, n2 in cutting_edges_list if n2 == the_other_child][0]\n\n M.tree.add_edge(i, j)\n\n except Exception:\n raise Exception(\"in the part of split() suc-function of BCT_operator() function\")\n\n return split_node_parent, node\n\n\n def insertion(M, insert_node, split_node_parent, split_node, operator, split_node_position):\n # ##\n # Return a new binary construction tree\n #\n # Parameter:\n # split_node_parent: string, the old operator\n # split_node: string, the cut node, is used to reinsert to the binary construction tree\n # operator: string, the new operator, typically two options (\"series\" and \"parallel\")\n # split_node_position: string, the new position allocated to the cut node.\n #\n # Return:\n # M: BinaryConstructionTree\n # ##\n\n try:\n # Relabel the arributes of relevant nodes.\n mapping = {split_node_parent: operator}\n M.tree = nx.relabel_nodes(M.tree, mapping)\n M.tree.node[operator]['position'] = M.tree.node[insert_node]['position']\n insert_node_parent = M.tree.predecessors(insert_node)[0]\n\n # Re-allocate the position to the relevant nodes.\n if split_node_position == 'right' and split_node_position == M.tree.node[insert_node]['position']:\n M.tree.node[insert_node]['position'] = 'left'\n\n elif split_node_position == 'left' and split_node_position == M.tree.node[insert_node]['position']:\n M.tree.node[insert_node]['position'] = 'right'\n M.tree.node[split_node]['position'] = split_node_position\n\n # print M.tree.edges()\n # Remove the related edges of the current binary tree\n M.tree.remove_edge(insert_node_parent, insert_node)\n\n # Add the new edges to binary tree\n M.tree.add_edge(insert_node_parent, operator)\n M.tree.add_edge(operator, insert_node)\n\n # Eliminate the redundant edge.\n # for i, j in M.tree.edges():\n\n except Exception:\n raise Exception('in tha part of insertion() sub-function of BCT_operator() function')\n\n return M\n\n # To preserve meta structure.\n M_self = copy.deepcopy(self)\n\n # To traverse all possible isomorphic binary tree\n for node in leaves_original:\n\n M = copy.deepcopy(M_self)\n\n # Do split operation\n split_node_parent, split_node = split(node)\n\n # The children that are used to be inserted\n leaves_insertion = leaves_original[:]\n leaves_insertion.remove(split_node)\n\n # print leaves_insertion\n # Do insertion operation\n for insertnode in leaves_insertion:\n\n # Choose the operator (\"series\" and \"parallel\")\n for operator in ['series', 'parallel']:\n operator_id = len([n for n in M.tree.nodes() if n.__contains__(operator)])\n operator_entity = operator + str(operator_id)\n for position in ['left', 'right']:\n M_split = copy.deepcopy(M)\n M_split = insertion(M_split, insertnode, split_node_parent, split_node, operator_entity,\n position)\n\n is_heteromorphism = 0\n\n identity_series_order = M_split.identity_isomorphic_order()\n\n for m in self.heteromorphism:\n m_identity_series_order = m.identity_isomorphic_order()\n # print \"m_identity:{}\".format(m_identity_series_order)\n # print \"M_split:{}\".format(identity_series_order)\n if identity_series_order != m_identity_series_order:\n is_heteromorphism += 1\n\n if is_heteromorphism == len(self.heteromorphism):\n self.heteromorphism.append(M_split)\n # print M_split.series_partial_order_position_representation()\n # print M_split.tree.nodes(data = True)\n # print\n\n return","def _auxRefreshTree(self, tree_index):\n tree_item = self.treeItem(tree_index)\n logger.debug(\"_auxRefreshTree({}): {}{}\".format(\n tree_index, tree_item.obj_path,\n \"*\" if tree_item.children_fetched else \"\"))\n\n if tree_item.children_fetched:\n\n old_items = tree_item.child_items\n new_items = self._fetchObjectChildren(tree_item.obj,\n tree_item.obj_path)\n\n old_item_names = [(item.obj_name,\n item.is_attribute) for item in old_items]\n new_item_names = [(item.obj_name,\n item.is_attribute) for item in new_items]\n seqMatcher = SequenceMatcher(isjunk=None, a=old_item_names,\n b=new_item_names,\n autojunk=False)\n opcodes = seqMatcher.get_opcodes()\n\n logger.debug(\"(reversed) \"\n \"opcodes: {}\".format(list(reversed(opcodes))))\n\n for tag, i1, i2, j1, j2 in reversed(opcodes):\n\n if 1 or tag != 'equal':\n logger.debug(\" {:7s}, a[{}:{}] ({}), b[{}:{}] ({})\"\n .format(tag, i1, i2,\n old_item_names[i1:i2], j1, j2,\n new_item_names[j1:j2]))\n\n if tag == 'equal':\n # Only when node names are equal is _auxRefreshTree\n # called recursively.\n assert i2-i1 == j2-j1, (\"equal sanity \"\n \"check failed \"\n \"{} != {}\".format(i2-i1, j2-j1))\n for old_row, new_row in zip(range(i1, i2), range(j1, j2)):\n old_items[old_row].obj = new_items[new_row].obj\n child_index = self.index(old_row, 0, parent=tree_index)\n self._auxRefreshTree(child_index)\n\n elif tag == 'replace':\n # Explicitly remove the old item and insert the new.\n # The old item may have child nodes which indices must be\n # removed by Qt, otherwise it crashes.\n assert i2-i1 == j2-j1, (\"replace sanity \"\n \"check failed \"\n \"{} != {}\").format(i2-i1, j2-j1)\n\n # row number of first removed\n first = i1\n # row number of last element after insertion\n last = i1 + i2 - 1\n logger.debug(\" calling \"\n \"beginRemoveRows({}, {}, {})\".format(\n tree_index, first, last))\n self.beginRemoveRows(tree_index, first, last)\n del tree_item.child_items[i1:i2]\n self.endRemoveRows()\n\n # row number of first element after insertion\n first = i1\n # row number of last element after insertion\n last = i1 + j2 - j1 - 1\n logger.debug(\" calling \"\n \"beginInsertRows({}, {}, {})\".format(\n tree_index, first, last))\n self.beginInsertRows(tree_index, first, last)\n tree_item.insert_children(i1, new_items[j1:j2])\n self.endInsertRows()\n\n elif tag == 'delete':\n assert j1 == j2, (\"delete\"\n \" sanity check \"\n \"failed. {} != {}\".format(j1, j2))\n # row number of first that will be removed\n first = i1\n # row number of last element after insertion\n last = i1 + i2 - 1\n logger.debug(\" calling \"\n \"beginRemoveRows\"\n \"({}, {}, {})\".format(tree_index,\n first, last))\n self.beginRemoveRows(tree_index, first, last)\n del tree_item.child_items[i1:i2]\n self.endRemoveRows()\n\n elif tag == 'insert':\n assert i1 == i2, (\"insert \"\n \"sanity check \"\n \"failed. {} != {}\".format(i1, i2))\n # row number of first element after insertion\n first = i1\n # row number of last element after insertion\n last = i1 + j2 - j1 - 1\n logger.debug(\" \"\n \"calling beginInsertRows\"\n \"({}, {}, {})\".format(tree_index,\n first, last))\n self.beginInsertRows(tree_index, first, last)\n tree_item.insert_children(i1, new_items[j1:j2])\n self.endInsertRows()\n else:\n raise ValueError(\"Invalid tag: {}\".format(tag))","def propertyValueFromNodeSetter(instance, val):\n\n subspace = nodeGetter(instance)\n\n if SynchronousPropertyAccess.SynchronousPropertyAccess.getCurrent() is not None:\n if not subspace.loaded:\n subspace.keyspace.waitLoaded()\n\n if subspace.value != (val,):\n subspace.value = (val,)","def _initialize_trees(self):","def set_node_positions(self):","def change_child_value(self, place, hasElement ):\n raise NotImplementedError","def test_split_adds_parents(mock_amg):\n\n mock_amg.cells[0].split()\n assert mock_amg.cells[-4].parent is mock_amg.cells[0]\n assert mock_amg.cells[-3].parent is mock_amg.cells[0]\n assert mock_amg.cells[-2].parent is mock_amg.cells[0]\n assert mock_amg.cells[-1].parent is mock_amg.cells[0]","def __setitem__(self, key, value):\n self.tree[key] = value","def setValue(self,val):\n for f,v in zip(self.fields,val):\n f.setValue(v)","def updateParList(self, parList):\n counter = 0\n for modelName in self._modelList:\n model = self.__modelDict[modelName]\n modelParDict = model.parFitDict\n for parName in modelParDict.keys():\n if modelParDict[parName][\"vary\"]:\n modelParDict[parName][\"value\"] = parList[counter]\n counter += 1\n else:\n pass","def split(T):\r\n mid = T.max_data//2\r\n if T.isLeaf:\r\n leftChild = BTree(T.data[:mid],max_data=T.max_data) \r\n rightChild = BTree(T.data[mid+1:],max_data=T.max_data) \r\n else:\r\n leftChild = BTree(T.data[:mid],T.child[:mid+1],T.isLeaf,max_data=T.max_data) \r\n rightChild = BTree(T.data[mid+1:],T.child[mid+1:],T.isLeaf,max_data=T.max_data) \r\n return T.data[mid], leftChild, rightChild","def update(self, iterable):\n self._update_nodes(iterable)","def setSegments(self, segments):\n for point, segment in zip(self.points, segments):\n point.set(segment.p1)","def add_computed_fields(self, treenum, tree, halonum=None, validate=False):\n nhalos = len(tree['SnapNum'])\n if treenum == -1:\n assert (nhalos == self.totnhalos)\n assert (halonum is None)\n elif nhalos != self.nhalos_per_tree[treenum]:\n assert (nhalos == 1)\n assert (halonum is not None)\n else:\n halonum = None\n # Unique ID for each halo and descendant in tree\n idx = self.get_total_index(treenum, halonum)\n uid = self.all_uids[idx]\n desc_uid = self.all_desc_uids[idx]\n # Scale factors\n scale_factor = self.scale_factors[tree['SnapNum']]\n # Position x, y, z\n x = tree['Pos'][:, 0]\n y = tree['Pos'][:, 1]\n z = tree['Pos'][:, 2]\n # Velocity x, y, z\n vx = tree['Vel'][:, 0]\n vy = tree['Vel'][:, 1]\n vz = tree['Vel'][:, 2]\n # Spin x, y, z\n Jx = tree['Spin'][:, 0]\n Jy = tree['Spin'][:, 1]\n Jz = tree['Spin'][:, 2]\n # Add new fields\n new_fields = dict(uid=uid, desc_uid=desc_uid, scale_factor=scale_factor,\n x=x, y=y, z=z, vx=vx, vy=vy, vz=vz, Jx=Jx, Jy=Jy, Jz=Jz)\n out = tree\n out.update(**new_fields)\n if validate:\n self.validate_fields(out)\n return out","def update_set(self):\n for field in self.children:\n if issubclass(field.__class__, MyTextField):\n val = field.get_field().value\n setattr(self.set, field.get_field().name, val if val != \"\" else None)","def set_split(self,split='train'):\r\n \r\n self._target_data = self.processed_data[split]\r\n self.split_ = split","def set_global_properties(self, validate=False):\n # Tree num array\n self.treenum_arr = np.zeros(self.totnhalos, dtype='int64')\n start = self.nhalos_before_tree\n stop = start + self.nhalos_per_tree\n for t in range(self.ntrees):\n self.treenum_arr[start[t]:stop[t]] = t\n # Memmap/file object\n self.fobj = np.memmap(self.filename, dtype=self.item_dtype, mode='c',\n offset=self.header_size)\n # Read all data\n data = self.read_all_trees(skip_add_fields=True, validate=validate)\n # File number\n self.filenum = data['FileNr'][0]\n if (data['SnapNum'][0] + 1) != len(self.scale_factors): # pragma: no cover\n ytreeLogger.warning(\n f\"First FoF central is in snapshot {data['SnapNum'][0] + 1}/{len(self.scale_factors)}.\")\n # Halo unique IDs\n self.all_uids = np.bitwise_or(\n np.int64(self.filenum) << 32, np.arange(self.totnhalos, dtype='int64'))\n # Get descendant unique IDs\n desc = data['Descendant']\n pos_flag = (desc >= 0)\n desc_uid = np.zeros(self.totnhalos, dtype='int64') - 1\n desc_abs = self.get_total_index(self.treenum_arr, desc)\n desc_uid[pos_flag] = self.all_uids[desc_abs[pos_flag]]\n self.all_desc_uids = desc_uid\n # Add fields and cache root fields\n data = self.add_computed_fields(-1, data, validate=validate)\n root_idx = self.nhalos_before_tree\n self._root_data = dict()\n for k in self.fields:\n self._root_data[k] = data[k][root_idx]","def update_attr_par(self):\n\n # Retrieve all current values\n self.all_values_temp = nx.get_node_attributes(self.G, 'value')\n\n # Calculate all new values\n new_values_list = Parallel(n_jobs=2)(delayed(self.single_node_update)(i) \\\n for i in range(self.n_v))\n\n # # Set list to dict as needed for node update\n # new_values_dict = {}\n # for i, value in enumerate(new_values_list):\n # new_values_dict[i] = {'value': value}\n #\n # # Update node value\n # nx.set_node_attributes(self.G, new_values_dict)","def setSplitCount(self, count):\n pass","def update(self, values):\n pass","def split(self, thresh=0):\n\n new_tree_bounds = []\n new_tree_ids = []\n\n self.contains_null = False\n\n for qi, quad in enumerate(self.tree):\n\n left, bottom, right, top = quad.bounds\n xcenter = left + (right - left) / 2.0\n ycenter = top - (top - bottom) / 2.0\n\n quad_id = self.tree_ids[qi]\n\n for id_, bbox in zip(\n [1, 3, 0, 2],\n [\n (left, ycenter, xcenter, top),\n (xcenter, ycenter, right, top),\n (left, bottom, xcenter, ycenter),\n (xcenter, bottom, right, ycenter),\n ],\n ):\n\n id_list = list(self.sindex.intersection(bbox))\n\n if id_list:\n\n if len(id_list) > thresh:\n\n new_tree_bounds.append(bbox)\n new_tree_ids.append(quad_id + str(id_))\n\n else:\n self.contains_null = True\n\n else:\n self.contains_null = True\n\n self.tree_bounds = new_tree_bounds\n self.tree_ids = new_tree_ids\n\n return self","def _UpdateDataSetValues( self ):\n pass","def _set_lightpath_states(self, lightpath_values):\n\n self._inserted = lightpath_values[self.closed_limit]['value']\n self._removed = lightpath_values[self.open_limit]['value']","def _set_lightpath_states(self, lightpath_values):\n\n self._inserted = lightpath_values[self.closed_limit]['value']\n self._removed = lightpath_values[self.open_limit]['value']","def set_branch(self, value):\n self.update(value)","def update(self, paths):\n raise NotImplementedError","def SetNbSplitPoints(self, *args):\n return _ShapeUpgrade.ShapeUpgrade_ShapeDivideClosed_SetNbSplitPoints(self, *args)","def splitPlace(self):\r\n \r\n \r\n \r\n nodeSortedIter = sorted(self.G.degree_iter(),key=itemgetter(1),reverse=True)\r\n \r\n placeCnt = 0\r\n \r\n for node in nodeSortedIter:\r\n if placeCnt<self.cells/2:\r\n self.sitesA.append(node[0])\r\n self.G.node[node[0]][\"part\"] = 'A'\r\n else:\r\n self.sitesB.append(node[0])\r\n self.G.node[node[0]][\"part\"] = 'B'\r\n placeCnt+=1","def __setitem__(self, idx: int, val: float) -> None:\n assert 0 <= idx < self.capacity, f\"idx={idx} capacity={self.capacity}\"\n\n # Index of the leaf to insert into (always insert in \"second half\"\n # of the tree, the first half is reserved for already calculated\n # reduction-values).\n idx += self.capacity\n self.value[idx] = val\n\n # Recalculate all affected reduction values (in \"first half\" of tree).\n idx = idx >> 1 # Divide by 2 (faster than division).\n while idx >= 1:\n update_idx = 2 * idx # calculate only once\n # Update the reduction value at the correct \"first half\" idx.\n self.value[idx] = self.operation(\n self.value[update_idx], self.value[update_idx + 1]\n )\n idx = idx >> 1 # Divide by 2 (faster than division).","def split_leaf(self, update_tree=True):\n if not self.is_leaf():\n raise RuntimeError('Cannot split internal node.')\n return self.replace_subtree(Tree(Tree(), Tree()), update_tree=update_tree)","def split_at(self, i):\n\n if i in self.forced:\n inconsistent_generation()\n\n assert not self.is_exhausted\n\n key = self.values[i]\n\n child = TreeNode(\n bit_lengths=self.bit_lengths[i + 1 :],\n values=self.values[i + 1 :],\n transition=self.transition,\n )\n self.transition = Branch(bit_length=self.bit_lengths[i], children={key: child})\n if self.__forced is not None:\n child.__forced = {j - i - 1 for j in self.__forced if j > i}\n self.__forced = {j for j in self.__forced if j < i}\n child.check_exhausted()\n del self.values[i:]\n del self.bit_lengths[i:]\n assert len(self.values) == len(self.bit_lengths) == i"],"string":"[\n \"def SetSplitValues(self, *args):\\n return _ShapeUpgrade.ShapeUpgrade_SplitCurve_SetSplitValues(self, *args)\",\n \"def split(self):\\n pos_median = len(self.keys)/2\\n key_median = self.keys[pos_median]\\n value_median = self.values[pos_median]\\n keys_left = self.keys[:pos_median]\\n keys_right = self.keys[pos_median+1:]\\n values_left = self.values[:pos_median]\\n values_right = self.values[pos_median+1:]\\n if self.is_leaf():\\n refs_left = []\\n refs_right = []\\n else:\\n refs_left = self.refs[:pos_median]\\n refs_right = self.refs[pos_median+1:]\\n\\n # Update the current node.\\n self.keys = keys_left\\n self.values = values_left\\n self.refs = refs_left\\n\\n # Create a new sibling with the right data.\\n sibling = BTreeNode(self.m)\\n sibling.parent = self.parent\\n sibling.keys = keys_right\\n sibling.values = values_right\\n sibling.refs = refs_right\\n for ref in sibling.refs:\\n ref.parent = sibling\\n\\n # If the current node is root, we need to create a new root.\\n if self.is_root():\\n new_root = BTreeNode(self.m)\\n new_root.keys = [key_median]\\n new_root.values = [value_median]\\n new_root.refs = [self, sibling]\\n self.parent = new_root\\n sibling.parent = new_root\\n else:\\n index = self.parent.refs.index(self)\\n self.parent.keys.insert(index+1, key_median)\\n self.parent.values.insert(index+1, value_median)\\n self.parent.refs.insert(index+1, sibling)\\n\\n if self.parent.is_full():\\n self.parent.split()\",\n \"def AdjustTree(self):\\n p = self\\n while p != None:\\n # If current node's leaves number is more than M, just split and adjust father node MBR\\n if len(p.leaves) > p.M:\\n p.SplitNode()\\n else:\\n # Or just adjust father point MBR\\n if p.father != None:\\n p.father.MBR = merge(p.father.MBR, p.MBR)\\n p = p.father\",\n \"def split(self):\\n left = BPlusNode(self.order)\\n right = BPlusNode(self.order)\\n mid = self.order // 2\\n\\n left.keys = self.keys[:mid]\\n left.values = self.values[:mid]\\n\\n right.keys = self.keys[mid:]\\n right.values = self.values[mid:]\\n\\n # When the node is split, set the parent key to the left-most key of the right child node.\\n self.keys = [right.keys[0]]\\n self.values = [left, right]\\n self.leaf = False\",\n \"def set_values(self, new_values):\\n for name, value in new_values.items():\\n self.nodes_db.loc[name][\\\"node\\\"].set_value(value)\",\n \"def split(self, place_leaf_splitted):\\n raise NotImplementedError\",\n \"def setSplit(self,split):\\n self.split=split\",\n \"def SetVSplitValues(self, *args):\\n return _ShapeUpgrade.ShapeUpgrade_SplitSurface_SetVSplitValues(self, *args)\",\n \"def update(self, tree_path, value):\\n\\t\\traise NotImplementedError\",\n \"def update(self):\\n map(lambda x: x.update(), self._children.values())\",\n \"def grow(self):\\n while self.splittable_nodes:\\n self.split_next()\",\n \"def updateTree(self):\\n self.reset()\\n self.resetTree() \\n self.read()\",\n \"def addSplitValue(self, split):\\n self.balance += split.value\",\n \"def update(self, probs: torch.Tensor):\\n tree, capacity = self._create_tree(probs, self.tree)\\n self.tree = tree\\n self.capacity = capacity\",\n \"def update(self,x,y):\\n if self.ncores > 1:\\n # parallel updates\\n pass # FIXME\\n else:\\n # sequential updates\\n for tree in self.forest:\\n tree.update(x,y)\",\n \"def split(self, splits, catchall=False):\\r\\n raise NotImplementedError()\",\n \"def updateTree(self, i, val, cur):\\n start, end = cur.start, cur.end\\n if start == end == i:\\n cur.val = val\\n return\\n mid = start+(end-start)/2\\n if i <= mid:\\n cur.val -= cur.left.val\\n self.updateTree(i, val, cur.left)\\n cur.val += cur.left.val\\n else:\\n cur.val -= cur.right.val\\n self.updateTree(i, val, cur.right)\\n cur.val += cur.right.val\",\n \"def update(self) -> None:\\n\\t\\t# Clear attributes that will be updates\\n\\t\\tself.node_names: List[str] = []\\n\\t\\tself.subnode_names: Dict[str, Set[str]] = {}\\n\\t\\t# Iterate over RootNodes\\n\\t\\tname: str\\n\\t\\ts_name: str\\n\\t\\tfor rootnode in self.root_nodes:\\n\\t\\t\\t# Iterate over Nodes\\n\\t\\t\\tfor node in rootnode.nodes:\\n\\t\\t\\t\\tself._update_with_node(node)\\n\\t\\t\\tif len(rootnode.subnodes):\\n\\t\\t\\t\\t# Create Set in subnode_names for the RootNode's SubNodes\\n\\t\\t\\t\\tself.subnode_names[rootnode.name] = set()\\n\\t\\t\\t\\t# Iterate over SubNodes\\n\\t\\t\\t\\tfor subnode in rootnode.subnodes:\\n\\t\\t\\t\\t\\tself.subnode_names[rootnode.name].add(subnode.name)\",\n \"def changeInitValues(self, betas):\\n\\n for e in self.children:\\n e.changeInitValues(betas)\",\n \"def __setitem__(self, t: Tuple[int, ...], o: 'Tree') -> None:\\n ...\",\n \"def update(self, feature_col, feature_value, node_type, nodes, children=[]):\\n self.feature_col = feature_col\\n self.feature_value = feature_value\\n self.node_type = node_type\\n self.nodes = nodes\\n self.children = children\",\n \"def change_node_vals(root, sorted_inorder):\\r\\n if root is None:\\r\\n return\\r\\n\\r\\n change_node_vals(root.left, sorted_inorder)\\r\\n\\r\\n root.val = sorted_inorder[0]\\r\\n sorted_inorder.pop(0)\\r\\n\\r\\n change_node_vals(root.right, sorted_inorder)\",\n \"def SetUSplitValues(self, *args):\\n return _ShapeUpgrade.ShapeUpgrade_SplitSurface_SetUSplitValues(self, *args)\",\n \"def fillBestSplitsInDataByInfoGainIntoDict(self, data, structure, colName, numOfSplits, splitsList, indexToInsert):\\n if len(data) <= 0 or numOfSplits <= 0:\\n return []\\n colIndex = structure[colName]['index']\\n split = self.findBestSplitInDataByInfoGain(data, structure, colName)\\n if str(indexToInsert) in splitsList:\\n splitsList[str(indexToInsert)] += [split]\\n else:\\n splitsList[str(indexToInsert)] = [split]\\n indexToInsert, numOfSplits = indexToInsert + 1, numOfSplits - 1\\n\\n if split:\\n newDataBellowSplit = list(filter(lambda y: float(y[colIndex]) <= split[0], data))\\n newDataAboveSplit = list(filter(lambda y: float(y[colIndex]) > split[0], data))\\n self.fillBestSplitsInDataByInfoGainIntoDict(newDataBellowSplit, structure, colName, numOfSplits, splitsList, indexToInsert)\\n self.fillBestSplitsInDataByInfoGainIntoDict(newDataAboveSplit, structure, colName, numOfSplits, splitsList, indexToInsert)\",\n \"def __update(self, idx):\\n parent = (idx - 1) // 2\\n while parent >= 0:\\n left, right = 2 * parent + 1, 2 * parent + 2\\n self.__tree[parent] = self.__tree[left] + self.__tree[right]\\n parent = (parent - 1) // 2\",\n \"async def _set_split(self, row, value):\\n self.sheet.update_cell(row, 2, value)\\n return True\",\n \"def _setup_splits(self):\\n #ntot = self.reredux_conf['nperfile']\\n ntot = self.reredux_conf['Ngals']\\n npersplit = self.runconf['nper']\\n\\n self.beglist, self.endlist = get_splits(ntot, npersplit)\",\n \"def set_datasplits(self, df):\\n\\t\\tdf.to_csv(self.splitsFile)\",\n \"def fillDictWithBestValueSplitsOfDataByGini(self, data, structure, colIndex, numOfSplits, splitsList, indexToInsert):\\n if len(data) <= 0 or numOfSplits <= 0:\\n return []\\n split = self.findBestValueSplitByGini(data, structure, colIndex)\\n if str(indexToInsert) in splitsList:\\n splitsList[str(indexToInsert)] += [split]\\n else:\\n splitsList[str(indexToInsert)] = [split]\\n indexToInsert, numOfSplits = indexToInsert + 1, numOfSplits - 1\\n\\n if split:\\n newDataBellowSplit = list(filter(lambda y: float(y[colIndex]) <= split[0], data))\\n newDataAboveSplit = list(filter(lambda y: float(y[colIndex]) > split[0], data))\\n self.fillDictWithBestValueSplitsOfDataByGini(newDataBellowSplit, structure, colIndex, numOfSplits, splitsList, indexToInsert)\\n self.fillDictWithBestValueSplitsOfDataByGini(newDataAboveSplit, structure, colIndex, numOfSplits, splitsList, indexToInsert)\",\n \"def test_split_adds_children(mock_amg):\\n\\n mock_amg.cells[0].split()\\n assert mock_amg.cells[0].children['bl'] is mock_amg.cells[-4]\\n assert mock_amg.cells[0].children['br'] is mock_amg.cells[-3]\\n assert mock_amg.cells[0].children['tl'] is mock_amg.cells[-2]\\n assert mock_amg.cells[0].children['tr'] is mock_amg.cells[-1]\",\n \"def split(self, attribute):\\n if attribute not in self.attributes:\\n raise KeyError('Attribute not present in node')\\n \\n self.split_attr = attribute\\n \\n # list() is used to make a copy of the list instead of pointing to the same list\\n child_attributes = list(self.attributes)\\n child_attributes.remove(attribute)\\n \\n child1_ancestors = list(self.ancestors)\\n child0_ancestors = list(self.ancestors)\\n child1_ancestors.append(attribute_value(attribute, 1))\\n child0_ancestors.append(attribute_value(attribute, 0))\\n \\n self.val1 = Node(child_attributes, child1_ancestors, self.data, self.heuristic)\\n self.val0 = Node(child_attributes, child0_ancestors, self.data, self.heuristic)\",\n \"def addSplit(self):\\n pass\",\n \"async def update_split(self, name, delta, items=None):\\n\\n # Generates list\\n splits_list = await self._get_all_splits()\\n\\n # Gets index of name based on fuzzy search match\\n index = await self._get_name_index(name, splits_list)\\n\\n # If index is valid, adds provided value to splits\\n if index == -1:\\n return None\\n prev_val = int(splits_list[index][1])\\n new_val = prev_val + delta\\n await self._set_split(index + 1, new_val)\\n\\n # If item provided, appends item to end of item list\\n if items is not None:\\n item_list = self.sheet.cell(index + 1, 3).value\\n if len(item_list) != 0:\\n new_item_list = item_list + \\\", \\\" + items\\n else: \\n new_item_list = items\\n self.sheet.update_cell(index + 1, 3, new_item_list)\\n\\n # Returns both previous and new value\\n return prev_val, new_val, splits_list[index][0]\",\n \"def change_leaf_value(self, place, has_element_new):\\n self.has_element = has_element_new\",\n \"def split(root, Dk, maxDepth, minRows, currDepth):\\n \\n left, right = root['branches']\\n del(root['branches'])\\n \\n# if not left and not right:\\n# return\\n \\n # Check if the node is a leaf\\n if not len(left): \\n root['left'] = root['right'] = getLeafClass(right)\\n return\\n elif not len(right):\\n root['left'] = root['right'] = getLeafClass(left)\\n return\\n \\n # Check for max depth\\n if(currDepth >= maxDepth):\\n root['left'], root['right'] = getLeafClass(left), getLeafClass(right)\\n return\\n \\n # Process left branch\\n if(len(left) <= minRows):\\n root['left'] = getLeafClass(left)\\n else:\\n root['left'] = findNextSplit(left, Dk)\\n split(root['left'], Dk, maxDepth, minRows, currDepth + 1)\\n \\n # Process right branch\\n if(len(right) <= minRows):\\n root['right'] = getLeafClass(right)\\n else:\\n root['right'] = findNextSplit(right, Dk)\\n split(root['right'], Dk, maxDepth, minRows, currDepth + 1)\",\n \"def place_at_splits(data):\\n groups = defaultdict(list)\\n for runner_idx, runner in enumerate(data):\\n splits = runner['splits']\\n for split in splits:\\n split['runner_idx'] = runner_idx\\n groups[split['split_dist']].append(split)\\n\\n ranks = []\\n srt_keys = sorted(groups, key=groups.get)\\n for key in srt_keys:\\n group = groups[key]\\n srt_group = sorted(group, key=lambda t: t['split_mins'])\\n ranked_group = []\\n for rank, split in enumerate(srt_group):\\n split['rank'] = rank\\n ranked_group.append(split)\\n ranks.append(ranked_group)\\n\\n return data, ranks\",\n \"def update(\\n self, index: Union[int, np.ndarray], value: Union[float, np.ndarray]\\n ):\\n\\n tree_index = self.capacity + index\\n self._tree[tree_index] = value\\n\\n # Propagate up the tree.\\n parent = tree_index // 2\\n while np.any(parent > 0):\\n left = self._tree[2 * parent] # Children/sibling.\\n right = self._tree[2 * parent + 1]\\n # Note: Due to possible floating point error in the sum-tree case,\\n # it's safer to recompute the parent nodes directly rather than to\\n # accumulate an \\\"update\\\" up the tree which could be faster.\\n self._tree[parent] = self.operation(left, right)\\n parent = parent // 2\",\n \"def update(self, other):\\n b = self.hallucinate_merge(other)\\n self.l_child = b.l_child\\n self.r_child = b.r_child\",\n \"def parameter_tree_changed(self, param, changes):\\n for param, change, data in changes:\\n path = self.settings.childPath(param)\\n if path is not None:\\n childName = '.'.join(path)\\n else:\\n childName = param.name()\\n if change == 'childAdded':pass\\n\\n elif change == 'value':\\n\\n if param.name() == 'Detectors':\\n self.update_plot_det_items(param)\\n\\n elif param.name() == 'scan_average':\\n self.show_average_dock(param.value() > 1)\\n elif change == 'parent':pass\",\n \"def _fill_tree(self):\\r\\n self._tree.delete(*self._tree.get_children())\\r\\n for point_index, point in enumerate(self._structure.points):\\r\\n self._tree.insert('', 'end', values=[point_index, round(point[0]), round(point[1])])\\r\\n if point_index == self._index_of_sel_point:\\r\\n self._set_selection(point_index)\",\n \"def updateSubTreesHeight(self):\\n \\n # Get sons...\\n # ---------------------------------------------------- #\\n nodeLeftSon = self._leftSon\\n nodeRightSon = self._rightSon\\n \\n # Calc left subtree height...\\n # ---------------------------------------------------- #\\n if(nodeLeftSon is not None):\\n self._leftSubtreeHeight = max(nodeLeftSon._leftSubtreeHeight, nodeLeftSon._rightSubtreeHeight) + 1\\n else:\\n self._leftSubtreeHeight = 0\\n \\n # Calc right subtree height...\\n # ---------------------------------------------------- #\\n if(nodeRightSon is not None):\\n self._rightSubtreeHeight = max(nodeRightSon._leftSubtreeHeight, nodeRightSon._rightSubtreeHeight) + 1\\n else:\\n self._rightSubtreeHeight = 0\",\n \"def update_many(self, base_tree_path, values, level=NONTRANSACTIONAL):\\n\\t\\tassert transactional == NONTRANSACTIONAL, 'Transactional updates are not supported'\\n\\n\\t\\t# The default implementation, if the chosen backend does not provide a more efficient one\\n\\t\\tbase_tree_path = list(base_tree_path)\\n\\t\\tret_values = []\\n\\t\\tfor tree_path, value in values:\\n\\t\\t\\tret_values.append(\\n\\t\\t\\t\\tself.update(base_tree_path + list(tree_path), value)\\n\\t\\t\\t)\\n\\n\\t\\treturn ret_values\",\n \"def refresh_tree(self):\\n self.process_tree = ProcessNode.objects.get(id=self.process_tree_id)\",\n \"def update_nodes(self):\\n raise NotImplementedError('ERROR: sweeper has to implement update_nodes(self)')\",\n \"def _synchronize_attributes(self):\\n\\t\\tself._depth = 0\\n\\t\\tself._max_chars = 1\\n\\t\\tself._size = 0\\n\\t\\tif (not self._root):\\n\\t\\t\\treturn\\n\\t\\tattrs = [\\\"_is_balanced\\\", \\\"_isvalidBST\\\", \\\"_max\\\", \\\"_min\\\"]\\n\\t\\tqueue = c3.Queue()\\n\\t\\tqueue.enqueue((1, self._root))\\n\\t\\twhile queue.peek():\\n\\t\\t\\tnodelev, node = queue.dequeue()._data\\n\\t\\t\\tself._size += 1\\n\\t\\t\\tif (self._treetype and type(node.value()) != self._treetype):\\n\\t\\t\\t\\t#print \\\"WARNING: Tree has been corrupted with data of the wrong type. \\\" \\\\\\n\\t\\t\\t\\t#\\t+ str(type(node.value())) + \\\": \\\" + str(node.value())\\n\\t\\t\\t\\tpass\\n\\t\\t\\tfor attr in attrs:\\n\\t\\t\\t\\tif hasattr(node, attr):\\n\\t\\t\\t\\t\\tdelattr(node, attr)\\n\\t\\t\\tnode.setdepth(nodelev)\\n\\t\\t\\tif (nodelev > self._depth):\\n\\t\\t\\t\\tself._depth = nodelev\\n\\t\\t\\tif (len(str(node.value())) > self._max_chars):\\n\\t\\t\\t\\tself._max_chars = len(str(node.value()))\\n\\t\\t\\tif (node.lchild()):\\n\\t\\t\\t\\tqueue.enqueue((nodelev + 1, node.lchild()))\\n\\t\\t\\tif (node.rchild()):\\n\\t\\t\\t\\tqueue.enqueue((nodelev + 1, node.rchild()))\",\n \"def _parse_split_dims(tree, split_dims, level=0, parent=None, max_level=7,\\n split_positions=None):\\n if level == max_level:\\n # this is leaf tree, and split_dim=-1.\\n return\\n\\n if tree.lesser is not None:\\n _parse_split_dims(tree.lesser, split_dims, level=level+1, parent=tree,\\n max_level=max_level, split_positions=split_positions)\\n else:\\n # This will happen when the point is overlapped and `split_dim==-1`,\\n # in this case just use parent `tree`.\\n # print('tree.lesser is None, level {}'.format(level))\\n _parse_split_dims(tree, split_dims, level=level+1, parent=tree,\\n max_level=max_level, split_positions=split_positions)\\n if tree.greater is not None:\\n _parse_split_dims(tree.greater, split_dims, level=level+1, parent=tree,\\n max_level=max_level, split_positions=split_positions)\\n else:\\n # This will happen when the point is overlapped and `split_dim==-1`,\\n # in this case just use parent `tree`.\\n # print('[WARNING] tree.greater is None, level {}'.format(level))\\n _parse_split_dims(tree, split_dims, level=level+1, parent=tree,\\n max_level=max_level, split_positions=split_positions)\\n\\n if level < max_level:\\n split_dim = tree.split_dim\\n if split_dim == -1:\\n # since we repeated premature leafs, we get invalid splits\\n # in this case just use the parents.\\n # This case happen when the points are overlapped.\\n # print('split_dim is -1 at level', level)\\n split_dim = parent.split_dim if (parent.split_dim > -1) else 0\\n split_dims[level].append(split_dim)\\n if split_positions is not None:\\n split = tree.split\\n if split_dim == -1:\\n split = parent.split if (parent.split_dim > -1) else 0\\n split_positions[level].append(split)\",\n \"def __test_all_segments_with_updates(self, arr, fnc, upd):\\n segment_tree = SegmentTree(arr, fnc)\\n for index, value in upd.items():\\n arr[index] = value\\n segment_tree.update(index, value)\\n self.__test_segments_helper(segment_tree, fnc, arr)\",\n \"def set_splits(self, train_E, train_E_false=None, test_E=None, test_E_false=None, directed=False, nw_name='test',\\n TG=None, split_id=0, split_alg='spanning_tree', verbose=False):\\n # Initialize the training graph\\n if TG is None:\\n if directed:\\n TG = nx.DiGraph()\\n else:\\n TG = nx.Graph()\\n TG.add_edges_from(train_E)\\n TG.add_edges_from(train_E_false)\\n\\n # Set the parameters by calling the parent class private set method\\n super(SPEvalSplit, self)._set_splits(train_E=train_E, train_E_false=train_E_false, test_E=test_E,\\n test_E_false=test_E_false, directed=directed, nw_name=nw_name,\\n TG=TG, split_id=split_id, split_alg=split_alg, verbose=verbose)\",\n \"def _update_statistics(self):\\n\\n self._finalize_data()\\n if 'z' in self.data.dtype.names:\\n self.tree.settings['min_depth'] = np.nanmin(self.node_data['z']).compute()\\n self.tree.settings['max_depth'] = np.nanmax(self.node_data['z']).compute()\\n if 'tvu' in self.data.dtype.names:\\n self.tree.settings['min_tvu'] = np.nanmin(self.node_data['tvu']).compute()\\n self.tree.settings['max_tvu'] = np.nanmax(self.node_data['tvu']).compute()\",\n \"def __setitem__(self, i: int, o: 'Tree') -> None:\\n ...\",\n \"def _do_pytree(array, split_indices, reshape_shape):\\n pytree = jnp.split(array, split_indices)\\n pytree[0] = pytree[0].reshape(reshape_shape)\\n pytree[-1] = {'-1': pytree[-1]}\\n return pytree\",\n \"def _finalize_splittable_nodes(self):\\n while len(self.splittable_nodes) > 0:\\n node = self.splittable_nodes.pop()\\n self._finalize_leaf(node)\",\n \"def splits(self) -> List[int]:\\n if self._splits is None:\\n self.RefreshStats()\\n return self._splits\",\n \"def update(self, idx, value):\\n idx = self.__capacity - 1 + idx\\n self.__tree[idx] = value\\n self.__update(idx)\",\n \"def set_tree(self, new_tree):\\n if isinstance(new_tree, BinaryTree):\\n self.tree = new_tree\",\n \"def __set__(self, instance, value):\\n # Run process for the nested field type for each value in list\\n instance._values[self.name] = [self.field.process(v) for v in value]\",\n \"def _tree_update(self, new_tree: Tree, event: Event):\\n raise NotImplementedError()\",\n \"def _SetParameters(self, data, setter_name):\\n # First, collect all non-terminal paths seen among the judgments:\\n self._paths = set()\\n for responses, _ in data.itervalues():\\n for _, judgment, _ in responses:\\n # We want the path minus the last element. For example, if the\\n # judgment is ('disk', 'not edge-on', 'spiral'), we need a submodel\\n # rooted at the ('disk', 'not edge-on') key.\\n self._paths.add(judgment[:-1])\\n # Now we make sure we have all the subpaths. In the above example, once we\\n # have ('disk', 'not edge-on'), we also need to have ('disk',).\\n for path in self._paths.copy():\\n self._paths.update((path[:index] for index in range(len(path))))\\n\\n # Next, create a PathView of the data and iterate over all the slices:\\n data_view = PathView(data)\\n for path in self._paths:\\n data_view.SetPrimaryKey(path)\\n # Create the submodel for this key if it doesn't already exist:\\n if path not in self.model_tree:\\n # Construct a new submodel at this node in the tree:\\n self.model_tree[path] = self._CreateSubmodel(path)\\n # Set the question weights according to the parent node of path:\\n weights = {}\\n if path:\\n for question, (_, resolution_map) in data.iteritems():\\n if path in resolution_map:\\n weights[question] = resolution_map[path]\\n # Call the appropriate SetXParameters method for the node in model_tree\\n # corresponding to the path path:\\n getattr(self.model_tree[path], setter_name)(data_view,\\n question_weights=weights)\",\n \"def regenerate_tree(self, newpos):\\n self.path = self.tree[newpos][2]\\n self.tree = self.get_tree()\\n self.pos = self.get_curpos()\",\n \"def delSplitValue(self, split):\\n self.balance -= split.value\",\n \"def _set_by_path(tree, keys, value):\\n _get_by_path(tree, keys[:-1])[keys[-1]] = value\",\n \"def _set_by_path(tree, keys, value):\\n _get_by_path(tree, keys[:-1])[keys[-1]] = value\",\n \"def update(self, status):\\n\\n for name, c in self.children.items():\\n c.update(status.child(name))\",\n \"def set_splits(self, train_E, train_E_false=None, test_E=None, test_E_false=None, directed=False, nw_name='test',\\n TG=None, split_id=0, split_alg='spanning_tree', owa=True, verbose=False):\\n # Set the LP specific parameters\\n self._owa = owa\\n if train_E_false is not None:\\n self._fe_ratio = np.around(len(train_E_false) / len(train_E), 4)\\n else:\\n self._fe_ratio = 1\\n\\n # Set the remaining parameters by calling the parent class private set method\\n super(LPEvalSplit, self)._set_splits(train_E=train_E, train_E_false=train_E_false, test_E=test_E,\\n test_E_false=test_E_false, directed=directed, nw_name=nw_name,\\n TG=TG, split_id=split_id, split_alg=split_alg, verbose=verbose)\",\n \"def reassignWeights(self,weights):\\n\\t\\n\\t\\tbranches = self.collectAllBranches()\\n\\n\\t\\tfor i in range(self.nBranches):\\n\\n\\t\\t\\tbranches[i].weight = weights[i]\",\n \"def sync_tree_with_data(self, tree: QTreeView, data: List[DataNode]) -> None:\\n tree.setModel(self.create_model_from_nodes(data))\\n tree.expandAll()\",\n \"def split(self, user, number=2, piece='a', comment=None, force_refresh=True):\\n if comment is None:\\n comment = 'Split sample into {0} pieces'.format(number)\\n\\n process = Process.objects.create(title='Split Sample',\\n comment=comment,\\n user=user,\\n type_id='split-process')\\n nodes = []\\n\\n branch = self.get_piece(piece)\\n for i in range(number):\\n if i == 0:\\n new_piece = piece\\n else:\\n new_piece = self._get_next_piece()\\n # Note: Issue #248 in django-mptt causes the tree to not be properly\\n # updated when inserting objects if parent is set. Workaround\\n # is to set parent_id instead. This fixes methods such as\\n # MPTTModel.get_descendants(). Since you are referencing an\\n # object that has changed in the database (process_tree),\\n # the lft and rght items are not updated properly. Workarounds\\n # include manually updating the root node or requerying for\\n # the sample object which will force a refresh.\\n nodes.append(self._insert_node(process, new_piece, i + 1, branch))\\n if force_refresh: # workaround to force the root node to update\\n self.refresh_tree()\\n return nodes\",\n \"def _tree_update(self, new_tree: Tree, tree_update_time: datetime):\\n self.__tree_update_time = tree_update_time\\n self.__new_tree = new_tree\\n self.__new_event_types_listeners = self._register_event_listeners(self.__new_tree)\\n self.__is_simultaneous_state = True\",\n \"def update(self, initial, follows):\",\n \"def BCT_operators(self):\\n leaves_original = [node for node, degree in self.tree.out_degree().items() if degree == 0]\\n\\n def split(node):\\n # ##\\n # Return bin-tuple of the orphaned tree\\n #\\n # Parameter:\\n # node: string\\n #\\n # Return:\\n # (split_node_parent, node)\\n # ##\\n\\n # Trivialize the orphaned subtree and re-allocate the position to\\n # the child of the split_node_parent does not be cut.\\n split_node_parent = M.tree.predecessors(node)[0]\\n\\n if M.tree.predecessors(split_node_parent) != []:\\n split_node_parent_parent = M.tree.predecessors(split_node_parent)[0]\\n else:\\n split_node_parent_parent = None\\n M.tree.node[node]['position'] = 'trivial'\\n the_other_child = [n for n in M.tree.successors(split_node_parent) if n != node][0]\\n\\n # Shift the child to the position of its parent\\n M.tree.node[the_other_child]['position'] = M.tree.node[split_node_parent]['position']\\n M.tree.node[split_node_parent]['position'] = 'trivial'\\n\\n # Cutting the edge which is related to the parent of the split node\\n try:\\n cutting_edges_list = [(n1, n2) for n1, n2 in M.tree.edges() if\\n (n1 == split_node_parent or n2 == split_node_parent) and (n2 != node)]\\n\\n # Remove edeges\\n for i, j in cutting_edges_list:\\n M.tree.remove_edge(i, j)\\n\\n # Establish the edge on the new movement\\n if split_node_parent_parent:\\n i, j = [n1 for n1, n2 in cutting_edges_list if n1 == split_node_parent_parent][0], \\\\\\n [n2 for n1, n2 in cutting_edges_list if n2 == the_other_child][0]\\n\\n M.tree.add_edge(i, j)\\n\\n except Exception:\\n raise Exception(\\\"in the part of split() suc-function of BCT_operator() function\\\")\\n\\n return split_node_parent, node\\n\\n\\n def insertion(M, insert_node, split_node_parent, split_node, operator, split_node_position):\\n # ##\\n # Return a new binary construction tree\\n #\\n # Parameter:\\n # split_node_parent: string, the old operator\\n # split_node: string, the cut node, is used to reinsert to the binary construction tree\\n # operator: string, the new operator, typically two options (\\\"series\\\" and \\\"parallel\\\")\\n # split_node_position: string, the new position allocated to the cut node.\\n #\\n # Return:\\n # M: BinaryConstructionTree\\n # ##\\n\\n try:\\n # Relabel the arributes of relevant nodes.\\n mapping = {split_node_parent: operator}\\n M.tree = nx.relabel_nodes(M.tree, mapping)\\n M.tree.node[operator]['position'] = M.tree.node[insert_node]['position']\\n insert_node_parent = M.tree.predecessors(insert_node)[0]\\n\\n # Re-allocate the position to the relevant nodes.\\n if split_node_position == 'right' and split_node_position == M.tree.node[insert_node]['position']:\\n M.tree.node[insert_node]['position'] = 'left'\\n\\n elif split_node_position == 'left' and split_node_position == M.tree.node[insert_node]['position']:\\n M.tree.node[insert_node]['position'] = 'right'\\n M.tree.node[split_node]['position'] = split_node_position\\n\\n # print M.tree.edges()\\n # Remove the related edges of the current binary tree\\n M.tree.remove_edge(insert_node_parent, insert_node)\\n\\n # Add the new edges to binary tree\\n M.tree.add_edge(insert_node_parent, operator)\\n M.tree.add_edge(operator, insert_node)\\n\\n # Eliminate the redundant edge.\\n # for i, j in M.tree.edges():\\n\\n except Exception:\\n raise Exception('in tha part of insertion() sub-function of BCT_operator() function')\\n\\n return M\\n\\n # To preserve meta structure.\\n M_self = copy.deepcopy(self)\\n\\n # To traverse all possible isomorphic binary tree\\n for node in leaves_original:\\n\\n M = copy.deepcopy(M_self)\\n\\n # Do split operation\\n split_node_parent, split_node = split(node)\\n\\n # The children that are used to be inserted\\n leaves_insertion = leaves_original[:]\\n leaves_insertion.remove(split_node)\\n\\n # print leaves_insertion\\n # Do insertion operation\\n for insertnode in leaves_insertion:\\n\\n # Choose the operator (\\\"series\\\" and \\\"parallel\\\")\\n for operator in ['series', 'parallel']:\\n operator_id = len([n for n in M.tree.nodes() if n.__contains__(operator)])\\n operator_entity = operator + str(operator_id)\\n for position in ['left', 'right']:\\n M_split = copy.deepcopy(M)\\n M_split = insertion(M_split, insertnode, split_node_parent, split_node, operator_entity,\\n position)\\n\\n is_heteromorphism = 0\\n\\n identity_series_order = M_split.identity_isomorphic_order()\\n\\n for m in self.heteromorphism:\\n m_identity_series_order = m.identity_isomorphic_order()\\n # print \\\"m_identity:{}\\\".format(m_identity_series_order)\\n # print \\\"M_split:{}\\\".format(identity_series_order)\\n if identity_series_order != m_identity_series_order:\\n is_heteromorphism += 1\\n\\n if is_heteromorphism == len(self.heteromorphism):\\n self.heteromorphism.append(M_split)\\n # print M_split.series_partial_order_position_representation()\\n # print M_split.tree.nodes(data = True)\\n # print\\n\\n return\",\n \"def _auxRefreshTree(self, tree_index):\\n tree_item = self.treeItem(tree_index)\\n logger.debug(\\\"_auxRefreshTree({}): {}{}\\\".format(\\n tree_index, tree_item.obj_path,\\n \\\"*\\\" if tree_item.children_fetched else \\\"\\\"))\\n\\n if tree_item.children_fetched:\\n\\n old_items = tree_item.child_items\\n new_items = self._fetchObjectChildren(tree_item.obj,\\n tree_item.obj_path)\\n\\n old_item_names = [(item.obj_name,\\n item.is_attribute) for item in old_items]\\n new_item_names = [(item.obj_name,\\n item.is_attribute) for item in new_items]\\n seqMatcher = SequenceMatcher(isjunk=None, a=old_item_names,\\n b=new_item_names,\\n autojunk=False)\\n opcodes = seqMatcher.get_opcodes()\\n\\n logger.debug(\\\"(reversed) \\\"\\n \\\"opcodes: {}\\\".format(list(reversed(opcodes))))\\n\\n for tag, i1, i2, j1, j2 in reversed(opcodes):\\n\\n if 1 or tag != 'equal':\\n logger.debug(\\\" {:7s}, a[{}:{}] ({}), b[{}:{}] ({})\\\"\\n .format(tag, i1, i2,\\n old_item_names[i1:i2], j1, j2,\\n new_item_names[j1:j2]))\\n\\n if tag == 'equal':\\n # Only when node names are equal is _auxRefreshTree\\n # called recursively.\\n assert i2-i1 == j2-j1, (\\\"equal sanity \\\"\\n \\\"check failed \\\"\\n \\\"{} != {}\\\".format(i2-i1, j2-j1))\\n for old_row, new_row in zip(range(i1, i2), range(j1, j2)):\\n old_items[old_row].obj = new_items[new_row].obj\\n child_index = self.index(old_row, 0, parent=tree_index)\\n self._auxRefreshTree(child_index)\\n\\n elif tag == 'replace':\\n # Explicitly remove the old item and insert the new.\\n # The old item may have child nodes which indices must be\\n # removed by Qt, otherwise it crashes.\\n assert i2-i1 == j2-j1, (\\\"replace sanity \\\"\\n \\\"check failed \\\"\\n \\\"{} != {}\\\").format(i2-i1, j2-j1)\\n\\n # row number of first removed\\n first = i1\\n # row number of last element after insertion\\n last = i1 + i2 - 1\\n logger.debug(\\\" calling \\\"\\n \\\"beginRemoveRows({}, {}, {})\\\".format(\\n tree_index, first, last))\\n self.beginRemoveRows(tree_index, first, last)\\n del tree_item.child_items[i1:i2]\\n self.endRemoveRows()\\n\\n # row number of first element after insertion\\n first = i1\\n # row number of last element after insertion\\n last = i1 + j2 - j1 - 1\\n logger.debug(\\\" calling \\\"\\n \\\"beginInsertRows({}, {}, {})\\\".format(\\n tree_index, first, last))\\n self.beginInsertRows(tree_index, first, last)\\n tree_item.insert_children(i1, new_items[j1:j2])\\n self.endInsertRows()\\n\\n elif tag == 'delete':\\n assert j1 == j2, (\\\"delete\\\"\\n \\\" sanity check \\\"\\n \\\"failed. {} != {}\\\".format(j1, j2))\\n # row number of first that will be removed\\n first = i1\\n # row number of last element after insertion\\n last = i1 + i2 - 1\\n logger.debug(\\\" calling \\\"\\n \\\"beginRemoveRows\\\"\\n \\\"({}, {}, {})\\\".format(tree_index,\\n first, last))\\n self.beginRemoveRows(tree_index, first, last)\\n del tree_item.child_items[i1:i2]\\n self.endRemoveRows()\\n\\n elif tag == 'insert':\\n assert i1 == i2, (\\\"insert \\\"\\n \\\"sanity check \\\"\\n \\\"failed. {} != {}\\\".format(i1, i2))\\n # row number of first element after insertion\\n first = i1\\n # row number of last element after insertion\\n last = i1 + j2 - j1 - 1\\n logger.debug(\\\" \\\"\\n \\\"calling beginInsertRows\\\"\\n \\\"({}, {}, {})\\\".format(tree_index,\\n first, last))\\n self.beginInsertRows(tree_index, first, last)\\n tree_item.insert_children(i1, new_items[j1:j2])\\n self.endInsertRows()\\n else:\\n raise ValueError(\\\"Invalid tag: {}\\\".format(tag))\",\n \"def propertyValueFromNodeSetter(instance, val):\\n\\n subspace = nodeGetter(instance)\\n\\n if SynchronousPropertyAccess.SynchronousPropertyAccess.getCurrent() is not None:\\n if not subspace.loaded:\\n subspace.keyspace.waitLoaded()\\n\\n if subspace.value != (val,):\\n subspace.value = (val,)\",\n \"def _initialize_trees(self):\",\n \"def set_node_positions(self):\",\n \"def change_child_value(self, place, hasElement ):\\n raise NotImplementedError\",\n \"def test_split_adds_parents(mock_amg):\\n\\n mock_amg.cells[0].split()\\n assert mock_amg.cells[-4].parent is mock_amg.cells[0]\\n assert mock_amg.cells[-3].parent is mock_amg.cells[0]\\n assert mock_amg.cells[-2].parent is mock_amg.cells[0]\\n assert mock_amg.cells[-1].parent is mock_amg.cells[0]\",\n \"def __setitem__(self, key, value):\\n self.tree[key] = value\",\n \"def setValue(self,val):\\n for f,v in zip(self.fields,val):\\n f.setValue(v)\",\n \"def updateParList(self, parList):\\n counter = 0\\n for modelName in self._modelList:\\n model = self.__modelDict[modelName]\\n modelParDict = model.parFitDict\\n for parName in modelParDict.keys():\\n if modelParDict[parName][\\\"vary\\\"]:\\n modelParDict[parName][\\\"value\\\"] = parList[counter]\\n counter += 1\\n else:\\n pass\",\n \"def split(T):\\r\\n mid = T.max_data//2\\r\\n if T.isLeaf:\\r\\n leftChild = BTree(T.data[:mid],max_data=T.max_data) \\r\\n rightChild = BTree(T.data[mid+1:],max_data=T.max_data) \\r\\n else:\\r\\n leftChild = BTree(T.data[:mid],T.child[:mid+1],T.isLeaf,max_data=T.max_data) \\r\\n rightChild = BTree(T.data[mid+1:],T.child[mid+1:],T.isLeaf,max_data=T.max_data) \\r\\n return T.data[mid], leftChild, rightChild\",\n \"def update(self, iterable):\\n self._update_nodes(iterable)\",\n \"def setSegments(self, segments):\\n for point, segment in zip(self.points, segments):\\n point.set(segment.p1)\",\n \"def add_computed_fields(self, treenum, tree, halonum=None, validate=False):\\n nhalos = len(tree['SnapNum'])\\n if treenum == -1:\\n assert (nhalos == self.totnhalos)\\n assert (halonum is None)\\n elif nhalos != self.nhalos_per_tree[treenum]:\\n assert (nhalos == 1)\\n assert (halonum is not None)\\n else:\\n halonum = None\\n # Unique ID for each halo and descendant in tree\\n idx = self.get_total_index(treenum, halonum)\\n uid = self.all_uids[idx]\\n desc_uid = self.all_desc_uids[idx]\\n # Scale factors\\n scale_factor = self.scale_factors[tree['SnapNum']]\\n # Position x, y, z\\n x = tree['Pos'][:, 0]\\n y = tree['Pos'][:, 1]\\n z = tree['Pos'][:, 2]\\n # Velocity x, y, z\\n vx = tree['Vel'][:, 0]\\n vy = tree['Vel'][:, 1]\\n vz = tree['Vel'][:, 2]\\n # Spin x, y, z\\n Jx = tree['Spin'][:, 0]\\n Jy = tree['Spin'][:, 1]\\n Jz = tree['Spin'][:, 2]\\n # Add new fields\\n new_fields = dict(uid=uid, desc_uid=desc_uid, scale_factor=scale_factor,\\n x=x, y=y, z=z, vx=vx, vy=vy, vz=vz, Jx=Jx, Jy=Jy, Jz=Jz)\\n out = tree\\n out.update(**new_fields)\\n if validate:\\n self.validate_fields(out)\\n return out\",\n \"def update_set(self):\\n for field in self.children:\\n if issubclass(field.__class__, MyTextField):\\n val = field.get_field().value\\n setattr(self.set, field.get_field().name, val if val != \\\"\\\" else None)\",\n \"def set_split(self,split='train'):\\r\\n \\r\\n self._target_data = self.processed_data[split]\\r\\n self.split_ = split\",\n \"def set_global_properties(self, validate=False):\\n # Tree num array\\n self.treenum_arr = np.zeros(self.totnhalos, dtype='int64')\\n start = self.nhalos_before_tree\\n stop = start + self.nhalos_per_tree\\n for t in range(self.ntrees):\\n self.treenum_arr[start[t]:stop[t]] = t\\n # Memmap/file object\\n self.fobj = np.memmap(self.filename, dtype=self.item_dtype, mode='c',\\n offset=self.header_size)\\n # Read all data\\n data = self.read_all_trees(skip_add_fields=True, validate=validate)\\n # File number\\n self.filenum = data['FileNr'][0]\\n if (data['SnapNum'][0] + 1) != len(self.scale_factors): # pragma: no cover\\n ytreeLogger.warning(\\n f\\\"First FoF central is in snapshot {data['SnapNum'][0] + 1}/{len(self.scale_factors)}.\\\")\\n # Halo unique IDs\\n self.all_uids = np.bitwise_or(\\n np.int64(self.filenum) << 32, np.arange(self.totnhalos, dtype='int64'))\\n # Get descendant unique IDs\\n desc = data['Descendant']\\n pos_flag = (desc >= 0)\\n desc_uid = np.zeros(self.totnhalos, dtype='int64') - 1\\n desc_abs = self.get_total_index(self.treenum_arr, desc)\\n desc_uid[pos_flag] = self.all_uids[desc_abs[pos_flag]]\\n self.all_desc_uids = desc_uid\\n # Add fields and cache root fields\\n data = self.add_computed_fields(-1, data, validate=validate)\\n root_idx = self.nhalos_before_tree\\n self._root_data = dict()\\n for k in self.fields:\\n self._root_data[k] = data[k][root_idx]\",\n \"def update_attr_par(self):\\n\\n # Retrieve all current values\\n self.all_values_temp = nx.get_node_attributes(self.G, 'value')\\n\\n # Calculate all new values\\n new_values_list = Parallel(n_jobs=2)(delayed(self.single_node_update)(i) \\\\\\n for i in range(self.n_v))\\n\\n # # Set list to dict as needed for node update\\n # new_values_dict = {}\\n # for i, value in enumerate(new_values_list):\\n # new_values_dict[i] = {'value': value}\\n #\\n # # Update node value\\n # nx.set_node_attributes(self.G, new_values_dict)\",\n \"def setSplitCount(self, count):\\n pass\",\n \"def update(self, values):\\n pass\",\n \"def split(self, thresh=0):\\n\\n new_tree_bounds = []\\n new_tree_ids = []\\n\\n self.contains_null = False\\n\\n for qi, quad in enumerate(self.tree):\\n\\n left, bottom, right, top = quad.bounds\\n xcenter = left + (right - left) / 2.0\\n ycenter = top - (top - bottom) / 2.0\\n\\n quad_id = self.tree_ids[qi]\\n\\n for id_, bbox in zip(\\n [1, 3, 0, 2],\\n [\\n (left, ycenter, xcenter, top),\\n (xcenter, ycenter, right, top),\\n (left, bottom, xcenter, ycenter),\\n (xcenter, bottom, right, ycenter),\\n ],\\n ):\\n\\n id_list = list(self.sindex.intersection(bbox))\\n\\n if id_list:\\n\\n if len(id_list) > thresh:\\n\\n new_tree_bounds.append(bbox)\\n new_tree_ids.append(quad_id + str(id_))\\n\\n else:\\n self.contains_null = True\\n\\n else:\\n self.contains_null = True\\n\\n self.tree_bounds = new_tree_bounds\\n self.tree_ids = new_tree_ids\\n\\n return self\",\n \"def _UpdateDataSetValues( self ):\\n pass\",\n \"def _set_lightpath_states(self, lightpath_values):\\n\\n self._inserted = lightpath_values[self.closed_limit]['value']\\n self._removed = lightpath_values[self.open_limit]['value']\",\n \"def _set_lightpath_states(self, lightpath_values):\\n\\n self._inserted = lightpath_values[self.closed_limit]['value']\\n self._removed = lightpath_values[self.open_limit]['value']\",\n \"def set_branch(self, value):\\n self.update(value)\",\n \"def update(self, paths):\\n raise NotImplementedError\",\n \"def SetNbSplitPoints(self, *args):\\n return _ShapeUpgrade.ShapeUpgrade_ShapeDivideClosed_SetNbSplitPoints(self, *args)\",\n \"def splitPlace(self):\\r\\n \\r\\n \\r\\n \\r\\n nodeSortedIter = sorted(self.G.degree_iter(),key=itemgetter(1),reverse=True)\\r\\n \\r\\n placeCnt = 0\\r\\n \\r\\n for node in nodeSortedIter:\\r\\n if placeCnt<self.cells/2:\\r\\n self.sitesA.append(node[0])\\r\\n self.G.node[node[0]][\\\"part\\\"] = 'A'\\r\\n else:\\r\\n self.sitesB.append(node[0])\\r\\n self.G.node[node[0]][\\\"part\\\"] = 'B'\\r\\n placeCnt+=1\",\n \"def __setitem__(self, idx: int, val: float) -> None:\\n assert 0 <= idx < self.capacity, f\\\"idx={idx} capacity={self.capacity}\\\"\\n\\n # Index of the leaf to insert into (always insert in \\\"second half\\\"\\n # of the tree, the first half is reserved for already calculated\\n # reduction-values).\\n idx += self.capacity\\n self.value[idx] = val\\n\\n # Recalculate all affected reduction values (in \\\"first half\\\" of tree).\\n idx = idx >> 1 # Divide by 2 (faster than division).\\n while idx >= 1:\\n update_idx = 2 * idx # calculate only once\\n # Update the reduction value at the correct \\\"first half\\\" idx.\\n self.value[idx] = self.operation(\\n self.value[update_idx], self.value[update_idx + 1]\\n )\\n idx = idx >> 1 # Divide by 2 (faster than division).\",\n \"def split_leaf(self, update_tree=True):\\n if not self.is_leaf():\\n raise RuntimeError('Cannot split internal node.')\\n return self.replace_subtree(Tree(Tree(), Tree()), update_tree=update_tree)\",\n \"def split_at(self, i):\\n\\n if i in self.forced:\\n inconsistent_generation()\\n\\n assert not self.is_exhausted\\n\\n key = self.values[i]\\n\\n child = TreeNode(\\n bit_lengths=self.bit_lengths[i + 1 :],\\n values=self.values[i + 1 :],\\n transition=self.transition,\\n )\\n self.transition = Branch(bit_length=self.bit_lengths[i], children={key: child})\\n if self.__forced is not None:\\n child.__forced = {j - i - 1 for j in self.__forced if j > i}\\n self.__forced = {j for j in self.__forced if j < i}\\n child.check_exhausted()\\n del self.values[i:]\\n del self.bit_lengths[i:]\\n assert len(self.values) == len(self.bit_lengths) == i\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5888695","0.56457704","0.5637454","0.55085474","0.5473264","0.54514945","0.54263914","0.53565776","0.53152966","0.52939975","0.5229411","0.5209243","0.5178123","0.5173258","0.5074526","0.50700766","0.5065914","0.5059103","0.50479466","0.5044793","0.5040456","0.5031418","0.5024396","0.501202","0.500384","0.497433","0.49600124","0.49525553","0.4950879","0.4950554","0.4924908","0.4918453","0.49064216","0.49000603","0.48932686","0.4890207","0.48572892","0.4845525","0.4840218","0.48389292","0.483659","0.48328164","0.48102647","0.48072827","0.48043004","0.47922632","0.4789658","0.47804177","0.4779178","0.47760966","0.47732255","0.4770765","0.47578117","0.47365263","0.472084","0.4717746","0.47074062","0.47073784","0.46961692","0.46818632","0.46753216","0.46753216","0.46726352","0.467247","0.46677294","0.46673572","0.46662772","0.4660444","0.46558225","0.46437976","0.46386155","0.4630907","0.46306908","0.4614755","0.46123046","0.46035314","0.46005726","0.45962155","0.45889714","0.45863274","0.4585651","0.45780832","0.45774877","0.45678034","0.4565425","0.45594627","0.4557218","0.4556769","0.45467755","0.4538514","0.45297804","0.4519651","0.4519651","0.45190385","0.45166975","0.45092863","0.45066443","0.45051983","0.45050183","0.45038122"],"string":"[\n \"0.5888695\",\n \"0.56457704\",\n \"0.5637454\",\n \"0.55085474\",\n \"0.5473264\",\n \"0.54514945\",\n \"0.54263914\",\n \"0.53565776\",\n \"0.53152966\",\n \"0.52939975\",\n \"0.5229411\",\n \"0.5209243\",\n \"0.5178123\",\n \"0.5173258\",\n \"0.5074526\",\n \"0.50700766\",\n \"0.5065914\",\n \"0.5059103\",\n \"0.50479466\",\n \"0.5044793\",\n \"0.5040456\",\n \"0.5031418\",\n \"0.5024396\",\n \"0.501202\",\n \"0.500384\",\n \"0.497433\",\n \"0.49600124\",\n \"0.49525553\",\n \"0.4950879\",\n \"0.4950554\",\n \"0.4924908\",\n \"0.4918453\",\n \"0.49064216\",\n \"0.49000603\",\n \"0.48932686\",\n \"0.4890207\",\n \"0.48572892\",\n \"0.4845525\",\n \"0.4840218\",\n \"0.48389292\",\n \"0.483659\",\n \"0.48328164\",\n \"0.48102647\",\n \"0.48072827\",\n \"0.48043004\",\n \"0.47922632\",\n \"0.4789658\",\n \"0.47804177\",\n \"0.4779178\",\n \"0.47760966\",\n \"0.47732255\",\n \"0.4770765\",\n \"0.47578117\",\n \"0.47365263\",\n \"0.472084\",\n \"0.4717746\",\n \"0.47074062\",\n \"0.47073784\",\n \"0.46961692\",\n \"0.46818632\",\n \"0.46753216\",\n \"0.46753216\",\n \"0.46726352\",\n \"0.467247\",\n \"0.46677294\",\n \"0.46673572\",\n \"0.46662772\",\n \"0.4660444\",\n \"0.46558225\",\n \"0.46437976\",\n \"0.46386155\",\n \"0.4630907\",\n \"0.46306908\",\n \"0.4614755\",\n \"0.46123046\",\n \"0.46035314\",\n \"0.46005726\",\n \"0.45962155\",\n \"0.45889714\",\n \"0.45863274\",\n \"0.4585651\",\n \"0.45780832\",\n \"0.45774877\",\n \"0.45678034\",\n \"0.4565425\",\n \"0.45594627\",\n \"0.4557218\",\n \"0.4556769\",\n \"0.45467755\",\n \"0.4538514\",\n \"0.45297804\",\n \"0.4519651\",\n \"0.4519651\",\n \"0.45190385\",\n \"0.45166975\",\n \"0.45092863\",\n \"0.45066443\",\n \"0.45051983\",\n \"0.45050183\",\n \"0.45038122\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.57885617"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":78591,"cells":{"query":{"kind":"string","value":"Function to determine whether a node is a leaf (i.e., has no children)."},"document":{"kind":"string","value":"def isNodeLeaf ( self ):\n return self.nodes is None or len ( self.nodes ) == 0\n # End isNodeLeaf"},"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 isLeaf(node):\n\n return node.left is None and node.right is None","def is_leaf(self):\n if len(self.children) == 0: #If the Node has no children, it's a leaf\n return True\n else:\n return False","def is_leaf(self, node: object) -> bool:\n if node.left == None and node.right == None:\n return True\n else:\n return False","def is_leaf(node):\n return node.children == {}","def is_leaf_node(self):\n if self is None:\n return False\n if self.left is None and self.right is None:\n return True\n return False","def is_leaf(tree):\n\n return not branches(tree)","def is_leaf(tree):\n return not branches(tree)","def is_leaf(self):\n if len(self.children) == 0:\n return True\n else:\n return False","def leaf(self, node: object) -> bool:\n if node.left is None and node.right is None:\n return True\n\n else:\n return False","def is_leaf(self):\r\n return self.num_children() == 0","def is_leaf(self):\n # Has no children nodes\n return self.nodes is None or len(self.nodes) == 0","def is_leaf(self, node):\n self._validate_node(node)\n if self.num_children(node) == 0:\n return True\n return False","def isLeaf(self):\n \n # I am a leaf if I have no children\n return not self._children","def is_leaf(self):\n return not self.children.exists()","def is_leaf(self):\n return self.__left == None and self.__right==None","def is_leaf(self):\n return len(self.children) == 0","def isLeaf(self) -> bool:\n return not self.left and not self.right","def isLeaf(self):\n return self.left is None and self.right is None","def is_leaf(self):\n if self._leftchild or self._rightchild:\n return False\n return True","def isLeaf(self, treeNode):\n if not treeNode:\n return False\n\n if treeNode.left == None and treeNode.right == None:\n return True\n else:\n return False","def is_leaf(self):\n return len(self._children) == 0","def is_leaf(self, p):\n return self.num_children(p) == 0","def is_leaf(self) -> bool:\n return not any(self.children)","def is_leaf(self):\n return len(self.child_list) == 0","def is_leaf(self):\n return self._children == {}","def is_leaf(self):\n return self._children == {}","def is_leaf(self):\n return self._children == {}","def is_leaf(self):\n return self._children == {}","def is_leaf(self, n):\n return self.num_children(n) == 0","def leaf(self):\n if not self._leftchild and not self._rightchild:\n return True\n return False","def is_leaf(self):\n # TODO: Check if both left child and right child have no value\n return ... and ...","def leaf(self):\n if not self.left and not self.right:\n return True\n return False","def is_leaf(self):\n return len(self.blocks) == 0","def isLeaf(self):\n\n return self.children == {}","def is_leaf(self, p):\n return self.num_children(p) == 0","def is_leaf(self, p):\n return self.num_children(p) == 0","def is_leaf(self, p):\n return self.num_children(p) == 0","def is_leaf(self, p):\n return self.num_children(p) == 0","def IsLeaf(self):\n return not self.subtests","def is leaf(self, p):\n return self.num children(p) == 0","def isLeaf(self, node_name):\n if self.tree.node[node_name]['c'] != '':\n return True\n else:\n return False","def is_leaf(self) -> bool:\n return self.data_bytes[0] == ProofPath._KeyPrefix.LEAF","def is_leaf(self,p):\n node = self._validate(p)\n return self.children_num(p) == 0","def is_leaf(self):\n return isinstance(self, Leaf)","def node_leaf(self):\r\n return self.zero_son is None and self.one_son is None","def is_leaf(self):\n return len(self.refs) == 0","def is_leaf(self):\n return self.pixel_count > 0","def is_leaf(self, node_id):\n return self.tree.children_left[node_id] == INVALID_NODEID","def next_leaf(node):\n return len(node[1][0][1]) == 0","def has_leaf(self) -> bool:\r\n self._logger.debug(log_message_formatter(\r\n \"get\", f\"{self}\", \"has_leaf\"))\r\n return self._hvac_mode == \"eco\"","def is_leaf(self, pos):\n if pos >= (self.size//2) and pos <= self.size: \n return True\n return False","def is_huffman_leaf(tree):\n return not is_leaf(tree) and is_leaf(branches(tree)[0])","def check_leaf_node(df):\r\n \r\n return len(set(df['class'])) == 1","def is_leaf(self, i):\n return len(self.children[i]) == 0 or len(self.pq[i]) == 0","def has_zero_length_leaves(self):\n for l in self.leaves():\n if l.has_zero_length:\n return True\n return False","def test_is_leaf(self):\n self.assertEqual(True, comparator.is_leaf(None))\n self.assertEqual(True, comparator.is_leaf(True))\n self.assertEqual(True, comparator.is_leaf(False))\n self.assertEqual(True, comparator.is_leaf(int()))\n self.assertEqual(True, comparator.is_leaf(str()))\n self.assertEqual(False, comparator.is_leaf(list()))\n self.assertEqual(False, comparator.is_leaf(dict()))","def _is_leaf(self, index):\r\n return 2*index+1 > self._size - 1","def isLeaf(self, pos):\n if (self.size // 2) <= pos <= self.size:\n return True\n return False","def isLeaf(self, pos):\n if (self.size // 2) <= pos <= self.size:\n return True\n return False","def son_is_leaf(self, place):\n raise NotImplementedError","def is_leaf(self, cat: typing.Union[str, HierarchicalCategory]) -> bool:\n if not isinstance(cat, HierarchicalCategory):\n return self.is_leaf(self._all_codes_map[cat])\n\n return cat.is_leaf","def isLeaf(self, path):\n # pylint: disable=E1101\n # E1101: pylint could not resolve the node_kind attribute. \n\n return self._determineItemKind(path, pysvn.node_kind.file)","def is_root(self, node: object) -> bool:\n if node == self.root:\n return True\n else:\n return False","def is_leaf(node_value):\n return isinstance(node_value, dict) and 'required' in node_value","def isleaf(self):\n no_kids = super(PartitionDevice, self).isleaf\n # it is possible that the disk that originally contained this partition\n # no longer contains a disklabel, in which case we can assume that this\n # device is a leaf\n if self.disk and self.partedPartition and \\\n self.disk.format.type == \"disklabel\" and \\\n self.partedPartition in self.disk.format.partitions:\n disklabel = self.disk.format\n else:\n disklabel = None\n\n extended_has_logical = (self.isExtended and\n (disklabel and disklabel.logicalPartitions))\n return (no_kids and not extended_has_logical)","def is_branch_node(tree, node):\n if node == tree.root:\n return tree.degree(node) >= 2\n else:\n return tree.degree(node) >= 3","def is_root(self, node):\n self._validate_node(node)\n return node._index == 0","def is_empty(self):\n if self.root == None:\n return True\n return False","def is_root(self, node: Node) -> bool:\n return node == self._root","def calculate_leafs(self):\n self._leafs = [node for node in self._nodes if not self._nodes[node]['children']]","def isLeaf(self, clip):\n\n if not isinstance(clip, Clip):\n raise TypeError(\"clip must be an instance of Clip\")\n\n return clip in self.leaves","def test_small_tree_has_no_root(small_tree):\n assert small_tree.root.left is None","def is_root(self):\n return (self.__type & NODE_ROOT) == NODE_ROOT","def is_tree(t):\n if type(t) != list or len(t) < 1:\n return False\n elif is_leaf(t):\n return True\n else:\n return all([is_tree(b) for b in t[1:]])","def empty(self) -> bool:\n return True if self.root is None else False","def is_empty(self):\n return self.root is None","def is_empty(self):\n return self.root is None","def isBlankNode(self):\n ret = libxml2mod.xmlIsBlankNode(self._o)\n return ret","def get_leaf_nodes(self):\n pass","def is_empty(self):\n return self.__root == None","def is_root(self):\n return self.root in [-1, self]","def test_tree_with_one_node_root_no_children(one_t):\n assert not one_t.root.left\n assert not one_t.root.right","def count_leaf(self):\n if self.is_empty():\n return 0\n elif self.is_leaf():\n return 1\n else:\n if self.get_left():\n if self.get_right():\n return 0 + self.get_left().count_leaf() + self.get_right().count_leaf()\n else:\n return 0 + self.get_left().count_leaf()\n else:\n return 0 + self.get_right().count_leaf()","def num_leaves(tree):\n return ((tree.n_node_samples > 0) & (tree.feature == INVALID_VALUE)).sum()","def is_root(self):\n return True","def is_root(self):\n return True","def is_root(self, p):\n return self.root() == 0","def _check_for_children(self):\n if len(self.node.get_children()) > 0:\n raise ValueError('This Node is not a leaf node. Children of this node '\n 'are {}'.format(self.client.get_children()))","def has_single_root(self):\n root = self.left_root\n if root != NULL and self.right_sib(root) == NULL:\n return True\n return False","def is_internal(self):\n if self.is_leaf() or self.is_semileaf():\n return False\n return True","def is_root(self):\n return self.unpack_word(0x2) & 0x0004 > 0","def is_root(self):\n return not self.parents.exists()","def is_stump(self):\n if self.is_leaf():\n return False\n return self.left_subtree.is_leaf() and self.right_subtree.is_leaf()","def is_root(self):\n return not self.parent","def is_full(self, node):\n if node.right != None and node.left != None:\n return True\n return False","def delete_leaves(self):\n if not (self.left or self.right):\n return True\n if self.left:\n delete = self.left.delete_leaves()\n if delete is True:\n self.left = None\n if self.right:\n delete = self.right.delete_leaves()\n if delete is True:\n self.right = None","def is_root(self) -> bool:\n return self.parent_id is None","def is_leaf_path(p: Path) -> bool:\n return p.is_file() or (p.is_dir() and not any(p.glob(\"*\")))","def is_root(self):\n return self._parent == None","def is_root(self):\n return self.parent == None"],"string":"[\n \"def isLeaf(node):\\n\\n return node.left is None and node.right is None\",\n \"def is_leaf(self):\\n if len(self.children) == 0: #If the Node has no children, it's a leaf\\n return True\\n else:\\n return False\",\n \"def is_leaf(self, node: object) -> bool:\\n if node.left == None and node.right == None:\\n return True\\n else:\\n return False\",\n \"def is_leaf(node):\\n return node.children == {}\",\n \"def is_leaf_node(self):\\n if self is None:\\n return False\\n if self.left is None and self.right is None:\\n return True\\n return False\",\n \"def is_leaf(tree):\\n\\n return not branches(tree)\",\n \"def is_leaf(tree):\\n return not branches(tree)\",\n \"def is_leaf(self):\\n if len(self.children) == 0:\\n return True\\n else:\\n return False\",\n \"def leaf(self, node: object) -> bool:\\n if node.left is None and node.right is None:\\n return True\\n\\n else:\\n return False\",\n \"def is_leaf(self):\\r\\n return self.num_children() == 0\",\n \"def is_leaf(self):\\n # Has no children nodes\\n return self.nodes is None or len(self.nodes) == 0\",\n \"def is_leaf(self, node):\\n self._validate_node(node)\\n if self.num_children(node) == 0:\\n return True\\n return False\",\n \"def isLeaf(self):\\n \\n # I am a leaf if I have no children\\n return not self._children\",\n \"def is_leaf(self):\\n return not self.children.exists()\",\n \"def is_leaf(self):\\n return self.__left == None and self.__right==None\",\n \"def is_leaf(self):\\n return len(self.children) == 0\",\n \"def isLeaf(self) -> bool:\\n return not self.left and not self.right\",\n \"def isLeaf(self):\\n return self.left is None and self.right is None\",\n \"def is_leaf(self):\\n if self._leftchild or self._rightchild:\\n return False\\n return True\",\n \"def isLeaf(self, treeNode):\\n if not treeNode:\\n return False\\n\\n if treeNode.left == None and treeNode.right == None:\\n return True\\n else:\\n return False\",\n \"def is_leaf(self):\\n return len(self._children) == 0\",\n \"def is_leaf(self, p):\\n return self.num_children(p) == 0\",\n \"def is_leaf(self) -> bool:\\n return not any(self.children)\",\n \"def is_leaf(self):\\n return len(self.child_list) == 0\",\n \"def is_leaf(self):\\n return self._children == {}\",\n \"def is_leaf(self):\\n return self._children == {}\",\n \"def is_leaf(self):\\n return self._children == {}\",\n \"def is_leaf(self):\\n return self._children == {}\",\n \"def is_leaf(self, n):\\n return self.num_children(n) == 0\",\n \"def leaf(self):\\n if not self._leftchild and not self._rightchild:\\n return True\\n return False\",\n \"def is_leaf(self):\\n # TODO: Check if both left child and right child have no value\\n return ... and ...\",\n \"def leaf(self):\\n if not self.left and not self.right:\\n return True\\n return False\",\n \"def is_leaf(self):\\n return len(self.blocks) == 0\",\n \"def isLeaf(self):\\n\\n return self.children == {}\",\n \"def is_leaf(self, p):\\n return self.num_children(p) == 0\",\n \"def is_leaf(self, p):\\n return self.num_children(p) == 0\",\n \"def is_leaf(self, p):\\n return self.num_children(p) == 0\",\n \"def is_leaf(self, p):\\n return self.num_children(p) == 0\",\n \"def IsLeaf(self):\\n return not self.subtests\",\n \"def is leaf(self, p):\\n return self.num children(p) == 0\",\n \"def isLeaf(self, node_name):\\n if self.tree.node[node_name]['c'] != '':\\n return True\\n else:\\n return False\",\n \"def is_leaf(self) -> bool:\\n return self.data_bytes[0] == ProofPath._KeyPrefix.LEAF\",\n \"def is_leaf(self,p):\\n node = self._validate(p)\\n return self.children_num(p) == 0\",\n \"def is_leaf(self):\\n return isinstance(self, Leaf)\",\n \"def node_leaf(self):\\r\\n return self.zero_son is None and self.one_son is None\",\n \"def is_leaf(self):\\n return len(self.refs) == 0\",\n \"def is_leaf(self):\\n return self.pixel_count > 0\",\n \"def is_leaf(self, node_id):\\n return self.tree.children_left[node_id] == INVALID_NODEID\",\n \"def next_leaf(node):\\n return len(node[1][0][1]) == 0\",\n \"def has_leaf(self) -> bool:\\r\\n self._logger.debug(log_message_formatter(\\r\\n \\\"get\\\", f\\\"{self}\\\", \\\"has_leaf\\\"))\\r\\n return self._hvac_mode == \\\"eco\\\"\",\n \"def is_leaf(self, pos):\\n if pos >= (self.size//2) and pos <= self.size: \\n return True\\n return False\",\n \"def is_huffman_leaf(tree):\\n return not is_leaf(tree) and is_leaf(branches(tree)[0])\",\n \"def check_leaf_node(df):\\r\\n \\r\\n return len(set(df['class'])) == 1\",\n \"def is_leaf(self, i):\\n return len(self.children[i]) == 0 or len(self.pq[i]) == 0\",\n \"def has_zero_length_leaves(self):\\n for l in self.leaves():\\n if l.has_zero_length:\\n return True\\n return False\",\n \"def test_is_leaf(self):\\n self.assertEqual(True, comparator.is_leaf(None))\\n self.assertEqual(True, comparator.is_leaf(True))\\n self.assertEqual(True, comparator.is_leaf(False))\\n self.assertEqual(True, comparator.is_leaf(int()))\\n self.assertEqual(True, comparator.is_leaf(str()))\\n self.assertEqual(False, comparator.is_leaf(list()))\\n self.assertEqual(False, comparator.is_leaf(dict()))\",\n \"def _is_leaf(self, index):\\r\\n return 2*index+1 > self._size - 1\",\n \"def isLeaf(self, pos):\\n if (self.size // 2) <= pos <= self.size:\\n return True\\n return False\",\n \"def isLeaf(self, pos):\\n if (self.size // 2) <= pos <= self.size:\\n return True\\n return False\",\n \"def son_is_leaf(self, place):\\n raise NotImplementedError\",\n \"def is_leaf(self, cat: typing.Union[str, HierarchicalCategory]) -> bool:\\n if not isinstance(cat, HierarchicalCategory):\\n return self.is_leaf(self._all_codes_map[cat])\\n\\n return cat.is_leaf\",\n \"def isLeaf(self, path):\\n # pylint: disable=E1101\\n # E1101: pylint could not resolve the node_kind attribute. \\n\\n return self._determineItemKind(path, pysvn.node_kind.file)\",\n \"def is_root(self, node: object) -> bool:\\n if node == self.root:\\n return True\\n else:\\n return False\",\n \"def is_leaf(node_value):\\n return isinstance(node_value, dict) and 'required' in node_value\",\n \"def isleaf(self):\\n no_kids = super(PartitionDevice, self).isleaf\\n # it is possible that the disk that originally contained this partition\\n # no longer contains a disklabel, in which case we can assume that this\\n # device is a leaf\\n if self.disk and self.partedPartition and \\\\\\n self.disk.format.type == \\\"disklabel\\\" and \\\\\\n self.partedPartition in self.disk.format.partitions:\\n disklabel = self.disk.format\\n else:\\n disklabel = None\\n\\n extended_has_logical = (self.isExtended and\\n (disklabel and disklabel.logicalPartitions))\\n return (no_kids and not extended_has_logical)\",\n \"def is_branch_node(tree, node):\\n if node == tree.root:\\n return tree.degree(node) >= 2\\n else:\\n return tree.degree(node) >= 3\",\n \"def is_root(self, node):\\n self._validate_node(node)\\n return node._index == 0\",\n \"def is_empty(self):\\n if self.root == None:\\n return True\\n return False\",\n \"def is_root(self, node: Node) -> bool:\\n return node == self._root\",\n \"def calculate_leafs(self):\\n self._leafs = [node for node in self._nodes if not self._nodes[node]['children']]\",\n \"def isLeaf(self, clip):\\n\\n if not isinstance(clip, Clip):\\n raise TypeError(\\\"clip must be an instance of Clip\\\")\\n\\n return clip in self.leaves\",\n \"def test_small_tree_has_no_root(small_tree):\\n assert small_tree.root.left is None\",\n \"def is_root(self):\\n return (self.__type & NODE_ROOT) == NODE_ROOT\",\n \"def is_tree(t):\\n if type(t) != list or len(t) < 1:\\n return False\\n elif is_leaf(t):\\n return True\\n else:\\n return all([is_tree(b) for b in t[1:]])\",\n \"def empty(self) -> bool:\\n return True if self.root is None else False\",\n \"def is_empty(self):\\n return self.root is None\",\n \"def is_empty(self):\\n return self.root is None\",\n \"def isBlankNode(self):\\n ret = libxml2mod.xmlIsBlankNode(self._o)\\n return ret\",\n \"def get_leaf_nodes(self):\\n pass\",\n \"def is_empty(self):\\n return self.__root == None\",\n \"def is_root(self):\\n return self.root in [-1, self]\",\n \"def test_tree_with_one_node_root_no_children(one_t):\\n assert not one_t.root.left\\n assert not one_t.root.right\",\n \"def count_leaf(self):\\n if self.is_empty():\\n return 0\\n elif self.is_leaf():\\n return 1\\n else:\\n if self.get_left():\\n if self.get_right():\\n return 0 + self.get_left().count_leaf() + self.get_right().count_leaf()\\n else:\\n return 0 + self.get_left().count_leaf()\\n else:\\n return 0 + self.get_right().count_leaf()\",\n \"def num_leaves(tree):\\n return ((tree.n_node_samples > 0) & (tree.feature == INVALID_VALUE)).sum()\",\n \"def is_root(self):\\n return True\",\n \"def is_root(self):\\n return True\",\n \"def is_root(self, p):\\n return self.root() == 0\",\n \"def _check_for_children(self):\\n if len(self.node.get_children()) > 0:\\n raise ValueError('This Node is not a leaf node. Children of this node '\\n 'are {}'.format(self.client.get_children()))\",\n \"def has_single_root(self):\\n root = self.left_root\\n if root != NULL and self.right_sib(root) == NULL:\\n return True\\n return False\",\n \"def is_internal(self):\\n if self.is_leaf() or self.is_semileaf():\\n return False\\n return True\",\n \"def is_root(self):\\n return self.unpack_word(0x2) & 0x0004 > 0\",\n \"def is_root(self):\\n return not self.parents.exists()\",\n \"def is_stump(self):\\n if self.is_leaf():\\n return False\\n return self.left_subtree.is_leaf() and self.right_subtree.is_leaf()\",\n \"def is_root(self):\\n return not self.parent\",\n \"def is_full(self, node):\\n if node.right != None and node.left != None:\\n return True\\n return False\",\n \"def delete_leaves(self):\\n if not (self.left or self.right):\\n return True\\n if self.left:\\n delete = self.left.delete_leaves()\\n if delete is True:\\n self.left = None\\n if self.right:\\n delete = self.right.delete_leaves()\\n if delete is True:\\n self.right = None\",\n \"def is_root(self) -> bool:\\n return self.parent_id is None\",\n \"def is_leaf_path(p: Path) -> bool:\\n return p.is_file() or (p.is_dir() and not any(p.glob(\\\"*\\\")))\",\n \"def is_root(self):\\n return self._parent == None\",\n \"def is_root(self):\\n return self.parent == None\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8605668","0.85680234","0.853242","0.849539","0.84208226","0.840783","0.84036934","0.83483315","0.83079994","0.8281862","0.82678497","0.82634103","0.82323253","0.8224074","0.8210887","0.8189795","0.8183536","0.8168549","0.81192285","0.81134427","0.8108384","0.8075463","0.80047625","0.79517716","0.7942067","0.7942067","0.7942067","0.7942067","0.7931014","0.79082704","0.79014736","0.78898686","0.78637695","0.7857929","0.77971756","0.77971756","0.77971756","0.77971756","0.7795626","0.7775074","0.7756825","0.7728549","0.77074635","0.7595763","0.75765955","0.74976957","0.7420152","0.73693305","0.7327548","0.71834546","0.7046983","0.6975116","0.69738275","0.69583255","0.695018","0.69125813","0.68389845","0.6804927","0.6804927","0.68039656","0.67896247","0.6751518","0.67109686","0.6664828","0.6598921","0.6581814","0.65481967","0.65455085","0.6476369","0.6449807","0.6425073","0.6423879","0.6364044","0.63555056","0.6346089","0.628551","0.628551","0.6277596","0.62622213","0.62591696","0.62376136","0.621984","0.62109107","0.6161232","0.61601293","0.61601293","0.6148533","0.6101953","0.60988516","0.6096361","0.6092871","0.6091866","0.6043637","0.60334533","0.6007581","0.59947604","0.59931654","0.59923476","0.5983604","0.598259"],"string":"[\n \"0.8605668\",\n \"0.85680234\",\n \"0.853242\",\n \"0.849539\",\n \"0.84208226\",\n \"0.840783\",\n \"0.84036934\",\n \"0.83483315\",\n \"0.83079994\",\n \"0.8281862\",\n \"0.82678497\",\n \"0.82634103\",\n \"0.82323253\",\n \"0.8224074\",\n \"0.8210887\",\n \"0.8189795\",\n \"0.8183536\",\n \"0.8168549\",\n \"0.81192285\",\n \"0.81134427\",\n \"0.8108384\",\n \"0.8075463\",\n \"0.80047625\",\n \"0.79517716\",\n \"0.7942067\",\n \"0.7942067\",\n \"0.7942067\",\n \"0.7942067\",\n \"0.7931014\",\n \"0.79082704\",\n \"0.79014736\",\n \"0.78898686\",\n \"0.78637695\",\n \"0.7857929\",\n \"0.77971756\",\n \"0.77971756\",\n \"0.77971756\",\n \"0.77971756\",\n \"0.7795626\",\n \"0.7775074\",\n \"0.7756825\",\n \"0.7728549\",\n \"0.77074635\",\n \"0.7595763\",\n \"0.75765955\",\n \"0.74976957\",\n \"0.7420152\",\n \"0.73693305\",\n \"0.7327548\",\n \"0.71834546\",\n \"0.7046983\",\n \"0.6975116\",\n \"0.69738275\",\n \"0.69583255\",\n \"0.695018\",\n \"0.69125813\",\n \"0.68389845\",\n \"0.6804927\",\n \"0.6804927\",\n \"0.68039656\",\n \"0.67896247\",\n \"0.6751518\",\n \"0.67109686\",\n \"0.6664828\",\n \"0.6598921\",\n \"0.6581814\",\n \"0.65481967\",\n \"0.65455085\",\n \"0.6476369\",\n \"0.6449807\",\n \"0.6425073\",\n \"0.6423879\",\n \"0.6364044\",\n \"0.63555056\",\n \"0.6346089\",\n \"0.628551\",\n \"0.628551\",\n \"0.6277596\",\n \"0.62622213\",\n \"0.62591696\",\n \"0.62376136\",\n \"0.621984\",\n \"0.62109107\",\n \"0.6161232\",\n \"0.61601293\",\n \"0.61601293\",\n \"0.6148533\",\n \"0.6101953\",\n \"0.60988516\",\n \"0.6096361\",\n \"0.6092871\",\n \"0.6091866\",\n \"0.6043637\",\n \"0.60334533\",\n \"0.6007581\",\n \"0.59947604\",\n \"0.59931654\",\n \"0.59923476\",\n \"0.5983604\",\n \"0.598259\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8422532"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":78592,"cells":{"query":{"kind":"string","value":"Function to get the midpoints between values of the feature array to score in determining best split."},"document":{"kind":"string","value":"def get_valid_midpoints ( feature_array: np.ndarray, target_array: np.ndarray ):\n # Get sorted indices\n indices = np.argsort ( feature_array )\n\n # Get sorted feature array\n sorted_feature_array = feature_array [ indices ]\n\n # Get the differences between adjacent values\n feature_array_diffs = np.diff ( sorted_feature_array )\n\n # Get the midpoints\n midpoints = sorted_feature_array [ 1 : ] - feature_array_diffs / 2\n\n # Get points where differences are greater than 0 (uniqueness) and y values are not the same\n # See report for details on the latter part.\n valid_midpoints = midpoints [ np.bitwise_and ( feature_array_diffs > 0, np.diff (target_array [ indices ] ) > 0 ) ]\n\n return valid_midpoints\n # End get_valid_midpoints()"},"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 midpoints(self):\n return self.bins[:, 1]","def split(self, X, y, feature_array):\n n, p = X.shape\n\n best_gain = 0\n best_split_point = 0\n best_feature_id = -1\n for feature_id in feature_array:\n cur_gain, cur_split_point = self.find_best_split(\n X[:, feature_id], y)\n if cur_gain > best_gain - self.eps:\n best_gain = cur_gain\n best_split_point = cur_split_point\n best_feature_id = feature_id\n\n assert(best_feature_id != -1)\n\n x = X[:, best_feature_id]\n left_index = x < best_split_point\n right_index = x >= best_split_point\n\n self.split_id = best_feature_id\n self.split_val = best_split_point\n\n return (left_index, right_index)","def get_valid_midpoints(arr: np.ndarray, y: np.ndarray):\n # Get sorted indices\n idxs = np.argsort(arr)\n\n # Get sorted feature array\n sorted_arr = arr[idxs]\n\n # Get the differences between adjacent values\n arr_diffs = np.diff(sorted_arr)\n\n # Get the midpoints\n midpoints = sorted_arr[1:] - arr_diffs / 2\n\n # Get points where differences are greater than 0 (uniqueness) and y values are not the same\n # See report for details on the latter part.\n valid_midpoints = midpoints[np.bitwise_and(arr_diffs > 0, np.diff(y[idxs]) > 0)]\n\n return valid_midpoints","def getSplit(self, array, left, right, epsilon):\r\n if epsilon < 10 ** (-6):\r\n return (left + right) / 2\r\n else:\r\n return self.getNoisyMedian(array, left, right, epsilon)","def get_split(self,X,y):\n \n BEST_COL = 0\n BEST_SPLIT =0\n BEST_IMPUR = 99\n for i,feature in enumerate(X.T):\n arg_sort=np.argsort(feature) #Sort the feature for optimizing the find of splitting points\n feature= feature[arg_sort]\n y_sort = y[arg_sort]\n splits = self.possible_splits(feature,y_sort) #Get \n\n impur,splits = self.test_split(feature,y_sort,splits) #Get impurity for splitting points\n best_idx = np.argmin(impur)\n best_impur = impur[best_idx]\n \n if best_impur==0.0: #Found perfect split, terminate\n return(i,splits[best_idx])\n elif best_impur<BEST_IMPUR:\n BEST_IMPUR=best_impur\n BEST_SPLIT=splits[best_idx]\n BEST_COL=i\n return (BEST_COL,BEST_SPLIT)","def midpoint(self,i,f):\n\n summation = self.points[f, :] + self.points[i, :]\n midploint = summation/2\n x_mid = midploint[0]\n y_mid = midploint[1]\n\n return x_mid,y_mid","def get_optimal_continuous_feature_split (\n self, feature_matrix: np.ndarray, target_array: np.ndarray, feature_column: int\n ):\n midpoints = BaseTree.get_valid_midpoints ( feature_array = feature_matrix [ :, feature_column ], target_array = target_array )\n # If midpoints, get the best one\n if len ( midpoints ) > 0:\n return BaseTree.get_min_across_splits_continuous (\n feature_array = feature_matrix [ :, feature_column ], target_array = target_array, splits = midpoints, evaluate_function = self.evaluate_function\n )\n\n # If no split points, return inf (can't split here)\n return ( 0, np.inf, 1 )\n # End get_optimal_continuous_feature_split()","def get_split(data):\n \"\"\" gets the best feature, and best value \"\"\"\n\n best_feature = None\n best_value = 0.0\n columns = data.columns\n gini_base = gini_impurity(data)\n n_rows = len(data.index) # total number of rows of data before split\n\n # Fininding which split yields the best gini gain\n max_gain = 0\n\n for i in range(len(columns)-1): # -1 b.c. class is final column\n xs = data[columns[i]].unique() # get values to test\n for x in xs: # test values\n # split dataset\n df_left = data[data[columns[i]] < x]\n df_right = data[data[columns[i]] >= x]\n\n # get gini impurities\n gini_left = gini_impurity(df_left)\n gini_right = gini_impurity(df_right)\n \n\n # Calculated weighted gini impurity\n w_left = len(df_left.index) / n_rows\n w_right = len(df_right.index) / n_rows\n\n w_gini = gini_left * w_left + gini_right * w_right\n \n\n # Calculate gini gain (we want to minimize w_gini for the smallest impurity. Ideal split is perfect Left=c1, Right=c2)\n # why not just find min w_gin instead of uding gini_gain and gini_base vaiables?\n gini_gain = gini_base - w_gini\n\n # check if this is the best split so far, store values, update max_gini\n if gini_gain > max_gain:\n best_feature = columns[i]\n best_value = x\n max_gain = gini_gain\n\n df_left = data.loc[data[best_feature] < best_value]\n df_right = data.loc[data[best_feature] >= best_value]\n \n\n return best_feature, best_value, df_left, df_right","def find_best_split(self, x, y):\n\n # check cornor case: all same x\n n = y.size\n\n if all(x == x[0]):\n return (0, amin(x) - self.eps)\n\n sort_index = argsort(x)\n x_sorted = x[sort_index]\n y_sorted = y[sort_index]\n\n # build potential split index array\n split_index_array = array([i for i in range(1, n)\n if x_sorted[i] != x_sorted[i - 1]\n and y_sorted[i] != y_sorted[i - 1]])\n\n # split_index_array = linspace(\n # 0, y.size, num=min(5, ceil(n / 5)), endpoint=False, dtype='int')\n # split_index_array = split_index_array[1:]\n\n best_split_index = 0\n best_gain = 0\n h_x = self.cur_entropy\n\n for split_index in split_index_array:\n left_entropy = self.entropy(y_sorted[:split_index])\n right_entropy = self.entropy(y_sorted[split_index:])\n h_xy = (split_index * left_entropy +\n (n - split_index) * right_entropy) / n\n cur_gain = h_x - h_xy\n\n if cur_gain > best_gain:\n best_gain = cur_gain\n best_split_index = split_index\n\n if best_split_index != 0:\n best_split_point = (x_sorted[best_split_index] +\n x_sorted[best_split_index - 1]) / 2\n else:\n best_split_point = x_sorted[best_split_index] - self.eps\n\n return (best_gain, best_split_point)","def midpoint(self) -> Tuple[int, int]:\n pass","def midpoints(min_r_value, max_r_value, bin_size):\n min_r = min_r_value + 0.5 * bin_size\n max_r = max_r_value - 0.5 * bin_size\n return np.arange(min_r, max_r, bin_size)","def __find_best_split(self, x, y):\n data = np.transpose(np.vstack((np.transpose(x), y)))\n num_features = data.shape[1] - 1\n\n # initialise splitting rule components\n integer_splitting_rule = None\n feature_index_to_split = None\n max_info_gain = 0\n\n # iterate over all the features and find best splits within these\n for feature in range(num_features):\n info_gain, split_int = self.__find_best_split_in_feature(\n data[:, [feature, -1]])\n if info_gain is None:\n continue\n # update max info gain so far as it iterates over features\n if info_gain > max_info_gain:\n max_info_gain = info_gain\n feature_index_to_split = feature\n integer_splitting_rule = int(split_int)\n\n return feature_index_to_split, integer_splitting_rule","def get_optimal_continuous_feature_split(\n self, X: np.ndarray, y: np.ndarray, feature_col: int\n ):\n midpoints = BaseTree.get_valid_midpoints(arr=X[:, feature_col], y=y)\n # If midpoints, get the best one\n if len(midpoints) > 0:\n return BaseTree.get_min_across_splits_continuous(\n arr=X[:, feature_col], y=y, splits=midpoints, eval_func=self.eval_func\n )\n\n # If no split points, return inf (can't split here)\n return (0, np.inf, 1)","def find_split(eps, nfeats_test):\n # TODO your code here\n # Consider a random subset of features of the specified size\n total_feature_num = len(eps[0].values)\n if nfeats_test <= total_feature_num:\n features_to_test = sorted(random.sample(range(total_feature_num), nfeats_test))\n else:\n features_to_test = range(total_feature_num)\n\n # For each feature under consideration, and each splitting value:\n # various values that show up in the profiles for the feature at hand, and take the midpoints between adjacent values.\n # calculate the impurity of each of the two subsets of profiles split accordingly.\n res = None\n for feature in features_to_test:\n values_for_split = [ep[feature] for ep in eps]\n splitting_points = sorted(list(set(values_for_split)))\n # take the midpoints between adjacent values\n for i in range(len(splitting_points) - 1):\n splitting_points[i] = (splitting_points[i] + splitting_points[i + 1]) / 2\n splitting_points.pop()\n\n # calculate the impurity of each of the two subsets of profiles split accordingly.\n for sp_value in splitting_points:\n subset1 = [ep for ep in eps if ep[feature] < sp_value]\n gini1 = cal_gini(subset1)\n subset2 = [ep for ep in eps if ep[feature] >= sp_value]\n gini2 = cal_gini(subset2)\n # Sum these, weighted by the fraction of profiles in each subset.\n gini = len(subset1) / len(eps) * gini1 + len(subset2) / len(eps) * gini2\n if res is None:\n res = (feature, sp_value, gini)\n elif gini < res[2]:\n res = (feature, sp_value, gini)\n\n return res","def splitDetectorPeakInfo(self):\r\n\t\tsplit_raw_min = np.amin(self.splitData)\r\n\t\tsplit_min = split_raw_min - self.splitBaseline\r\n\t\t\t\t\r\n\t\tsplit_raw_max = np.amax(self.splitData)\r\n\t\tsplit_max = split_raw_max - self.splitBaseline\r\n\t\r\n\t\tself.splitMax = split_max\r\n\t\tself.splitMin = split_min","def midpoint(self) -> Tuple[int, int]:\n minx, miny, maxx, maxy = self.substrates.bounds\n return ((minx + maxx) // 2, (miny + maxy) // 2)","def choose_best_split(self, X_subset, y_subset):\n # YOUR CODE HERE\n feature_index = None\n threshold = None\n best_G = np.inf\n N = len(X_subset)\n \n for current_feature in range(X_subset.shape[1]):\n thresholds = np.unique(X_subset[:, current_feature])\n \n for t in thresholds:\n y_left, y_right = self.make_split_only_y(current_feature, t, X_subset, y_subset)\n H_L = self.H(y_left)\n H_R = self.H(y_right)\n \n G = (len(y_left) / N) * H_L + (len(y_right) / N) * H_R\n \n if G < best_G:\n best_G = G\n feature_index = current_feature\n threshold = t\n \n return feature_index, threshold","def midpoint(p1, p2):\n return np.array([(p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2, (p1[2] + p2[2]) / 2])","def get_min_across_splits_continuous (\n feature_array: np.ndarray, target_array: np.ndarray, splits: np.ndarray, evaluate_function: Callable\n ):\n n = len ( splits )\n if n > 500:\n # If many split points, use some threading\n with multiprocessing.Pool ( processes = 8 ) as p:\n # Get evaluation scores across all the splits\n post_split_evals = dict (\n zip (\n range ( len ( splits ) ),\n p.starmap (\n BaseTree.get_split_goodness_fit_continuous,\n zip ( [ feature_array] * n, [ target_array ] * n, splits, [ evaluate_function ] * n ),\n ),\n )\n )\n p.close()\n else:\n # If not too many split points, get scores across all splits\n post_split_evals = dict (\n zip (\n range ( len ( splits ) ),\n map (\n lambda x: BaseTree.get_split_goodness_fit_continuous ( * x ),\n zip ( [ feature_array ] * n, [ target_array ] * n, splits, [ evaluate_function ] * n ),\n ),\n )\n )\n # Get the minimum split based on gain ratio\n min_eval = min (\n post_split_evals,\n key = lambda x: pipe (\n post_split_evals.get ( x ),\n lambda results: results [ 0 ] / results [ 1 ], # entropy / intrinsic value\n ),\n )\n\n # Return the best split and the splits scores\n return ( splits [ min_eval ], * post_split_evals.get ( min_eval ) )\n # End get_min_across_splits_continuous()","def midpoint(ptA, ptB):\n return( (ptA[0] + ptB[0]) * 0.5, (ptA[1]+ ptB[1]) * 0.5 )","def _bestFeat2split(dataSet, impurity_crit, min_impurity_decrease, min_samples_split):\n\t\tm, n = dataSet.shape\n\t\tbestFeatInd, bestVal = None, DecisionTree._make_leaf(dataSet, impurity_crit)\n\n\t\tif m < min_samples_split or len(set(dataSet[:,-1])) == 1:\n\t\t\treturn bestFeatInd, bestVal\n\n\t\timpurity = m * impurity_crit(dataSet)\n\t\tmin_impurity = np.inf\n\t\t\n\n\t\tfor feat_ind in range(n-1):\n\t\t\tif type(dataSet[:, feat_ind][0]) != str:\n\t\t\t\tuniqVal = set(dataSet[:, feat_ind])\n\t\t\telse:\n\t\t\t\tuniqVal = map(set, subsets(list(dataSet[:, feat_ind])))\n\t\t\tfor val in uniqVal:\n\t\t\t\tD1, D2 = DecisionTree._binarySplit(dataSet, feat_ind, val)\n\t\t\t\tif len(D1) < min_samples_split or len(D2) < min_samples_split:\n\t\t\t\t\tcontinue\n\t\t\t\tnew_impurity = len(D1)*impurity_crit(D1) + len(D2)*impurity_crit(D2)\n\t\t\t\tif impurity - new_impurity < min_impurity_decrease:\n\t\t\t\t\tcontinue\n\t\t\t\tif new_impurity < min_impurity:\n\t\t\t\t\tmin_impurity = new_impurity\n\t\t\t\t\tbestFeatInd = feat_ind; bestVal = val\n\t\treturn bestFeatInd, bestVal","def mid(self):\n return LibraryFunctions.per(self.nums(), 0.5)","def midpoint(a, b):\n return ((a[0] + b[0]) / 2, (a[1] + b[1]) / 2)","def get_best_split_all(x, y) -> Tuple[int, float, float]:\n m = x.shape[1]\n col_best_gin = np.ones(shape=m)\n col_best_val = np.ones(shape=m)\n for c in range(m):\n best = 1\n best_x = 0\n for i in np.unique(x[:, c]):\n gini = Tree.split(x[:, c], y, i)\n if gini < best:\n best = gini\n best_x = i\n col_best_gin[c] = best\n col_best_val[c] = best_x\n\n # Select best feature to split on\n col_idx = np.argmin(col_best_gin)\n # Convert to bool index\n col_idx = np.array(range(x.shape[1])) == col_idx\n\n return col_idx, col_best_val[col_idx], col_best_gin[col_idx]","def midpoint_of_points(pnts: Iterable[Point]) -> Point:\n num = len(pnts)\n x = sum(pnt.x for pnt in pnts)/num\n y = sum(pnt.y for pnt in pnts)/num\n z = sum(pnt.z for pnt in pnts)/num\n return Point(x, y, z)","def possible_splits(self,feature,y):\n\n yi = y[:-1]\n yi1= y[1:]\n idx=np.argwhere((yi1-yi)!=0)\n return idx.flatten()","def _get_best_fit(self, segmented_instances, num_labels,\\\n stats, end_points, i, j, k, pos_angle=True):\n min_angle = None\n seg_section = None\n min_seg_dist = None\n\n img = np.zeros(segmented_instances.shape)\n img[segmented_instances== (i+1)]= 100\n #self.showme(img, str(i))\n img[segmented_instances== (j+1)]= 100\n #self.showme(img, str(i)+'and? '+str(j))\n cv2.circle(img, (end_points[i][k][0], end_points[i][k][1]), 3, 70, -1)\n seg_section=None\n mid_point_i=[0,0]\n for l in range(0, len(end_points[j])): #Iterate over all endpoints of segment j\n #cv2.line(img,(end_points[i][k][0], end_points[i][k][1]),(stats['centroid'][i,0], stats['centroid'][i,1]),100,4)\n seg_dist = math.sqrt((end_points[j][l][0]-end_points[i][k][0])**2.0 +\n (end_points[j][l][1]-end_points[i][k][1])**2.0 )\n #cv2.line(img,(end_points[j][l][0], end_points[j][l][1]),(stats['centroid'][i,0], stats['centroid'][i,1]),255,4)\n # Stem segments with side branches usually miss a good connection because the centroid is off\n # the end point's axis. To account for this we replace the centroind with a point that is closer to the end point.\n mid_point_i[0] = int(end_points[i][k][0]+ (stats['centroid'][i][0]-end_points[i][k][0])/4.0)\n mid_point_i[1] = int(end_points[i][k][1]+ (stats['centroid'][i][1]-end_points[i][k][1])/4.0)\n\n angle = self._ang([stats['centroid'][j],end_points[j][l]], \\\n [stats['centroid'][j], mid_point_i] )\n if angle==999: #check for a divide by zero error\n cv2.line(img,(stats['centroid'][j][0], stats['centroid'][j][1]),\n (end_points[j][l][0], end_points[j][l][1]), 150, 4 )\n cv2.line(img,(stats['centroid'][j][0], stats['centroid'][j][1]),\n (stats['centroid'][i][0], stats['centroid'][i][1]), 150, 4 )\n cv2.line(img,(end_points[j][l][0], end_points[j][l][1]),\\\n (end_points[i][k][0], end_points[i][k][1]),255,4)\n self.showme(img, str(i)+' '+str(j)+' '+str(angle))\n\n if (pos_angle and angle<=self.angle_thresh) or ( not(pos_angle) and angle>=360-self.angle_thresh):\n if min_seg_dist is None or seg_dist < min_seg_dist:\n min_seg_dist = seg_dist\n min_angle = angle\n seg_section = l\n elif seg_dist<50:\n cv2.line(img,(stats['centroid'][j][0], stats['centroid'][j][1]),\n (end_points[j][l][0], end_points[j][l][1]), 150, 4 )\n cv2.line(img,(stats['centroid'][j][0], stats['centroid'][j][1]),\n (stats['centroid'][i][0], stats['centroid'][i][1]), 150, 4 )\n cv2.line(img,(end_points[j][l][0], end_points[j][l][1]),\\\n (end_points[i][k][0], end_points[i][k][1]),255,4)\n #self.showme(img, str(i)+' '+str(j)+' '+str(angle))\n\n return min_angle, seg_section, min_seg_dist","def test_midpoint(self):\n p1 = Point(0, 0)\n p2 = Point(10, 10)\n midpoint = p1.midpoint(p2)\n self.assertAlmostEqual(midpoint.lat, 5)\n self.assertAlmostEqual(midpoint.lon, 5)","def find_split(x, y):\n\n # Need the starting entropy so we can measure improvement...\n start_entropy = calculate_entropy(y)\n\n # Best thus far, initialised to a dud that will be replaced immediately...\n best = {'infogain': -np.inf}\n\n # Randomly allocate the splits to be traversed (without replacement)\n feature_total = x.shape[1]\n feature_subset_count = int(np.sqrt(feature_total))\n feature_subset = np.random.permutation(feature_total)[:feature_subset_count]\n\n # Loop every possible split of every feature...\n for feature_index in feature_subset:\n for split in np.unique(x[:, feature_index]):\n\n left_indices = []\n right_indices = []\n\n # Get index of rows where x[row_index,feature_index] <= split\n for row_index,row in enumerate(x):\n left_indices.append(row_index) if x[row_index,feature_index] <= split else right_indices.append(row_index)\n\n left_ys = y[left_indices]\n right_ys = y[right_indices]\n\n nleft = len(left_ys)\n nright = len(right_ys)\n ntotal = nleft + nright\n infogain = start_entropy - (nleft / ntotal) * calculate_entropy(left_ys) - (\n nright / ntotal) * calculate_entropy(right_ys)\n\n if infogain > best['infogain']:\n best = {'feature': feature_index,\n 'split': split,\n 'infogain': infogain,\n 'left_indices': left_indices,\n 'right_indices': right_indices}\n return best","def __find_best_split_in_feature(self, feature_and_class):\n\n # sort the feature and class and use changes in the class to reduce\n # number of potential split info gain calculations\n sorted_data = feature_and_class[\n feature_and_class[:, 0].astype(np.int).argsort()]\n potential_splits = self.__find_integers_with_class_change(sorted_data)\n info_gains = self.__info_gain_from_splits(potential_splits,\n sorted_data)\n\n # returning nothing in no information gains are found\n if len(info_gains) == 0:\n return None, None\n\n index = info_gains.index(max(info_gains))\n return info_gains[index], potential_splits[index]","def midpoint(bbox):\n return (0.5*(bbox[0][0] + bbox[1][0]), 0.5*(bbox[0][1] + bbox[1][1]))","def closest_split_pair(x, delta):\n mid_point_x = x[len(x)//2][0]\n strip = []\n\n for point in y:\n if abs(mid_point_x - point[0]) < delta:\n strip.append(point)\n strip = sorted(strip, key= lambda x: x[0])\n\n n = len(strip)\n min_distance = float(\"inf\")\n last_pair = None\n for i in range(n):\n for j in range(i+1, i+7):\n if j < n:\n result = distance(points[i], points[j])\n if result < min_distance:\n min_distance = result\n last_pair = [points[i], points[j]]\n return last_pair","def __get_split_feature(self, data_set, target_feature, tree_features):\n\n if self.__criterion == 'entropy':\n feature_gains = {feature: self.__gain(data_set, feature, target_feature) for (feature) in tree_features}\n split_feature = max(feature_gains, key=feature_gains.get)\n return split_feature\n elif self.__criterion == 'gini':\n feature_ginis = {feature: self.__gini(data_set, feature, target_feature) for (feature) in tree_features}\n split_feature = min(feature_ginis, key=feature_ginis.get)\n return split_feature\n # TODO: I should check this (gini index).","def test_split(self,X,y,splits):\n n_data = len(y) #Number of data points\n splits=(X[splits]+X[splits+1])/2\n\n idx_greater = (X>splits[:,None]) #index for greater split\n idx_lower = (X<splits[:,None]) #index for lower split\n\n imp_greater =[self.impurity(y[idx]) for idx in idx_greater] #impurity for greater\n imp_lower = [self.impurity(y[idx]) for idx in idx_lower] #impurity lower\n\n impur = [sum(idx_great)/n_data*imp_great+sum(idx_low)/n_data*imp_low for idx_great,imp_great,idx_low,imp_low in zip(idx_greater,imp_greater,idx_lower,imp_lower)] #Weighted impurity\n return (impur,splits)","def GetMiddle(cluster):\n x = np.mean(np.array([cluster[i][0] for i in range(len(cluster))]))\n y = np.mean(np.array([cluster[i][1] for i in range(len(cluster))]))\n return [x, y]","def find_best_point(self, start_i, end_i, ranges):\n # do a sliding window average over the data in the max gap, this will\n # help the car to avoid hitting corners\n averaged_max_gap = np.convolve(ranges[start_i:end_i], np.ones(self.BEST_POINT_CONV_SIZE), 'same') / self.BEST_POINT_CONV_SIZE\n return averaged_max_gap.argmax() + start_i","def split_data(data, feature, split_point):\n data_l = data[data[:, feature - 1] < split_point]\n data_r = data[data[:, feature - 1] >= split_point]\n\n return data_l, data_r","def mid(p1, p2):\n\treturn [(p1[0]+p2[0])/2., (p1[1]+p2[1])/2.]","def __call__(self, features):\n\n data = np.array(features)\n min = np.amin(data, axis=0)\n dif = np.amax(data, axis=0) - min\n for i in range(len(dif)):\n if dif[i] == 0:\n data[:, i] = min[i]\n dif[i] = 1\n \n return [list((d - min)/ dif) for d in data]","def get_splits(self):\n\t\treturn self.k","def mid_mAP(P, Y, S, bg_class):\n # segment groundtruth intervals\n gt_file, gt_labels, gt_intervals = [], [], []\n for i, y in enumerate(Y):\n gt_labels += [_segment_labels(y)]\n gt_intervals += [np.array(_segment_intervals(y))]\n gt_file += [[i]*len(gt_labels[-1])]\n gt_file = np.hstack(gt_file)\n gt_intervals = np.vstack(gt_intervals)\n gt_labels = np.hstack(gt_labels)\n\n # segment detected intervals\n det_file, det_labels, det_intervals, det_scores = [], [], [], []\n for i, y in enumerate(P):\n det_labels += [_segment_labels(y)]\n det_intervals += [np.array(_segment_intervals(y))]\n det_file += [[i]*len(det_labels[-1])]\n det_scores += [S[i][inter[0]:inter[1]][:, label].max()\n for inter, label in zip(det_intervals[-1],\n det_labels[-1])]\n det_file = np.hstack(det_file)\n det_intervals = np.vstack(det_intervals)\n det_labels = np.hstack(det_labels)\n det_scores = np.hstack(det_scores)\n\n pr, ap, mAP_mid = _midpoint_mAP(gt_file, det_file, gt_labels, det_labels,\n gt_intervals, det_intervals, det_scores,\n bg_class=bg_class)\n return np.array(ap), mAP_mid*100","def make_split(self, feature_index, threshold, X_subset, y_subset):\n\n # YOUR CODE HERE\n ind = (X_subset[:, feature_index] < threshold)\n \n X_left, y_left = X_subset[ind], y_subset[ind]\n X_right, y_right = X_subset[~ind], y_subset[~ind]\n \n return (X_left, y_left), (X_right, y_right)","def centroids(img_segm):\n m = np.amax(img_segm)\n xs = np.zeros(m)\n ys = np.zeros(m)\n \n for i in range(0,m):\n pos_list = np.where(img_segm==i+1)\n xs[i] = np.mean(pos_list[0])\n ys[i] = np.mean(pos_list[1])\n return xs,ys","def get_min_across_splits_continuous(\n arr: np.ndarray, y: np.ndarray, splits: np.ndarray, eval_func: Callable\n ):\n n = len(splits)\n if n > 500:\n # If many split points, use some threading\n with multiprocessing.Pool(processes=8) as p:\n # Get evaluation scores across all the splits\n post_split_evals = dict(\n zip(\n range(len(splits)),\n p.starmap(\n BaseTree.get_split_goodness_fit_continuous,\n zip([arr] * n, [y] * n, splits, [eval_func] * n),\n ),\n )\n )\n p.close()\n else:\n # If not too many split points, get scores across all splits\n post_split_evals = dict(\n zip(\n range(len(splits)),\n map(\n lambda x: BaseTree.get_split_goodness_fit_continuous(*x),\n zip([arr] * n, [y] * n, splits, [eval_func] * n),\n ),\n )\n )\n # Get the minimum split based on gain ratio\n min_eval = min(\n post_split_evals,\n key=lambda x: pipe(\n post_split_evals.get(x),\n lambda results: results[0] / results[1], # entropy / intrinsic value\n ),\n )\n\n # Return the best split and the splits scores\n return (splits[min_eval], *post_split_evals.get(min_eval))","def midpoint(point1, point2):\n\n x, y = (int((point1[0] + point2[0]) / 2), int((point1[1] + point2[1]) / 2))\n return (x, y)","def centroids(img_segm):\n m = int(np.amax(img_segm))\n xs = np.zeros(m)\n ys = np.zeros(m)\n \n for i in range(0,m):\n pos_list = np.where(img_segm==i+1)\n xs[i] = np.mean(pos_list[0])\n ys[i] = np.mean(pos_list[1])\n return xs,ys","def _best_split(cls, X, y):\n n = X.shape[0]\n num_feature = X.shape[1]\n y_types = np.unique(y)\n\n # initialize\n min_score = float(n)\n feature_idx = None\n best_theta = None\n best_idx = None\n\n for feature_idx in xrange(num_feature):\n # counter for y\n cumulate_y = Counter()\n rest_y = Counter()\n for y_type in y_types:\n cnt = np.where(y == y_type)[0].shape[0]\n rest_y[y_type] = cnt\n\n # sorted data\n sorted_idx = np.argsort(X[:, feature_idx])\n sorted_X = np.copy(X)\n sorted_y = np.copy(y)\n sorted_X = sorted_X[sorted_idx]\n sorted_y = sorted_y[sorted_idx]\n #print \"_best_split:\", sorted_X.shape, sorted_y.shape\n\n for idx in xrange(n-1):\n theta = (sorted_X[idx, feature_idx] + sorted_X[idx + 1, feature_idx]) / 2\n y_label = sorted_y[idx]\n cumulate_y[y_label] += 1\n rest_y[y_label] -= 1\n left_cnt = sum(cumulate_y.values())\n right_cnt = sum(rest_y.values())\n w_1 = left_cnt * cls._gini_index(cumulate_y.values())\n w_2 = right_cnt * cls._gini_index(rest_y.values())\n score = w_1 + w_2\n if score < min_score:\n min_score = score\n best_theta = theta\n best_idx = feature_idx\n #print('new min score: %.3f' % score)\n #print('feature: %d, theta: %.3f' % (best_idx, best_theta))\n #print('left: %d, right: %d' % (left_cnt, right_cnt))\n print('feature: %d, theta: %.3f' % (best_idx, best_theta))\n return (best_idx, best_theta)","def _best_split(cls, X, y):\n n = X.shape[0]\n num_feature = X.shape[1]\n y_types = np.unique(y)\n\n # initialize\n min_score = float(n)\n feature_idx = None\n best_theta = None\n best_idx = None\n\n for feature_idx in xrange(num_feature):\n # counter for y\n cumulate_y = Counter()\n rest_y = Counter()\n for y_type in y_types:\n cnt = np.where(y == y_type)[0].shape[0]\n rest_y[y_type] = cnt\n\n # sorted data\n sorted_idx = np.argsort(X[:, feature_idx])\n sorted_X = np.copy(X)\n sorted_y = np.copy(y)\n sorted_X = sorted_X[sorted_idx]\n sorted_y = sorted_y[sorted_idx]\n #print \"_best_split:\", sorted_X.shape, sorted_y.shape\n\n for idx in xrange(n-1):\n theta = (sorted_X[idx, feature_idx] + sorted_X[idx + 1, feature_idx]) / 2\n y_label = sorted_y[idx]\n cumulate_y[y_label] += 1\n rest_y[y_label] -= 1\n left_cnt = sum(cumulate_y.values())\n right_cnt = sum(rest_y.values())\n w_1 = left_cnt * cls._gini_index(cumulate_y.values())\n w_2 = right_cnt * cls._gini_index(rest_y.values())\n score = w_1 + w_2\n if score < min_score:\n min_score = score\n best_theta = theta\n best_idx = feature_idx\n #print('new min score: %.3f' % score)\n #print('feature: %d, theta: %.3f' % (best_idx, best_theta))\n #print('left: %d, right: %d' % (left_cnt, right_cnt))\n print('feature: %d, theta: %.3f' % (best_idx, best_theta))\n return (best_idx, best_theta)","def segement_divide(pts,step=0.10, offset_x=0.01, offset_y=0.0):\n\n # Select the x and y of the points\n n = len(pts)\n \n z = pts[0][2]\n \n points_plane = [] \n points_x = []\n paint_point = []\n\n for i in range(n):\n points_plane.append([pts[i][0], pts[i][1]])\n \n # Sorted the list according to x \n points_plane.sort(key=lambda x:x[0])\n\n # Segment the points according to x \n counter = 0 # Count the interval\n x_min = points_plane[0][0]\n x_max = points_plane[n-1][0]\n\n # The whole interval that needs to be divided\n upper = x_max + offset_x\n lower = x_min - offset_x\n lower_bound = lower\n \n # Set each segement's lower and upperbound\n while (lower_bound + step <= upper): \n # The break condition will be lower_bound > upper - step\n upper_bound = lower_bound + step\n\n # Find the index between lower bound and upper bound\n # First, find the index which x >= lower bound\n index = 0\n \n while (points_plane[index][0] < lower_bound): \n index = index + 1 # The index of the first point in the interval\n \n # If there is at least one point in the [lower_bound, upper_bound]\n if (points_plane[index][0] <= upper_bound): \n\n x_start = points_plane[index][0]\n y_max = points_plane[index][1]\n y_min = points_plane[index][1]\n \n while (points_plane[index][0] <= upper_bound): \n # The break condition will be x[index] > upper bound or index = n - 1\n # Compute the y max and y min in this interval\n \n if points_plane[index][1] > y_max: \n y_max = points_plane[index][1]\n\n if points_plane[index][1] < y_min:\n y_min = points_plane[index][1]\n \n if index < n - 1:\n index = index + 1\n else:\n break\n # The index of the last point in the interval, when index < n-1\n \n x_end = points_plane[index][0]\n\n paint_point.append([lower_bound,y_max+offset_y,z]) \n paint_point.append([lower_bound,y_min-offset_y,z])\n points_x.append([x_start, x_end])\n \n counter = counter + 1\n\n # Update interval\n lower_bound = upper_bound - offset_x\n \n # Deal with the last interval\n lower_bound_last = upper - step\n index_last = 0\n counter = counter + 1\n while ((index_last < n) and (points_plane[index_last][0] < lower_bound_last)): \n # The first point in the last interval\n index_last = index_last + 1\n \n if (index_last < n): \n # There is at least one point in the last interval\n x_start_last = points_plane[index_last][0]\n y_max_last = points_plane[index_last][1]\n y_min_last = points_plane[index_last][1]\n\n while ((index_last)<n) and (points_plane[index_last][0] <= upper):\n\n if points_plane[index_last][1] > y_max_last: \n y_max_last = points_plane[index_last][1]\n \n if points_plane[index_last][1] < y_min_last:\n y_min_last = points_plane[index_last][1]\n\n index_last = index_last + 1\n \n index_last = index_last - 1 # The index of the last point in the interval\n \n paint_point.append([lower_bound_last, y_max_last+offset_y, z])\n paint_point.append([lower_bound_last, y_min_last-offset_y, z])\n# paint_point.append([upper, y_max_last+offset_y, z])\n# paint_point.append([upper, y_min_last-offset_y, z])\n# return trans_to_end(paint_point)\n return paint_point","def find_split(self, X, y):\n choices = y.size\n if choices <= 1:\n return None, None\n\n # find the number of each option in the current node.\n options_parent = [np.sum(y == c) for c in range(self.num_outcomes)]\n\n # find the gini of current node.\n best_gini = 1.0 - sum((n / choices) ** 2 for n in options_parent)\n best_idx, best_split = None, None\n\n # loop through the features to get splits and options.\n for idx in range(self.num_features):\n splits, options = zip(*sorted(zip(X[:, idx], y)))\n\n num_left = [0] * self.num_outcomes\n num_right = options_parent.copy()\n for i in range(1, choices):\n c = options[i - 1]\n num_left[c] += 1\n num_right[c] -= 1\n gini_left = 1.0 - sum(\n (num_left[x] / i) ** 2 for x in range(self.num_outcomes)\n )\n gini_right = 1.0 - sum(\n (num_right[x] / i) ** 2 for x in range(self.num_outcomes)\n )\n\n gini = (i * gini_left + (choices - i) * gini_right) / choices\n\n if splits[i] == splits[i - 1]:\n continue\n\n if gini < best_gini:\n best_gini = gini\n best_idx = idx\n best_split = (splits[i] + splits[i - 1]) / 2\n\n return best_idx, best_split","def detect_splits(self):\n logg.info(' abstracted graph will have {} nodes'.format(self.n_splits+1))\n indices_all = np.arange(self.X.shape[0], dtype=int)\n segs = [indices_all]\n if False: # this is safe, but not compatible with on-the-fly computation\n tips_all = np.array(np.unravel_index(np.argmax(self.Dchosen), self.Dchosen.shape))\n else:\n if self.iroot is not None:\n tip_0 = np.argmax(self.Dchosen[self.iroot])\n else:\n tip_0 = np.argmax(self.Dchosen[0]) # just a random index, here fixed to \"0\"\n tips_all = np.array([tip_0, np.argmax(self.Dchosen[tip_0])])\n # we keep a list of the tips of each segment\n segs_tips = [tips_all]\n if self.clusters_precomputed_names:\n self.segs_names_original = [', '.join(self.clusters_precomputed_names)]\n segs_undecided = [True]\n segs_adjacency = [[]]\n segs_distances = np.zeros((1, 1))\n segs_adjacency_nodes = [{}]\n # logg.info(' do not consider groups with less than {} points for splitting'\n # .format(self.min_group_size))\n for ibranch in range(self.n_splits):\n if self.clusters == 'unconstrained_segments':\n iseg, new_tips = self.select_segment(segs, segs_tips, segs_undecided)\n if iseg == -1:\n logg.info('... partitioning converged')\n break\n logg.info('... branching {}:'.format(ibranch + 1),\n 'split group', iseg)\n segs_distances = self.do_split(segs, segs_tips,\n segs_undecided,\n segs_adjacency,\n segs_distances,\n iseg, new_tips)\n else:\n logg.msg(' split', ibranch + 1, v=4)\n stop, segs_distances = self.do_split_constrained(segs, segs_tips,\n segs_adjacency,\n segs_adjacency_nodes,\n segs_distances)\n if stop: break\n\n # segments\n self.segs = segs\n self.segs_tips = segs_tips\n self.segs_sizes = []\n for iseg, seg in enumerate(self.segs): self.segs_sizes.append(len(seg))\n\n # the full, unscaled adjacency matrix\n self.segs_adjacency_full_attachedness = 1/segs_distances\n # if self.attachedness_measure == 'connectedness':\n # norm = np.sqrt(np.multiply.outer(self.segs_sizes, self.segs_sizes))\n # self.segs_adjacency_full_attachedness /= norm\n self.segs_adjacency_full_confidence, self.segs_adjacency_tree_confidence \\\n = self.compute_adjacency_confidence(\n self.segs_adjacency_full_attachedness,\n segs_adjacency,\n self.tree_based_confidence)\n np.fill_diagonal(self.segs_adjacency_full_attachedness, 0)","def midpoint(f, x0, h):\n return 2.0*h*f(x0+h);","def getSplit(self):\n b_index, b_value, b_score, b_groups = 999, 999, 999, None\n for j in range(len(self[0]) - 1):\n for i in range(len(self)):\n groups = self.splitAttribute(j, self[i][j]) # lit, big\n gini = self.giniIndex(groups)\n if gini < b_score and (j, \"%.1f\" % self[i][j]) not in self.atr:\n b_index, b_value, b_score, b_groups = j, self[i][\n j], gini, groups\n return b_index, b_value, b_groups, b_score","def fit(self, data, targets):\n # update these three\n self.idx = 0\n self.val = None\n self.left = None\n self.right = None\n ### YOUR CODE HERE\n # i have added a slow and a fast version\n \n num_points, num_features = data.shape\n # print('num points, num_features', num_points, num_features)\n \n def feat_score(feat_idx):\n feat = data[:, feat_idx].copy()\n perm = np.argsort(feat)\n s_feat = feat[perm]\n s_targets = targets[perm]\n target_var = ((s_targets - s_targets.mean())**2).sum()\n s_left, s_right = sum_squares(s_targets)\n def score(idx, _vals):\n ## slow version\n #left = _vals[0:idx]\n #right = _vals[idx:]\n #assert len(left) + len(right) == len(_vals), (len(left), len(right), len(_vals))\n #left_mean = np.mean(left)\n #right_mean = np.mean(right)\n #left_error = np.sum((left-left_mean)**2)\n #assert np.allclose(left_error, s_left[idx]) \n #right_error = np.sum((right-right_mean)**2)\n #assert np.allclose(right_error, s_right[idx])\n # return left_error+right_error\n # fast version\n return s_left[idx] + s_right[idx]\n # score for every split\n scores = np.array([score(x, s_targets) for x in range(0, num_points)])\n assert scores.min() <= target_var, target_var\n best_score_idx = np.argmin(scores)\n best_score = scores[best_score_idx]\n val = s_feat[best_score_idx]\n # print('best score', feat_idx, best_score, best_score_idx, val, s_feat[best_score_idx+1])\n \n return best_score, {'val': val, \n 'left': np.mean(s_targets[:best_score_idx]), \n 'right': np.mean(s_targets[best_score_idx:])\n } \n\n split_scores = []\n for f in range(0, num_features):\n total_score, _params = feat_score(f)\n split_scores.append(total_score)\n # print('score of {0} - {1}'.format(feat_names[f], total_score))\n # print('feature scores:', np.array(split_scores))\n best_feat = np.argmin(split_scores)\n best_score = split_scores[best_feat]\n # print('Best Feature idx: {0} - Best Cost: {1}'.format(best_feat, best_score))\n score_again, params = feat_score(best_feat)\n # print('double check score', score_again, best_score)\n self.idx = best_feat\n self.val = params['val']\n self.left = params['left']\n self.right = params['right']\n print(\"idx={}, val={}, left={}, right={}\".format(self.idx, self.val, self.left, self.right))\n assert not np.isnan(self.left)\n assert not np.isnan(self.right)\n ### END CODE","def findMaxCrossingSubarray(self, array, low, mid, high):\n left_index = 0\n left_sum = float(\"-inf\")\n temp_sum = 0\n for i in range(mid-1, low-1, -1):\n temp_sum += array[i]\n if temp_sum > left_sum:\n left_sum = temp_sum\n left_index = i\n right_index = 0\n right_sum = float(\"-inf\")\n temp_sum = 0\n for i in range(mid, (high + 1)):\n temp_sum += array[i]\n if temp_sum > right_sum:\n right_sum = temp_sum\n right_index = i\n return (left_index, right_index, left_sum + right_sum)","def segement_divide(pts,step=0.10, offset_x=0.01, offset_y=0.01):\n\n # Select the x and y of the points\n n = len(pts)\n \n z = 0.0\n \n points_plane = [] \n points_x = []\n paint_point = []\n\n for i in range(n):\n points_plane.append([pts[i][0], pts[i][1]])\n \n # Sorted the list according to x \n points_plane.sort(key=lambda x:x[0])\n\n # Segment the points according to x \n counter = 0 # Count the interval\n x_min = points_plane[0][0]\n x_max = points_plane[n-1][0]\n\n # The whole interval that needs to be divided\n upper = x_max + offset_x\n lower = x_min - offset_x\n lower_bound = lower\n \n # Set each segement's lower and upperbound\n while (lower_bound + step <= upper): \n # The break condition will be lower_bound > upper - step\n upper_bound = lower_bound + step\n\n # Find the index between lower bound and upper bound\n # First, find the index which x >= lower bound\n index = 0\n \n while (points_plane[index][0] < lower_bound): \n index = index + 1 # The index of the first point in the interval\n \n # If there is at least one point in the [lower_bound, upper_bound]\n if (points_plane[index][0] <= upper_bound): \n\n x_start = points_plane[index][0]\n y_max = points_plane[index][1]\n y_min = points_plane[index][1]\n \n while (points_plane[index][0] <= upper_bound): \n # The break condition will be x[index] > upper bound or index = n - 1\n # Compute the y max and y min in this interval\n \n if points_plane[index][1] > y_max: \n y_max = points_plane[index][1]\n\n if points_plane[index][1] < y_min:\n y_min = points_plane[index][1]\n \n if index < n - 1:\n index = index + 1\n else:\n break\n # The index of the last point in the interval, when index < n-1\n \n x_end = points_plane[index][0]\n\n paint_point.append([lower_bound,y_max+offset_y,z]) \n paint_point.append([lower_bound,y_min-offset_y,z])\n points_x.append([x_start, x_end])\n \n counter = counter + 1\n\n # Update interval\n lower_bound = upper_bound - offset_x\n \n # Deal with the last interval\n lower_bound_last = upper - step\n index_last = 0\n counter = counter + 1\n while ((index_last < n) and (points_plane[index_last][0] < lower_bound_last)): \n # The first point in the last interval\n index_last = index_last + 1\n \n if (index_last < n): \n # There is at least one point in the last interval\n x_start_last = points_plane[index_last][0]\n y_max_last = points_plane[index_last][1]\n y_min_last = points_plane[index_last][1]\n\n while ((index_last)<n) and (points_plane[index_last][0] <= upper):\n\n if points_plane[index_last][1] > y_max_last: \n y_max_last = points_plane[index_last][1]\n \n if points_plane[index_last][1] < y_min_last:\n y_min_last = points_plane[index_last][1]\n\n index_last = index_last + 1\n \n index_last = index_last - 1 # The index of the last point in the interval\n \n paint_point.append([lower_bound_last, y_max_last+offset_y, z])\n paint_point.append([lower_bound_last, y_min_last-offset_y, z])\n# paint_point.append([upper, y_max_last+offset_y, z])\n# paint_point.append([upper, y_min_last-offset_y, z])\n# return trans_to_end(paint_point)\n return paint_point","def __call__(self, features):\n minmax_f = []\n if self.a == 0:\n self.minf = []\n self.maxf = []\n for i in range(len(features)):\n if i == 0:\n for j in range(len(features[i])):\n self.minf.append(features[i][j])\n self.maxf.append(features[i][j])\n else:\n for j in range(len(features[i])):\n if self.minf[j] > features[i][j]:\n self.minf[j] = features[i][j]\n if self.maxf[j] < features[i][j]:\n self.maxf[j] = features[i][j]\n for i in range(len(features)):\n temp = [] \n for j in range(len(features[i])):\n x = features[i][j]\n if (self.maxf[j] - self.minf[j]) != 0:\n x = (x - self.minf[j])/(self.maxf[j] - self.minf[j])\n \n else:\n x = (x - self.minf[j])\n temp.append(x)\n minmax_f.append(temp)\n self.a = 1\n elif self.a == 1:\n for i in range(len(features)):\n temp = [] \n for j in range(len(features[i])):\n x = features[i][j]\n if (self.maxf[j] - self.minf[j]) != 0:\n x = (x - self.minf[j])/(self.maxf[j] - self.minf[j])\n \n else:\n x = (x - self.minf[j])\n temp.append(x)\n minmax_f.append(temp)\n return minmax_f\n raise NotImplementedError","def mid_point(self, vector):\n return self.eval_2pts(vector, 0.5)","def _split_between_values(X, permuted, low, high):\n gt_low = permuted >= low\n lt_high = permuted < high\n mask = gt_low & lt_high\n\n # Get the sparsified matrices (mask gets zeroed, so use inverse)\n in_range = _sparsify_from_mask(X, ~mask)\n outside_range = _sparsify_from_mask(X, mask)\n return in_range, outside_range","def _extract_shape(idx, x, j, cur_center, normalize=True):\r\n _a = []\r\n for i in range(len(idx)):\r\n if idx[i] == j:\r\n if cur_center.sum() == 0:\r\n opt_x = x[i]\r\n else:\r\n _, opt_x = _sbd(cur_center, x[i])\r\n _a.append(opt_x)\r\n a = np.array(_a)\r\n\r\n if len(a) == 0:\r\n return np.zeros((1, x.shape[1]))\r\n columns = a.shape[1]\r\n if normalize:\r\n y = zscore(a, axis=1, ddof=1)\r\n s = np.dot(y.transpose(), y)\r\n\r\n p = np.empty((columns, columns))\r\n p.fill(1.0/columns)\r\n p = np.eye(columns) - p\r\n\r\n m = np.dot(np.dot(p, s), p)\r\n _, vec = eigh(m)\r\n else: \r\n s = np.dot(a.transpose(), a)\r\n m = s \r\n _, vec = eigh(m)\r\n \r\n centroid = vec[:, -1]\r\n finddistance1 = math.sqrt(((a[0] - centroid) ** 2).sum())\r\n finddistance2 = math.sqrt(((a[0] + centroid) ** 2).sum())\r\n\r\n if finddistance1 >= finddistance2:\r\n centroid *= -1\r\n \r\n return zscore(centroid, ddof=1) if normalize else centroid","def get_midpoint(half_distance: int, steps: [(int, str, str)]) -> (str, str):\r\n cur_distance = 0\r\n cur_step = 0\r\n while(cur_distance + steps[cur_step][0] <= half_distance):\r\n cur_distance += steps[cur_step][0]\r\n cur_step += 1\r\n\r\n left_over_distance = half_distance - cur_distance\r\n\r\n # lat, lng\r\n startpos = (steps[cur_step][1]['lat'],steps[cur_step][1]['lng'])\r\n endpos = (steps[cur_step][2]['lat'],steps[cur_step][2]['lng'])\r\n lat_length = endpos[0] - startpos[0]\r\n lng_length = endpos[1] - startpos[1]\r\n\r\n\r\n # get angle in radians\r\n angle = math.atan(lng_length/lat_length)\r\n\r\n if (endpos[0] > startpos[0] and endpos[1] > startpos[1]) or \\\r\n (endpos[0] < startpos[0] and endpos[1] > startpos[1]):\r\n return (startpos[0]+left_over_distance*math.cos(angle)/111000, startpos[1]+left_over_distance*math.sin(angle)/111000)\r\n return (startpos[0]-left_over_distance*math.cos(angle)/111000, startpos[1]-left_over_distance*math.sin(angle)/111000)","def d_midpoint(edge):\n v0, v1 = EDGES[edge]\n v0_pos = VERTICES[v0]\n v1_pos = VERTICES[v1]\n return ((x+y) for (x,y) in zip(v0_pos, v1_pos))","def best_split(self):\r\n best_splits = [[0, None, None]]\r\n impurity, best_S, best_xj = 0, None, None\r\n \r\n for xj in self.x_names:\r\n for S in self.potential_splits(xj):\r\n ir = float(self.impurity_reduction(xj, S))\r\n if ir > impurity:\r\n impurity, best_S, best_xj = ir, S, xj\r\n best_splits.append([S, xj])\r\n else: \r\n pass\r\n \r\n return best_S, best_xj","def find_approx_fb(self,min_offset,max_offset,min_cdp,max_cdp,offset_spacing,n_split=100):\n fbs=np.zeros((self.dataset['pred_avg'].shape[0],1))\n min_offset=(min_offset+offset_spacing)*self.scalar_offset\n max_offset=(max_offset-offset_spacing)*self.scalar_offset\n offsets=np.arange(min_offset,max_offset,offset_spacing*self.scalar_offset)\n for i,coffset in enumerate(offsets):\n print('Working on central offset:\\t{}'.format(coffset/self.scalar_offset))\n obin_trcs=np.where(np.logical_and(self.dataset['cdp'][:]<=max_cdp,np.logical_and(self.dataset['cdp'][:]>=min_cdp,np.logical_and(self.dataset['offset'][:]>=coffset-offset_spacing,self.dataset['offset'][:]<coffset+offset_spacing))))[0]\n tmp1=np.array_split(obin_trcs,n_split) \n if len(obin_trcs)>10:\n for k,l in enumerate(tmp1):\n tmp0=self.dataset['pred_avg'][list(tmp1[k]),:]\n tmp2=np.sum(tmp0,axis=0)\n tmp2=np.where(tmp2[:]==np.amax(tmp2))[0]\n for m,n in enumerate(tmp1[k]):\n fbs[n]=np.int(tmp2)\n else:\n print('Not enough traces in a splitted offset bin')","def middle(self):\n return (self.lo+self.hi)/2","def get_next_split ( self, feature_matrix: np.ndarray, target_array: np.ndarray, tree_split: TreeSplits):\n # If only 1 y value, make a leaf node\n if len ( set ( target_array ) ) == 1:\n tree_split.updateTreeValues (\n feature_column = None,\n feature_value = None,\n node_type = None,\n nodes = {},\n children = target_array,\n )\n return tree_split\n\n # Get the presplit entropy\n presplit_entropy = self.evaluate_function ( target_array )\n\n column_values = {}\n for k, v in self.map_column_node_type.items():\n # If there's only one value in feature matrix \"X\", set the split value to infinity\n if len ( set ( feature_matrix [ :, k ] ) ) == 1:\n value = np.inf\n split = None\n class_ratios = 1\n elif v == \"continuous\":\n # Get the best possible continuous split for the column\n split, value, class_ratios = self.get_optimal_continuous_feature_split (\n feature_matrix = feature_matrix, target_array = target_array, feature_column = k\n )\n else:\n # Get the split value for the discrete column\n value, class_ratios = self.get_optimal_discrete_feature_split (\n feature_matrix = feature_matrix, target_array = target_array, feature_column = k\n )\n split = None\n\n column_values [ k ] = ( split, value, class_ratios )\n\n # Get the column with the largest gain ratio\n col_idx_with_min_value = max (\n column_values,\n key = lambda x: ( presplit_entropy - column_values.get ( x ) [ 1 ] )\n / column_values.get ( x ) [ 2 ],\n )\n\n # If stopping criteria are met or all splits are infinite, terminate the process\n if (\n self.early_stopping_comparison (\n column_values.get ( col_idx_with_min_value ) [ 1 ], self.early_stopping_value\n )\n ) or not np.isfinite ( column_values.get ( col_idx_with_min_value ) [ 1 ] ):\n self.get_terminal_node (\n feature_column = col_idx_with_min_value,\n feature_value = column_values [ col_idx_with_min_value ] [ 0 ],\n node = tree_split,\n feature_matrix = feature_matrix ,\n target_array = target_array,\n )\n return tree_split\n\n # If the best split is continuous, add a continuous node\n if self.map_column_node_type.get ( col_idx_with_min_value ) == \"continuous\":\n return self.get_continuous_node (\n feature_column = col_idx_with_min_value,\n feature_value = column_values [col_idx_with_min_value ] [ 0 ],\n feature_matrix = feature_matrix,\n target_array = target_array,\n node = tree_split,\n )\n\n # Otherwise, add a discrete node.\n else:\n return self.get_discrete_node (\n feature_matrix = feature_matrix,\n target_array = target_array,\n feature_value = column_values [ col_idx_with_min_value ] [ 0 ],\n feature_column = col_idx_with_min_value,\n node = tree_split,\n )\n # End get_next_split","def findBestValueSplitByGini(self, data, structure, colIndex):\n minGini, bestSplit = 1, []\n for i in range(0, len(data)-1):\n split = (float(data[i][colIndex]) + float(data[i+1][colIndex])) / 2\n giniSplit = self.calcGiniSplitBySplitValue(data, structure, colIndex, split)\n if giniSplit <= minGini:\n minGini = giniSplit\n bestSplit = [split, giniSplit]\n return bestSplit","def find_split(data):\n ret = {\"router\": None, \"split_point\": None, \"entropy\": get_entropy(data[:, 7])}\n\n # Create array of unique datapoints\n split_points_list = list()\n\n for i in range(data.shape[1] - 1):\n unique_signal = np.unique(data[:, i])\n split_points = list()\n for j in range(len(unique_signal) - 1):\n split_points.append((unique_signal[j]+unique_signal[j+1])/2)\n split_points_list.append(split_points)\n\n # Split data by split points and calculate entropy\n for feature in range(len(split_points_list)):\n for i in range(len(split_points_list[feature])):\n data_l, data_r = split_data(data, feature + 1, split_points_list[feature][i])\n entropy = get_entropy(data_l[:, 7], data_r[:, 7])\n if entropy < ret[\"entropy\"]:\n ret[\"entropy\"] = entropy\n ret[\"router\"] = feature + 1\n ret[\"split_point\"] = split_points_list[feature][i]\n\n return ret[\"router\"], ret[\"split_point\"], split_data(data, ret[\"router\"], ret[\"split_point\"])","def determine_best_split(data, potential_splits, mltask):\n\n first_iteration = True\n for column_index in potential_splits:\n for value in potential_splits[column_index]:\n data_below,data_above = split_data(data, column_index, value)\n \n if mltask == 'regression':\n current_overall_metric = calculate_overall_metric(data_below, data_above, metric_function = calculate_mse)\n \n # classification\n else:\n current_overall_metric = calculate_overall_metric(data_below, data_above, metric_function = calculate_entropy)\n \n \n if first_iteration or current_overall_metric <= best_overall_metric:\n first_iteration = False\n \n best_overall_metric = current_overall_metric\n best_split_column = column_index\n best_split_value = value\n \n \n return best_split_column,best_split_value","def centroids2(img_segm,liste):\n m = len(liste)\n xs = np.zeros(m)\n ys = np.zeros(m)\n j=0\n for elt in liste:\n pos_list = np.where(img_segm==elt)\n xs[j] = np.mean(pos_list[0])\n ys[j] = np.mean(pos_list[1])\n j+=1\n return xs,ys","def _split_threshold(self, node):\n\n # define the score to improve upon\n if self.n_clusters >= self.min_leaves and node.size <= self.max_leaf_size:\n # split only if min(children scores) > node.score\n force_split = False\n best_score = node.score\n else:\n # force split: just take the best (even if children are worse)\n force_split = True\n best_score = None\n\n left, right = None, None\n\n # iterate over embedding dimensions (first ones are more reliable)\n # up to max_n_vec (included), until we found an improving split\n for _vec in range(self.n_vec):\n\n # get the candidate thresholds along this dimension\n threshs = self._get_candidate_thresholds(node, _vec)\n\n # look for an improving best split along this eigenvector\n for _t in threshs:\n # compute the split\n below_thresh = self.E[node.ids, _vec] < _t\n _lids = node.ids[below_thresh]\n _rids = node.ids[np.logical_not(below_thresh)]\n # check if the tubes are not too small\n _nl, _nr = len(_lids), len(_rids)\n is_valid = _nl >= self.min_leaf_size and _nr >= self.min_leaf_size\n if is_valid:\n # compute the score of the new tubes only\n _sl = self.get_tube_score(_lids)\n _sr = self.get_tube_score(_rids)\n # get the score of this split\n split_score = min(_sl, _sr)\n if best_score is None or split_score > best_score:\n # better split\n best_score = split_score\n node.has_children = True\n node.thresh = _t\n left = SpectralNode(\n _lids, _vec, score=_sl, name=node.name + \"0\")\n right = SpectralNode(\n _rids, _vec, score=_sr, name=node.name + \"1\")\n\n # check stopping criterion\n if node.has_children:\n # we found an improving split\n if _vec > 0 or not force_split:\n # found an improving non-forced split: stop here\n break\n\n return left, right","def minimum_spanning_arborescence(sol):","def root_midpoint(self):\n node1, node2, distance = self.find_middle_point()\n self.root_nodes(node1, node2, distance)","def find_nearest_neighbours_SURF(averageDistance,inst,distanceArray,maxInst): \r\n NN=[]\r\n min_indices=[] \r\n\r\n for j in range(maxInst):\r\n if inst != j:\r\n locator = [inst,j]\r\n locator = sorted(locator, reverse=True) #Access corect half of table (result of removed table redundancy)\r\n d = distanceArray[locator[0]][locator[1]]\r\n if d<averageDistance:\r\n min_indices.append(j)\r\n \r\n for j in range(len(min_indices)):\r\n NN.append(min_indices[j])\r\n \r\n return NN","def split(self,X,y=None):\n all_idx = pd.Series(np.arange(X.shape[0])) \n mbrg = int(X.shape[0]*self.embargo_pct)\n test_starts=[(i[0],i[-1]+1) for i in np.array_split(all_idx.values,self.n_splits)]\n for i, j in test_starts:\n t0 = all_idx.index[i] # start of test set\n test_indices = all_idx.values[i:j]\n maxT1Idx = all_idx.index.searchsorted(all_idx[test_indices].max())\n train_indices = all_idx.index.searchsorted(all_idx[all_idx<=t0].index)\n if maxT1Idx < X.shape[0]: \n train_indices=np.concatenate((train_indices,all_idx[maxT1Idx+mbrg:]))\n yield train_indices,test_indices","def relevant_indexes(data, min_threshold):\n\n start_index = 1\n end_index = len(data) - 1\n\n for i in range(len(data)):\n if data[i] > min_threshold:\n start_index = i\n break\n\n for i in range(len(data)):\n if data[::-1][i] > min_threshold:\n end_index = i\n break\n\n return start_index, end_index","def get_best_split(rows):\n best_gain = 0\n best_question = None\n current_impurity = get_gini(rows)\n n_features = len(rows[0])\n\n for col in range(n_features):\n\n for row in rows:\n question = Question(col, row[col])\n true_rows, false_rows = partition(rows, question)\n\n if len(true_rows) == 0 or len(false_rows) == 0:\n break\n\n question_gain = get_info_gain(true_rows, false_rows, current_impurity)\n\n if question_gain >= best_gain:\n best_gain = question_gain\n best_question = question\n\n print(best_gain)\n print(best_question)\n return best_gain, best_question","def _get_closest(centers, features):\n pred_labels = []\n\n features = features\n for feature in features:\n distances = End2End._dist(centers, feature)\n pred_labels.append(distances.argmin().item())\n\n return np.array(pred_labels)","def _get_end_points(self, segmented_instances, i, stats, idx):\n\n end_points=[]\n\n # find all points intersecting the bbox\n #(tl_x, th_y, width, height, area)\n label_num=i+1\n leftmost_x = stats['bbox'][i][cv2.CC_STAT_LEFT]\n topmost_y = stats['bbox'][i][cv2.CC_STAT_TOP]\n width = stats['bbox'][i][cv2.CC_STAT_WIDTH]\n height = stats['bbox'][i][cv2.CC_STAT_HEIGHT]\n bottom_most_y = topmost_y + height-1\n right_most_x = leftmost_x + width-1\n\n segmented_instances_copy=segmented_instances.copy()\n edge_points = np.zeros(segmented_instances.shape).astype(np.uint8)\n segs = np.zeros(segmented_instances.shape).astype(np.uint8)\n segs[segmented_instances==label_num]=255\n cv2.rectangle(segmented_instances_copy,(leftmost_x, topmost_y), (right_most_x, bottom_most_y), 150, 2)\n\n #Get all points for the current stem segment\n label_points = np.argwhere(segmented_instances.copy()==label_num)\n\n # upper points from (tl_x,th_y) to (th_x, th_y) that instersect with the upper edge of the bouding box\n upper_points = [i for i in label_points if i[0]==topmost_y and i[1]>=leftmost_x and i[1]<=right_most_x]\n x_pts, segs, edge_points = self._update_imgs_and_pt_list(upper_points, edge_points, segs, 1)\n center_upper_pts = sorted(self._get_centeroids(x_pts))\n\n # left side points from (tl_x, tl_y) to (tl_x, th_y) that instersect with the left edge of the bouding box\n left_points = [i for i in label_points if i[1]==leftmost_x and i[0]<=bottom_most_y and i[0]>=topmost_y]\n x_pts, segs, edge_points = self._update_imgs_and_pt_list(left_points, edge_points, segs, 0)\n center_left_pts = sorted(self._get_centeroids(x_pts))\n\n #right side points form (th_x, tl_y) to (th_x, th_y) that instersect with the right edge of the bouding box\n right_points = [i for i in label_points if i[1]==right_most_x and i[0]<=bottom_most_y and i[0]>=topmost_y]\n x_pts, segs, edge_points = self._update_imgs_and_pt_list(right_points, edge_points, segs, 0)\n center_right_pts = sorted(self._get_centeroids(x_pts))\n\n #bottom points from (tl_x, tl_y) to (th_x,tl_y)\n bottom_points = [i for i in label_points if i[1]>=leftmost_x and i[1]<=right_most_x and i[0]==bottom_most_y]\n x_pts, segs, edge_points = self._update_imgs_and_pt_list(bottom_points, edge_points, segs, 1)\n center_bottom_pts = sorted(self._get_centeroids(x_pts))\n\n # If there are corner edges, get the centroid of that\n center_x_lb, center_y_lb, center_left_pts, center_bottom_pts = self._get_corner_centers(center_left_pts, \\\n center_bottom_pts, bottom_most_y, leftmost_x)\n if (center_x_lb != None) and (center_y_lb != None):\n end_points.append([center_x_lb, center_y_lb])\n else:\n if len(center_left_pts)>0:\n for pt_idx in range(0, len(center_left_pts)):\n end_points.append([leftmost_x, center_left_pts[pt_idx]])\n if len(center_bottom_pts)>0:\n for pt_idx in range(0, len(center_bottom_pts)):\n end_points.append([center_bottom_pts[pt_idx], bottom_most_y])\n\n # If there are corner edges, get the centroid of that\n center_x_ur, center_y_ur, center_right_pts, center_upper_pts = self._get_corner_centers(center_right_pts, \\\n center_upper_pts, topmost_y, right_most_x)\n if (center_x_ur != None) and (center_y_ur != None):\n end_points.append([center_x_ur, center_y_ur])\n else:\n if len(center_right_pts)>0:\n for pt_idx in range(0, len(center_right_pts)):\n end_points.append([right_most_x, center_right_pts[pt_idx]])\n if len(center_upper_pts)>0:\n for pt_idx in range(0, len(center_upper_pts)):\n end_points.append([center_upper_pts[pt_idx], topmost_y])\n\n # If there are corner edges, get the centroid of that\n center_x_ul, center_y_ul, center_left_pts, center_upper_pts = self._get_corner_centers(center_left_pts, \\\n center_upper_pts, topmost_y, leftmost_x)\n if (center_x_ul != None) and (center_y_ul != None):\n end_points.append([center_x_ul, center_y_ul])\n else:\n if len(center_left_pts)>0:\n for pt_idx in range(0, len(center_left_pts)):\n end_points.append([leftmost_x, center_left_pts[pt_idx]])\n if len(center_upper_pts)>0:\n for pt_idx in range(0, len(center_upper_pts)):\n end_points.append([center_upper_pts[pt_idx], topmost_y])\n\n\n # If there are corner edges, get the centroid of that\n center_x_br, center_y_br, center_right_pts, center_bottom_pts = self._get_corner_centers(center_right_pts, \\\n center_bottom_pts, bottom_most_y, right_most_x)\n if (center_x_br != None) and (center_y_br != None):\n end_points.append([center_x_br, center_y_br])\n else:\n if len(center_right_pts)>0:\n for pt_idx in range(0, len(center_right_pts)):\n end_points.append([right_most_x, center_right_pts[pt_idx]])\n if len(center_bottom_pts)>0:\n for pt_idx in range(0, len(center_bottom_pts)):\n end_points.append([center_bottom_pts[pt_idx], bottom_most_y])\n\n #self.showme(segmented_instances_copy, 'bbox')\n\n return end_points","def splitArray(self, nums: List[int], m: int) -> int:\n l = max(nums)\n r = sum(nums)\n ans = r\n\n while l <= r:\n mid = (l + r) // 2\n range_sum = 0\n range_sum_count = 1\n for i in range(len(nums)):\n if (range_sum + nums[i] > mid):\n range_sum = nums[i]\n range_sum_count += 1\n else:\n range_sum += nums[i]\n if range_sum_count <= m:\n ans = min(ans, mid)\n r = mid - 1\n else:\n l = mid + 1\n return ans","def find_best_split(rows):\n best_gain = 0 # keep track of the best information gain\n best_question = None # keep train of the feature / value that produced it\n current_uncertainty = gini(rows)\n n_features = len(rows[0]) - 1 # number of columns\n #print(\"n_features:\", n_features)\n\n for col in range(1,n_features): # for each feature\n # for each iteration this is the set of all values of a specific column, eg, All pixels number 0\n values = set([row[col] for row in rows]) # unique values in the column\n for val in values: # for each value\n\n # Create a question object for each val under a column, holding the val and the col number\n question = Question(col, val)\n\n # try splitting the dataset\n true_rows, false_rows = partition(rows, question)\n\n # Skip this split if it doesn't divide the\n # dataset.\n if len(true_rows) == 0 or len(false_rows) == 0:\n continue\n\n # Calculate the information gain from this split\n gain = info_gain(true_rows, false_rows, current_uncertainty)\n\n # You actually can use '>' instead of '>=' here\n # but I wanted the tree to look a certain way for our\n # toy dataset.\n if gain >= best_gain:\n best_gain, best_question = gain, question\n\n return best_gain, best_question","def midpoint(self) -> Point:\n l = self._line.meet(infty_hyperplane(self.dim))\n return harmonic_set(*self.vertices, l)","def segment(self):\n start = self.alignment.matching_function_startpoint(self.idx)\n end = self.alignment.matching_function_endpoint(self.idx)\n return [start, end]","def get_point_of_interest(self):\n if self.point_of_interest == \"centroid\":\n return (round(float(self.kf.x[0][0]), 2), round(float(self.kf.x[1][0]), 2))\n elif self.point_of_interest == \"botmid\":\n x1, y1, x2, y2 = convert_x_to_bbox(self.kf.x)[0]\n x = (x2 + x1) / 2\n y = y2\n return (round(float(x), 2), round(float(y), 2))\n elif self.point_of_interest == \"topmid\":\n x1, y1, x2, y2 = convert_x_to_bbox(self.kf.x)[0]\n x = (x2 + x1) / 2\n y = y1\n return (round(float(x), 2), round(float(y), 2))\n else:\n print(\"point of interest not devised\")\n exit()","def split_data(data,split_column,split_value):\n split_column_value = data[:,split_column]\n type_of_feature = FEATURE_TYPE[split_column]\n\n if type_of_feature == 'continuous':\n data_below = data[split_column_value <= split_value]\n data_above = data[split_column_value > split_value]\n else:\n data_below = data[split_column_value == split_value]\n data_above = data[split_column_value != split_value]\n return data_below,data_above","def find_midpoint(start, end):\n mid = (start + end) / 2\n return int(mid)","def mid(self, line):\n return [(line.x1 + line.x2) // 2, (line.y1 + line.y2) // 2]","def get_splits(self) -> Dict[str, np.array]:\n\n return self.splits","def get_starting_point(self, Otrain, Ftrain, y):\n return self.get_curve_fmin(Otrain, Ftrain, [y])\n # xx = np.linspace(np.min(Otrain), np.max(Otrain), 50)\n # scores, xx = self.compute_scores(Otrain, Ftrain, y, xx)\n # bestScore = np.max(scores)\n # Ibest = np.where(scores == bestScore)[0]\n # x = xx[Ibest[0]]\n return x","def compute_splits(feature_df, target_col, max_num_splits):\n tree_estimator = DecisionTreeClassifier(max_leaf_nodes=max_num_splits+1,\n class_weight='balanced',\n random_state=1407)\n\n tree_estimator.fit(feature_df, target_col)\n thresholds = tree_estimator.tree_.threshold[tree_estimator.tree_.children_left != _tree.TREE_LEAF]\n return sorted(thresholds)","def findfeatures(xarr, farr, sl, sf, ws, mdiff=20, wdiff=20, sigma=5, niter=5,\n sections=3):\n\n # detect lines in the input spectrum and identify the peaks and peak values\n xp, xf = find_points(xarr, farr, kernal_size=sigma, sections=sections)\n\n # return no solution if no peaks were found\n if len(xp) == 0:\n return None\n\n # find the best match to the lines\n wp = findmatch(xarr, farr, xp, xf, sl, sf, ws, xlimit=mdiff, wlimit=wdiff)\n\n try:\n for i in range(len(xp)):\n if wp[i] > -1:\n pass\n except Exception as e:\n message = 'Unable to match line lists because %s' % e\n raise SpecError(message)\n return xp, wp","def mid_point(a: Point, b: Point) -> Point:\n return Point((a.x + b.x) / 2, (a.y + b.y) / 2)","def select_segment(self, segs, segs_tips, segs_undecided):\n scores_tips = np.zeros((len(segs), 4))\n allindices = np.arange(self.X.shape[0], dtype=int)\n for iseg, seg in enumerate(segs):\n # do not consider too small segments\n if segs_tips[iseg][0] == -1: continue\n # restrict distance matrix to points in segment\n if not isinstance(self.Dchosen, data_graph.OnFlySymMatrix):\n Dseg = self.Dchosen[np.ix_(seg, seg)]\n else:\n Dseg = self.Dchosen.restrict(seg)\n # map the global position to the position within the segment\n tips = [np.where(allindices[seg] == tip)[0][0]\n for tip in segs_tips[iseg]]\n # find the third point on the segment that has maximal\n # added distance from the two tip points\n dseg = Dseg[tips[0]] + Dseg[tips[1]]\n third_tip = np.argmax(dseg)\n new_tips = np.append(tips, third_tip)\n # compute the score as ratio of the added distance to the third tip,\n # to what it would be if it were on the straight line between the\n # two first tips, given by Dseg[tips[:2]]\n # if we did not normalize, there would be a danger of simply\n # assigning the highest score to the longest segment\n if 'bi' == self.flavor_develop:\n score = Dseg[new_tips[0], new_tips[1]]\n elif 'tri' == self.flavor_develop:\n score = dseg[new_tips[2]] / Dseg[new_tips[0], new_tips[1]] * len(seg)\n else:\n raise ValueError('unknown `self.flavor_develop`')\n score = len(seg) if self.choose_largest_segment else score # simply the number of points\n # self.choose_largest_segment = False\n logg.msg('... group', iseg, 'score', score, 'n_points', len(seg),\n '(too small)' if len(seg) < self.min_group_size else '', v=4)\n if len(seg) <= self.min_group_size: score = 0\n # write result\n scores_tips[iseg, 0] = score\n scores_tips[iseg, 1:] = new_tips\n iseg = np.argmax(scores_tips[:, 0])\n if scores_tips[iseg, 0] == 0: return -1, None\n new_tips = scores_tips[iseg, 1:].astype(int)\n return iseg, new_tips","def get_split_goodness_fit_continuous (\n feature_array: np.ndarray, target_array: np.ndarray, split: float, evaluate_function: Callable\n ):\n # Get above and below the split value\n above = feature_array >= split\n below = feature_array < split\n\n # Get weighted average evaluate_function on the splits\n n_above = np.sum ( above )\n above_eval = (\n evaluate_function ( target_array [ above ] ) * n_above / len ( target_array )\n ) # Weight = frac points in above\n below_eval = (\n evaluate_function ( target_array [ below ] ) * ( len ( target_array ) - n_above ) / len ( target_array )\n ) # Weight = frac points not in above\n\n # returns weighted sum of evaluate_function across splits & the gain ratio denominator\n return (\n above_eval + below_eval,\n -1\n * sum (\n map (\n lambda x: x * np.log ( x ),\n [ n_above / len ( target_array ), ( len ( target_array ) - n_above ) / len ( target_array ) ],\n )\n ),\n ) # End get_split_goodness_fit_continuous","def handle_singleton_ppn_candidate(pts, ppn_candidates):\n assert ppn_candidates.shape[0] == 1\n score = ppn_candidates[0][5:]\n label = np.argmax(score)\n dist = cdist(pts, ppn_candidates[:, :3])\n pt_near = pts[dist.argmin(axis=0)]\n pt_far = pts[dist.argmax(axis=0)]\n if label == 0:\n startpoint = pt_near.reshape(-1)\n endpoint = pt_far.reshape(-1)\n else:\n endpoint = pt_near.reshape(-1)\n startpoint = pt_far.reshape(-1)\n\n new_points = np.vstack([startpoint, endpoint])\n\n return new_points","def _find_split(self, X, y, n_features):\r\n splits_info = []\r\n\r\n # Select features to consider\r\n features = self._feature_selection.get_features(n_features, self._feature_prob)\r\n\r\n # Get candidate splits\r\n for feature_id in features:\r\n for split_value in compute_split_values(X[:, feature_id]):\r\n splits_info.append(\r\n compute_split_info(self._split_criterion, X, y, feature_id, split_value, self._min_samples_leaf))\r\n\r\n splits = []\r\n for split_info in splits_info:\r\n if split_info is not None:\r\n gain, feature_id, split_value = split_info\r\n split = Split(feature_id, value=split_value, gain=gain)\r\n splits.append(split)\r\n else:\r\n continue\r\n\r\n selected_split = self._split_chooser.get_split(splits)\r\n return selected_split","def get_avg_points(self):\n pass","def midleft(self):\n return (self.left, self.centery)","def mid(arr):\n\n \n arr_ln = len(arr)\n mid = arr_ln//2\n val = arr.pop(mid)\n\n return arr, val","def compute_midpoints(structure_centroids):\n\n from metadata import all_known_structures, singular_structures, convert_to_left_name, convert_to_right_name\n\n midpoints = {}\n for s in all_known_structures:\n if s in singular_structures:\n if s not in structure_centroids:\n continue\n c = np.array(structure_centroids[s])\n else:\n sl = convert_to_left_name(s)\n sr = convert_to_right_name(s)\n if sl not in structure_centroids or sr not in structure_centroids:\n continue\n c = (np.array(structure_centroids[sl]) + np.array(structure_centroids[sr]))/2\n midpoints[s] = c\n return midpoints"],"string":"[\n \"def midpoints(self):\\n return self.bins[:, 1]\",\n \"def split(self, X, y, feature_array):\\n n, p = X.shape\\n\\n best_gain = 0\\n best_split_point = 0\\n best_feature_id = -1\\n for feature_id in feature_array:\\n cur_gain, cur_split_point = self.find_best_split(\\n X[:, feature_id], y)\\n if cur_gain > best_gain - self.eps:\\n best_gain = cur_gain\\n best_split_point = cur_split_point\\n best_feature_id = feature_id\\n\\n assert(best_feature_id != -1)\\n\\n x = X[:, best_feature_id]\\n left_index = x < best_split_point\\n right_index = x >= best_split_point\\n\\n self.split_id = best_feature_id\\n self.split_val = best_split_point\\n\\n return (left_index, right_index)\",\n \"def get_valid_midpoints(arr: np.ndarray, y: np.ndarray):\\n # Get sorted indices\\n idxs = np.argsort(arr)\\n\\n # Get sorted feature array\\n sorted_arr = arr[idxs]\\n\\n # Get the differences between adjacent values\\n arr_diffs = np.diff(sorted_arr)\\n\\n # Get the midpoints\\n midpoints = sorted_arr[1:] - arr_diffs / 2\\n\\n # Get points where differences are greater than 0 (uniqueness) and y values are not the same\\n # See report for details on the latter part.\\n valid_midpoints = midpoints[np.bitwise_and(arr_diffs > 0, np.diff(y[idxs]) > 0)]\\n\\n return valid_midpoints\",\n \"def getSplit(self, array, left, right, epsilon):\\r\\n if epsilon < 10 ** (-6):\\r\\n return (left + right) / 2\\r\\n else:\\r\\n return self.getNoisyMedian(array, left, right, epsilon)\",\n \"def get_split(self,X,y):\\n \\n BEST_COL = 0\\n BEST_SPLIT =0\\n BEST_IMPUR = 99\\n for i,feature in enumerate(X.T):\\n arg_sort=np.argsort(feature) #Sort the feature for optimizing the find of splitting points\\n feature= feature[arg_sort]\\n y_sort = y[arg_sort]\\n splits = self.possible_splits(feature,y_sort) #Get \\n\\n impur,splits = self.test_split(feature,y_sort,splits) #Get impurity for splitting points\\n best_idx = np.argmin(impur)\\n best_impur = impur[best_idx]\\n \\n if best_impur==0.0: #Found perfect split, terminate\\n return(i,splits[best_idx])\\n elif best_impur<BEST_IMPUR:\\n BEST_IMPUR=best_impur\\n BEST_SPLIT=splits[best_idx]\\n BEST_COL=i\\n return (BEST_COL,BEST_SPLIT)\",\n \"def midpoint(self,i,f):\\n\\n summation = self.points[f, :] + self.points[i, :]\\n midploint = summation/2\\n x_mid = midploint[0]\\n y_mid = midploint[1]\\n\\n return x_mid,y_mid\",\n \"def get_optimal_continuous_feature_split (\\n self, feature_matrix: np.ndarray, target_array: np.ndarray, feature_column: int\\n ):\\n midpoints = BaseTree.get_valid_midpoints ( feature_array = feature_matrix [ :, feature_column ], target_array = target_array )\\n # If midpoints, get the best one\\n if len ( midpoints ) > 0:\\n return BaseTree.get_min_across_splits_continuous (\\n feature_array = feature_matrix [ :, feature_column ], target_array = target_array, splits = midpoints, evaluate_function = self.evaluate_function\\n )\\n\\n # If no split points, return inf (can't split here)\\n return ( 0, np.inf, 1 )\\n # End get_optimal_continuous_feature_split()\",\n \"def get_split(data):\\n \\\"\\\"\\\" gets the best feature, and best value \\\"\\\"\\\"\\n\\n best_feature = None\\n best_value = 0.0\\n columns = data.columns\\n gini_base = gini_impurity(data)\\n n_rows = len(data.index) # total number of rows of data before split\\n\\n # Fininding which split yields the best gini gain\\n max_gain = 0\\n\\n for i in range(len(columns)-1): # -1 b.c. class is final column\\n xs = data[columns[i]].unique() # get values to test\\n for x in xs: # test values\\n # split dataset\\n df_left = data[data[columns[i]] < x]\\n df_right = data[data[columns[i]] >= x]\\n\\n # get gini impurities\\n gini_left = gini_impurity(df_left)\\n gini_right = gini_impurity(df_right)\\n \\n\\n # Calculated weighted gini impurity\\n w_left = len(df_left.index) / n_rows\\n w_right = len(df_right.index) / n_rows\\n\\n w_gini = gini_left * w_left + gini_right * w_right\\n \\n\\n # Calculate gini gain (we want to minimize w_gini for the smallest impurity. Ideal split is perfect Left=c1, Right=c2)\\n # why not just find min w_gin instead of uding gini_gain and gini_base vaiables?\\n gini_gain = gini_base - w_gini\\n\\n # check if this is the best split so far, store values, update max_gini\\n if gini_gain > max_gain:\\n best_feature = columns[i]\\n best_value = x\\n max_gain = gini_gain\\n\\n df_left = data.loc[data[best_feature] < best_value]\\n df_right = data.loc[data[best_feature] >= best_value]\\n \\n\\n return best_feature, best_value, df_left, df_right\",\n \"def find_best_split(self, x, y):\\n\\n # check cornor case: all same x\\n n = y.size\\n\\n if all(x == x[0]):\\n return (0, amin(x) - self.eps)\\n\\n sort_index = argsort(x)\\n x_sorted = x[sort_index]\\n y_sorted = y[sort_index]\\n\\n # build potential split index array\\n split_index_array = array([i for i in range(1, n)\\n if x_sorted[i] != x_sorted[i - 1]\\n and y_sorted[i] != y_sorted[i - 1]])\\n\\n # split_index_array = linspace(\\n # 0, y.size, num=min(5, ceil(n / 5)), endpoint=False, dtype='int')\\n # split_index_array = split_index_array[1:]\\n\\n best_split_index = 0\\n best_gain = 0\\n h_x = self.cur_entropy\\n\\n for split_index in split_index_array:\\n left_entropy = self.entropy(y_sorted[:split_index])\\n right_entropy = self.entropy(y_sorted[split_index:])\\n h_xy = (split_index * left_entropy +\\n (n - split_index) * right_entropy) / n\\n cur_gain = h_x - h_xy\\n\\n if cur_gain > best_gain:\\n best_gain = cur_gain\\n best_split_index = split_index\\n\\n if best_split_index != 0:\\n best_split_point = (x_sorted[best_split_index] +\\n x_sorted[best_split_index - 1]) / 2\\n else:\\n best_split_point = x_sorted[best_split_index] - self.eps\\n\\n return (best_gain, best_split_point)\",\n \"def midpoint(self) -> Tuple[int, int]:\\n pass\",\n \"def midpoints(min_r_value, max_r_value, bin_size):\\n min_r = min_r_value + 0.5 * bin_size\\n max_r = max_r_value - 0.5 * bin_size\\n return np.arange(min_r, max_r, bin_size)\",\n \"def __find_best_split(self, x, y):\\n data = np.transpose(np.vstack((np.transpose(x), y)))\\n num_features = data.shape[1] - 1\\n\\n # initialise splitting rule components\\n integer_splitting_rule = None\\n feature_index_to_split = None\\n max_info_gain = 0\\n\\n # iterate over all the features and find best splits within these\\n for feature in range(num_features):\\n info_gain, split_int = self.__find_best_split_in_feature(\\n data[:, [feature, -1]])\\n if info_gain is None:\\n continue\\n # update max info gain so far as it iterates over features\\n if info_gain > max_info_gain:\\n max_info_gain = info_gain\\n feature_index_to_split = feature\\n integer_splitting_rule = int(split_int)\\n\\n return feature_index_to_split, integer_splitting_rule\",\n \"def get_optimal_continuous_feature_split(\\n self, X: np.ndarray, y: np.ndarray, feature_col: int\\n ):\\n midpoints = BaseTree.get_valid_midpoints(arr=X[:, feature_col], y=y)\\n # If midpoints, get the best one\\n if len(midpoints) > 0:\\n return BaseTree.get_min_across_splits_continuous(\\n arr=X[:, feature_col], y=y, splits=midpoints, eval_func=self.eval_func\\n )\\n\\n # If no split points, return inf (can't split here)\\n return (0, np.inf, 1)\",\n \"def find_split(eps, nfeats_test):\\n # TODO your code here\\n # Consider a random subset of features of the specified size\\n total_feature_num = len(eps[0].values)\\n if nfeats_test <= total_feature_num:\\n features_to_test = sorted(random.sample(range(total_feature_num), nfeats_test))\\n else:\\n features_to_test = range(total_feature_num)\\n\\n # For each feature under consideration, and each splitting value:\\n # various values that show up in the profiles for the feature at hand, and take the midpoints between adjacent values.\\n # calculate the impurity of each of the two subsets of profiles split accordingly.\\n res = None\\n for feature in features_to_test:\\n values_for_split = [ep[feature] for ep in eps]\\n splitting_points = sorted(list(set(values_for_split)))\\n # take the midpoints between adjacent values\\n for i in range(len(splitting_points) - 1):\\n splitting_points[i] = (splitting_points[i] + splitting_points[i + 1]) / 2\\n splitting_points.pop()\\n\\n # calculate the impurity of each of the two subsets of profiles split accordingly.\\n for sp_value in splitting_points:\\n subset1 = [ep for ep in eps if ep[feature] < sp_value]\\n gini1 = cal_gini(subset1)\\n subset2 = [ep for ep in eps if ep[feature] >= sp_value]\\n gini2 = cal_gini(subset2)\\n # Sum these, weighted by the fraction of profiles in each subset.\\n gini = len(subset1) / len(eps) * gini1 + len(subset2) / len(eps) * gini2\\n if res is None:\\n res = (feature, sp_value, gini)\\n elif gini < res[2]:\\n res = (feature, sp_value, gini)\\n\\n return res\",\n \"def splitDetectorPeakInfo(self):\\r\\n\\t\\tsplit_raw_min = np.amin(self.splitData)\\r\\n\\t\\tsplit_min = split_raw_min - self.splitBaseline\\r\\n\\t\\t\\t\\t\\r\\n\\t\\tsplit_raw_max = np.amax(self.splitData)\\r\\n\\t\\tsplit_max = split_raw_max - self.splitBaseline\\r\\n\\t\\r\\n\\t\\tself.splitMax = split_max\\r\\n\\t\\tself.splitMin = split_min\",\n \"def midpoint(self) -> Tuple[int, int]:\\n minx, miny, maxx, maxy = self.substrates.bounds\\n return ((minx + maxx) // 2, (miny + maxy) // 2)\",\n \"def choose_best_split(self, X_subset, y_subset):\\n # YOUR CODE HERE\\n feature_index = None\\n threshold = None\\n best_G = np.inf\\n N = len(X_subset)\\n \\n for current_feature in range(X_subset.shape[1]):\\n thresholds = np.unique(X_subset[:, current_feature])\\n \\n for t in thresholds:\\n y_left, y_right = self.make_split_only_y(current_feature, t, X_subset, y_subset)\\n H_L = self.H(y_left)\\n H_R = self.H(y_right)\\n \\n G = (len(y_left) / N) * H_L + (len(y_right) / N) * H_R\\n \\n if G < best_G:\\n best_G = G\\n feature_index = current_feature\\n threshold = t\\n \\n return feature_index, threshold\",\n \"def midpoint(p1, p2):\\n return np.array([(p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2, (p1[2] + p2[2]) / 2])\",\n \"def get_min_across_splits_continuous (\\n feature_array: np.ndarray, target_array: np.ndarray, splits: np.ndarray, evaluate_function: Callable\\n ):\\n n = len ( splits )\\n if n > 500:\\n # If many split points, use some threading\\n with multiprocessing.Pool ( processes = 8 ) as p:\\n # Get evaluation scores across all the splits\\n post_split_evals = dict (\\n zip (\\n range ( len ( splits ) ),\\n p.starmap (\\n BaseTree.get_split_goodness_fit_continuous,\\n zip ( [ feature_array] * n, [ target_array ] * n, splits, [ evaluate_function ] * n ),\\n ),\\n )\\n )\\n p.close()\\n else:\\n # If not too many split points, get scores across all splits\\n post_split_evals = dict (\\n zip (\\n range ( len ( splits ) ),\\n map (\\n lambda x: BaseTree.get_split_goodness_fit_continuous ( * x ),\\n zip ( [ feature_array ] * n, [ target_array ] * n, splits, [ evaluate_function ] * n ),\\n ),\\n )\\n )\\n # Get the minimum split based on gain ratio\\n min_eval = min (\\n post_split_evals,\\n key = lambda x: pipe (\\n post_split_evals.get ( x ),\\n lambda results: results [ 0 ] / results [ 1 ], # entropy / intrinsic value\\n ),\\n )\\n\\n # Return the best split and the splits scores\\n return ( splits [ min_eval ], * post_split_evals.get ( min_eval ) )\\n # End get_min_across_splits_continuous()\",\n \"def midpoint(ptA, ptB):\\n return( (ptA[0] + ptB[0]) * 0.5, (ptA[1]+ ptB[1]) * 0.5 )\",\n \"def _bestFeat2split(dataSet, impurity_crit, min_impurity_decrease, min_samples_split):\\n\\t\\tm, n = dataSet.shape\\n\\t\\tbestFeatInd, bestVal = None, DecisionTree._make_leaf(dataSet, impurity_crit)\\n\\n\\t\\tif m < min_samples_split or len(set(dataSet[:,-1])) == 1:\\n\\t\\t\\treturn bestFeatInd, bestVal\\n\\n\\t\\timpurity = m * impurity_crit(dataSet)\\n\\t\\tmin_impurity = np.inf\\n\\t\\t\\n\\n\\t\\tfor feat_ind in range(n-1):\\n\\t\\t\\tif type(dataSet[:, feat_ind][0]) != str:\\n\\t\\t\\t\\tuniqVal = set(dataSet[:, feat_ind])\\n\\t\\t\\telse:\\n\\t\\t\\t\\tuniqVal = map(set, subsets(list(dataSet[:, feat_ind])))\\n\\t\\t\\tfor val in uniqVal:\\n\\t\\t\\t\\tD1, D2 = DecisionTree._binarySplit(dataSet, feat_ind, val)\\n\\t\\t\\t\\tif len(D1) < min_samples_split or len(D2) < min_samples_split:\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\tnew_impurity = len(D1)*impurity_crit(D1) + len(D2)*impurity_crit(D2)\\n\\t\\t\\t\\tif impurity - new_impurity < min_impurity_decrease:\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\tif new_impurity < min_impurity:\\n\\t\\t\\t\\t\\tmin_impurity = new_impurity\\n\\t\\t\\t\\t\\tbestFeatInd = feat_ind; bestVal = val\\n\\t\\treturn bestFeatInd, bestVal\",\n \"def mid(self):\\n return LibraryFunctions.per(self.nums(), 0.5)\",\n \"def midpoint(a, b):\\n return ((a[0] + b[0]) / 2, (a[1] + b[1]) / 2)\",\n \"def get_best_split_all(x, y) -> Tuple[int, float, float]:\\n m = x.shape[1]\\n col_best_gin = np.ones(shape=m)\\n col_best_val = np.ones(shape=m)\\n for c in range(m):\\n best = 1\\n best_x = 0\\n for i in np.unique(x[:, c]):\\n gini = Tree.split(x[:, c], y, i)\\n if gini < best:\\n best = gini\\n best_x = i\\n col_best_gin[c] = best\\n col_best_val[c] = best_x\\n\\n # Select best feature to split on\\n col_idx = np.argmin(col_best_gin)\\n # Convert to bool index\\n col_idx = np.array(range(x.shape[1])) == col_idx\\n\\n return col_idx, col_best_val[col_idx], col_best_gin[col_idx]\",\n \"def midpoint_of_points(pnts: Iterable[Point]) -> Point:\\n num = len(pnts)\\n x = sum(pnt.x for pnt in pnts)/num\\n y = sum(pnt.y for pnt in pnts)/num\\n z = sum(pnt.z for pnt in pnts)/num\\n return Point(x, y, z)\",\n \"def possible_splits(self,feature,y):\\n\\n yi = y[:-1]\\n yi1= y[1:]\\n idx=np.argwhere((yi1-yi)!=0)\\n return idx.flatten()\",\n \"def _get_best_fit(self, segmented_instances, num_labels,\\\\\\n stats, end_points, i, j, k, pos_angle=True):\\n min_angle = None\\n seg_section = None\\n min_seg_dist = None\\n\\n img = np.zeros(segmented_instances.shape)\\n img[segmented_instances== (i+1)]= 100\\n #self.showme(img, str(i))\\n img[segmented_instances== (j+1)]= 100\\n #self.showme(img, str(i)+'and? '+str(j))\\n cv2.circle(img, (end_points[i][k][0], end_points[i][k][1]), 3, 70, -1)\\n seg_section=None\\n mid_point_i=[0,0]\\n for l in range(0, len(end_points[j])): #Iterate over all endpoints of segment j\\n #cv2.line(img,(end_points[i][k][0], end_points[i][k][1]),(stats['centroid'][i,0], stats['centroid'][i,1]),100,4)\\n seg_dist = math.sqrt((end_points[j][l][0]-end_points[i][k][0])**2.0 +\\n (end_points[j][l][1]-end_points[i][k][1])**2.0 )\\n #cv2.line(img,(end_points[j][l][0], end_points[j][l][1]),(stats['centroid'][i,0], stats['centroid'][i,1]),255,4)\\n # Stem segments with side branches usually miss a good connection because the centroid is off\\n # the end point's axis. To account for this we replace the centroind with a point that is closer to the end point.\\n mid_point_i[0] = int(end_points[i][k][0]+ (stats['centroid'][i][0]-end_points[i][k][0])/4.0)\\n mid_point_i[1] = int(end_points[i][k][1]+ (stats['centroid'][i][1]-end_points[i][k][1])/4.0)\\n\\n angle = self._ang([stats['centroid'][j],end_points[j][l]], \\\\\\n [stats['centroid'][j], mid_point_i] )\\n if angle==999: #check for a divide by zero error\\n cv2.line(img,(stats['centroid'][j][0], stats['centroid'][j][1]),\\n (end_points[j][l][0], end_points[j][l][1]), 150, 4 )\\n cv2.line(img,(stats['centroid'][j][0], stats['centroid'][j][1]),\\n (stats['centroid'][i][0], stats['centroid'][i][1]), 150, 4 )\\n cv2.line(img,(end_points[j][l][0], end_points[j][l][1]),\\\\\\n (end_points[i][k][0], end_points[i][k][1]),255,4)\\n self.showme(img, str(i)+' '+str(j)+' '+str(angle))\\n\\n if (pos_angle and angle<=self.angle_thresh) or ( not(pos_angle) and angle>=360-self.angle_thresh):\\n if min_seg_dist is None or seg_dist < min_seg_dist:\\n min_seg_dist = seg_dist\\n min_angle = angle\\n seg_section = l\\n elif seg_dist<50:\\n cv2.line(img,(stats['centroid'][j][0], stats['centroid'][j][1]),\\n (end_points[j][l][0], end_points[j][l][1]), 150, 4 )\\n cv2.line(img,(stats['centroid'][j][0], stats['centroid'][j][1]),\\n (stats['centroid'][i][0], stats['centroid'][i][1]), 150, 4 )\\n cv2.line(img,(end_points[j][l][0], end_points[j][l][1]),\\\\\\n (end_points[i][k][0], end_points[i][k][1]),255,4)\\n #self.showme(img, str(i)+' '+str(j)+' '+str(angle))\\n\\n return min_angle, seg_section, min_seg_dist\",\n \"def test_midpoint(self):\\n p1 = Point(0, 0)\\n p2 = Point(10, 10)\\n midpoint = p1.midpoint(p2)\\n self.assertAlmostEqual(midpoint.lat, 5)\\n self.assertAlmostEqual(midpoint.lon, 5)\",\n \"def find_split(x, y):\\n\\n # Need the starting entropy so we can measure improvement...\\n start_entropy = calculate_entropy(y)\\n\\n # Best thus far, initialised to a dud that will be replaced immediately...\\n best = {'infogain': -np.inf}\\n\\n # Randomly allocate the splits to be traversed (without replacement)\\n feature_total = x.shape[1]\\n feature_subset_count = int(np.sqrt(feature_total))\\n feature_subset = np.random.permutation(feature_total)[:feature_subset_count]\\n\\n # Loop every possible split of every feature...\\n for feature_index in feature_subset:\\n for split in np.unique(x[:, feature_index]):\\n\\n left_indices = []\\n right_indices = []\\n\\n # Get index of rows where x[row_index,feature_index] <= split\\n for row_index,row in enumerate(x):\\n left_indices.append(row_index) if x[row_index,feature_index] <= split else right_indices.append(row_index)\\n\\n left_ys = y[left_indices]\\n right_ys = y[right_indices]\\n\\n nleft = len(left_ys)\\n nright = len(right_ys)\\n ntotal = nleft + nright\\n infogain = start_entropy - (nleft / ntotal) * calculate_entropy(left_ys) - (\\n nright / ntotal) * calculate_entropy(right_ys)\\n\\n if infogain > best['infogain']:\\n best = {'feature': feature_index,\\n 'split': split,\\n 'infogain': infogain,\\n 'left_indices': left_indices,\\n 'right_indices': right_indices}\\n return best\",\n \"def __find_best_split_in_feature(self, feature_and_class):\\n\\n # sort the feature and class and use changes in the class to reduce\\n # number of potential split info gain calculations\\n sorted_data = feature_and_class[\\n feature_and_class[:, 0].astype(np.int).argsort()]\\n potential_splits = self.__find_integers_with_class_change(sorted_data)\\n info_gains = self.__info_gain_from_splits(potential_splits,\\n sorted_data)\\n\\n # returning nothing in no information gains are found\\n if len(info_gains) == 0:\\n return None, None\\n\\n index = info_gains.index(max(info_gains))\\n return info_gains[index], potential_splits[index]\",\n \"def midpoint(bbox):\\n return (0.5*(bbox[0][0] + bbox[1][0]), 0.5*(bbox[0][1] + bbox[1][1]))\",\n \"def closest_split_pair(x, delta):\\n mid_point_x = x[len(x)//2][0]\\n strip = []\\n\\n for point in y:\\n if abs(mid_point_x - point[0]) < delta:\\n strip.append(point)\\n strip = sorted(strip, key= lambda x: x[0])\\n\\n n = len(strip)\\n min_distance = float(\\\"inf\\\")\\n last_pair = None\\n for i in range(n):\\n for j in range(i+1, i+7):\\n if j < n:\\n result = distance(points[i], points[j])\\n if result < min_distance:\\n min_distance = result\\n last_pair = [points[i], points[j]]\\n return last_pair\",\n \"def __get_split_feature(self, data_set, target_feature, tree_features):\\n\\n if self.__criterion == 'entropy':\\n feature_gains = {feature: self.__gain(data_set, feature, target_feature) for (feature) in tree_features}\\n split_feature = max(feature_gains, key=feature_gains.get)\\n return split_feature\\n elif self.__criterion == 'gini':\\n feature_ginis = {feature: self.__gini(data_set, feature, target_feature) for (feature) in tree_features}\\n split_feature = min(feature_ginis, key=feature_ginis.get)\\n return split_feature\\n # TODO: I should check this (gini index).\",\n \"def test_split(self,X,y,splits):\\n n_data = len(y) #Number of data points\\n splits=(X[splits]+X[splits+1])/2\\n\\n idx_greater = (X>splits[:,None]) #index for greater split\\n idx_lower = (X<splits[:,None]) #index for lower split\\n\\n imp_greater =[self.impurity(y[idx]) for idx in idx_greater] #impurity for greater\\n imp_lower = [self.impurity(y[idx]) for idx in idx_lower] #impurity lower\\n\\n impur = [sum(idx_great)/n_data*imp_great+sum(idx_low)/n_data*imp_low for idx_great,imp_great,idx_low,imp_low in zip(idx_greater,imp_greater,idx_lower,imp_lower)] #Weighted impurity\\n return (impur,splits)\",\n \"def GetMiddle(cluster):\\n x = np.mean(np.array([cluster[i][0] for i in range(len(cluster))]))\\n y = np.mean(np.array([cluster[i][1] for i in range(len(cluster))]))\\n return [x, y]\",\n \"def find_best_point(self, start_i, end_i, ranges):\\n # do a sliding window average over the data in the max gap, this will\\n # help the car to avoid hitting corners\\n averaged_max_gap = np.convolve(ranges[start_i:end_i], np.ones(self.BEST_POINT_CONV_SIZE), 'same') / self.BEST_POINT_CONV_SIZE\\n return averaged_max_gap.argmax() + start_i\",\n \"def split_data(data, feature, split_point):\\n data_l = data[data[:, feature - 1] < split_point]\\n data_r = data[data[:, feature - 1] >= split_point]\\n\\n return data_l, data_r\",\n \"def mid(p1, p2):\\n\\treturn [(p1[0]+p2[0])/2., (p1[1]+p2[1])/2.]\",\n \"def __call__(self, features):\\n\\n data = np.array(features)\\n min = np.amin(data, axis=0)\\n dif = np.amax(data, axis=0) - min\\n for i in range(len(dif)):\\n if dif[i] == 0:\\n data[:, i] = min[i]\\n dif[i] = 1\\n \\n return [list((d - min)/ dif) for d in data]\",\n \"def get_splits(self):\\n\\t\\treturn self.k\",\n \"def mid_mAP(P, Y, S, bg_class):\\n # segment groundtruth intervals\\n gt_file, gt_labels, gt_intervals = [], [], []\\n for i, y in enumerate(Y):\\n gt_labels += [_segment_labels(y)]\\n gt_intervals += [np.array(_segment_intervals(y))]\\n gt_file += [[i]*len(gt_labels[-1])]\\n gt_file = np.hstack(gt_file)\\n gt_intervals = np.vstack(gt_intervals)\\n gt_labels = np.hstack(gt_labels)\\n\\n # segment detected intervals\\n det_file, det_labels, det_intervals, det_scores = [], [], [], []\\n for i, y in enumerate(P):\\n det_labels += [_segment_labels(y)]\\n det_intervals += [np.array(_segment_intervals(y))]\\n det_file += [[i]*len(det_labels[-1])]\\n det_scores += [S[i][inter[0]:inter[1]][:, label].max()\\n for inter, label in zip(det_intervals[-1],\\n det_labels[-1])]\\n det_file = np.hstack(det_file)\\n det_intervals = np.vstack(det_intervals)\\n det_labels = np.hstack(det_labels)\\n det_scores = np.hstack(det_scores)\\n\\n pr, ap, mAP_mid = _midpoint_mAP(gt_file, det_file, gt_labels, det_labels,\\n gt_intervals, det_intervals, det_scores,\\n bg_class=bg_class)\\n return np.array(ap), mAP_mid*100\",\n \"def make_split(self, feature_index, threshold, X_subset, y_subset):\\n\\n # YOUR CODE HERE\\n ind = (X_subset[:, feature_index] < threshold)\\n \\n X_left, y_left = X_subset[ind], y_subset[ind]\\n X_right, y_right = X_subset[~ind], y_subset[~ind]\\n \\n return (X_left, y_left), (X_right, y_right)\",\n \"def centroids(img_segm):\\n m = np.amax(img_segm)\\n xs = np.zeros(m)\\n ys = np.zeros(m)\\n \\n for i in range(0,m):\\n pos_list = np.where(img_segm==i+1)\\n xs[i] = np.mean(pos_list[0])\\n ys[i] = np.mean(pos_list[1])\\n return xs,ys\",\n \"def get_min_across_splits_continuous(\\n arr: np.ndarray, y: np.ndarray, splits: np.ndarray, eval_func: Callable\\n ):\\n n = len(splits)\\n if n > 500:\\n # If many split points, use some threading\\n with multiprocessing.Pool(processes=8) as p:\\n # Get evaluation scores across all the splits\\n post_split_evals = dict(\\n zip(\\n range(len(splits)),\\n p.starmap(\\n BaseTree.get_split_goodness_fit_continuous,\\n zip([arr] * n, [y] * n, splits, [eval_func] * n),\\n ),\\n )\\n )\\n p.close()\\n else:\\n # If not too many split points, get scores across all splits\\n post_split_evals = dict(\\n zip(\\n range(len(splits)),\\n map(\\n lambda x: BaseTree.get_split_goodness_fit_continuous(*x),\\n zip([arr] * n, [y] * n, splits, [eval_func] * n),\\n ),\\n )\\n )\\n # Get the minimum split based on gain ratio\\n min_eval = min(\\n post_split_evals,\\n key=lambda x: pipe(\\n post_split_evals.get(x),\\n lambda results: results[0] / results[1], # entropy / intrinsic value\\n ),\\n )\\n\\n # Return the best split and the splits scores\\n return (splits[min_eval], *post_split_evals.get(min_eval))\",\n \"def midpoint(point1, point2):\\n\\n x, y = (int((point1[0] + point2[0]) / 2), int((point1[1] + point2[1]) / 2))\\n return (x, y)\",\n \"def centroids(img_segm):\\n m = int(np.amax(img_segm))\\n xs = np.zeros(m)\\n ys = np.zeros(m)\\n \\n for i in range(0,m):\\n pos_list = np.where(img_segm==i+1)\\n xs[i] = np.mean(pos_list[0])\\n ys[i] = np.mean(pos_list[1])\\n return xs,ys\",\n \"def _best_split(cls, X, y):\\n n = X.shape[0]\\n num_feature = X.shape[1]\\n y_types = np.unique(y)\\n\\n # initialize\\n min_score = float(n)\\n feature_idx = None\\n best_theta = None\\n best_idx = None\\n\\n for feature_idx in xrange(num_feature):\\n # counter for y\\n cumulate_y = Counter()\\n rest_y = Counter()\\n for y_type in y_types:\\n cnt = np.where(y == y_type)[0].shape[0]\\n rest_y[y_type] = cnt\\n\\n # sorted data\\n sorted_idx = np.argsort(X[:, feature_idx])\\n sorted_X = np.copy(X)\\n sorted_y = np.copy(y)\\n sorted_X = sorted_X[sorted_idx]\\n sorted_y = sorted_y[sorted_idx]\\n #print \\\"_best_split:\\\", sorted_X.shape, sorted_y.shape\\n\\n for idx in xrange(n-1):\\n theta = (sorted_X[idx, feature_idx] + sorted_X[idx + 1, feature_idx]) / 2\\n y_label = sorted_y[idx]\\n cumulate_y[y_label] += 1\\n rest_y[y_label] -= 1\\n left_cnt = sum(cumulate_y.values())\\n right_cnt = sum(rest_y.values())\\n w_1 = left_cnt * cls._gini_index(cumulate_y.values())\\n w_2 = right_cnt * cls._gini_index(rest_y.values())\\n score = w_1 + w_2\\n if score < min_score:\\n min_score = score\\n best_theta = theta\\n best_idx = feature_idx\\n #print('new min score: %.3f' % score)\\n #print('feature: %d, theta: %.3f' % (best_idx, best_theta))\\n #print('left: %d, right: %d' % (left_cnt, right_cnt))\\n print('feature: %d, theta: %.3f' % (best_idx, best_theta))\\n return (best_idx, best_theta)\",\n \"def _best_split(cls, X, y):\\n n = X.shape[0]\\n num_feature = X.shape[1]\\n y_types = np.unique(y)\\n\\n # initialize\\n min_score = float(n)\\n feature_idx = None\\n best_theta = None\\n best_idx = None\\n\\n for feature_idx in xrange(num_feature):\\n # counter for y\\n cumulate_y = Counter()\\n rest_y = Counter()\\n for y_type in y_types:\\n cnt = np.where(y == y_type)[0].shape[0]\\n rest_y[y_type] = cnt\\n\\n # sorted data\\n sorted_idx = np.argsort(X[:, feature_idx])\\n sorted_X = np.copy(X)\\n sorted_y = np.copy(y)\\n sorted_X = sorted_X[sorted_idx]\\n sorted_y = sorted_y[sorted_idx]\\n #print \\\"_best_split:\\\", sorted_X.shape, sorted_y.shape\\n\\n for idx in xrange(n-1):\\n theta = (sorted_X[idx, feature_idx] + sorted_X[idx + 1, feature_idx]) / 2\\n y_label = sorted_y[idx]\\n cumulate_y[y_label] += 1\\n rest_y[y_label] -= 1\\n left_cnt = sum(cumulate_y.values())\\n right_cnt = sum(rest_y.values())\\n w_1 = left_cnt * cls._gini_index(cumulate_y.values())\\n w_2 = right_cnt * cls._gini_index(rest_y.values())\\n score = w_1 + w_2\\n if score < min_score:\\n min_score = score\\n best_theta = theta\\n best_idx = feature_idx\\n #print('new min score: %.3f' % score)\\n #print('feature: %d, theta: %.3f' % (best_idx, best_theta))\\n #print('left: %d, right: %d' % (left_cnt, right_cnt))\\n print('feature: %d, theta: %.3f' % (best_idx, best_theta))\\n return (best_idx, best_theta)\",\n \"def segement_divide(pts,step=0.10, offset_x=0.01, offset_y=0.0):\\n\\n # Select the x and y of the points\\n n = len(pts)\\n \\n z = pts[0][2]\\n \\n points_plane = [] \\n points_x = []\\n paint_point = []\\n\\n for i in range(n):\\n points_plane.append([pts[i][0], pts[i][1]])\\n \\n # Sorted the list according to x \\n points_plane.sort(key=lambda x:x[0])\\n\\n # Segment the points according to x \\n counter = 0 # Count the interval\\n x_min = points_plane[0][0]\\n x_max = points_plane[n-1][0]\\n\\n # The whole interval that needs to be divided\\n upper = x_max + offset_x\\n lower = x_min - offset_x\\n lower_bound = lower\\n \\n # Set each segement's lower and upperbound\\n while (lower_bound + step <= upper): \\n # The break condition will be lower_bound > upper - step\\n upper_bound = lower_bound + step\\n\\n # Find the index between lower bound and upper bound\\n # First, find the index which x >= lower bound\\n index = 0\\n \\n while (points_plane[index][0] < lower_bound): \\n index = index + 1 # The index of the first point in the interval\\n \\n # If there is at least one point in the [lower_bound, upper_bound]\\n if (points_plane[index][0] <= upper_bound): \\n\\n x_start = points_plane[index][0]\\n y_max = points_plane[index][1]\\n y_min = points_plane[index][1]\\n \\n while (points_plane[index][0] <= upper_bound): \\n # The break condition will be x[index] > upper bound or index = n - 1\\n # Compute the y max and y min in this interval\\n \\n if points_plane[index][1] > y_max: \\n y_max = points_plane[index][1]\\n\\n if points_plane[index][1] < y_min:\\n y_min = points_plane[index][1]\\n \\n if index < n - 1:\\n index = index + 1\\n else:\\n break\\n # The index of the last point in the interval, when index < n-1\\n \\n x_end = points_plane[index][0]\\n\\n paint_point.append([lower_bound,y_max+offset_y,z]) \\n paint_point.append([lower_bound,y_min-offset_y,z])\\n points_x.append([x_start, x_end])\\n \\n counter = counter + 1\\n\\n # Update interval\\n lower_bound = upper_bound - offset_x\\n \\n # Deal with the last interval\\n lower_bound_last = upper - step\\n index_last = 0\\n counter = counter + 1\\n while ((index_last < n) and (points_plane[index_last][0] < lower_bound_last)): \\n # The first point in the last interval\\n index_last = index_last + 1\\n \\n if (index_last < n): \\n # There is at least one point in the last interval\\n x_start_last = points_plane[index_last][0]\\n y_max_last = points_plane[index_last][1]\\n y_min_last = points_plane[index_last][1]\\n\\n while ((index_last)<n) and (points_plane[index_last][0] <= upper):\\n\\n if points_plane[index_last][1] > y_max_last: \\n y_max_last = points_plane[index_last][1]\\n \\n if points_plane[index_last][1] < y_min_last:\\n y_min_last = points_plane[index_last][1]\\n\\n index_last = index_last + 1\\n \\n index_last = index_last - 1 # The index of the last point in the interval\\n \\n paint_point.append([lower_bound_last, y_max_last+offset_y, z])\\n paint_point.append([lower_bound_last, y_min_last-offset_y, z])\\n# paint_point.append([upper, y_max_last+offset_y, z])\\n# paint_point.append([upper, y_min_last-offset_y, z])\\n# return trans_to_end(paint_point)\\n return paint_point\",\n \"def find_split(self, X, y):\\n choices = y.size\\n if choices <= 1:\\n return None, None\\n\\n # find the number of each option in the current node.\\n options_parent = [np.sum(y == c) for c in range(self.num_outcomes)]\\n\\n # find the gini of current node.\\n best_gini = 1.0 - sum((n / choices) ** 2 for n in options_parent)\\n best_idx, best_split = None, None\\n\\n # loop through the features to get splits and options.\\n for idx in range(self.num_features):\\n splits, options = zip(*sorted(zip(X[:, idx], y)))\\n\\n num_left = [0] * self.num_outcomes\\n num_right = options_parent.copy()\\n for i in range(1, choices):\\n c = options[i - 1]\\n num_left[c] += 1\\n num_right[c] -= 1\\n gini_left = 1.0 - sum(\\n (num_left[x] / i) ** 2 for x in range(self.num_outcomes)\\n )\\n gini_right = 1.0 - sum(\\n (num_right[x] / i) ** 2 for x in range(self.num_outcomes)\\n )\\n\\n gini = (i * gini_left + (choices - i) * gini_right) / choices\\n\\n if splits[i] == splits[i - 1]:\\n continue\\n\\n if gini < best_gini:\\n best_gini = gini\\n best_idx = idx\\n best_split = (splits[i] + splits[i - 1]) / 2\\n\\n return best_idx, best_split\",\n \"def detect_splits(self):\\n logg.info(' abstracted graph will have {} nodes'.format(self.n_splits+1))\\n indices_all = np.arange(self.X.shape[0], dtype=int)\\n segs = [indices_all]\\n if False: # this is safe, but not compatible with on-the-fly computation\\n tips_all = np.array(np.unravel_index(np.argmax(self.Dchosen), self.Dchosen.shape))\\n else:\\n if self.iroot is not None:\\n tip_0 = np.argmax(self.Dchosen[self.iroot])\\n else:\\n tip_0 = np.argmax(self.Dchosen[0]) # just a random index, here fixed to \\\"0\\\"\\n tips_all = np.array([tip_0, np.argmax(self.Dchosen[tip_0])])\\n # we keep a list of the tips of each segment\\n segs_tips = [tips_all]\\n if self.clusters_precomputed_names:\\n self.segs_names_original = [', '.join(self.clusters_precomputed_names)]\\n segs_undecided = [True]\\n segs_adjacency = [[]]\\n segs_distances = np.zeros((1, 1))\\n segs_adjacency_nodes = [{}]\\n # logg.info(' do not consider groups with less than {} points for splitting'\\n # .format(self.min_group_size))\\n for ibranch in range(self.n_splits):\\n if self.clusters == 'unconstrained_segments':\\n iseg, new_tips = self.select_segment(segs, segs_tips, segs_undecided)\\n if iseg == -1:\\n logg.info('... partitioning converged')\\n break\\n logg.info('... branching {}:'.format(ibranch + 1),\\n 'split group', iseg)\\n segs_distances = self.do_split(segs, segs_tips,\\n segs_undecided,\\n segs_adjacency,\\n segs_distances,\\n iseg, new_tips)\\n else:\\n logg.msg(' split', ibranch + 1, v=4)\\n stop, segs_distances = self.do_split_constrained(segs, segs_tips,\\n segs_adjacency,\\n segs_adjacency_nodes,\\n segs_distances)\\n if stop: break\\n\\n # segments\\n self.segs = segs\\n self.segs_tips = segs_tips\\n self.segs_sizes = []\\n for iseg, seg in enumerate(self.segs): self.segs_sizes.append(len(seg))\\n\\n # the full, unscaled adjacency matrix\\n self.segs_adjacency_full_attachedness = 1/segs_distances\\n # if self.attachedness_measure == 'connectedness':\\n # norm = np.sqrt(np.multiply.outer(self.segs_sizes, self.segs_sizes))\\n # self.segs_adjacency_full_attachedness /= norm\\n self.segs_adjacency_full_confidence, self.segs_adjacency_tree_confidence \\\\\\n = self.compute_adjacency_confidence(\\n self.segs_adjacency_full_attachedness,\\n segs_adjacency,\\n self.tree_based_confidence)\\n np.fill_diagonal(self.segs_adjacency_full_attachedness, 0)\",\n \"def midpoint(f, x0, h):\\n return 2.0*h*f(x0+h);\",\n \"def getSplit(self):\\n b_index, b_value, b_score, b_groups = 999, 999, 999, None\\n for j in range(len(self[0]) - 1):\\n for i in range(len(self)):\\n groups = self.splitAttribute(j, self[i][j]) # lit, big\\n gini = self.giniIndex(groups)\\n if gini < b_score and (j, \\\"%.1f\\\" % self[i][j]) not in self.atr:\\n b_index, b_value, b_score, b_groups = j, self[i][\\n j], gini, groups\\n return b_index, b_value, b_groups, b_score\",\n \"def fit(self, data, targets):\\n # update these three\\n self.idx = 0\\n self.val = None\\n self.left = None\\n self.right = None\\n ### YOUR CODE HERE\\n # i have added a slow and a fast version\\n \\n num_points, num_features = data.shape\\n # print('num points, num_features', num_points, num_features)\\n \\n def feat_score(feat_idx):\\n feat = data[:, feat_idx].copy()\\n perm = np.argsort(feat)\\n s_feat = feat[perm]\\n s_targets = targets[perm]\\n target_var = ((s_targets - s_targets.mean())**2).sum()\\n s_left, s_right = sum_squares(s_targets)\\n def score(idx, _vals):\\n ## slow version\\n #left = _vals[0:idx]\\n #right = _vals[idx:]\\n #assert len(left) + len(right) == len(_vals), (len(left), len(right), len(_vals))\\n #left_mean = np.mean(left)\\n #right_mean = np.mean(right)\\n #left_error = np.sum((left-left_mean)**2)\\n #assert np.allclose(left_error, s_left[idx]) \\n #right_error = np.sum((right-right_mean)**2)\\n #assert np.allclose(right_error, s_right[idx])\\n # return left_error+right_error\\n # fast version\\n return s_left[idx] + s_right[idx]\\n # score for every split\\n scores = np.array([score(x, s_targets) for x in range(0, num_points)])\\n assert scores.min() <= target_var, target_var\\n best_score_idx = np.argmin(scores)\\n best_score = scores[best_score_idx]\\n val = s_feat[best_score_idx]\\n # print('best score', feat_idx, best_score, best_score_idx, val, s_feat[best_score_idx+1])\\n \\n return best_score, {'val': val, \\n 'left': np.mean(s_targets[:best_score_idx]), \\n 'right': np.mean(s_targets[best_score_idx:])\\n } \\n\\n split_scores = []\\n for f in range(0, num_features):\\n total_score, _params = feat_score(f)\\n split_scores.append(total_score)\\n # print('score of {0} - {1}'.format(feat_names[f], total_score))\\n # print('feature scores:', np.array(split_scores))\\n best_feat = np.argmin(split_scores)\\n best_score = split_scores[best_feat]\\n # print('Best Feature idx: {0} - Best Cost: {1}'.format(best_feat, best_score))\\n score_again, params = feat_score(best_feat)\\n # print('double check score', score_again, best_score)\\n self.idx = best_feat\\n self.val = params['val']\\n self.left = params['left']\\n self.right = params['right']\\n print(\\\"idx={}, val={}, left={}, right={}\\\".format(self.idx, self.val, self.left, self.right))\\n assert not np.isnan(self.left)\\n assert not np.isnan(self.right)\\n ### END CODE\",\n \"def findMaxCrossingSubarray(self, array, low, mid, high):\\n left_index = 0\\n left_sum = float(\\\"-inf\\\")\\n temp_sum = 0\\n for i in range(mid-1, low-1, -1):\\n temp_sum += array[i]\\n if temp_sum > left_sum:\\n left_sum = temp_sum\\n left_index = i\\n right_index = 0\\n right_sum = float(\\\"-inf\\\")\\n temp_sum = 0\\n for i in range(mid, (high + 1)):\\n temp_sum += array[i]\\n if temp_sum > right_sum:\\n right_sum = temp_sum\\n right_index = i\\n return (left_index, right_index, left_sum + right_sum)\",\n \"def segement_divide(pts,step=0.10, offset_x=0.01, offset_y=0.01):\\n\\n # Select the x and y of the points\\n n = len(pts)\\n \\n z = 0.0\\n \\n points_plane = [] \\n points_x = []\\n paint_point = []\\n\\n for i in range(n):\\n points_plane.append([pts[i][0], pts[i][1]])\\n \\n # Sorted the list according to x \\n points_plane.sort(key=lambda x:x[0])\\n\\n # Segment the points according to x \\n counter = 0 # Count the interval\\n x_min = points_plane[0][0]\\n x_max = points_plane[n-1][0]\\n\\n # The whole interval that needs to be divided\\n upper = x_max + offset_x\\n lower = x_min - offset_x\\n lower_bound = lower\\n \\n # Set each segement's lower and upperbound\\n while (lower_bound + step <= upper): \\n # The break condition will be lower_bound > upper - step\\n upper_bound = lower_bound + step\\n\\n # Find the index between lower bound and upper bound\\n # First, find the index which x >= lower bound\\n index = 0\\n \\n while (points_plane[index][0] < lower_bound): \\n index = index + 1 # The index of the first point in the interval\\n \\n # If there is at least one point in the [lower_bound, upper_bound]\\n if (points_plane[index][0] <= upper_bound): \\n\\n x_start = points_plane[index][0]\\n y_max = points_plane[index][1]\\n y_min = points_plane[index][1]\\n \\n while (points_plane[index][0] <= upper_bound): \\n # The break condition will be x[index] > upper bound or index = n - 1\\n # Compute the y max and y min in this interval\\n \\n if points_plane[index][1] > y_max: \\n y_max = points_plane[index][1]\\n\\n if points_plane[index][1] < y_min:\\n y_min = points_plane[index][1]\\n \\n if index < n - 1:\\n index = index + 1\\n else:\\n break\\n # The index of the last point in the interval, when index < n-1\\n \\n x_end = points_plane[index][0]\\n\\n paint_point.append([lower_bound,y_max+offset_y,z]) \\n paint_point.append([lower_bound,y_min-offset_y,z])\\n points_x.append([x_start, x_end])\\n \\n counter = counter + 1\\n\\n # Update interval\\n lower_bound = upper_bound - offset_x\\n \\n # Deal with the last interval\\n lower_bound_last = upper - step\\n index_last = 0\\n counter = counter + 1\\n while ((index_last < n) and (points_plane[index_last][0] < lower_bound_last)): \\n # The first point in the last interval\\n index_last = index_last + 1\\n \\n if (index_last < n): \\n # There is at least one point in the last interval\\n x_start_last = points_plane[index_last][0]\\n y_max_last = points_plane[index_last][1]\\n y_min_last = points_plane[index_last][1]\\n\\n while ((index_last)<n) and (points_plane[index_last][0] <= upper):\\n\\n if points_plane[index_last][1] > y_max_last: \\n y_max_last = points_plane[index_last][1]\\n \\n if points_plane[index_last][1] < y_min_last:\\n y_min_last = points_plane[index_last][1]\\n\\n index_last = index_last + 1\\n \\n index_last = index_last - 1 # The index of the last point in the interval\\n \\n paint_point.append([lower_bound_last, y_max_last+offset_y, z])\\n paint_point.append([lower_bound_last, y_min_last-offset_y, z])\\n# paint_point.append([upper, y_max_last+offset_y, z])\\n# paint_point.append([upper, y_min_last-offset_y, z])\\n# return trans_to_end(paint_point)\\n return paint_point\",\n \"def __call__(self, features):\\n minmax_f = []\\n if self.a == 0:\\n self.minf = []\\n self.maxf = []\\n for i in range(len(features)):\\n if i == 0:\\n for j in range(len(features[i])):\\n self.minf.append(features[i][j])\\n self.maxf.append(features[i][j])\\n else:\\n for j in range(len(features[i])):\\n if self.minf[j] > features[i][j]:\\n self.minf[j] = features[i][j]\\n if self.maxf[j] < features[i][j]:\\n self.maxf[j] = features[i][j]\\n for i in range(len(features)):\\n temp = [] \\n for j in range(len(features[i])):\\n x = features[i][j]\\n if (self.maxf[j] - self.minf[j]) != 0:\\n x = (x - self.minf[j])/(self.maxf[j] - self.minf[j])\\n \\n else:\\n x = (x - self.minf[j])\\n temp.append(x)\\n minmax_f.append(temp)\\n self.a = 1\\n elif self.a == 1:\\n for i in range(len(features)):\\n temp = [] \\n for j in range(len(features[i])):\\n x = features[i][j]\\n if (self.maxf[j] - self.minf[j]) != 0:\\n x = (x - self.minf[j])/(self.maxf[j] - self.minf[j])\\n \\n else:\\n x = (x - self.minf[j])\\n temp.append(x)\\n minmax_f.append(temp)\\n return minmax_f\\n raise NotImplementedError\",\n \"def mid_point(self, vector):\\n return self.eval_2pts(vector, 0.5)\",\n \"def _split_between_values(X, permuted, low, high):\\n gt_low = permuted >= low\\n lt_high = permuted < high\\n mask = gt_low & lt_high\\n\\n # Get the sparsified matrices (mask gets zeroed, so use inverse)\\n in_range = _sparsify_from_mask(X, ~mask)\\n outside_range = _sparsify_from_mask(X, mask)\\n return in_range, outside_range\",\n \"def _extract_shape(idx, x, j, cur_center, normalize=True):\\r\\n _a = []\\r\\n for i in range(len(idx)):\\r\\n if idx[i] == j:\\r\\n if cur_center.sum() == 0:\\r\\n opt_x = x[i]\\r\\n else:\\r\\n _, opt_x = _sbd(cur_center, x[i])\\r\\n _a.append(opt_x)\\r\\n a = np.array(_a)\\r\\n\\r\\n if len(a) == 0:\\r\\n return np.zeros((1, x.shape[1]))\\r\\n columns = a.shape[1]\\r\\n if normalize:\\r\\n y = zscore(a, axis=1, ddof=1)\\r\\n s = np.dot(y.transpose(), y)\\r\\n\\r\\n p = np.empty((columns, columns))\\r\\n p.fill(1.0/columns)\\r\\n p = np.eye(columns) - p\\r\\n\\r\\n m = np.dot(np.dot(p, s), p)\\r\\n _, vec = eigh(m)\\r\\n else: \\r\\n s = np.dot(a.transpose(), a)\\r\\n m = s \\r\\n _, vec = eigh(m)\\r\\n \\r\\n centroid = vec[:, -1]\\r\\n finddistance1 = math.sqrt(((a[0] - centroid) ** 2).sum())\\r\\n finddistance2 = math.sqrt(((a[0] + centroid) ** 2).sum())\\r\\n\\r\\n if finddistance1 >= finddistance2:\\r\\n centroid *= -1\\r\\n \\r\\n return zscore(centroid, ddof=1) if normalize else centroid\",\n \"def get_midpoint(half_distance: int, steps: [(int, str, str)]) -> (str, str):\\r\\n cur_distance = 0\\r\\n cur_step = 0\\r\\n while(cur_distance + steps[cur_step][0] <= half_distance):\\r\\n cur_distance += steps[cur_step][0]\\r\\n cur_step += 1\\r\\n\\r\\n left_over_distance = half_distance - cur_distance\\r\\n\\r\\n # lat, lng\\r\\n startpos = (steps[cur_step][1]['lat'],steps[cur_step][1]['lng'])\\r\\n endpos = (steps[cur_step][2]['lat'],steps[cur_step][2]['lng'])\\r\\n lat_length = endpos[0] - startpos[0]\\r\\n lng_length = endpos[1] - startpos[1]\\r\\n\\r\\n\\r\\n # get angle in radians\\r\\n angle = math.atan(lng_length/lat_length)\\r\\n\\r\\n if (endpos[0] > startpos[0] and endpos[1] > startpos[1]) or \\\\\\r\\n (endpos[0] < startpos[0] and endpos[1] > startpos[1]):\\r\\n return (startpos[0]+left_over_distance*math.cos(angle)/111000, startpos[1]+left_over_distance*math.sin(angle)/111000)\\r\\n return (startpos[0]-left_over_distance*math.cos(angle)/111000, startpos[1]-left_over_distance*math.sin(angle)/111000)\",\n \"def d_midpoint(edge):\\n v0, v1 = EDGES[edge]\\n v0_pos = VERTICES[v0]\\n v1_pos = VERTICES[v1]\\n return ((x+y) for (x,y) in zip(v0_pos, v1_pos))\",\n \"def best_split(self):\\r\\n best_splits = [[0, None, None]]\\r\\n impurity, best_S, best_xj = 0, None, None\\r\\n \\r\\n for xj in self.x_names:\\r\\n for S in self.potential_splits(xj):\\r\\n ir = float(self.impurity_reduction(xj, S))\\r\\n if ir > impurity:\\r\\n impurity, best_S, best_xj = ir, S, xj\\r\\n best_splits.append([S, xj])\\r\\n else: \\r\\n pass\\r\\n \\r\\n return best_S, best_xj\",\n \"def find_approx_fb(self,min_offset,max_offset,min_cdp,max_cdp,offset_spacing,n_split=100):\\n fbs=np.zeros((self.dataset['pred_avg'].shape[0],1))\\n min_offset=(min_offset+offset_spacing)*self.scalar_offset\\n max_offset=(max_offset-offset_spacing)*self.scalar_offset\\n offsets=np.arange(min_offset,max_offset,offset_spacing*self.scalar_offset)\\n for i,coffset in enumerate(offsets):\\n print('Working on central offset:\\\\t{}'.format(coffset/self.scalar_offset))\\n obin_trcs=np.where(np.logical_and(self.dataset['cdp'][:]<=max_cdp,np.logical_and(self.dataset['cdp'][:]>=min_cdp,np.logical_and(self.dataset['offset'][:]>=coffset-offset_spacing,self.dataset['offset'][:]<coffset+offset_spacing))))[0]\\n tmp1=np.array_split(obin_trcs,n_split) \\n if len(obin_trcs)>10:\\n for k,l in enumerate(tmp1):\\n tmp0=self.dataset['pred_avg'][list(tmp1[k]),:]\\n tmp2=np.sum(tmp0,axis=0)\\n tmp2=np.where(tmp2[:]==np.amax(tmp2))[0]\\n for m,n in enumerate(tmp1[k]):\\n fbs[n]=np.int(tmp2)\\n else:\\n print('Not enough traces in a splitted offset bin')\",\n \"def middle(self):\\n return (self.lo+self.hi)/2\",\n \"def get_next_split ( self, feature_matrix: np.ndarray, target_array: np.ndarray, tree_split: TreeSplits):\\n # If only 1 y value, make a leaf node\\n if len ( set ( target_array ) ) == 1:\\n tree_split.updateTreeValues (\\n feature_column = None,\\n feature_value = None,\\n node_type = None,\\n nodes = {},\\n children = target_array,\\n )\\n return tree_split\\n\\n # Get the presplit entropy\\n presplit_entropy = self.evaluate_function ( target_array )\\n\\n column_values = {}\\n for k, v in self.map_column_node_type.items():\\n # If there's only one value in feature matrix \\\"X\\\", set the split value to infinity\\n if len ( set ( feature_matrix [ :, k ] ) ) == 1:\\n value = np.inf\\n split = None\\n class_ratios = 1\\n elif v == \\\"continuous\\\":\\n # Get the best possible continuous split for the column\\n split, value, class_ratios = self.get_optimal_continuous_feature_split (\\n feature_matrix = feature_matrix, target_array = target_array, feature_column = k\\n )\\n else:\\n # Get the split value for the discrete column\\n value, class_ratios = self.get_optimal_discrete_feature_split (\\n feature_matrix = feature_matrix, target_array = target_array, feature_column = k\\n )\\n split = None\\n\\n column_values [ k ] = ( split, value, class_ratios )\\n\\n # Get the column with the largest gain ratio\\n col_idx_with_min_value = max (\\n column_values,\\n key = lambda x: ( presplit_entropy - column_values.get ( x ) [ 1 ] )\\n / column_values.get ( x ) [ 2 ],\\n )\\n\\n # If stopping criteria are met or all splits are infinite, terminate the process\\n if (\\n self.early_stopping_comparison (\\n column_values.get ( col_idx_with_min_value ) [ 1 ], self.early_stopping_value\\n )\\n ) or not np.isfinite ( column_values.get ( col_idx_with_min_value ) [ 1 ] ):\\n self.get_terminal_node (\\n feature_column = col_idx_with_min_value,\\n feature_value = column_values [ col_idx_with_min_value ] [ 0 ],\\n node = tree_split,\\n feature_matrix = feature_matrix ,\\n target_array = target_array,\\n )\\n return tree_split\\n\\n # If the best split is continuous, add a continuous node\\n if self.map_column_node_type.get ( col_idx_with_min_value ) == \\\"continuous\\\":\\n return self.get_continuous_node (\\n feature_column = col_idx_with_min_value,\\n feature_value = column_values [col_idx_with_min_value ] [ 0 ],\\n feature_matrix = feature_matrix,\\n target_array = target_array,\\n node = tree_split,\\n )\\n\\n # Otherwise, add a discrete node.\\n else:\\n return self.get_discrete_node (\\n feature_matrix = feature_matrix,\\n target_array = target_array,\\n feature_value = column_values [ col_idx_with_min_value ] [ 0 ],\\n feature_column = col_idx_with_min_value,\\n node = tree_split,\\n )\\n # End get_next_split\",\n \"def findBestValueSplitByGini(self, data, structure, colIndex):\\n minGini, bestSplit = 1, []\\n for i in range(0, len(data)-1):\\n split = (float(data[i][colIndex]) + float(data[i+1][colIndex])) / 2\\n giniSplit = self.calcGiniSplitBySplitValue(data, structure, colIndex, split)\\n if giniSplit <= minGini:\\n minGini = giniSplit\\n bestSplit = [split, giniSplit]\\n return bestSplit\",\n \"def find_split(data):\\n ret = {\\\"router\\\": None, \\\"split_point\\\": None, \\\"entropy\\\": get_entropy(data[:, 7])}\\n\\n # Create array of unique datapoints\\n split_points_list = list()\\n\\n for i in range(data.shape[1] - 1):\\n unique_signal = np.unique(data[:, i])\\n split_points = list()\\n for j in range(len(unique_signal) - 1):\\n split_points.append((unique_signal[j]+unique_signal[j+1])/2)\\n split_points_list.append(split_points)\\n\\n # Split data by split points and calculate entropy\\n for feature in range(len(split_points_list)):\\n for i in range(len(split_points_list[feature])):\\n data_l, data_r = split_data(data, feature + 1, split_points_list[feature][i])\\n entropy = get_entropy(data_l[:, 7], data_r[:, 7])\\n if entropy < ret[\\\"entropy\\\"]:\\n ret[\\\"entropy\\\"] = entropy\\n ret[\\\"router\\\"] = feature + 1\\n ret[\\\"split_point\\\"] = split_points_list[feature][i]\\n\\n return ret[\\\"router\\\"], ret[\\\"split_point\\\"], split_data(data, ret[\\\"router\\\"], ret[\\\"split_point\\\"])\",\n \"def determine_best_split(data, potential_splits, mltask):\\n\\n first_iteration = True\\n for column_index in potential_splits:\\n for value in potential_splits[column_index]:\\n data_below,data_above = split_data(data, column_index, value)\\n \\n if mltask == 'regression':\\n current_overall_metric = calculate_overall_metric(data_below, data_above, metric_function = calculate_mse)\\n \\n # classification\\n else:\\n current_overall_metric = calculate_overall_metric(data_below, data_above, metric_function = calculate_entropy)\\n \\n \\n if first_iteration or current_overall_metric <= best_overall_metric:\\n first_iteration = False\\n \\n best_overall_metric = current_overall_metric\\n best_split_column = column_index\\n best_split_value = value\\n \\n \\n return best_split_column,best_split_value\",\n \"def centroids2(img_segm,liste):\\n m = len(liste)\\n xs = np.zeros(m)\\n ys = np.zeros(m)\\n j=0\\n for elt in liste:\\n pos_list = np.where(img_segm==elt)\\n xs[j] = np.mean(pos_list[0])\\n ys[j] = np.mean(pos_list[1])\\n j+=1\\n return xs,ys\",\n \"def _split_threshold(self, node):\\n\\n # define the score to improve upon\\n if self.n_clusters >= self.min_leaves and node.size <= self.max_leaf_size:\\n # split only if min(children scores) > node.score\\n force_split = False\\n best_score = node.score\\n else:\\n # force split: just take the best (even if children are worse)\\n force_split = True\\n best_score = None\\n\\n left, right = None, None\\n\\n # iterate over embedding dimensions (first ones are more reliable)\\n # up to max_n_vec (included), until we found an improving split\\n for _vec in range(self.n_vec):\\n\\n # get the candidate thresholds along this dimension\\n threshs = self._get_candidate_thresholds(node, _vec)\\n\\n # look for an improving best split along this eigenvector\\n for _t in threshs:\\n # compute the split\\n below_thresh = self.E[node.ids, _vec] < _t\\n _lids = node.ids[below_thresh]\\n _rids = node.ids[np.logical_not(below_thresh)]\\n # check if the tubes are not too small\\n _nl, _nr = len(_lids), len(_rids)\\n is_valid = _nl >= self.min_leaf_size and _nr >= self.min_leaf_size\\n if is_valid:\\n # compute the score of the new tubes only\\n _sl = self.get_tube_score(_lids)\\n _sr = self.get_tube_score(_rids)\\n # get the score of this split\\n split_score = min(_sl, _sr)\\n if best_score is None or split_score > best_score:\\n # better split\\n best_score = split_score\\n node.has_children = True\\n node.thresh = _t\\n left = SpectralNode(\\n _lids, _vec, score=_sl, name=node.name + \\\"0\\\")\\n right = SpectralNode(\\n _rids, _vec, score=_sr, name=node.name + \\\"1\\\")\\n\\n # check stopping criterion\\n if node.has_children:\\n # we found an improving split\\n if _vec > 0 or not force_split:\\n # found an improving non-forced split: stop here\\n break\\n\\n return left, right\",\n \"def minimum_spanning_arborescence(sol):\",\n \"def root_midpoint(self):\\n node1, node2, distance = self.find_middle_point()\\n self.root_nodes(node1, node2, distance)\",\n \"def find_nearest_neighbours_SURF(averageDistance,inst,distanceArray,maxInst): \\r\\n NN=[]\\r\\n min_indices=[] \\r\\n\\r\\n for j in range(maxInst):\\r\\n if inst != j:\\r\\n locator = [inst,j]\\r\\n locator = sorted(locator, reverse=True) #Access corect half of table (result of removed table redundancy)\\r\\n d = distanceArray[locator[0]][locator[1]]\\r\\n if d<averageDistance:\\r\\n min_indices.append(j)\\r\\n \\r\\n for j in range(len(min_indices)):\\r\\n NN.append(min_indices[j])\\r\\n \\r\\n return NN\",\n \"def split(self,X,y=None):\\n all_idx = pd.Series(np.arange(X.shape[0])) \\n mbrg = int(X.shape[0]*self.embargo_pct)\\n test_starts=[(i[0],i[-1]+1) for i in np.array_split(all_idx.values,self.n_splits)]\\n for i, j in test_starts:\\n t0 = all_idx.index[i] # start of test set\\n test_indices = all_idx.values[i:j]\\n maxT1Idx = all_idx.index.searchsorted(all_idx[test_indices].max())\\n train_indices = all_idx.index.searchsorted(all_idx[all_idx<=t0].index)\\n if maxT1Idx < X.shape[0]: \\n train_indices=np.concatenate((train_indices,all_idx[maxT1Idx+mbrg:]))\\n yield train_indices,test_indices\",\n \"def relevant_indexes(data, min_threshold):\\n\\n start_index = 1\\n end_index = len(data) - 1\\n\\n for i in range(len(data)):\\n if data[i] > min_threshold:\\n start_index = i\\n break\\n\\n for i in range(len(data)):\\n if data[::-1][i] > min_threshold:\\n end_index = i\\n break\\n\\n return start_index, end_index\",\n \"def get_best_split(rows):\\n best_gain = 0\\n best_question = None\\n current_impurity = get_gini(rows)\\n n_features = len(rows[0])\\n\\n for col in range(n_features):\\n\\n for row in rows:\\n question = Question(col, row[col])\\n true_rows, false_rows = partition(rows, question)\\n\\n if len(true_rows) == 0 or len(false_rows) == 0:\\n break\\n\\n question_gain = get_info_gain(true_rows, false_rows, current_impurity)\\n\\n if question_gain >= best_gain:\\n best_gain = question_gain\\n best_question = question\\n\\n print(best_gain)\\n print(best_question)\\n return best_gain, best_question\",\n \"def _get_closest(centers, features):\\n pred_labels = []\\n\\n features = features\\n for feature in features:\\n distances = End2End._dist(centers, feature)\\n pred_labels.append(distances.argmin().item())\\n\\n return np.array(pred_labels)\",\n \"def _get_end_points(self, segmented_instances, i, stats, idx):\\n\\n end_points=[]\\n\\n # find all points intersecting the bbox\\n #(tl_x, th_y, width, height, area)\\n label_num=i+1\\n leftmost_x = stats['bbox'][i][cv2.CC_STAT_LEFT]\\n topmost_y = stats['bbox'][i][cv2.CC_STAT_TOP]\\n width = stats['bbox'][i][cv2.CC_STAT_WIDTH]\\n height = stats['bbox'][i][cv2.CC_STAT_HEIGHT]\\n bottom_most_y = topmost_y + height-1\\n right_most_x = leftmost_x + width-1\\n\\n segmented_instances_copy=segmented_instances.copy()\\n edge_points = np.zeros(segmented_instances.shape).astype(np.uint8)\\n segs = np.zeros(segmented_instances.shape).astype(np.uint8)\\n segs[segmented_instances==label_num]=255\\n cv2.rectangle(segmented_instances_copy,(leftmost_x, topmost_y), (right_most_x, bottom_most_y), 150, 2)\\n\\n #Get all points for the current stem segment\\n label_points = np.argwhere(segmented_instances.copy()==label_num)\\n\\n # upper points from (tl_x,th_y) to (th_x, th_y) that instersect with the upper edge of the bouding box\\n upper_points = [i for i in label_points if i[0]==topmost_y and i[1]>=leftmost_x and i[1]<=right_most_x]\\n x_pts, segs, edge_points = self._update_imgs_and_pt_list(upper_points, edge_points, segs, 1)\\n center_upper_pts = sorted(self._get_centeroids(x_pts))\\n\\n # left side points from (tl_x, tl_y) to (tl_x, th_y) that instersect with the left edge of the bouding box\\n left_points = [i for i in label_points if i[1]==leftmost_x and i[0]<=bottom_most_y and i[0]>=topmost_y]\\n x_pts, segs, edge_points = self._update_imgs_and_pt_list(left_points, edge_points, segs, 0)\\n center_left_pts = sorted(self._get_centeroids(x_pts))\\n\\n #right side points form (th_x, tl_y) to (th_x, th_y) that instersect with the right edge of the bouding box\\n right_points = [i for i in label_points if i[1]==right_most_x and i[0]<=bottom_most_y and i[0]>=topmost_y]\\n x_pts, segs, edge_points = self._update_imgs_and_pt_list(right_points, edge_points, segs, 0)\\n center_right_pts = sorted(self._get_centeroids(x_pts))\\n\\n #bottom points from (tl_x, tl_y) to (th_x,tl_y)\\n bottom_points = [i for i in label_points if i[1]>=leftmost_x and i[1]<=right_most_x and i[0]==bottom_most_y]\\n x_pts, segs, edge_points = self._update_imgs_and_pt_list(bottom_points, edge_points, segs, 1)\\n center_bottom_pts = sorted(self._get_centeroids(x_pts))\\n\\n # If there are corner edges, get the centroid of that\\n center_x_lb, center_y_lb, center_left_pts, center_bottom_pts = self._get_corner_centers(center_left_pts, \\\\\\n center_bottom_pts, bottom_most_y, leftmost_x)\\n if (center_x_lb != None) and (center_y_lb != None):\\n end_points.append([center_x_lb, center_y_lb])\\n else:\\n if len(center_left_pts)>0:\\n for pt_idx in range(0, len(center_left_pts)):\\n end_points.append([leftmost_x, center_left_pts[pt_idx]])\\n if len(center_bottom_pts)>0:\\n for pt_idx in range(0, len(center_bottom_pts)):\\n end_points.append([center_bottom_pts[pt_idx], bottom_most_y])\\n\\n # If there are corner edges, get the centroid of that\\n center_x_ur, center_y_ur, center_right_pts, center_upper_pts = self._get_corner_centers(center_right_pts, \\\\\\n center_upper_pts, topmost_y, right_most_x)\\n if (center_x_ur != None) and (center_y_ur != None):\\n end_points.append([center_x_ur, center_y_ur])\\n else:\\n if len(center_right_pts)>0:\\n for pt_idx in range(0, len(center_right_pts)):\\n end_points.append([right_most_x, center_right_pts[pt_idx]])\\n if len(center_upper_pts)>0:\\n for pt_idx in range(0, len(center_upper_pts)):\\n end_points.append([center_upper_pts[pt_idx], topmost_y])\\n\\n # If there are corner edges, get the centroid of that\\n center_x_ul, center_y_ul, center_left_pts, center_upper_pts = self._get_corner_centers(center_left_pts, \\\\\\n center_upper_pts, topmost_y, leftmost_x)\\n if (center_x_ul != None) and (center_y_ul != None):\\n end_points.append([center_x_ul, center_y_ul])\\n else:\\n if len(center_left_pts)>0:\\n for pt_idx in range(0, len(center_left_pts)):\\n end_points.append([leftmost_x, center_left_pts[pt_idx]])\\n if len(center_upper_pts)>0:\\n for pt_idx in range(0, len(center_upper_pts)):\\n end_points.append([center_upper_pts[pt_idx], topmost_y])\\n\\n\\n # If there are corner edges, get the centroid of that\\n center_x_br, center_y_br, center_right_pts, center_bottom_pts = self._get_corner_centers(center_right_pts, \\\\\\n center_bottom_pts, bottom_most_y, right_most_x)\\n if (center_x_br != None) and (center_y_br != None):\\n end_points.append([center_x_br, center_y_br])\\n else:\\n if len(center_right_pts)>0:\\n for pt_idx in range(0, len(center_right_pts)):\\n end_points.append([right_most_x, center_right_pts[pt_idx]])\\n if len(center_bottom_pts)>0:\\n for pt_idx in range(0, len(center_bottom_pts)):\\n end_points.append([center_bottom_pts[pt_idx], bottom_most_y])\\n\\n #self.showme(segmented_instances_copy, 'bbox')\\n\\n return end_points\",\n \"def splitArray(self, nums: List[int], m: int) -> int:\\n l = max(nums)\\n r = sum(nums)\\n ans = r\\n\\n while l <= r:\\n mid = (l + r) // 2\\n range_sum = 0\\n range_sum_count = 1\\n for i in range(len(nums)):\\n if (range_sum + nums[i] > mid):\\n range_sum = nums[i]\\n range_sum_count += 1\\n else:\\n range_sum += nums[i]\\n if range_sum_count <= m:\\n ans = min(ans, mid)\\n r = mid - 1\\n else:\\n l = mid + 1\\n return ans\",\n \"def find_best_split(rows):\\n best_gain = 0 # keep track of the best information gain\\n best_question = None # keep train of the feature / value that produced it\\n current_uncertainty = gini(rows)\\n n_features = len(rows[0]) - 1 # number of columns\\n #print(\\\"n_features:\\\", n_features)\\n\\n for col in range(1,n_features): # for each feature\\n # for each iteration this is the set of all values of a specific column, eg, All pixels number 0\\n values = set([row[col] for row in rows]) # unique values in the column\\n for val in values: # for each value\\n\\n # Create a question object for each val under a column, holding the val and the col number\\n question = Question(col, val)\\n\\n # try splitting the dataset\\n true_rows, false_rows = partition(rows, question)\\n\\n # Skip this split if it doesn't divide the\\n # dataset.\\n if len(true_rows) == 0 or len(false_rows) == 0:\\n continue\\n\\n # Calculate the information gain from this split\\n gain = info_gain(true_rows, false_rows, current_uncertainty)\\n\\n # You actually can use '>' instead of '>=' here\\n # but I wanted the tree to look a certain way for our\\n # toy dataset.\\n if gain >= best_gain:\\n best_gain, best_question = gain, question\\n\\n return best_gain, best_question\",\n \"def midpoint(self) -> Point:\\n l = self._line.meet(infty_hyperplane(self.dim))\\n return harmonic_set(*self.vertices, l)\",\n \"def segment(self):\\n start = self.alignment.matching_function_startpoint(self.idx)\\n end = self.alignment.matching_function_endpoint(self.idx)\\n return [start, end]\",\n \"def get_point_of_interest(self):\\n if self.point_of_interest == \\\"centroid\\\":\\n return (round(float(self.kf.x[0][0]), 2), round(float(self.kf.x[1][0]), 2))\\n elif self.point_of_interest == \\\"botmid\\\":\\n x1, y1, x2, y2 = convert_x_to_bbox(self.kf.x)[0]\\n x = (x2 + x1) / 2\\n y = y2\\n return (round(float(x), 2), round(float(y), 2))\\n elif self.point_of_interest == \\\"topmid\\\":\\n x1, y1, x2, y2 = convert_x_to_bbox(self.kf.x)[0]\\n x = (x2 + x1) / 2\\n y = y1\\n return (round(float(x), 2), round(float(y), 2))\\n else:\\n print(\\\"point of interest not devised\\\")\\n exit()\",\n \"def split_data(data,split_column,split_value):\\n split_column_value = data[:,split_column]\\n type_of_feature = FEATURE_TYPE[split_column]\\n\\n if type_of_feature == 'continuous':\\n data_below = data[split_column_value <= split_value]\\n data_above = data[split_column_value > split_value]\\n else:\\n data_below = data[split_column_value == split_value]\\n data_above = data[split_column_value != split_value]\\n return data_below,data_above\",\n \"def find_midpoint(start, end):\\n mid = (start + end) / 2\\n return int(mid)\",\n \"def mid(self, line):\\n return [(line.x1 + line.x2) // 2, (line.y1 + line.y2) // 2]\",\n \"def get_splits(self) -> Dict[str, np.array]:\\n\\n return self.splits\",\n \"def get_starting_point(self, Otrain, Ftrain, y):\\n return self.get_curve_fmin(Otrain, Ftrain, [y])\\n # xx = np.linspace(np.min(Otrain), np.max(Otrain), 50)\\n # scores, xx = self.compute_scores(Otrain, Ftrain, y, xx)\\n # bestScore = np.max(scores)\\n # Ibest = np.where(scores == bestScore)[0]\\n # x = xx[Ibest[0]]\\n return x\",\n \"def compute_splits(feature_df, target_col, max_num_splits):\\n tree_estimator = DecisionTreeClassifier(max_leaf_nodes=max_num_splits+1,\\n class_weight='balanced',\\n random_state=1407)\\n\\n tree_estimator.fit(feature_df, target_col)\\n thresholds = tree_estimator.tree_.threshold[tree_estimator.tree_.children_left != _tree.TREE_LEAF]\\n return sorted(thresholds)\",\n \"def findfeatures(xarr, farr, sl, sf, ws, mdiff=20, wdiff=20, sigma=5, niter=5,\\n sections=3):\\n\\n # detect lines in the input spectrum and identify the peaks and peak values\\n xp, xf = find_points(xarr, farr, kernal_size=sigma, sections=sections)\\n\\n # return no solution if no peaks were found\\n if len(xp) == 0:\\n return None\\n\\n # find the best match to the lines\\n wp = findmatch(xarr, farr, xp, xf, sl, sf, ws, xlimit=mdiff, wlimit=wdiff)\\n\\n try:\\n for i in range(len(xp)):\\n if wp[i] > -1:\\n pass\\n except Exception as e:\\n message = 'Unable to match line lists because %s' % e\\n raise SpecError(message)\\n return xp, wp\",\n \"def mid_point(a: Point, b: Point) -> Point:\\n return Point((a.x + b.x) / 2, (a.y + b.y) / 2)\",\n \"def select_segment(self, segs, segs_tips, segs_undecided):\\n scores_tips = np.zeros((len(segs), 4))\\n allindices = np.arange(self.X.shape[0], dtype=int)\\n for iseg, seg in enumerate(segs):\\n # do not consider too small segments\\n if segs_tips[iseg][0] == -1: continue\\n # restrict distance matrix to points in segment\\n if not isinstance(self.Dchosen, data_graph.OnFlySymMatrix):\\n Dseg = self.Dchosen[np.ix_(seg, seg)]\\n else:\\n Dseg = self.Dchosen.restrict(seg)\\n # map the global position to the position within the segment\\n tips = [np.where(allindices[seg] == tip)[0][0]\\n for tip in segs_tips[iseg]]\\n # find the third point on the segment that has maximal\\n # added distance from the two tip points\\n dseg = Dseg[tips[0]] + Dseg[tips[1]]\\n third_tip = np.argmax(dseg)\\n new_tips = np.append(tips, third_tip)\\n # compute the score as ratio of the added distance to the third tip,\\n # to what it would be if it were on the straight line between the\\n # two first tips, given by Dseg[tips[:2]]\\n # if we did not normalize, there would be a danger of simply\\n # assigning the highest score to the longest segment\\n if 'bi' == self.flavor_develop:\\n score = Dseg[new_tips[0], new_tips[1]]\\n elif 'tri' == self.flavor_develop:\\n score = dseg[new_tips[2]] / Dseg[new_tips[0], new_tips[1]] * len(seg)\\n else:\\n raise ValueError('unknown `self.flavor_develop`')\\n score = len(seg) if self.choose_largest_segment else score # simply the number of points\\n # self.choose_largest_segment = False\\n logg.msg('... group', iseg, 'score', score, 'n_points', len(seg),\\n '(too small)' if len(seg) < self.min_group_size else '', v=4)\\n if len(seg) <= self.min_group_size: score = 0\\n # write result\\n scores_tips[iseg, 0] = score\\n scores_tips[iseg, 1:] = new_tips\\n iseg = np.argmax(scores_tips[:, 0])\\n if scores_tips[iseg, 0] == 0: return -1, None\\n new_tips = scores_tips[iseg, 1:].astype(int)\\n return iseg, new_tips\",\n \"def get_split_goodness_fit_continuous (\\n feature_array: np.ndarray, target_array: np.ndarray, split: float, evaluate_function: Callable\\n ):\\n # Get above and below the split value\\n above = feature_array >= split\\n below = feature_array < split\\n\\n # Get weighted average evaluate_function on the splits\\n n_above = np.sum ( above )\\n above_eval = (\\n evaluate_function ( target_array [ above ] ) * n_above / len ( target_array )\\n ) # Weight = frac points in above\\n below_eval = (\\n evaluate_function ( target_array [ below ] ) * ( len ( target_array ) - n_above ) / len ( target_array )\\n ) # Weight = frac points not in above\\n\\n # returns weighted sum of evaluate_function across splits & the gain ratio denominator\\n return (\\n above_eval + below_eval,\\n -1\\n * sum (\\n map (\\n lambda x: x * np.log ( x ),\\n [ n_above / len ( target_array ), ( len ( target_array ) - n_above ) / len ( target_array ) ],\\n )\\n ),\\n ) # End get_split_goodness_fit_continuous\",\n \"def handle_singleton_ppn_candidate(pts, ppn_candidates):\\n assert ppn_candidates.shape[0] == 1\\n score = ppn_candidates[0][5:]\\n label = np.argmax(score)\\n dist = cdist(pts, ppn_candidates[:, :3])\\n pt_near = pts[dist.argmin(axis=0)]\\n pt_far = pts[dist.argmax(axis=0)]\\n if label == 0:\\n startpoint = pt_near.reshape(-1)\\n endpoint = pt_far.reshape(-1)\\n else:\\n endpoint = pt_near.reshape(-1)\\n startpoint = pt_far.reshape(-1)\\n\\n new_points = np.vstack([startpoint, endpoint])\\n\\n return new_points\",\n \"def _find_split(self, X, y, n_features):\\r\\n splits_info = []\\r\\n\\r\\n # Select features to consider\\r\\n features = self._feature_selection.get_features(n_features, self._feature_prob)\\r\\n\\r\\n # Get candidate splits\\r\\n for feature_id in features:\\r\\n for split_value in compute_split_values(X[:, feature_id]):\\r\\n splits_info.append(\\r\\n compute_split_info(self._split_criterion, X, y, feature_id, split_value, self._min_samples_leaf))\\r\\n\\r\\n splits = []\\r\\n for split_info in splits_info:\\r\\n if split_info is not None:\\r\\n gain, feature_id, split_value = split_info\\r\\n split = Split(feature_id, value=split_value, gain=gain)\\r\\n splits.append(split)\\r\\n else:\\r\\n continue\\r\\n\\r\\n selected_split = self._split_chooser.get_split(splits)\\r\\n return selected_split\",\n \"def get_avg_points(self):\\n pass\",\n \"def midleft(self):\\n return (self.left, self.centery)\",\n \"def mid(arr):\\n\\n \\n arr_ln = len(arr)\\n mid = arr_ln//2\\n val = arr.pop(mid)\\n\\n return arr, val\",\n \"def compute_midpoints(structure_centroids):\\n\\n from metadata import all_known_structures, singular_structures, convert_to_left_name, convert_to_right_name\\n\\n midpoints = {}\\n for s in all_known_structures:\\n if s in singular_structures:\\n if s not in structure_centroids:\\n continue\\n c = np.array(structure_centroids[s])\\n else:\\n sl = convert_to_left_name(s)\\n sr = convert_to_right_name(s)\\n if sl not in structure_centroids or sr not in structure_centroids:\\n continue\\n c = (np.array(structure_centroids[sl]) + np.array(structure_centroids[sr]))/2\\n midpoints[s] = c\\n return midpoints\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7009221","0.66867995","0.6500667","0.6397656","0.6387852","0.6146362","0.6117075","0.6101361","0.60497683","0.60440624","0.6034719","0.60301876","0.6004744","0.59204274","0.58992785","0.5869794","0.5834895","0.58053046","0.57847375","0.5784375","0.5763142","0.57535654","0.5734336","0.57179314","0.57176197","0.56986636","0.5696211","0.56858945","0.5671843","0.5664231","0.5644525","0.56351197","0.5623001","0.5574017","0.5568625","0.55670965","0.5523811","0.5517441","0.5464537","0.54540426","0.5451041","0.5450987","0.54474807","0.54424655","0.54212797","0.5420013","0.540519","0.540519","0.5404319","0.5400652","0.53963757","0.5389615","0.53679544","0.5366592","0.53660375","0.5363439","0.534938","0.5322928","0.53203404","0.53144383","0.5306751","0.52946025","0.52842224","0.52840614","0.52790475","0.52722126","0.5265599","0.526214","0.52554405","0.52546585","0.5252637","0.52521825","0.5240174","0.5236864","0.52227247","0.5214542","0.52102584","0.5203589","0.51989156","0.51961625","0.5193505","0.51922935","0.5187292","0.5185296","0.5175374","0.51735425","0.51597595","0.5156427","0.51559633","0.5149196","0.5147509","0.5142795","0.51404476","0.51287556","0.51271075","0.5124461","0.5119968","0.5119829","0.51191306","0.5114608"],"string":"[\n \"0.7009221\",\n \"0.66867995\",\n \"0.6500667\",\n \"0.6397656\",\n \"0.6387852\",\n \"0.6146362\",\n \"0.6117075\",\n \"0.6101361\",\n \"0.60497683\",\n \"0.60440624\",\n \"0.6034719\",\n \"0.60301876\",\n \"0.6004744\",\n \"0.59204274\",\n \"0.58992785\",\n \"0.5869794\",\n \"0.5834895\",\n \"0.58053046\",\n \"0.57847375\",\n \"0.5784375\",\n \"0.5763142\",\n \"0.57535654\",\n \"0.5734336\",\n \"0.57179314\",\n \"0.57176197\",\n \"0.56986636\",\n \"0.5696211\",\n \"0.56858945\",\n \"0.5671843\",\n \"0.5664231\",\n \"0.5644525\",\n \"0.56351197\",\n \"0.5623001\",\n \"0.5574017\",\n \"0.5568625\",\n \"0.55670965\",\n \"0.5523811\",\n \"0.5517441\",\n \"0.5464537\",\n \"0.54540426\",\n \"0.5451041\",\n \"0.5450987\",\n \"0.54474807\",\n \"0.54424655\",\n \"0.54212797\",\n \"0.5420013\",\n \"0.540519\",\n \"0.540519\",\n \"0.5404319\",\n \"0.5400652\",\n \"0.53963757\",\n \"0.5389615\",\n \"0.53679544\",\n \"0.5366592\",\n \"0.53660375\",\n \"0.5363439\",\n \"0.534938\",\n \"0.5322928\",\n \"0.53203404\",\n \"0.53144383\",\n \"0.5306751\",\n \"0.52946025\",\n \"0.52842224\",\n \"0.52840614\",\n \"0.52790475\",\n \"0.52722126\",\n \"0.5265599\",\n \"0.526214\",\n \"0.52554405\",\n \"0.52546585\",\n \"0.5252637\",\n \"0.52521825\",\n \"0.5240174\",\n \"0.5236864\",\n \"0.52227247\",\n \"0.5214542\",\n \"0.52102584\",\n \"0.5203589\",\n \"0.51989156\",\n \"0.51961625\",\n \"0.5193505\",\n \"0.51922935\",\n \"0.5187292\",\n \"0.5185296\",\n \"0.5175374\",\n \"0.51735425\",\n \"0.51597595\",\n \"0.5156427\",\n \"0.51559633\",\n \"0.5149196\",\n \"0.5147509\",\n \"0.5142795\",\n \"0.51404476\",\n \"0.51287556\",\n \"0.51271075\",\n \"0.5124461\",\n \"0.5119968\",\n \"0.5119829\",\n \"0.51191306\",\n \"0.5114608\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.70583206"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":78593,"cells":{"query":{"kind":"string","value":"Function to evaluate the goodness of the continuous split value."},"document":{"kind":"string","value":"def get_split_goodness_fit_continuous (\n feature_array: np.ndarray, target_array: np.ndarray, split: float, evaluate_function: Callable\n ):\n # Get above and below the split value\n above = feature_array >= split\n below = feature_array < split\n\n # Get weighted average evaluate_function on the splits\n n_above = np.sum ( above )\n above_eval = (\n evaluate_function ( target_array [ above ] ) * n_above / len ( target_array )\n ) # Weight = frac points in above\n below_eval = (\n evaluate_function ( target_array [ below ] ) * ( len ( target_array ) - n_above ) / len ( target_array )\n ) # Weight = frac points not in above\n\n # returns weighted sum of evaluate_function across splits & the gain ratio denominator\n return (\n above_eval + below_eval,\n -1\n * sum (\n map (\n lambda x: x * np.log ( x ),\n [ n_above / len ( target_array ), ( len ( target_array ) - n_above ) / len ( target_array ) ],\n )\n ),\n ) # End get_split_goodness_fit_continuous"},"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_split_goodness_fit_continuous(\n arr: np.ndarray, y: np.ndarray, split: float, eval_func: Callable\n ):\n # Get above and below the split value\n above = arr >= split\n below = arr < split\n\n # get weighted average eval_func on the splits\n n_above = np.sum(above)\n above_eval = (\n eval_func(y[above]) * n_above / len(y)\n ) # weight = frac points in above\n below_eval = (\n eval_func(y[below]) * (len(y) - n_above) / len(y)\n ) # weight = frac points not in above\n\n # returns weighted sum of eval_func across splits, and the gain ratio denominator\n return (\n above_eval + below_eval,\n -1\n * sum(\n map(\n lambda x: x * np.log(x),\n [n_above / len(y), (len(y) - n_above) / len(y)],\n )\n ),\n )","def test_ThinData(self):\n for split in self.splits:\n y_data, x_data = data_process.thinData(y_test, xdim_test, split)\n oldStep = float(xdim_test[1]) - float(xdim_test[0])\n newStep = float(x_data[1]) - float(x_data[0])\n self.assertAlmostEqual(newStep/oldStep,split)\n self.assertTrue(len(y_data) == len(x_data))","def test_split(self,X,y,splits):\n n_data = len(y) #Number of data points\n splits=(X[splits]+X[splits+1])/2\n\n idx_greater = (X>splits[:,None]) #index for greater split\n idx_lower = (X<splits[:,None]) #index for lower split\n\n imp_greater =[self.impurity(y[idx]) for idx in idx_greater] #impurity for greater\n imp_lower = [self.impurity(y[idx]) for idx in idx_lower] #impurity lower\n\n impur = [sum(idx_great)/n_data*imp_great+sum(idx_low)/n_data*imp_low for idx_great,imp_great,idx_low,imp_low in zip(idx_greater,imp_greater,idx_lower,imp_lower)] #Weighted impurity\n return (impur,splits)","def sanity_check(self):\n score = 0\n curvatures = self._curvature()\n if abs(curvatures[0] - curvatures[1]) / max(curvatures) > 0.15:\n # difference in curvature is more than 15%\n score -= 1\n\n diff_std = np.std(self.right_fitx - self.left_fitx)\n if diff_std > 30:\n # std of the difference between the right lane and left lane is more than 30 pixel\n score -= 1\n\n # roughly parallel\n if abs(self.left_fit[0] - self.right_fit[0]) / max(self.left_fit[0], self.right_fit[0]) > 0.15:\n # difference in slope is more than 15%\n score -= 1\n\n return score","def test_Sobol_G_raises_error_if_values_gt_one():\n evaluate(np.array([0, 1, .02, 0.23, 1.234, 0.02848848, 0, 0.78]))","def test_continuous():\n # assert the distribution of the samples is close to the distribution of the data\n # using kstest:\n # - uniform (assert p-value > 0.05)\n # - gaussian (assert p-value > 0.05)\n # - inversely correlated (assert correlation < 0)","def test_gross_range_check(self):\n fail_span = (10, 50)\n suspect_span = (20, 40)\n vals = [\n 5, 10, # Sensor range.\n 15, # User range.\n 20, 25, 30, 35, 40, # Valid\n 45, # User range.\n 51 # Sensor range.\n ]\n result = np.ma.array([\n 4, 3,\n 3,\n 1, 1, 1, 1, 1,\n 3,\n 4\n ])\n\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\")\n inputs = [\n vals,\n np.array(vals, dtype=np.integer),\n np.array(vals, dtype=np.floating),\n dask_arr(np.array(vals, dtype=np.integer)),\n dask_arr(np.array(vals, dtype=np.floating))\n ]\n\n for i in inputs:\n npt.assert_array_equal(\n qartod.gross_range_test(\n inp=i,\n fail_span=fail_span,\n suspect_span=suspect_span\n ),\n result\n )","def test_value_loss(self):\n ValueEstimator = self.notebook_locals[\"ValueEstimator\"]\n value_f = ValueEstimator(\n num_hidden=1, hidden_dim=2, obs_dim=2, action_dim=1\n )\n student_value_loss = self.notebook_locals[\"util_compute_value_loss\"]\n # initialize to constant values\n for p in value_f.parameters():\n torch.nn.init.ones_(p)\n\n # test tensors\n obs = torch.ones(3, 2) * 2.0\n returns = torch.arange(3, 6).float()\n\n loss_student = student_value_loss(value_f, obs, returns)\n self.assertTrue(\n torch.abs(loss_student - 2.0317) < 0.1,\n \"The value loss computation is incorrect\",\n )","def test_fit_score(self):\n oz = ClassificationScoreVisualizer(GaussianNB())\n assert_not_fitted(oz, X_test=self.binary.X.test)\n assert oz.fit(self.binary.X.train, self.binary.y.train) is oz\n assert 0.0 <= oz.score(self.binary.X.test, self.binary.y.test) <= 1.0\n assert_fitted(oz, X_test=self.binary.X.test)","def test_divide_curve():\n c1 = Curve(data=data_num, mnemonic='test')\n c2 = c1 / 2\n assert (c2.df.iloc[0][0] - 0.5) < 0.0001","def get_split(data):\n \"\"\" gets the best feature, and best value \"\"\"\n\n best_feature = None\n best_value = 0.0\n columns = data.columns\n gini_base = gini_impurity(data)\n n_rows = len(data.index) # total number of rows of data before split\n\n # Fininding which split yields the best gini gain\n max_gain = 0\n\n for i in range(len(columns)-1): # -1 b.c. class is final column\n xs = data[columns[i]].unique() # get values to test\n for x in xs: # test values\n # split dataset\n df_left = data[data[columns[i]] < x]\n df_right = data[data[columns[i]] >= x]\n\n # get gini impurities\n gini_left = gini_impurity(df_left)\n gini_right = gini_impurity(df_right)\n \n\n # Calculated weighted gini impurity\n w_left = len(df_left.index) / n_rows\n w_right = len(df_right.index) / n_rows\n\n w_gini = gini_left * w_left + gini_right * w_right\n \n\n # Calculate gini gain (we want to minimize w_gini for the smallest impurity. Ideal split is perfect Left=c1, Right=c2)\n # why not just find min w_gin instead of uding gini_gain and gini_base vaiables?\n gini_gain = gini_base - w_gini\n\n # check if this is the best split so far, store values, update max_gini\n if gini_gain > max_gain:\n best_feature = columns[i]\n best_value = x\n max_gain = gini_gain\n\n df_left = data.loc[data[best_feature] < best_value]\n df_right = data.loc[data[best_feature] >= best_value]\n \n\n return best_feature, best_value, df_left, df_right","def divide_train_test(fr):\n b = fr['TIN_hash_byte']\n train = fr[ b < 200 ]\n valid = fr[ (200 <= b) & (b < 232) ]\n test = fr[ 232 <= b ]\n return train, valid, test","def calc(self,newValue):\n return np.sum(self.values<=newValue)/self.n","def check_if_stopping_criterion_is_met(original_training_data_values):\n if len(original_training_data_values)<23:\n return True\n else:\n target_column = original_training_data_values[:, -1]\n recipe_type, cupcake_muffin_count = np.unique(target_column, return_counts=True)\n cupcake_ratio = cupcake_muffin_count[0] / (cupcake_muffin_count.sum())\n muffin_ratio = cupcake_muffin_count[1] / (cupcake_muffin_count.sum())\n\n if cupcake_ratio >= 0.9 or muffin_ratio >= 0.9:\n return True\n else:\n return False","def test_half_case(self):\n steps = save_divide(np.ones(2), 2 * np.ones(2))\n np.testing.assert_equal(steps, 0.5 * np.ones(2))","def test_percentage_metric_in_interval_0_1(a, b, dim, metric):\n res = metric(a, b, dim)\n assert not (res < 0).any()\n assert not (res > 1).any()\n assert not res.isnull().any()","def test_kpss(self):\n\n kpsstest = kpss(self.ts_df['y'], regression='c')\n kpss_output = pd.Series(kpsstest[0:3], index=['Test Statistic', 'p-value', 'Lags Used'])\n for key, value in kpsstest[3].items():\n kpss_output['Critical Value (%s)' % key] = value\n print(kpss_output)\n if kpsstest[0] > kpsstest[3]['5%']:\n print(\n \"Test statistic greater than critical value at 5% --> series seems to be not stationary. \"\n \"Look at critical values at 1% and 10% too, ideally they also should be greater than test statistic.\")\n else:\n print(\n \"Test statistic less than critical value at 5% --> series seems to be stationary. \"\n \"Look at critical values at 1% and 10% too, ideally they also should be less than test statistic.\")","def test_gini_gain(self):\n self.decision_tree.train(self.data,\n list(range(self.data.num_samples)),\n max_depth=1,\n min_samples_per_node=1,\n use_stop_conditions=False,\n max_p_value_chi_sq=None)\n self.assertEqual(self.decision_tree.get_root_node().node_split.separation_attrib_index, 0)\n self.assertEqual(self.decision_tree.get_root_node().node_split.splits_values,\n [set([0]), set([1])])\n self.assertEqual(self.decision_tree.get_root_node().node_split.values_to_split,\n {0:0, 1:1})\n self.assertEqual(self.decision_tree.get_root_node().node_split.criterion_value, 0.5)","def error(self, in_sample=True):\n if in_sample:\n error = 0.0\n for i, point in enumerate(self.X):\n if self.Y[i] != self.rbf_classify(point):\n error += 1\n return error / 100\n else:\n error = 0.0\n for i, point in enumerate(self.test_X):\n if self.test_Y[i] != self.rbf_classify(point):\n error += 1\n return error / 10000","def test_estimateFullRichness(self):\r\n # Verified with iNEXT.\r\n\r\n # f2 > 0\r\n obs = self.estimator3.estimateFullRichness()\r\n assert_almost_equal(obs, 5.5)\r\n\r\n # f2 == 0\r\n obs = self.estimator4.estimateFullRichness()\r\n assert_almost_equal(obs, 4)","def evaluate(self, training_scores, original_test_scores, imitation_test_scores):\n\n #finding a threshold: third to smallest training score\n sorted_scores = np.sort(training_scores)\n threshold = sorted_scores[2]\n\n #computing the number of errors\n errors = len(np.where(original_test_scores < threshold)[0])\n errors += len(np.where(imitation_test_scores > threshold)[0])\n\n #computing the local accuracy\n accuracy = 1 - errors/(len(original_test_scores)+len(imitation_test_scores))\n return accuracy, threshold","def test_gini_gain(self):\n self.decision_tree.train(self.data,\n list(range(self.data.num_samples)),\n max_depth=1,\n min_samples_per_node=1,\n use_stop_conditions=False,\n max_p_value_chi_sq=None)\n self.assertEqual(self.decision_tree.get_root_node().node_split.separation_attrib_index, 1)\n self.assertEqual(self.decision_tree.get_root_node().node_split.splits_values,\n [set([0]), set([1]), set([2])])\n self.assertEqual(self.decision_tree.get_root_node().node_split.values_to_split,\n {0:0, 1:1, 2:2})\n self.assertEqual(self.decision_tree.get_root_node().node_split.criterion_value, 0.66)","def important_features_(self):\n return self.scores_ > self.score_cutoff_","def test_error_curve(self):\r\n\r\n scores = self.test_confidences\r\n sort = numpy.argsort(scores, axis=0)\r\n sorted_scores = scores[sort]\r\n\r\n test_errors = numpy.zeros((scores.shape[0]))\r\n thresholds = numpy.zeros((scores.shape[0]))\r\n\r\n for i in range(sort.shape[0]):\r\n thresholds[i] = sorted_scores[i]\r\n test_errors[i] = numpy.sum(self.test_errors[self.test_confidences >= thresholds[i]]) / float(numpy.sum(self.test_confidences >= thresholds[i]))\r\n\r\n return test_errors, thresholds","def classify(self, testInstance):\n return self.fire(testInstance) > 0.5","def qc_NoiseRank(spread):\n\n variance = spread*spread # for a Gaussian\n \n if (variance <= 0.2):\n qc_label = 'good'\n elif (0.2 < variance < 0.25):\n qc_label = 'ok'\n else:\n qc_label = 'bad'\n \n return qc_label","def evaluate_split( df, attribute, split ):\n mask = df[attribute] <= split\n \n # split the dataset on the split attribute\n dfl = df[mask]\n dfr = df[~mask]\n \n \n # calculate weighting factors for child\n weighting_factor_left = float(dfl.shape[0])/df.shape[0]\n weighting_factor_right = float(dfr.shape[0])/df.shape[0]\n\n # calculate gini for left and right\n gini_parent = gini_impurity(df)\n gini_left = gini_impurity(dfl)\n gini_right = gini_impurity(dfr)\n \n # calculate weighted gini for this split \n weighted_gini = gini_parent - (weighting_factor_left*gini_left + weighting_factor_right*gini_right)\n return weighted_gini","def test_data_split_good():\n\tdf_true = pd.read_csv(\"test/sample_data.csv\")\n\tdf_test = df_true.copy()\n\ttarget = df_true['price']\n\tfeatures = df_true.loc[:, df_true.columns != 'price']\n\n\tX_train_true, X_test_true, y_train_true, y_test_true = train_test_split(features, target, \n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\ttest_size=0.4, random_state=0)\n\n\tsplit_data = {'test_size': 0.4, 'random_state': 0}\n\tX_train_test, X_test_test, y_train_test, y_test_test = data_split(df_test, 'price', split_data)\n\n\tassert X_train_true.equals(X_train_test)\n\tassert y_train_true.equals(y_train_test)\n\tassert X_test_true.equals(X_test_test)\n\tassert y_test_true.equals(y_test_test)","def test_Sobol_G_raises_error_if_values_gt_one():\n with raises(ValueError):\n evaluate(np.array([0, 1, .02, 0.23, 1.234, 0.02848848, 0, 0.78]))","def test_compute_unnormalized_scores(self):\n # todo: implement this test!\n pass","def test_increasing_trend_is_false_if_price_decreases(self):\n self.given_a_series_of_prices([8, 12, 10])\n self.assertFalse(self.goog.is_increasing_trend())","def test_demand_variability(self):\n demand_variability = self._uncertain_demand.demand_variability\n avg_order = sum([int(item) for item in self._data_set.values()]) //len(self._data_set)\n variance = [(item - avg_order) for item in self._data_set.values()]\n stdev = pow(sum([pow(j, 2) for j in variance]) / len(self._data_set), 0.5)\n cal_variability = lambda x, y: x / y\n test_variability = cal_variability(stdev, avg_order)\n self.assertEqual(demand_variability, test_variability)","def test_score_with_fitted_estimator(self):\n model = GaussianNB().fit(self.binary.X.train, self.binary.y.train)\n\n # NOTE that the wrapper will pass a call down to `classes_`\n oz = ClassificationScoreVisualizer(model)\n assert_not_fitted(oz, [\"class_counts_\", \"score_\"])\n\n msg = \"could not determine class_counts_\"\n with pytest.warns(YellowbrickWarning, match=msg):\n oz.score(self.binary.X.test, self.binary.y.test)\n assert_fitted(oz, [\"classes_\", \"class_counts_\", \"score_\"])","def quality_data(self, s):\n known_symbols = np.mod(range(176),48)>=32\n print('quality_data',np.sum(np.real(s[known_symbols])<0))\n success = np.sum(np.real(s[known_symbols])<0) < 20\n return success,0 ## no doppler estimate for data frames","def evaluate(self, test_data, split=2):\n size = int(len(test_data) / split)\n mini_batch_split = np.arange(size, len(test_data), size)\n mini_batches = np.split(test_data, mini_batch_split)\n total = 0\n\n for mini_batch in mini_batches:\n xs, ys = np.array(mini_batch).T\n xs = cp.array(cp.vstack(xs).astype(np.float64).reshape((-1, self.sizes[0], 1)))\n ys = cp.array(ys.astype(np.int64))\n total += cp.sum(cp.argmax(self.feedforward(xs), axis=(1, 2)) == ys)\n return total","def test_half_life():\n assert np.isclose(\n half_life(\"tritium\").to(u.s).value, (12.32 * u.yr).to(u.s).value, rtol=2e-4\n ), \"Incorrect half-life for tritium.\"","def compute_confidence_interval(self) -> bool:\n return False","def test_threat(self):\n metric = verif.metric.Threat()\n obs = np.array([0, 1, 2, 3])\n fcst = np.array([0, 3, 1, 2])\n\n # Hits: 1\n # FA: 1\n # Miss: 1\n # CR: 0\n interval = verif.interval.Interval(1.5, np.inf, True, True)\n f_interval = verif.interval.Interval(1.5, np.inf, True, True)\n value = metric.compute_from_obs_fcst(obs, fcst, interval, f_interval)\n self.assertEqual(value, 1.0/3)","def test_gain_ratio(self):\n self.decision_tree.train(self.data,\n list(range(self.data.num_samples)),\n max_depth=1,\n min_samples_per_node=1,\n use_stop_conditions=False,\n max_p_value_chi_sq=None)\n self.assertEqual(self.decision_tree.get_root_node().node_split.separation_attrib_index, 0)\n self.assertEqual(self.decision_tree.get_root_node().node_split.splits_values,\n [set([0]), set([1])])\n self.assertEqual(self.decision_tree.get_root_node().node_split.values_to_split,\n {0:0, 1:1})\n self.assertEqual(self.decision_tree.get_root_node().node_split.criterion_value, 1.0)","def test_increasing_trend_is_false_if_price_equal(self):\n self.given_a_series_of_prices([8, 10, 10])\n self.assertFalse(self.goog.is_increasing_trend())","def train_val_test_split(data):\n raise NotImplementedError","def test_information_gain(self):\n self.decision_tree.train(self.data,\n list(range(self.data.num_samples)),\n max_depth=1,\n min_samples_per_node=1,\n use_stop_conditions=False,\n max_p_value_chi_sq=None)\n self.assertEqual(self.decision_tree.get_root_node().node_split.separation_attrib_index, 1)\n self.assertEqual(self.decision_tree.get_root_node().node_split.splits_values,\n [set([0]), set([1]), set([2])])\n self.assertEqual(self.decision_tree.get_root_node().node_split.values_to_split,\n {0:0, 1:1, 2:2})\n self.assertAlmostEqual(self.decision_tree.get_root_node().node_split.criterion_value,\n 2. * -0.3 * math.log2(0.3) - 0.4 * math.log2(0.4))","def test_Sobol_G_raises_error_if_values_lt_zero():\n evaluate(np.array([0, -1, -.02, 1, 1, -0.1, -0, -12]))","def test_left(self):\n x = np.array([-1.1, -1, 0, 1, 2, 100])\n self.assertEqual(npinterval.half_sample_mode(x), -1.05)","def test_gain_ratio(self):\n self.decision_tree.train(self.data,\n list(range(self.data.num_samples)),\n max_depth=1,\n min_samples_per_node=1,\n use_stop_conditions=False,\n max_p_value_chi_sq=None)\n self.assertEqual(self.decision_tree.get_root_node().node_split.separation_attrib_index, 1)\n self.assertEqual(self.decision_tree.get_root_node().node_split.splits_values,\n [set([0]), set([1]), set([2])])\n self.assertEqual(self.decision_tree.get_root_node().node_split.values_to_split,\n {0:0, 1:1, 2:2})\n self.assertEqual(self.decision_tree.get_root_node().node_split.criterion_value, 1.0)","def test_efficiency(self):\n effs = self.gr.calculate_global_efficiencies()\n ans = [a/6 for a in [1.5, 2., 1.5]]\n self.assertListEqual(effs.values(), ans)\n\n E = self.gr.global_efficiency()\n self.assertEqual(E, sum(ans))\n\n v_min = (E - (1/3)) / E\n mx, v = self.gr.vulnerability()\n # the middle node (2) is the most vulnerable\n self.assertEqual(mx, (2, v_min))","def test_sdp_output():\n state_output_value = fidelity_of_separability(sep_rho, [2, 2], 2)\n assert np.isclose(1, state_output_value)","def get_min_across_splits_continuous(\n arr: np.ndarray, y: np.ndarray, splits: np.ndarray, eval_func: Callable\n ):\n n = len(splits)\n if n > 500:\n # If many split points, use some threading\n with multiprocessing.Pool(processes=8) as p:\n # Get evaluation scores across all the splits\n post_split_evals = dict(\n zip(\n range(len(splits)),\n p.starmap(\n BaseTree.get_split_goodness_fit_continuous,\n zip([arr] * n, [y] * n, splits, [eval_func] * n),\n ),\n )\n )\n p.close()\n else:\n # If not too many split points, get scores across all splits\n post_split_evals = dict(\n zip(\n range(len(splits)),\n map(\n lambda x: BaseTree.get_split_goodness_fit_continuous(*x),\n zip([arr] * n, [y] * n, splits, [eval_func] * n),\n ),\n )\n )\n # Get the minimum split based on gain ratio\n min_eval = min(\n post_split_evals,\n key=lambda x: pipe(\n post_split_evals.get(x),\n lambda results: results[0] / results[1], # entropy / intrinsic value\n ),\n )\n\n # Return the best split and the splits scores\n return (splits[min_eval], *post_split_evals.get(min_eval))","def test_rdivide_curve():\n c1 = Curve(data=data_num, mnemonic='test')\n c2 = 400 / c1\n assert (c2.df.iloc[-1][0] - 2.0) < 0.0001","def test_gradient_convergence(self):\n pass","def checks(self, poly_fit, poly_fitx, poly_fity):\n if self.best_fit is not None:\n if not (np.abs(self.best_fit-poly_fit) <\n np.array([0.001, 1, 500])).all():\n return False\n if self.bestx is not None:\n if np.mean(np.abs(self.bestx-poly_fitx)) > 200:\n return False\n\n return True","def test_is_ramped_using_int(self):\n self.feature_test.set_percentage(100)\n self.assertTrue(self.feature_test._is_ramped(5))","def expected_value(held_dice, num_die_sides, num_free_dice):\r\n \r\n scores = []\r\n \r\n die_sides = [(die + 1) for die in range(num_die_sides)]\r\n \r\n pos_outcomes = gen_all_sequences(die_sides, num_free_dice)\r\n\r\n for outcome in pos_outcomes:\r\n scores.append(score(held_dice + outcome))\r\n \r\n expected_result = float(sum(scores))/len(scores)\r\n \r\n return expected_result","def determine_threshold(yval,pval):\n\n F1 = 0\n epsilon = 0\n for _epsilon in np.linspace(min(pval),max(pval),1000):\n ## Compute stats\n _F1,stats = evaluate_epsilon(yval,pval,_epsilon)\n\n if _F1 > F1:\n F1 = _F1\n epsilon = _epsilon\n print(\"Better threshold found! {} ==> F1 {}\".format(epsilon,F1))\n \n return epsilon, F1","def test_evaluate():\n X_train, X_test, y_train, y_test = src.load()\n clf, score = src.train(X_train, y_train)\n test_score = src.evaluate(clf, X_test, y_test)\n assert isinstance(test_score, float)","def is_best(self, metric: float) -> bool:","def test_Gaussian_NB_estimators():","def possession(self, good):\n return float(self._haves[good])","def test_score(self):\n reg = ElasticRegistration()\n reg.fit(self.unimodal_samples)\n score = reg.score(self.unimodal_samples)\n np.testing.assert_almost_equal(score, 0.9994225)","def expected_value(held_dice, num_die_sides, num_free_dice):\n list_scores = []\n die_sides = [die for die in range(1, num_die_sides + 1)]\n possible_seq = gen_all_sequences(die_sides, num_free_dice)\n for item in possible_seq:\n list_scores.append(score(held_dice + item))\n \n return float(sum(list_scores)) / len(list_scores)","def isgood(self):\n\t\tanswer = True\n\t\t\n\t\tif self.mes_flux <= 0.0:\n\t\t\tanswer = False\n\n\t\treturn answer","def sanity_check(self):\n res = True\n res = res and self.detected\n res = res and np.sum(self.diffs) < 30000 # experimental value\n return res","def test_decision_tree_min_samples_split_parameter(params, X_train, X_test, y_train, y_test):","def test_evaluate(self):\n # Check build does not raise errors\n dataset = KDDCupDataset()\n dataset.create_fixed_samples(\n *self.data, samples_num=1, partition_sizes=self.partition_sizes)\n dataset.set_current_sample(0)\n model = self.MODEL(dataset, **self.model_arguments)\n model.fit(training_epochs=50)\n metric = model.evaluate('test')\n self.assertLessEqual(0, metric)\n self.assertGreaterEqual(1, metric)","def checkConvergence(self, iteration):\n threshold = abs(0.05*self.overBestVal)\n stdev = np.std(np.array([particle.bestXYZ[2] for particle in self.swarm]))\n if self.overBestVal==self.prevBestVal:\n self.bestStreak+=1\n else:\n self.bestStreak=0\n if stdev<=threshold:\n exitFlag = 0 #set this convergence pattern as exit flag 0\n print('Converged: All points converged to same position; std was less than threshold')\n elif self.bestStreak>=50:\n exitFlag = 1 #set this convergence patter as exit flag 1\n print('Converged: Best value did not increase %d times in a row' %50)\n elif iteration>=800:\n exitFlag = 2 #sets no convergence as exit flag 2\n print('Did not converge, exceeded iteration threshold')\n else:\n exitFlag = None\n return [stdev <= threshold or self.bestStreak>=50 or iteration>=800, exitFlag]","def calcGiniSplitBySplitValue(self, data, structure, colIndex, splitValue):\n dataBellow = list(filter(lambda x: float(x[colIndex]) <= splitValue, data))\n dataAbove = list(filter(lambda x: float(x[colIndex]) > splitValue, data))\n giniSplit = (len(dataBellow) / len(data)) * self.calcDataGini(dataBellow, structure) +\\\n (len(dataAbove) / len(data)) * self.calcDataGini(dataAbove, structure)\n return round(giniSplit, 3)","def score(self):\n\n\t\tsplits = 10\n\t\tscore = 0\n\n\t\tkf = KFold(n_splits=splits, shuffle=True)\n\t\tkf.get_n_splits(self.data)\n\n\t\tfor train_ind, test_ind in kf.split(self.data):\n\n\t\t\ttrain = [self.data[ind] for ind in train_ind]\n\t\t\ttest = [self.data[ind] for ind in test_ind]\n\n\t\t\tself.model = self._fit(train)\n\t\t\ttemp_score = self.score_one(test)\n\t\t\tscore += temp_score\n\n\t\treturn score/float(splits)","def score(self):\n\n\t\tsplits = 10\n\t\tscore = 0\n\n\t\tkf = KFold(n_splits=splits, shuffle=True)\n\t\tkf.get_n_splits(self.data)\n\n\t\tfor train_ind, test_ind in kf.split(self.data):\n\n\t\t\ttrain = [self.data[ind] for ind in train_ind]\n\t\t\ttest = [self.data[ind] for ind in test_ind]\n\n\t\t\tself.model = self._fit(train)\n\t\t\ttemp_score = self.score_one(test)\n\t\t\tscore += temp_score\n\n\t\treturn score/float(splits)","def get_min_across_splits_continuous (\n feature_array: np.ndarray, target_array: np.ndarray, splits: np.ndarray, evaluate_function: Callable\n ):\n n = len ( splits )\n if n > 500:\n # If many split points, use some threading\n with multiprocessing.Pool ( processes = 8 ) as p:\n # Get evaluation scores across all the splits\n post_split_evals = dict (\n zip (\n range ( len ( splits ) ),\n p.starmap (\n BaseTree.get_split_goodness_fit_continuous,\n zip ( [ feature_array] * n, [ target_array ] * n, splits, [ evaluate_function ] * n ),\n ),\n )\n )\n p.close()\n else:\n # If not too many split points, get scores across all splits\n post_split_evals = dict (\n zip (\n range ( len ( splits ) ),\n map (\n lambda x: BaseTree.get_split_goodness_fit_continuous ( * x ),\n zip ( [ feature_array ] * n, [ target_array ] * n, splits, [ evaluate_function ] * n ),\n ),\n )\n )\n # Get the minimum split based on gain ratio\n min_eval = min (\n post_split_evals,\n key = lambda x: pipe (\n post_split_evals.get ( x ),\n lambda results: results [ 0 ] / results [ 1 ], # entropy / intrinsic value\n ),\n )\n\n # Return the best split and the splits scores\n return ( splits [ min_eval ], * post_split_evals.get ( min_eval ) )\n # End get_min_across_splits_continuous()","def within_value(v1, v2):\n percentage = 0.1\n error_allowed = percentage * v1\n high = v1 + error_allowed\n low = v1 - error_allowed\n\n return low <= v2 <= high","def detection_score(self, y_true, y_pred):\n ospa_score = ospa(y_true, y_pred, self.minipatch)\n return 1 - ospa_score","def test_denominator_float(self):\n steps = save_divide(np.ones(2), 2)\n np.testing.assert_equal(steps, 0.5 * np.ones(2))","def part2():\n\tX, Xval, yval = loadDataSet('ex8data2.mat')\n\tmu, sigma2 = estimateGaussian(X)\n\tp = multivariateGaussian(X, mu, sigma2)\n\tpval = multivariateGaussian(Xval, mu, sigma2)\n\tepsilon, F1 = selectThreshold(yval, pval)\n\n\tprint('Best epsilon found using cross-validation: %e\\n' % (epsilon))\n\tprint('Best F1 on Cross Validation Set: %f\\n' % (F1))\n\tprint('# Outliers found: %d\\n' % (np.sum(p < epsilon)))\n\tprint('(you should see a value epsilon of about 1.38e-18)\\n\\n')","def test_numerator_float(self):\n steps = save_divide(1, np.ones(2) * 2)\n np.testing.assert_equal(steps, 0.5 * np.ones(2))","def gss(self,LB,UB,tol,itr):\n \n GoldenRatio = (math.sqrt(5) + 1) / 2\n \n iterations=0\n gss=[]\n gss_x=[LB,UB]\n \n c = UB - (UB - LB) / GoldenRatio\n d = LB + (UB - LB) / GoldenRatio\n while abs(UB - LB) > tol and iterations < itr:\n if self.Func(c) < self.Func(d):\n UB = d\n gss_x.append(UB)\n iterations+=1\n else:\n LB = c\n \n gss_x.append(LB)\n iterations+=1\n c = UB - (UB - LB) / GoldenRatio\n d = LB + (UB - LB) / GoldenRatio\n \n \n #print(\" best at %.15f\"% ((UB + LB)/2) , \"itr = \",iterations)\n gss.append(gss_x)\n gss.append((LB+UB)/2)\n gss.append(iterations)\n \n return gss","def test_extrapolated_values(self, alpha):\n num_x = 150\n num_y = 100\n x_vals = np.linspace(0, 2 * np.pi, num_x)\n y_vals = (np.sin(x_vals[:num_y]) + 0.3 * np.random.randn(num_y) + 0.5)\n\n y_pred = extrapolated_lowess(x_vals, y_vals, alpha=alpha)\n\n assert len(y_pred) == num_x\n assert np.isfinite(y_pred).all()\n # At least 3/4 of the extrapolated values are unique\n assert (y_pred[num_y:] != y_pred[-1]).sum() > ((num_y - num_x) * 3 / 4)","def find_split(eps, nfeats_test):\n # TODO your code here\n # Consider a random subset of features of the specified size\n total_feature_num = len(eps[0].values)\n if nfeats_test <= total_feature_num:\n features_to_test = sorted(random.sample(range(total_feature_num), nfeats_test))\n else:\n features_to_test = range(total_feature_num)\n\n # For each feature under consideration, and each splitting value:\n # various values that show up in the profiles for the feature at hand, and take the midpoints between adjacent values.\n # calculate the impurity of each of the two subsets of profiles split accordingly.\n res = None\n for feature in features_to_test:\n values_for_split = [ep[feature] for ep in eps]\n splitting_points = sorted(list(set(values_for_split)))\n # take the midpoints between adjacent values\n for i in range(len(splitting_points) - 1):\n splitting_points[i] = (splitting_points[i] + splitting_points[i + 1]) / 2\n splitting_points.pop()\n\n # calculate the impurity of each of the two subsets of profiles split accordingly.\n for sp_value in splitting_points:\n subset1 = [ep for ep in eps if ep[feature] < sp_value]\n gini1 = cal_gini(subset1)\n subset2 = [ep for ep in eps if ep[feature] >= sp_value]\n gini2 = cal_gini(subset2)\n # Sum these, weighted by the fraction of profiles in each subset.\n gini = len(subset1) / len(eps) * gini1 + len(subset2) / len(eps) * gini2\n if res is None:\n res = (feature, sp_value, gini)\n elif gini < res[2]:\n res = (feature, sp_value, gini)\n\n return res","def test_confidence_intervals(self):\n # Taken from a T-Test table\n\n # Two Tailed\n p, ci = _p_value_and_confidence_intervals(2.228, 10, 'two')\n\n self.assertAlmostEqual(p, .05, delta = .001)\n self.assertTrue(ci.shape == (2, ))\n np.testing.assert_allclose(ci, [-2.228, 2.228], atol=.001)\n\n # Left One-Tailed\n p, ci = _p_value_and_confidence_intervals(1.895, 7, 'left')\n\n self.assertAlmostEqual(p, .05, delta = .001)\n self.assertTrue(ci.shape == (2, ))\n self.assertTrue(np.isinf(ci[0]))\n np.testing.assert_allclose(ci, [-np.inf, 1.895], atol=.001)\n\n # Right One-Tailed\n p, ci = _p_value_and_confidence_intervals(1.761, 14, 'right')\n\n self.assertAlmostEqual(1-p, .05, delta = .001)\n self.assertTrue(ci.shape == (2, ))\n self.assertTrue(np.isinf(ci[1])) \n np.testing.assert_allclose(ci, [-1.761, np.inf], atol=.001)","def test_random_forest_min_samples_split_parameter(params, X_train, X_test, y_train, y_test):","def check_performance(self):\n self.lg.debug('Checking performance.')\n avg_up = (sum(self.results_up)) / len(self.results_up)\n avg_down = (sum(self.results_down)) / len(self.results_down)\n if (\n avg_up < self.tolerance * self.up or\n avg_down < self.tolerance * self.down\n ):\n self.bad_performance = True\n else:\n self.bad_performance = False","def evaluate_fit_range(predicted, fit_range):\n test1 = (predicted[0] >= fit_range[0])\n test2 = (predicted[0] <= fit_range[1])\n test3 = (predicted[1] >= fit_range[2])\n test4 = (predicted[1] <= fit_range[3])\n return all([test1, test2, test3, test4])","def test_grade(grade_list):\n num_grade=scale_grade(grade_list)\n trend=[]\n for ind in range(len(num_grade)-1):\n if num_grade[ind+1]>num_grade[ind]:\n trend.append(1)\n elif num_grade[ind+1]<num_grade[ind]:\n trend.append(-1)\n else:\n trend.append(0)\n \n if sum(trend)>0:\n return 1\n elif sum(trend)<0:\n return -1\n else:\n return 0","def get_discrete_split_value ( feature_array: np.ndarray, target_array: np.ndarray, evaluate_function: Callable ):\n\n # First element is the weighted average evaluate_function of the split\n # Second term is the intrinsic value to penalize many splits.\n return (\n sum (\n [\n evaluate_function ( target_array [ feature_array == value ] ) * np.sum ( feature_array == value ) / len ( target_array )\n for value in set ( feature_array )\n ]\n ),\n -1\n * sum (\n [\n pipe (\n np.sum ( feature_array == value ) / len ( target_array ),\n lambda ratio: ratio * np.log ( ratio ),\n )\n for value in set ( feature_array )\n ]\n ),\n ) # End get_discrete_split_value()","def continuous_mse(individual, test_data, truth_data, name=None):\r\n test_data = np.array(test_data)\r\n truth_data = np.array(truth_data)\r\n error = 0\r\n\r\n for test_item, truth_item in zip(test_data, truth_data):\r\n error += np.sqrt(np.mean(np.square(truth_item - test_item)))\r\n\r\n return error","def test_basic(self):\n data = get()\n metrics = [verif.metric.Within(),\n verif.metric.A(), # Hit\n verif.metric.B(), # FA\n verif.metric.C(), # Miss\n verif.metric.D(), # Correct rejection\n verif.metric.Hit(),\n verif.metric.Threat(),\n verif.metric.Conditional(),\n verif.metric.XConditional(func=np.median),\n ]\n intervals = [verif.interval.Interval(-np.inf, 0, True, True), # [-inf, 0]\n verif.interval.Interval(-np.inf, 1, True, True),\n verif.interval.Interval(-np.inf, 2, True, True),\n ]\n obs = [0, 1.5, 2]\n fcst = [3.1, 1.1, -2.1]\n N = len(obs)*1.0\n\n # Each line is one metric (one number for each threshold)\n expected = [[0/N, 100/N, 100/N], # Within\n [0/N, 0/N, 2/N], # Hit\n [1/N, 1/N, 0/N], # FA\n [1/N, 1/N, 1/N], # Miss\n [1/N, 1/N, 0/N], # Correct rejection\n [0, 0, 2.0/3], # Hit rate\n [0, 0, 2.0/3], # Threat score\n [3.1, 3.1, 0.7], # Average fcst given obs in interval\n [0, 0, 1.5], # Average obs given obs in interval\n ]\n\n for m in range(len(metrics)):\n metric = metrics[m]\n for i in range(len(intervals)):\n value = metric.compute_from_obs_fcst(np.array(obs), np.array(fcst), intervals[i])\n ex = expected[m][i] * 1.0\n if np.isnan(value):\n self.assertTrue(np.isnan(ex))\n else:\n self.assertAlmostEqual(ex, value)","def class0AccuracyEvalFunction(individual, test_data, truth_data, name=None):\r\n test_data = np.array(test_data)\r\n truth_data = np.array(truth_data)\r\n total = 0\r\n num_wrong = 0\r\n for test_point, truth_point in zip(test_data, truth_data):\r\n if truth_point == 0:\r\n if test_point < 0 or test_point > 2:\r\n num_wrong += 1\r\n total += 1\r\n if num_wrong == 0:\r\n # We don't want 'perfect' equate it with 100% error\r\n return 1.0\r\n else:\r\n return float(num_wrong)/float(total)","def train_val_test_split(df):\n from sklearn.model_selction import train_test_split\n train, test = train_test_split(df, train_size = 0.80, test_size=0.20,\n random_state = 42)\n train, val = train_test_split(train, train_size = 0.70, val_size=0.30)\n print(train.shape, val.shape, test.shape)\n\n return train, val, test","def fit_test(self):","def converged(old, new):\n # https://github.com/amirgholami/PyHessian/commit/0f7e0f63a0f132998608013351ba19955fc9d861#diff-ba06409ffbc677fe556485172e62649fe7a069631390f5a780766bff3289b06bR149-R150 # noqa: B950\n return (old - new).abs() / (old.abs() + 1e-6) < tol","def get_discrete_split_value(arr: np.ndarray, y: np.ndarray, eval_func: Callable):\n\n # First element is the weighted average eval_func of the split\n # Second term is the intrinsic value to penalize many splits.\n return (\n sum(\n [\n eval_func(y[arr == value]) * np.sum(arr == value) / len(y)\n for value in set(arr)\n ]\n ),\n -1\n * sum(\n [\n pipe(\n np.sum(arr == value) / len(y),\n lambda ratio: ratio * np.log(ratio),\n )\n for value in set(arr)\n ]\n ),\n )","def c_test_fitness_function(self, function):\r\n return 1","def c_test_fitness_function(self, function):\r\n return 1","def test_right(self):\n x = np.array([-100, -2, -1, 0, 1, 1.1])\n self.assertEqual(npinterval.half_sample_mode(x), +1.05)","def test(self):\r\n error_count = 0\r\n N_TESTING = len(self.TESTING_DATA)\r\n for i in range(N_TESTING):\r\n x_vec = self.TESTING_DATA[i][:-1]\r\n y = self.TESTING_DATA[i][-1]\r\n\r\n result = self.bp.classify(x_vec)\r\n if result != y: error_count += 1\r\n print(error_count, \" errors on the test data, out of \", N_TESTING, \"items.\")","def precision_loss(data): #singular value\n start = np.std(data.head(round(len(data)/8)))\n end = np.std(data.tail(round(len(data)/8)))\n change = end/start\n return change","def get_split(self,X,y):\n \n BEST_COL = 0\n BEST_SPLIT =0\n BEST_IMPUR = 99\n for i,feature in enumerate(X.T):\n arg_sort=np.argsort(feature) #Sort the feature for optimizing the find of splitting points\n feature= feature[arg_sort]\n y_sort = y[arg_sort]\n splits = self.possible_splits(feature,y_sort) #Get \n\n impur,splits = self.test_split(feature,y_sort,splits) #Get impurity for splitting points\n best_idx = np.argmin(impur)\n best_impur = impur[best_idx]\n \n if best_impur==0.0: #Found perfect split, terminate\n return(i,splits[best_idx])\n elif best_impur<BEST_IMPUR:\n BEST_IMPUR=best_impur\n BEST_SPLIT=splits[best_idx]\n BEST_COL=i\n return (BEST_COL,BEST_SPLIT)","def evaluate(self, dataset):\n success = 0\n for sample, labelVector, label in dataset.tests:\n if self.guessLabel(sample) == label:\n success += 1\n return success / len(dataset.tests)","def determine_best_split(data, potential_splits, mltask):\n\n first_iteration = True\n for column_index in potential_splits:\n for value in potential_splits[column_index]:\n data_below,data_above = split_data(data, column_index, value)\n \n if mltask == 'regression':\n current_overall_metric = calculate_overall_metric(data_below, data_above, metric_function = calculate_mse)\n \n # classification\n else:\n current_overall_metric = calculate_overall_metric(data_below, data_above, metric_function = calculate_entropy)\n \n \n if first_iteration or current_overall_metric <= best_overall_metric:\n first_iteration = False\n \n best_overall_metric = current_overall_metric\n best_split_column = column_index\n best_split_value = value\n \n \n return best_split_column,best_split_value","def test_rf_value(self):\n\t\tdetails = self.watcher.describe()\t\t\n\t\tself.assertTrue((details.rf.to_numpy()[0:8] == 9.0).all())","def test_rosenbrock(self):\n fun = get_problem('rosenbrock', self.dimension)\n self.assertEqual(fun(self.array2), 0.0)"],"string":"[\n \"def get_split_goodness_fit_continuous(\\n arr: np.ndarray, y: np.ndarray, split: float, eval_func: Callable\\n ):\\n # Get above and below the split value\\n above = arr >= split\\n below = arr < split\\n\\n # get weighted average eval_func on the splits\\n n_above = np.sum(above)\\n above_eval = (\\n eval_func(y[above]) * n_above / len(y)\\n ) # weight = frac points in above\\n below_eval = (\\n eval_func(y[below]) * (len(y) - n_above) / len(y)\\n ) # weight = frac points not in above\\n\\n # returns weighted sum of eval_func across splits, and the gain ratio denominator\\n return (\\n above_eval + below_eval,\\n -1\\n * sum(\\n map(\\n lambda x: x * np.log(x),\\n [n_above / len(y), (len(y) - n_above) / len(y)],\\n )\\n ),\\n )\",\n \"def test_ThinData(self):\\n for split in self.splits:\\n y_data, x_data = data_process.thinData(y_test, xdim_test, split)\\n oldStep = float(xdim_test[1]) - float(xdim_test[0])\\n newStep = float(x_data[1]) - float(x_data[0])\\n self.assertAlmostEqual(newStep/oldStep,split)\\n self.assertTrue(len(y_data) == len(x_data))\",\n \"def test_split(self,X,y,splits):\\n n_data = len(y) #Number of data points\\n splits=(X[splits]+X[splits+1])/2\\n\\n idx_greater = (X>splits[:,None]) #index for greater split\\n idx_lower = (X<splits[:,None]) #index for lower split\\n\\n imp_greater =[self.impurity(y[idx]) for idx in idx_greater] #impurity for greater\\n imp_lower = [self.impurity(y[idx]) for idx in idx_lower] #impurity lower\\n\\n impur = [sum(idx_great)/n_data*imp_great+sum(idx_low)/n_data*imp_low for idx_great,imp_great,idx_low,imp_low in zip(idx_greater,imp_greater,idx_lower,imp_lower)] #Weighted impurity\\n return (impur,splits)\",\n \"def sanity_check(self):\\n score = 0\\n curvatures = self._curvature()\\n if abs(curvatures[0] - curvatures[1]) / max(curvatures) > 0.15:\\n # difference in curvature is more than 15%\\n score -= 1\\n\\n diff_std = np.std(self.right_fitx - self.left_fitx)\\n if diff_std > 30:\\n # std of the difference between the right lane and left lane is more than 30 pixel\\n score -= 1\\n\\n # roughly parallel\\n if abs(self.left_fit[0] - self.right_fit[0]) / max(self.left_fit[0], self.right_fit[0]) > 0.15:\\n # difference in slope is more than 15%\\n score -= 1\\n\\n return score\",\n \"def test_Sobol_G_raises_error_if_values_gt_one():\\n evaluate(np.array([0, 1, .02, 0.23, 1.234, 0.02848848, 0, 0.78]))\",\n \"def test_continuous():\\n # assert the distribution of the samples is close to the distribution of the data\\n # using kstest:\\n # - uniform (assert p-value > 0.05)\\n # - gaussian (assert p-value > 0.05)\\n # - inversely correlated (assert correlation < 0)\",\n \"def test_gross_range_check(self):\\n fail_span = (10, 50)\\n suspect_span = (20, 40)\\n vals = [\\n 5, 10, # Sensor range.\\n 15, # User range.\\n 20, 25, 30, 35, 40, # Valid\\n 45, # User range.\\n 51 # Sensor range.\\n ]\\n result = np.ma.array([\\n 4, 3,\\n 3,\\n 1, 1, 1, 1, 1,\\n 3,\\n 4\\n ])\\n\\n with warnings.catch_warnings():\\n warnings.simplefilter(\\\"ignore\\\")\\n inputs = [\\n vals,\\n np.array(vals, dtype=np.integer),\\n np.array(vals, dtype=np.floating),\\n dask_arr(np.array(vals, dtype=np.integer)),\\n dask_arr(np.array(vals, dtype=np.floating))\\n ]\\n\\n for i in inputs:\\n npt.assert_array_equal(\\n qartod.gross_range_test(\\n inp=i,\\n fail_span=fail_span,\\n suspect_span=suspect_span\\n ),\\n result\\n )\",\n \"def test_value_loss(self):\\n ValueEstimator = self.notebook_locals[\\\"ValueEstimator\\\"]\\n value_f = ValueEstimator(\\n num_hidden=1, hidden_dim=2, obs_dim=2, action_dim=1\\n )\\n student_value_loss = self.notebook_locals[\\\"util_compute_value_loss\\\"]\\n # initialize to constant values\\n for p in value_f.parameters():\\n torch.nn.init.ones_(p)\\n\\n # test tensors\\n obs = torch.ones(3, 2) * 2.0\\n returns = torch.arange(3, 6).float()\\n\\n loss_student = student_value_loss(value_f, obs, returns)\\n self.assertTrue(\\n torch.abs(loss_student - 2.0317) < 0.1,\\n \\\"The value loss computation is incorrect\\\",\\n )\",\n \"def test_fit_score(self):\\n oz = ClassificationScoreVisualizer(GaussianNB())\\n assert_not_fitted(oz, X_test=self.binary.X.test)\\n assert oz.fit(self.binary.X.train, self.binary.y.train) is oz\\n assert 0.0 <= oz.score(self.binary.X.test, self.binary.y.test) <= 1.0\\n assert_fitted(oz, X_test=self.binary.X.test)\",\n \"def test_divide_curve():\\n c1 = Curve(data=data_num, mnemonic='test')\\n c2 = c1 / 2\\n assert (c2.df.iloc[0][0] - 0.5) < 0.0001\",\n \"def get_split(data):\\n \\\"\\\"\\\" gets the best feature, and best value \\\"\\\"\\\"\\n\\n best_feature = None\\n best_value = 0.0\\n columns = data.columns\\n gini_base = gini_impurity(data)\\n n_rows = len(data.index) # total number of rows of data before split\\n\\n # Fininding which split yields the best gini gain\\n max_gain = 0\\n\\n for i in range(len(columns)-1): # -1 b.c. class is final column\\n xs = data[columns[i]].unique() # get values to test\\n for x in xs: # test values\\n # split dataset\\n df_left = data[data[columns[i]] < x]\\n df_right = data[data[columns[i]] >= x]\\n\\n # get gini impurities\\n gini_left = gini_impurity(df_left)\\n gini_right = gini_impurity(df_right)\\n \\n\\n # Calculated weighted gini impurity\\n w_left = len(df_left.index) / n_rows\\n w_right = len(df_right.index) / n_rows\\n\\n w_gini = gini_left * w_left + gini_right * w_right\\n \\n\\n # Calculate gini gain (we want to minimize w_gini for the smallest impurity. Ideal split is perfect Left=c1, Right=c2)\\n # why not just find min w_gin instead of uding gini_gain and gini_base vaiables?\\n gini_gain = gini_base - w_gini\\n\\n # check if this is the best split so far, store values, update max_gini\\n if gini_gain > max_gain:\\n best_feature = columns[i]\\n best_value = x\\n max_gain = gini_gain\\n\\n df_left = data.loc[data[best_feature] < best_value]\\n df_right = data.loc[data[best_feature] >= best_value]\\n \\n\\n return best_feature, best_value, df_left, df_right\",\n \"def divide_train_test(fr):\\n b = fr['TIN_hash_byte']\\n train = fr[ b < 200 ]\\n valid = fr[ (200 <= b) & (b < 232) ]\\n test = fr[ 232 <= b ]\\n return train, valid, test\",\n \"def calc(self,newValue):\\n return np.sum(self.values<=newValue)/self.n\",\n \"def check_if_stopping_criterion_is_met(original_training_data_values):\\n if len(original_training_data_values)<23:\\n return True\\n else:\\n target_column = original_training_data_values[:, -1]\\n recipe_type, cupcake_muffin_count = np.unique(target_column, return_counts=True)\\n cupcake_ratio = cupcake_muffin_count[0] / (cupcake_muffin_count.sum())\\n muffin_ratio = cupcake_muffin_count[1] / (cupcake_muffin_count.sum())\\n\\n if cupcake_ratio >= 0.9 or muffin_ratio >= 0.9:\\n return True\\n else:\\n return False\",\n \"def test_half_case(self):\\n steps = save_divide(np.ones(2), 2 * np.ones(2))\\n np.testing.assert_equal(steps, 0.5 * np.ones(2))\",\n \"def test_percentage_metric_in_interval_0_1(a, b, dim, metric):\\n res = metric(a, b, dim)\\n assert not (res < 0).any()\\n assert not (res > 1).any()\\n assert not res.isnull().any()\",\n \"def test_kpss(self):\\n\\n kpsstest = kpss(self.ts_df['y'], regression='c')\\n kpss_output = pd.Series(kpsstest[0:3], index=['Test Statistic', 'p-value', 'Lags Used'])\\n for key, value in kpsstest[3].items():\\n kpss_output['Critical Value (%s)' % key] = value\\n print(kpss_output)\\n if kpsstest[0] > kpsstest[3]['5%']:\\n print(\\n \\\"Test statistic greater than critical value at 5% --> series seems to be not stationary. \\\"\\n \\\"Look at critical values at 1% and 10% too, ideally they also should be greater than test statistic.\\\")\\n else:\\n print(\\n \\\"Test statistic less than critical value at 5% --> series seems to be stationary. \\\"\\n \\\"Look at critical values at 1% and 10% too, ideally they also should be less than test statistic.\\\")\",\n \"def test_gini_gain(self):\\n self.decision_tree.train(self.data,\\n list(range(self.data.num_samples)),\\n max_depth=1,\\n min_samples_per_node=1,\\n use_stop_conditions=False,\\n max_p_value_chi_sq=None)\\n self.assertEqual(self.decision_tree.get_root_node().node_split.separation_attrib_index, 0)\\n self.assertEqual(self.decision_tree.get_root_node().node_split.splits_values,\\n [set([0]), set([1])])\\n self.assertEqual(self.decision_tree.get_root_node().node_split.values_to_split,\\n {0:0, 1:1})\\n self.assertEqual(self.decision_tree.get_root_node().node_split.criterion_value, 0.5)\",\n \"def error(self, in_sample=True):\\n if in_sample:\\n error = 0.0\\n for i, point in enumerate(self.X):\\n if self.Y[i] != self.rbf_classify(point):\\n error += 1\\n return error / 100\\n else:\\n error = 0.0\\n for i, point in enumerate(self.test_X):\\n if self.test_Y[i] != self.rbf_classify(point):\\n error += 1\\n return error / 10000\",\n \"def test_estimateFullRichness(self):\\r\\n # Verified with iNEXT.\\r\\n\\r\\n # f2 > 0\\r\\n obs = self.estimator3.estimateFullRichness()\\r\\n assert_almost_equal(obs, 5.5)\\r\\n\\r\\n # f2 == 0\\r\\n obs = self.estimator4.estimateFullRichness()\\r\\n assert_almost_equal(obs, 4)\",\n \"def evaluate(self, training_scores, original_test_scores, imitation_test_scores):\\n\\n #finding a threshold: third to smallest training score\\n sorted_scores = np.sort(training_scores)\\n threshold = sorted_scores[2]\\n\\n #computing the number of errors\\n errors = len(np.where(original_test_scores < threshold)[0])\\n errors += len(np.where(imitation_test_scores > threshold)[0])\\n\\n #computing the local accuracy\\n accuracy = 1 - errors/(len(original_test_scores)+len(imitation_test_scores))\\n return accuracy, threshold\",\n \"def test_gini_gain(self):\\n self.decision_tree.train(self.data,\\n list(range(self.data.num_samples)),\\n max_depth=1,\\n min_samples_per_node=1,\\n use_stop_conditions=False,\\n max_p_value_chi_sq=None)\\n self.assertEqual(self.decision_tree.get_root_node().node_split.separation_attrib_index, 1)\\n self.assertEqual(self.decision_tree.get_root_node().node_split.splits_values,\\n [set([0]), set([1]), set([2])])\\n self.assertEqual(self.decision_tree.get_root_node().node_split.values_to_split,\\n {0:0, 1:1, 2:2})\\n self.assertEqual(self.decision_tree.get_root_node().node_split.criterion_value, 0.66)\",\n \"def important_features_(self):\\n return self.scores_ > self.score_cutoff_\",\n \"def test_error_curve(self):\\r\\n\\r\\n scores = self.test_confidences\\r\\n sort = numpy.argsort(scores, axis=0)\\r\\n sorted_scores = scores[sort]\\r\\n\\r\\n test_errors = numpy.zeros((scores.shape[0]))\\r\\n thresholds = numpy.zeros((scores.shape[0]))\\r\\n\\r\\n for i in range(sort.shape[0]):\\r\\n thresholds[i] = sorted_scores[i]\\r\\n test_errors[i] = numpy.sum(self.test_errors[self.test_confidences >= thresholds[i]]) / float(numpy.sum(self.test_confidences >= thresholds[i]))\\r\\n\\r\\n return test_errors, thresholds\",\n \"def classify(self, testInstance):\\n return self.fire(testInstance) > 0.5\",\n \"def qc_NoiseRank(spread):\\n\\n variance = spread*spread # for a Gaussian\\n \\n if (variance <= 0.2):\\n qc_label = 'good'\\n elif (0.2 < variance < 0.25):\\n qc_label = 'ok'\\n else:\\n qc_label = 'bad'\\n \\n return qc_label\",\n \"def evaluate_split( df, attribute, split ):\\n mask = df[attribute] <= split\\n \\n # split the dataset on the split attribute\\n dfl = df[mask]\\n dfr = df[~mask]\\n \\n \\n # calculate weighting factors for child\\n weighting_factor_left = float(dfl.shape[0])/df.shape[0]\\n weighting_factor_right = float(dfr.shape[0])/df.shape[0]\\n\\n # calculate gini for left and right\\n gini_parent = gini_impurity(df)\\n gini_left = gini_impurity(dfl)\\n gini_right = gini_impurity(dfr)\\n \\n # calculate weighted gini for this split \\n weighted_gini = gini_parent - (weighting_factor_left*gini_left + weighting_factor_right*gini_right)\\n return weighted_gini\",\n \"def test_data_split_good():\\n\\tdf_true = pd.read_csv(\\\"test/sample_data.csv\\\")\\n\\tdf_test = df_true.copy()\\n\\ttarget = df_true['price']\\n\\tfeatures = df_true.loc[:, df_true.columns != 'price']\\n\\n\\tX_train_true, X_test_true, y_train_true, y_test_true = train_test_split(features, target, \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\ttest_size=0.4, random_state=0)\\n\\n\\tsplit_data = {'test_size': 0.4, 'random_state': 0}\\n\\tX_train_test, X_test_test, y_train_test, y_test_test = data_split(df_test, 'price', split_data)\\n\\n\\tassert X_train_true.equals(X_train_test)\\n\\tassert y_train_true.equals(y_train_test)\\n\\tassert X_test_true.equals(X_test_test)\\n\\tassert y_test_true.equals(y_test_test)\",\n \"def test_Sobol_G_raises_error_if_values_gt_one():\\n with raises(ValueError):\\n evaluate(np.array([0, 1, .02, 0.23, 1.234, 0.02848848, 0, 0.78]))\",\n \"def test_compute_unnormalized_scores(self):\\n # todo: implement this test!\\n pass\",\n \"def test_increasing_trend_is_false_if_price_decreases(self):\\n self.given_a_series_of_prices([8, 12, 10])\\n self.assertFalse(self.goog.is_increasing_trend())\",\n \"def test_demand_variability(self):\\n demand_variability = self._uncertain_demand.demand_variability\\n avg_order = sum([int(item) for item in self._data_set.values()]) //len(self._data_set)\\n variance = [(item - avg_order) for item in self._data_set.values()]\\n stdev = pow(sum([pow(j, 2) for j in variance]) / len(self._data_set), 0.5)\\n cal_variability = lambda x, y: x / y\\n test_variability = cal_variability(stdev, avg_order)\\n self.assertEqual(demand_variability, test_variability)\",\n \"def test_score_with_fitted_estimator(self):\\n model = GaussianNB().fit(self.binary.X.train, self.binary.y.train)\\n\\n # NOTE that the wrapper will pass a call down to `classes_`\\n oz = ClassificationScoreVisualizer(model)\\n assert_not_fitted(oz, [\\\"class_counts_\\\", \\\"score_\\\"])\\n\\n msg = \\\"could not determine class_counts_\\\"\\n with pytest.warns(YellowbrickWarning, match=msg):\\n oz.score(self.binary.X.test, self.binary.y.test)\\n assert_fitted(oz, [\\\"classes_\\\", \\\"class_counts_\\\", \\\"score_\\\"])\",\n \"def quality_data(self, s):\\n known_symbols = np.mod(range(176),48)>=32\\n print('quality_data',np.sum(np.real(s[known_symbols])<0))\\n success = np.sum(np.real(s[known_symbols])<0) < 20\\n return success,0 ## no doppler estimate for data frames\",\n \"def evaluate(self, test_data, split=2):\\n size = int(len(test_data) / split)\\n mini_batch_split = np.arange(size, len(test_data), size)\\n mini_batches = np.split(test_data, mini_batch_split)\\n total = 0\\n\\n for mini_batch in mini_batches:\\n xs, ys = np.array(mini_batch).T\\n xs = cp.array(cp.vstack(xs).astype(np.float64).reshape((-1, self.sizes[0], 1)))\\n ys = cp.array(ys.astype(np.int64))\\n total += cp.sum(cp.argmax(self.feedforward(xs), axis=(1, 2)) == ys)\\n return total\",\n \"def test_half_life():\\n assert np.isclose(\\n half_life(\\\"tritium\\\").to(u.s).value, (12.32 * u.yr).to(u.s).value, rtol=2e-4\\n ), \\\"Incorrect half-life for tritium.\\\"\",\n \"def compute_confidence_interval(self) -> bool:\\n return False\",\n \"def test_threat(self):\\n metric = verif.metric.Threat()\\n obs = np.array([0, 1, 2, 3])\\n fcst = np.array([0, 3, 1, 2])\\n\\n # Hits: 1\\n # FA: 1\\n # Miss: 1\\n # CR: 0\\n interval = verif.interval.Interval(1.5, np.inf, True, True)\\n f_interval = verif.interval.Interval(1.5, np.inf, True, True)\\n value = metric.compute_from_obs_fcst(obs, fcst, interval, f_interval)\\n self.assertEqual(value, 1.0/3)\",\n \"def test_gain_ratio(self):\\n self.decision_tree.train(self.data,\\n list(range(self.data.num_samples)),\\n max_depth=1,\\n min_samples_per_node=1,\\n use_stop_conditions=False,\\n max_p_value_chi_sq=None)\\n self.assertEqual(self.decision_tree.get_root_node().node_split.separation_attrib_index, 0)\\n self.assertEqual(self.decision_tree.get_root_node().node_split.splits_values,\\n [set([0]), set([1])])\\n self.assertEqual(self.decision_tree.get_root_node().node_split.values_to_split,\\n {0:0, 1:1})\\n self.assertEqual(self.decision_tree.get_root_node().node_split.criterion_value, 1.0)\",\n \"def test_increasing_trend_is_false_if_price_equal(self):\\n self.given_a_series_of_prices([8, 10, 10])\\n self.assertFalse(self.goog.is_increasing_trend())\",\n \"def train_val_test_split(data):\\n raise NotImplementedError\",\n \"def test_information_gain(self):\\n self.decision_tree.train(self.data,\\n list(range(self.data.num_samples)),\\n max_depth=1,\\n min_samples_per_node=1,\\n use_stop_conditions=False,\\n max_p_value_chi_sq=None)\\n self.assertEqual(self.decision_tree.get_root_node().node_split.separation_attrib_index, 1)\\n self.assertEqual(self.decision_tree.get_root_node().node_split.splits_values,\\n [set([0]), set([1]), set([2])])\\n self.assertEqual(self.decision_tree.get_root_node().node_split.values_to_split,\\n {0:0, 1:1, 2:2})\\n self.assertAlmostEqual(self.decision_tree.get_root_node().node_split.criterion_value,\\n 2. * -0.3 * math.log2(0.3) - 0.4 * math.log2(0.4))\",\n \"def test_Sobol_G_raises_error_if_values_lt_zero():\\n evaluate(np.array([0, -1, -.02, 1, 1, -0.1, -0, -12]))\",\n \"def test_left(self):\\n x = np.array([-1.1, -1, 0, 1, 2, 100])\\n self.assertEqual(npinterval.half_sample_mode(x), -1.05)\",\n \"def test_gain_ratio(self):\\n self.decision_tree.train(self.data,\\n list(range(self.data.num_samples)),\\n max_depth=1,\\n min_samples_per_node=1,\\n use_stop_conditions=False,\\n max_p_value_chi_sq=None)\\n self.assertEqual(self.decision_tree.get_root_node().node_split.separation_attrib_index, 1)\\n self.assertEqual(self.decision_tree.get_root_node().node_split.splits_values,\\n [set([0]), set([1]), set([2])])\\n self.assertEqual(self.decision_tree.get_root_node().node_split.values_to_split,\\n {0:0, 1:1, 2:2})\\n self.assertEqual(self.decision_tree.get_root_node().node_split.criterion_value, 1.0)\",\n \"def test_efficiency(self):\\n effs = self.gr.calculate_global_efficiencies()\\n ans = [a/6 for a in [1.5, 2., 1.5]]\\n self.assertListEqual(effs.values(), ans)\\n\\n E = self.gr.global_efficiency()\\n self.assertEqual(E, sum(ans))\\n\\n v_min = (E - (1/3)) / E\\n mx, v = self.gr.vulnerability()\\n # the middle node (2) is the most vulnerable\\n self.assertEqual(mx, (2, v_min))\",\n \"def test_sdp_output():\\n state_output_value = fidelity_of_separability(sep_rho, [2, 2], 2)\\n assert np.isclose(1, state_output_value)\",\n \"def get_min_across_splits_continuous(\\n arr: np.ndarray, y: np.ndarray, splits: np.ndarray, eval_func: Callable\\n ):\\n n = len(splits)\\n if n > 500:\\n # If many split points, use some threading\\n with multiprocessing.Pool(processes=8) as p:\\n # Get evaluation scores across all the splits\\n post_split_evals = dict(\\n zip(\\n range(len(splits)),\\n p.starmap(\\n BaseTree.get_split_goodness_fit_continuous,\\n zip([arr] * n, [y] * n, splits, [eval_func] * n),\\n ),\\n )\\n )\\n p.close()\\n else:\\n # If not too many split points, get scores across all splits\\n post_split_evals = dict(\\n zip(\\n range(len(splits)),\\n map(\\n lambda x: BaseTree.get_split_goodness_fit_continuous(*x),\\n zip([arr] * n, [y] * n, splits, [eval_func] * n),\\n ),\\n )\\n )\\n # Get the minimum split based on gain ratio\\n min_eval = min(\\n post_split_evals,\\n key=lambda x: pipe(\\n post_split_evals.get(x),\\n lambda results: results[0] / results[1], # entropy / intrinsic value\\n ),\\n )\\n\\n # Return the best split and the splits scores\\n return (splits[min_eval], *post_split_evals.get(min_eval))\",\n \"def test_rdivide_curve():\\n c1 = Curve(data=data_num, mnemonic='test')\\n c2 = 400 / c1\\n assert (c2.df.iloc[-1][0] - 2.0) < 0.0001\",\n \"def test_gradient_convergence(self):\\n pass\",\n \"def checks(self, poly_fit, poly_fitx, poly_fity):\\n if self.best_fit is not None:\\n if not (np.abs(self.best_fit-poly_fit) <\\n np.array([0.001, 1, 500])).all():\\n return False\\n if self.bestx is not None:\\n if np.mean(np.abs(self.bestx-poly_fitx)) > 200:\\n return False\\n\\n return True\",\n \"def test_is_ramped_using_int(self):\\n self.feature_test.set_percentage(100)\\n self.assertTrue(self.feature_test._is_ramped(5))\",\n \"def expected_value(held_dice, num_die_sides, num_free_dice):\\r\\n \\r\\n scores = []\\r\\n \\r\\n die_sides = [(die + 1) for die in range(num_die_sides)]\\r\\n \\r\\n pos_outcomes = gen_all_sequences(die_sides, num_free_dice)\\r\\n\\r\\n for outcome in pos_outcomes:\\r\\n scores.append(score(held_dice + outcome))\\r\\n \\r\\n expected_result = float(sum(scores))/len(scores)\\r\\n \\r\\n return expected_result\",\n \"def determine_threshold(yval,pval):\\n\\n F1 = 0\\n epsilon = 0\\n for _epsilon in np.linspace(min(pval),max(pval),1000):\\n ## Compute stats\\n _F1,stats = evaluate_epsilon(yval,pval,_epsilon)\\n\\n if _F1 > F1:\\n F1 = _F1\\n epsilon = _epsilon\\n print(\\\"Better threshold found! {} ==> F1 {}\\\".format(epsilon,F1))\\n \\n return epsilon, F1\",\n \"def test_evaluate():\\n X_train, X_test, y_train, y_test = src.load()\\n clf, score = src.train(X_train, y_train)\\n test_score = src.evaluate(clf, X_test, y_test)\\n assert isinstance(test_score, float)\",\n \"def is_best(self, metric: float) -> bool:\",\n \"def test_Gaussian_NB_estimators():\",\n \"def possession(self, good):\\n return float(self._haves[good])\",\n \"def test_score(self):\\n reg = ElasticRegistration()\\n reg.fit(self.unimodal_samples)\\n score = reg.score(self.unimodal_samples)\\n np.testing.assert_almost_equal(score, 0.9994225)\",\n \"def expected_value(held_dice, num_die_sides, num_free_dice):\\n list_scores = []\\n die_sides = [die for die in range(1, num_die_sides + 1)]\\n possible_seq = gen_all_sequences(die_sides, num_free_dice)\\n for item in possible_seq:\\n list_scores.append(score(held_dice + item))\\n \\n return float(sum(list_scores)) / len(list_scores)\",\n \"def isgood(self):\\n\\t\\tanswer = True\\n\\t\\t\\n\\t\\tif self.mes_flux <= 0.0:\\n\\t\\t\\tanswer = False\\n\\n\\t\\treturn answer\",\n \"def sanity_check(self):\\n res = True\\n res = res and self.detected\\n res = res and np.sum(self.diffs) < 30000 # experimental value\\n return res\",\n \"def test_decision_tree_min_samples_split_parameter(params, X_train, X_test, y_train, y_test):\",\n \"def test_evaluate(self):\\n # Check build does not raise errors\\n dataset = KDDCupDataset()\\n dataset.create_fixed_samples(\\n *self.data, samples_num=1, partition_sizes=self.partition_sizes)\\n dataset.set_current_sample(0)\\n model = self.MODEL(dataset, **self.model_arguments)\\n model.fit(training_epochs=50)\\n metric = model.evaluate('test')\\n self.assertLessEqual(0, metric)\\n self.assertGreaterEqual(1, metric)\",\n \"def checkConvergence(self, iteration):\\n threshold = abs(0.05*self.overBestVal)\\n stdev = np.std(np.array([particle.bestXYZ[2] for particle in self.swarm]))\\n if self.overBestVal==self.prevBestVal:\\n self.bestStreak+=1\\n else:\\n self.bestStreak=0\\n if stdev<=threshold:\\n exitFlag = 0 #set this convergence pattern as exit flag 0\\n print('Converged: All points converged to same position; std was less than threshold')\\n elif self.bestStreak>=50:\\n exitFlag = 1 #set this convergence patter as exit flag 1\\n print('Converged: Best value did not increase %d times in a row' %50)\\n elif iteration>=800:\\n exitFlag = 2 #sets no convergence as exit flag 2\\n print('Did not converge, exceeded iteration threshold')\\n else:\\n exitFlag = None\\n return [stdev <= threshold or self.bestStreak>=50 or iteration>=800, exitFlag]\",\n \"def calcGiniSplitBySplitValue(self, data, structure, colIndex, splitValue):\\n dataBellow = list(filter(lambda x: float(x[colIndex]) <= splitValue, data))\\n dataAbove = list(filter(lambda x: float(x[colIndex]) > splitValue, data))\\n giniSplit = (len(dataBellow) / len(data)) * self.calcDataGini(dataBellow, structure) +\\\\\\n (len(dataAbove) / len(data)) * self.calcDataGini(dataAbove, structure)\\n return round(giniSplit, 3)\",\n \"def score(self):\\n\\n\\t\\tsplits = 10\\n\\t\\tscore = 0\\n\\n\\t\\tkf = KFold(n_splits=splits, shuffle=True)\\n\\t\\tkf.get_n_splits(self.data)\\n\\n\\t\\tfor train_ind, test_ind in kf.split(self.data):\\n\\n\\t\\t\\ttrain = [self.data[ind] for ind in train_ind]\\n\\t\\t\\ttest = [self.data[ind] for ind in test_ind]\\n\\n\\t\\t\\tself.model = self._fit(train)\\n\\t\\t\\ttemp_score = self.score_one(test)\\n\\t\\t\\tscore += temp_score\\n\\n\\t\\treturn score/float(splits)\",\n \"def score(self):\\n\\n\\t\\tsplits = 10\\n\\t\\tscore = 0\\n\\n\\t\\tkf = KFold(n_splits=splits, shuffle=True)\\n\\t\\tkf.get_n_splits(self.data)\\n\\n\\t\\tfor train_ind, test_ind in kf.split(self.data):\\n\\n\\t\\t\\ttrain = [self.data[ind] for ind in train_ind]\\n\\t\\t\\ttest = [self.data[ind] for ind in test_ind]\\n\\n\\t\\t\\tself.model = self._fit(train)\\n\\t\\t\\ttemp_score = self.score_one(test)\\n\\t\\t\\tscore += temp_score\\n\\n\\t\\treturn score/float(splits)\",\n \"def get_min_across_splits_continuous (\\n feature_array: np.ndarray, target_array: np.ndarray, splits: np.ndarray, evaluate_function: Callable\\n ):\\n n = len ( splits )\\n if n > 500:\\n # If many split points, use some threading\\n with multiprocessing.Pool ( processes = 8 ) as p:\\n # Get evaluation scores across all the splits\\n post_split_evals = dict (\\n zip (\\n range ( len ( splits ) ),\\n p.starmap (\\n BaseTree.get_split_goodness_fit_continuous,\\n zip ( [ feature_array] * n, [ target_array ] * n, splits, [ evaluate_function ] * n ),\\n ),\\n )\\n )\\n p.close()\\n else:\\n # If not too many split points, get scores across all splits\\n post_split_evals = dict (\\n zip (\\n range ( len ( splits ) ),\\n map (\\n lambda x: BaseTree.get_split_goodness_fit_continuous ( * x ),\\n zip ( [ feature_array ] * n, [ target_array ] * n, splits, [ evaluate_function ] * n ),\\n ),\\n )\\n )\\n # Get the minimum split based on gain ratio\\n min_eval = min (\\n post_split_evals,\\n key = lambda x: pipe (\\n post_split_evals.get ( x ),\\n lambda results: results [ 0 ] / results [ 1 ], # entropy / intrinsic value\\n ),\\n )\\n\\n # Return the best split and the splits scores\\n return ( splits [ min_eval ], * post_split_evals.get ( min_eval ) )\\n # End get_min_across_splits_continuous()\",\n \"def within_value(v1, v2):\\n percentage = 0.1\\n error_allowed = percentage * v1\\n high = v1 + error_allowed\\n low = v1 - error_allowed\\n\\n return low <= v2 <= high\",\n \"def detection_score(self, y_true, y_pred):\\n ospa_score = ospa(y_true, y_pred, self.minipatch)\\n return 1 - ospa_score\",\n \"def test_denominator_float(self):\\n steps = save_divide(np.ones(2), 2)\\n np.testing.assert_equal(steps, 0.5 * np.ones(2))\",\n \"def part2():\\n\\tX, Xval, yval = loadDataSet('ex8data2.mat')\\n\\tmu, sigma2 = estimateGaussian(X)\\n\\tp = multivariateGaussian(X, mu, sigma2)\\n\\tpval = multivariateGaussian(Xval, mu, sigma2)\\n\\tepsilon, F1 = selectThreshold(yval, pval)\\n\\n\\tprint('Best epsilon found using cross-validation: %e\\\\n' % (epsilon))\\n\\tprint('Best F1 on Cross Validation Set: %f\\\\n' % (F1))\\n\\tprint('# Outliers found: %d\\\\n' % (np.sum(p < epsilon)))\\n\\tprint('(you should see a value epsilon of about 1.38e-18)\\\\n\\\\n')\",\n \"def test_numerator_float(self):\\n steps = save_divide(1, np.ones(2) * 2)\\n np.testing.assert_equal(steps, 0.5 * np.ones(2))\",\n \"def gss(self,LB,UB,tol,itr):\\n \\n GoldenRatio = (math.sqrt(5) + 1) / 2\\n \\n iterations=0\\n gss=[]\\n gss_x=[LB,UB]\\n \\n c = UB - (UB - LB) / GoldenRatio\\n d = LB + (UB - LB) / GoldenRatio\\n while abs(UB - LB) > tol and iterations < itr:\\n if self.Func(c) < self.Func(d):\\n UB = d\\n gss_x.append(UB)\\n iterations+=1\\n else:\\n LB = c\\n \\n gss_x.append(LB)\\n iterations+=1\\n c = UB - (UB - LB) / GoldenRatio\\n d = LB + (UB - LB) / GoldenRatio\\n \\n \\n #print(\\\" best at %.15f\\\"% ((UB + LB)/2) , \\\"itr = \\\",iterations)\\n gss.append(gss_x)\\n gss.append((LB+UB)/2)\\n gss.append(iterations)\\n \\n return gss\",\n \"def test_extrapolated_values(self, alpha):\\n num_x = 150\\n num_y = 100\\n x_vals = np.linspace(0, 2 * np.pi, num_x)\\n y_vals = (np.sin(x_vals[:num_y]) + 0.3 * np.random.randn(num_y) + 0.5)\\n\\n y_pred = extrapolated_lowess(x_vals, y_vals, alpha=alpha)\\n\\n assert len(y_pred) == num_x\\n assert np.isfinite(y_pred).all()\\n # At least 3/4 of the extrapolated values are unique\\n assert (y_pred[num_y:] != y_pred[-1]).sum() > ((num_y - num_x) * 3 / 4)\",\n \"def find_split(eps, nfeats_test):\\n # TODO your code here\\n # Consider a random subset of features of the specified size\\n total_feature_num = len(eps[0].values)\\n if nfeats_test <= total_feature_num:\\n features_to_test = sorted(random.sample(range(total_feature_num), nfeats_test))\\n else:\\n features_to_test = range(total_feature_num)\\n\\n # For each feature under consideration, and each splitting value:\\n # various values that show up in the profiles for the feature at hand, and take the midpoints between adjacent values.\\n # calculate the impurity of each of the two subsets of profiles split accordingly.\\n res = None\\n for feature in features_to_test:\\n values_for_split = [ep[feature] for ep in eps]\\n splitting_points = sorted(list(set(values_for_split)))\\n # take the midpoints between adjacent values\\n for i in range(len(splitting_points) - 1):\\n splitting_points[i] = (splitting_points[i] + splitting_points[i + 1]) / 2\\n splitting_points.pop()\\n\\n # calculate the impurity of each of the two subsets of profiles split accordingly.\\n for sp_value in splitting_points:\\n subset1 = [ep for ep in eps if ep[feature] < sp_value]\\n gini1 = cal_gini(subset1)\\n subset2 = [ep for ep in eps if ep[feature] >= sp_value]\\n gini2 = cal_gini(subset2)\\n # Sum these, weighted by the fraction of profiles in each subset.\\n gini = len(subset1) / len(eps) * gini1 + len(subset2) / len(eps) * gini2\\n if res is None:\\n res = (feature, sp_value, gini)\\n elif gini < res[2]:\\n res = (feature, sp_value, gini)\\n\\n return res\",\n \"def test_confidence_intervals(self):\\n # Taken from a T-Test table\\n\\n # Two Tailed\\n p, ci = _p_value_and_confidence_intervals(2.228, 10, 'two')\\n\\n self.assertAlmostEqual(p, .05, delta = .001)\\n self.assertTrue(ci.shape == (2, ))\\n np.testing.assert_allclose(ci, [-2.228, 2.228], atol=.001)\\n\\n # Left One-Tailed\\n p, ci = _p_value_and_confidence_intervals(1.895, 7, 'left')\\n\\n self.assertAlmostEqual(p, .05, delta = .001)\\n self.assertTrue(ci.shape == (2, ))\\n self.assertTrue(np.isinf(ci[0]))\\n np.testing.assert_allclose(ci, [-np.inf, 1.895], atol=.001)\\n\\n # Right One-Tailed\\n p, ci = _p_value_and_confidence_intervals(1.761, 14, 'right')\\n\\n self.assertAlmostEqual(1-p, .05, delta = .001)\\n self.assertTrue(ci.shape == (2, ))\\n self.assertTrue(np.isinf(ci[1])) \\n np.testing.assert_allclose(ci, [-1.761, np.inf], atol=.001)\",\n \"def test_random_forest_min_samples_split_parameter(params, X_train, X_test, y_train, y_test):\",\n \"def check_performance(self):\\n self.lg.debug('Checking performance.')\\n avg_up = (sum(self.results_up)) / len(self.results_up)\\n avg_down = (sum(self.results_down)) / len(self.results_down)\\n if (\\n avg_up < self.tolerance * self.up or\\n avg_down < self.tolerance * self.down\\n ):\\n self.bad_performance = True\\n else:\\n self.bad_performance = False\",\n \"def evaluate_fit_range(predicted, fit_range):\\n test1 = (predicted[0] >= fit_range[0])\\n test2 = (predicted[0] <= fit_range[1])\\n test3 = (predicted[1] >= fit_range[2])\\n test4 = (predicted[1] <= fit_range[3])\\n return all([test1, test2, test3, test4])\",\n \"def test_grade(grade_list):\\n num_grade=scale_grade(grade_list)\\n trend=[]\\n for ind in range(len(num_grade)-1):\\n if num_grade[ind+1]>num_grade[ind]:\\n trend.append(1)\\n elif num_grade[ind+1]<num_grade[ind]:\\n trend.append(-1)\\n else:\\n trend.append(0)\\n \\n if sum(trend)>0:\\n return 1\\n elif sum(trend)<0:\\n return -1\\n else:\\n return 0\",\n \"def get_discrete_split_value ( feature_array: np.ndarray, target_array: np.ndarray, evaluate_function: Callable ):\\n\\n # First element is the weighted average evaluate_function of the split\\n # Second term is the intrinsic value to penalize many splits.\\n return (\\n sum (\\n [\\n evaluate_function ( target_array [ feature_array == value ] ) * np.sum ( feature_array == value ) / len ( target_array )\\n for value in set ( feature_array )\\n ]\\n ),\\n -1\\n * sum (\\n [\\n pipe (\\n np.sum ( feature_array == value ) / len ( target_array ),\\n lambda ratio: ratio * np.log ( ratio ),\\n )\\n for value in set ( feature_array )\\n ]\\n ),\\n ) # End get_discrete_split_value()\",\n \"def continuous_mse(individual, test_data, truth_data, name=None):\\r\\n test_data = np.array(test_data)\\r\\n truth_data = np.array(truth_data)\\r\\n error = 0\\r\\n\\r\\n for test_item, truth_item in zip(test_data, truth_data):\\r\\n error += np.sqrt(np.mean(np.square(truth_item - test_item)))\\r\\n\\r\\n return error\",\n \"def test_basic(self):\\n data = get()\\n metrics = [verif.metric.Within(),\\n verif.metric.A(), # Hit\\n verif.metric.B(), # FA\\n verif.metric.C(), # Miss\\n verif.metric.D(), # Correct rejection\\n verif.metric.Hit(),\\n verif.metric.Threat(),\\n verif.metric.Conditional(),\\n verif.metric.XConditional(func=np.median),\\n ]\\n intervals = [verif.interval.Interval(-np.inf, 0, True, True), # [-inf, 0]\\n verif.interval.Interval(-np.inf, 1, True, True),\\n verif.interval.Interval(-np.inf, 2, True, True),\\n ]\\n obs = [0, 1.5, 2]\\n fcst = [3.1, 1.1, -2.1]\\n N = len(obs)*1.0\\n\\n # Each line is one metric (one number for each threshold)\\n expected = [[0/N, 100/N, 100/N], # Within\\n [0/N, 0/N, 2/N], # Hit\\n [1/N, 1/N, 0/N], # FA\\n [1/N, 1/N, 1/N], # Miss\\n [1/N, 1/N, 0/N], # Correct rejection\\n [0, 0, 2.0/3], # Hit rate\\n [0, 0, 2.0/3], # Threat score\\n [3.1, 3.1, 0.7], # Average fcst given obs in interval\\n [0, 0, 1.5], # Average obs given obs in interval\\n ]\\n\\n for m in range(len(metrics)):\\n metric = metrics[m]\\n for i in range(len(intervals)):\\n value = metric.compute_from_obs_fcst(np.array(obs), np.array(fcst), intervals[i])\\n ex = expected[m][i] * 1.0\\n if np.isnan(value):\\n self.assertTrue(np.isnan(ex))\\n else:\\n self.assertAlmostEqual(ex, value)\",\n \"def class0AccuracyEvalFunction(individual, test_data, truth_data, name=None):\\r\\n test_data = np.array(test_data)\\r\\n truth_data = np.array(truth_data)\\r\\n total = 0\\r\\n num_wrong = 0\\r\\n for test_point, truth_point in zip(test_data, truth_data):\\r\\n if truth_point == 0:\\r\\n if test_point < 0 or test_point > 2:\\r\\n num_wrong += 1\\r\\n total += 1\\r\\n if num_wrong == 0:\\r\\n # We don't want 'perfect' equate it with 100% error\\r\\n return 1.0\\r\\n else:\\r\\n return float(num_wrong)/float(total)\",\n \"def train_val_test_split(df):\\n from sklearn.model_selction import train_test_split\\n train, test = train_test_split(df, train_size = 0.80, test_size=0.20,\\n random_state = 42)\\n train, val = train_test_split(train, train_size = 0.70, val_size=0.30)\\n print(train.shape, val.shape, test.shape)\\n\\n return train, val, test\",\n \"def fit_test(self):\",\n \"def converged(old, new):\\n # https://github.com/amirgholami/PyHessian/commit/0f7e0f63a0f132998608013351ba19955fc9d861#diff-ba06409ffbc677fe556485172e62649fe7a069631390f5a780766bff3289b06bR149-R150 # noqa: B950\\n return (old - new).abs() / (old.abs() + 1e-6) < tol\",\n \"def get_discrete_split_value(arr: np.ndarray, y: np.ndarray, eval_func: Callable):\\n\\n # First element is the weighted average eval_func of the split\\n # Second term is the intrinsic value to penalize many splits.\\n return (\\n sum(\\n [\\n eval_func(y[arr == value]) * np.sum(arr == value) / len(y)\\n for value in set(arr)\\n ]\\n ),\\n -1\\n * sum(\\n [\\n pipe(\\n np.sum(arr == value) / len(y),\\n lambda ratio: ratio * np.log(ratio),\\n )\\n for value in set(arr)\\n ]\\n ),\\n )\",\n \"def c_test_fitness_function(self, function):\\r\\n return 1\",\n \"def c_test_fitness_function(self, function):\\r\\n return 1\",\n \"def test_right(self):\\n x = np.array([-100, -2, -1, 0, 1, 1.1])\\n self.assertEqual(npinterval.half_sample_mode(x), +1.05)\",\n \"def test(self):\\r\\n error_count = 0\\r\\n N_TESTING = len(self.TESTING_DATA)\\r\\n for i in range(N_TESTING):\\r\\n x_vec = self.TESTING_DATA[i][:-1]\\r\\n y = self.TESTING_DATA[i][-1]\\r\\n\\r\\n result = self.bp.classify(x_vec)\\r\\n if result != y: error_count += 1\\r\\n print(error_count, \\\" errors on the test data, out of \\\", N_TESTING, \\\"items.\\\")\",\n \"def precision_loss(data): #singular value\\n start = np.std(data.head(round(len(data)/8)))\\n end = np.std(data.tail(round(len(data)/8)))\\n change = end/start\\n return change\",\n \"def get_split(self,X,y):\\n \\n BEST_COL = 0\\n BEST_SPLIT =0\\n BEST_IMPUR = 99\\n for i,feature in enumerate(X.T):\\n arg_sort=np.argsort(feature) #Sort the feature for optimizing the find of splitting points\\n feature= feature[arg_sort]\\n y_sort = y[arg_sort]\\n splits = self.possible_splits(feature,y_sort) #Get \\n\\n impur,splits = self.test_split(feature,y_sort,splits) #Get impurity for splitting points\\n best_idx = np.argmin(impur)\\n best_impur = impur[best_idx]\\n \\n if best_impur==0.0: #Found perfect split, terminate\\n return(i,splits[best_idx])\\n elif best_impur<BEST_IMPUR:\\n BEST_IMPUR=best_impur\\n BEST_SPLIT=splits[best_idx]\\n BEST_COL=i\\n return (BEST_COL,BEST_SPLIT)\",\n \"def evaluate(self, dataset):\\n success = 0\\n for sample, labelVector, label in dataset.tests:\\n if self.guessLabel(sample) == label:\\n success += 1\\n return success / len(dataset.tests)\",\n \"def determine_best_split(data, potential_splits, mltask):\\n\\n first_iteration = True\\n for column_index in potential_splits:\\n for value in potential_splits[column_index]:\\n data_below,data_above = split_data(data, column_index, value)\\n \\n if mltask == 'regression':\\n current_overall_metric = calculate_overall_metric(data_below, data_above, metric_function = calculate_mse)\\n \\n # classification\\n else:\\n current_overall_metric = calculate_overall_metric(data_below, data_above, metric_function = calculate_entropy)\\n \\n \\n if first_iteration or current_overall_metric <= best_overall_metric:\\n first_iteration = False\\n \\n best_overall_metric = current_overall_metric\\n best_split_column = column_index\\n best_split_value = value\\n \\n \\n return best_split_column,best_split_value\",\n \"def test_rf_value(self):\\n\\t\\tdetails = self.watcher.describe()\\t\\t\\n\\t\\tself.assertTrue((details.rf.to_numpy()[0:8] == 9.0).all())\",\n \"def test_rosenbrock(self):\\n fun = get_problem('rosenbrock', self.dimension)\\n self.assertEqual(fun(self.array2), 0.0)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71865433","0.6572121","0.6329187","0.5955071","0.59270036","0.5801792","0.5749482","0.57275933","0.5726107","0.5710863","0.5676883","0.5616585","0.56147176","0.56091195","0.5603875","0.5592451","0.55882514","0.5582341","0.5575127","0.5549959","0.55460423","0.5545164","0.5524377","0.5522152","0.55164146","0.5514004","0.5512138","0.5510309","0.55011517","0.55010235","0.5498988","0.54934573","0.54806215","0.5477032","0.547425","0.5467611","0.5460376","0.5440543","0.5432228","0.5430905","0.54279804","0.54163456","0.54140055","0.54083395","0.53965205","0.53957117","0.53918743","0.5383063","0.5377205","0.5373608","0.53649354","0.53642195","0.536083","0.53605217","0.5357231","0.5357103","0.5356874","0.53566915","0.535556","0.53502935","0.5349858","0.53465503","0.53418136","0.5337882","0.53347296","0.5330023","0.53285986","0.53285986","0.5327254","0.53267735","0.53251654","0.5317618","0.53118145","0.5311745","0.5309536","0.53074956","0.5306465","0.53064144","0.5305187","0.5293987","0.5285254","0.52840817","0.52826667","0.5281435","0.5270797","0.52668947","0.5262463","0.52624226","0.525191","0.52507013","0.5250224","0.5250224","0.5249502","0.52457607","0.5231815","0.52295864","0.52267885","0.5225704","0.5224833","0.5220748"],"string":"[\n \"0.71865433\",\n \"0.6572121\",\n \"0.6329187\",\n \"0.5955071\",\n \"0.59270036\",\n \"0.5801792\",\n \"0.5749482\",\n \"0.57275933\",\n \"0.5726107\",\n \"0.5710863\",\n \"0.5676883\",\n \"0.5616585\",\n \"0.56147176\",\n \"0.56091195\",\n \"0.5603875\",\n \"0.5592451\",\n \"0.55882514\",\n \"0.5582341\",\n \"0.5575127\",\n \"0.5549959\",\n \"0.55460423\",\n \"0.5545164\",\n \"0.5524377\",\n \"0.5522152\",\n \"0.55164146\",\n \"0.5514004\",\n \"0.5512138\",\n \"0.5510309\",\n \"0.55011517\",\n \"0.55010235\",\n \"0.5498988\",\n \"0.54934573\",\n \"0.54806215\",\n \"0.5477032\",\n \"0.547425\",\n \"0.5467611\",\n \"0.5460376\",\n \"0.5440543\",\n \"0.5432228\",\n \"0.5430905\",\n \"0.54279804\",\n \"0.54163456\",\n \"0.54140055\",\n \"0.54083395\",\n \"0.53965205\",\n \"0.53957117\",\n \"0.53918743\",\n \"0.5383063\",\n \"0.5377205\",\n \"0.5373608\",\n \"0.53649354\",\n \"0.53642195\",\n \"0.536083\",\n \"0.53605217\",\n \"0.5357231\",\n \"0.5357103\",\n \"0.5356874\",\n \"0.53566915\",\n \"0.535556\",\n \"0.53502935\",\n \"0.5349858\",\n \"0.53465503\",\n \"0.53418136\",\n \"0.5337882\",\n \"0.53347296\",\n \"0.5330023\",\n \"0.53285986\",\n \"0.53285986\",\n \"0.5327254\",\n \"0.53267735\",\n \"0.53251654\",\n \"0.5317618\",\n \"0.53118145\",\n \"0.5311745\",\n \"0.5309536\",\n \"0.53074956\",\n \"0.5306465\",\n \"0.53064144\",\n \"0.5305187\",\n \"0.5293987\",\n \"0.5285254\",\n \"0.52840817\",\n \"0.52826667\",\n \"0.5281435\",\n \"0.5270797\",\n \"0.52668947\",\n \"0.5262463\",\n \"0.52624226\",\n \"0.525191\",\n \"0.52507013\",\n \"0.5250224\",\n \"0.5250224\",\n \"0.5249502\",\n \"0.52457607\",\n \"0.5231815\",\n \"0.52295864\",\n \"0.52267885\",\n \"0.5225704\",\n \"0.5224833\",\n \"0.5220748\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6943928"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":78594,"cells":{"query":{"kind":"string","value":"Function to get the best split (i.e., minimum number) across many proposed splits."},"document":{"kind":"string","value":"def get_min_across_splits_continuous (\n feature_array: np.ndarray, target_array: np.ndarray, splits: np.ndarray, evaluate_function: Callable\n ):\n n = len ( splits )\n if n > 500:\n # If many split points, use some threading\n with multiprocessing.Pool ( processes = 8 ) as p:\n # Get evaluation scores across all the splits\n post_split_evals = dict (\n zip (\n range ( len ( splits ) ),\n p.starmap (\n BaseTree.get_split_goodness_fit_continuous,\n zip ( [ feature_array] * n, [ target_array ] * n, splits, [ evaluate_function ] * n ),\n ),\n )\n )\n p.close()\n else:\n # If not too many split points, get scores across all splits\n post_split_evals = dict (\n zip (\n range ( len ( splits ) ),\n map (\n lambda x: BaseTree.get_split_goodness_fit_continuous ( * x ),\n zip ( [ feature_array ] * n, [ target_array ] * n, splits, [ evaluate_function ] * n ),\n ),\n )\n )\n # Get the minimum split based on gain ratio\n min_eval = min (\n post_split_evals,\n key = lambda x: pipe (\n post_split_evals.get ( x ),\n lambda results: results [ 0 ] / results [ 1 ], # entropy / intrinsic value\n ),\n )\n\n # Return the best split and the splits scores\n return ( splits [ min_eval ], * post_split_evals.get ( min_eval ) )\n # End get_min_across_splits_continuous()"},"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 best_split(self):\r\n best_splits = [[0, None, None]]\r\n impurity, best_S, best_xj = 0, None, None\r\n \r\n for xj in self.x_names:\r\n for S in self.potential_splits(xj):\r\n ir = float(self.impurity_reduction(xj, S))\r\n if ir > impurity:\r\n impurity, best_S, best_xj = ir, S, xj\r\n best_splits.append([S, xj])\r\n else: \r\n pass\r\n \r\n return best_S, best_xj","def determine_best_split(data, potential_splits, mltask):\n\n first_iteration = True\n for column_index in potential_splits:\n for value in potential_splits[column_index]:\n data_below,data_above = split_data(data, column_index, value)\n \n if mltask == 'regression':\n current_overall_metric = calculate_overall_metric(data_below, data_above, metric_function = calculate_mse)\n \n # classification\n else:\n current_overall_metric = calculate_overall_metric(data_below, data_above, metric_function = calculate_entropy)\n \n \n if first_iteration or current_overall_metric <= best_overall_metric:\n first_iteration = False\n \n best_overall_metric = current_overall_metric\n best_split_column = column_index\n best_split_value = value\n \n \n return best_split_column,best_split_value","def get_best_split(rows):\n best_gain = 0\n best_question = None\n current_impurity = get_gini(rows)\n n_features = len(rows[0])\n\n for col in range(n_features):\n\n for row in rows:\n question = Question(col, row[col])\n true_rows, false_rows = partition(rows, question)\n\n if len(true_rows) == 0 or len(false_rows) == 0:\n break\n\n question_gain = get_info_gain(true_rows, false_rows, current_impurity)\n\n if question_gain >= best_gain:\n best_gain = question_gain\n best_question = question\n\n print(best_gain)\n print(best_question)\n return best_gain, best_question","def get_min_across_splits_continuous(\n arr: np.ndarray, y: np.ndarray, splits: np.ndarray, eval_func: Callable\n ):\n n = len(splits)\n if n > 500:\n # If many split points, use some threading\n with multiprocessing.Pool(processes=8) as p:\n # Get evaluation scores across all the splits\n post_split_evals = dict(\n zip(\n range(len(splits)),\n p.starmap(\n BaseTree.get_split_goodness_fit_continuous,\n zip([arr] * n, [y] * n, splits, [eval_func] * n),\n ),\n )\n )\n p.close()\n else:\n # If not too many split points, get scores across all splits\n post_split_evals = dict(\n zip(\n range(len(splits)),\n map(\n lambda x: BaseTree.get_split_goodness_fit_continuous(*x),\n zip([arr] * n, [y] * n, splits, [eval_func] * n),\n ),\n )\n )\n # Get the minimum split based on gain ratio\n min_eval = min(\n post_split_evals,\n key=lambda x: pipe(\n post_split_evals.get(x),\n lambda results: results[0] / results[1], # entropy / intrinsic value\n ),\n )\n\n # Return the best split and the splits scores\n return (splits[min_eval], *post_split_evals.get(min_eval))","def find_best_split(self, x, y):\n\n # check cornor case: all same x\n n = y.size\n\n if all(x == x[0]):\n return (0, amin(x) - self.eps)\n\n sort_index = argsort(x)\n x_sorted = x[sort_index]\n y_sorted = y[sort_index]\n\n # build potential split index array\n split_index_array = array([i for i in range(1, n)\n if x_sorted[i] != x_sorted[i - 1]\n and y_sorted[i] != y_sorted[i - 1]])\n\n # split_index_array = linspace(\n # 0, y.size, num=min(5, ceil(n / 5)), endpoint=False, dtype='int')\n # split_index_array = split_index_array[1:]\n\n best_split_index = 0\n best_gain = 0\n h_x = self.cur_entropy\n\n for split_index in split_index_array:\n left_entropy = self.entropy(y_sorted[:split_index])\n right_entropy = self.entropy(y_sorted[split_index:])\n h_xy = (split_index * left_entropy +\n (n - split_index) * right_entropy) / n\n cur_gain = h_x - h_xy\n\n if cur_gain > best_gain:\n best_gain = cur_gain\n best_split_index = split_index\n\n if best_split_index != 0:\n best_split_point = (x_sorted[best_split_index] +\n x_sorted[best_split_index - 1]) / 2\n else:\n best_split_point = x_sorted[best_split_index] - self.eps\n\n return (best_gain, best_split_point)","def __find_best_split(self, x, y):\n data = np.transpose(np.vstack((np.transpose(x), y)))\n num_features = data.shape[1] - 1\n\n # initialise splitting rule components\n integer_splitting_rule = None\n feature_index_to_split = None\n max_info_gain = 0\n\n # iterate over all the features and find best splits within these\n for feature in range(num_features):\n info_gain, split_int = self.__find_best_split_in_feature(\n data[:, [feature, -1]])\n if info_gain is None:\n continue\n # update max info gain so far as it iterates over features\n if info_gain > max_info_gain:\n max_info_gain = info_gain\n feature_index_to_split = feature\n integer_splitting_rule = int(split_int)\n\n return feature_index_to_split, integer_splitting_rule","def min_parts():\n # you must replace this with your own value\n return -1","def get_split(data):\n \"\"\" gets the best feature, and best value \"\"\"\n\n best_feature = None\n best_value = 0.0\n columns = data.columns\n gini_base = gini_impurity(data)\n n_rows = len(data.index) # total number of rows of data before split\n\n # Fininding which split yields the best gini gain\n max_gain = 0\n\n for i in range(len(columns)-1): # -1 b.c. class is final column\n xs = data[columns[i]].unique() # get values to test\n for x in xs: # test values\n # split dataset\n df_left = data[data[columns[i]] < x]\n df_right = data[data[columns[i]] >= x]\n\n # get gini impurities\n gini_left = gini_impurity(df_left)\n gini_right = gini_impurity(df_right)\n \n\n # Calculated weighted gini impurity\n w_left = len(df_left.index) / n_rows\n w_right = len(df_right.index) / n_rows\n\n w_gini = gini_left * w_left + gini_right * w_right\n \n\n # Calculate gini gain (we want to minimize w_gini for the smallest impurity. Ideal split is perfect Left=c1, Right=c2)\n # why not just find min w_gin instead of uding gini_gain and gini_base vaiables?\n gini_gain = gini_base - w_gini\n\n # check if this is the best split so far, store values, update max_gini\n if gini_gain > max_gain:\n best_feature = columns[i]\n best_value = x\n max_gain = gini_gain\n\n df_left = data.loc[data[best_feature] < best_value]\n df_right = data.loc[data[best_feature] >= best_value]\n \n\n return best_feature, best_value, df_left, df_right","def findBestValueSplitByGini(self, data, structure, colIndex):\n minGini, bestSplit = 1, []\n for i in range(0, len(data)-1):\n split = (float(data[i][colIndex]) + float(data[i+1][colIndex])) / 2\n giniSplit = self.calcGiniSplitBySplitValue(data, structure, colIndex, split)\n if giniSplit <= minGini:\n minGini = giniSplit\n bestSplit = [split, giniSplit]\n return bestSplit","def get_split(self,X,y):\n \n BEST_COL = 0\n BEST_SPLIT =0\n BEST_IMPUR = 99\n for i,feature in enumerate(X.T):\n arg_sort=np.argsort(feature) #Sort the feature for optimizing the find of splitting points\n feature= feature[arg_sort]\n y_sort = y[arg_sort]\n splits = self.possible_splits(feature,y_sort) #Get \n\n impur,splits = self.test_split(feature,y_sort,splits) #Get impurity for splitting points\n best_idx = np.argmin(impur)\n best_impur = impur[best_idx]\n \n if best_impur==0.0: #Found perfect split, terminate\n return(i,splits[best_idx])\n elif best_impur<BEST_IMPUR:\n BEST_IMPUR=best_impur\n BEST_SPLIT=splits[best_idx]\n BEST_COL=i\n return (BEST_COL,BEST_SPLIT)","def get_best_split_all(x, y) -> Tuple[int, float, float]:\n m = x.shape[1]\n col_best_gin = np.ones(shape=m)\n col_best_val = np.ones(shape=m)\n for c in range(m):\n best = 1\n best_x = 0\n for i in np.unique(x[:, c]):\n gini = Tree.split(x[:, c], y, i)\n if gini < best:\n best = gini\n best_x = i\n col_best_gin[c] = best\n col_best_val[c] = best_x\n\n # Select best feature to split on\n col_idx = np.argmin(col_best_gin)\n # Convert to bool index\n col_idx = np.array(range(x.shape[1])) == col_idx\n\n return col_idx, col_best_val[col_idx], col_best_gin[col_idx]","def minimum_spanning_arborescence(sol):","def best_split(values,labels,nonelabels=None):\n assert len(values) >= 2\n assert len(values) == len(labels)\n N = len(values)\n ilist = sorted((v,l) for (v,l) in zip(values,labels))\n leftcount = defaultdict(int)\n rightcount = defaultdict(int)\n for v,l in ilist:\n rightcount[l] += 1\n bestindex = -1\n bestcost = split_cost([leftcount,rightcount])\n\n cost = bestcost\n #costs = [cost]\n #print \"Split costs:\"\n for i in xrange(len(ilist)):\n v,l = ilist[i]\n rightcount[l] -= 1\n leftcount[l] += 1\n if i+1 >= len(ilist) or v == ilist[i+1][0]:\n #no splits when v is equal to the next value\n continue\n cost = split_cost([leftcount,rightcount])\n #print \" \",v,leftcount.values(),rightcount.values(),cost\n #costs.append(cost)\n if cost < bestcost:\n bestcost = cost\n bestindex = i\n #raw_input()\n if bestindex < 0:\n #no split found... try splitting in half\n splitval = (ilist[0][0]+ilist[-1][0])*0.5\n else:\n splitval = (ilist[bestindex][0] + ilist[bestindex+1][0])*0.5\n if nonelabels is None:\n return (splitval,bestcost)\n #reevaluate counts\n leftcount = defaultdict(int)\n rightcount = defaultdict(int)\n for l in nonelabels:\n leftcount[l] += 1\n rightcount[l] += 1\n for v,l in ilist:\n if v <= splitval:\n leftcount[l] += 1\n else:\n rightcount[l] += 1\n return splitval,split_cost([leftcount,rightcount])","def split_workload(workload):\n diff = sum(workload)\n minimum = abs(diff), 0\n for i, work in enumerate(workload, 1):\n diff -= 2 * work\n current = abs(diff), i\n if current < minimum:\n minimum = current\n return (None, None) if minimum == (0, 0) else minimum[::-1]","def pick_best_split(self,db,labels,ids,features=None):\n idlabels = [labels[id] for id in ids]\n if misclassification_error(idlabels) == 0:\n #base case: no misclassifications\n self.type = 'v'\n self.value = idlabels[0]\n return 0\n best = None\n bestCost = 0\n splitval = None\n discrete = True\n if features == None:\n if len(ids) < db.numFeatures():\n #look at all present features in the training set\n features = db.getPresentFeatures(ids)\n #print len(features),\"of\",db.numFeatures(),\"features selected\"\n else:\n features = range(db.numFeatures())\n elif callable(features):\n features = features()\n for i in features:\n if len(db.entryLists[i]) == 0: continue\n idiscrete = db.discreteFeature[i]\n if idiscrete:\n #count number of labels of a certain value\n splitter = defaultdict(lambda:defaultdict(int))\n #count of labels for missing values\n nmissing = defaultdict(int)\n for id in ids:\n val = db[i,id]\n if val is None:\n #missing values go down to all splits\n nmissing[labels[id]] += 1\n continue\n splitter[val][labels[id]] += 1\n if len(splitter) > continuous_variable_threshold:\n #print \"Determined to be a continuous variable\"\n idiscrete = False\n break\n if idiscrete:\n if len(splitter) <= 1:\n #only a single value\n continue\n #count number of missing values in all splits\n cmax = 0\n for k in splitter:\n for l,v in nmissing.iteritems():\n splitter[k][l] += v\n cmax = max(cmax,sum(splitter[k].values()))\n #shrink by fraction of (# of ids - largest child)/(# of ids)\n scale = (1.0-float(cmax)/float(len(ids)))*len(splitter)\n #evaluate cost\n cost = split_cost(splitter.values())*scale\n #print \"Split on\",i,\"information gain\",-cost,splitter.values()\n else:\n #continuous, need to learn the best split\n vals = []\n presentlabels = []\n nonelabels = []\n for id in ids:\n val = db[i,id]\n if val is None:\n nonelabels.append(labels[id])\n continue\n vals.append(val)\n presentlabels.append(labels[id])\n if len(vals) <= 1:\n print \"No values for feature\",i,\"?\"\n print vals\n continue\n #print \"Considering continuous split on\",i\n s,cost = best_split(vals,presentlabels,nonelabels)\n scale = (1.0-float(len(presentlabels)/2+len(nonelabels))/float(len(ids)))*2\n cost *= scale\n #print \"Result\",s,\"Information gain\",-cost\n \n if cost < bestCost:\n best = i\n bestCost = cost\n discrete = idiscrete\n if not idiscrete:\n splitval = s\n \n if best is None:\n self.type = 'v'\n if len(ids) > 0:\n self.value = vote(idlabels)\n return misclassification_error(idlabels)\n else:\n self.value = None\n return 0\n else:\n self.feature = best\n #discrete or inequality split\n if discrete:\n self.type = 's'\n else:\n self.type = 'i'\n self.value = splitval\n return bestCost","def find_best_split(rows):\n best_gain = 0 # keep track of the best information gain\n best_question = None # keep train of the feature / value that produced it\n current_uncertainty = gini(rows)\n n_features = len(rows[0]) - 1 # number of columns\n #print(\"n_features:\", n_features)\n\n for col in range(1,n_features): # for each feature\n # for each iteration this is the set of all values of a specific column, eg, All pixels number 0\n values = set([row[col] for row in rows]) # unique values in the column\n for val in values: # for each value\n\n # Create a question object for each val under a column, holding the val and the col number\n question = Question(col, val)\n\n # try splitting the dataset\n true_rows, false_rows = partition(rows, question)\n\n # Skip this split if it doesn't divide the\n # dataset.\n if len(true_rows) == 0 or len(false_rows) == 0:\n continue\n\n # Calculate the information gain from this split\n gain = info_gain(true_rows, false_rows, current_uncertainty)\n\n # You actually can use '>' instead of '>=' here\n # but I wanted the tree to look a certain way for our\n # toy dataset.\n if gain >= best_gain:\n best_gain, best_question = gain, question\n\n return best_gain, best_question","def find_split(self, X, y):\n choices = y.size\n if choices <= 1:\n return None, None\n\n # find the number of each option in the current node.\n options_parent = [np.sum(y == c) for c in range(self.num_outcomes)]\n\n # find the gini of current node.\n best_gini = 1.0 - sum((n / choices) ** 2 for n in options_parent)\n best_idx, best_split = None, None\n\n # loop through the features to get splits and options.\n for idx in range(self.num_features):\n splits, options = zip(*sorted(zip(X[:, idx], y)))\n\n num_left = [0] * self.num_outcomes\n num_right = options_parent.copy()\n for i in range(1, choices):\n c = options[i - 1]\n num_left[c] += 1\n num_right[c] -= 1\n gini_left = 1.0 - sum(\n (num_left[x] / i) ** 2 for x in range(self.num_outcomes)\n )\n gini_right = 1.0 - sum(\n (num_right[x] / i) ** 2 for x in range(self.num_outcomes)\n )\n\n gini = (i * gini_left + (choices - i) * gini_right) / choices\n\n if splits[i] == splits[i - 1]:\n continue\n\n if gini < best_gini:\n best_gini = gini\n best_idx = idx\n best_split = (splits[i] + splits[i - 1]) / 2\n\n return best_idx, best_split","def findBestColumnSplitByGini(self, data, structure):\n minGini, bestSplit = 1, None\n for colName in list(structure.keys())[:-1]:\n giniSplit = self.calcGiniSplitByColumn(data, structure, colName)\n if giniSplit <= minGini:\n minGini = giniSplit\n bestSplit = colName\n return bestSplit","def calculateOptimal(self) -> (list, int):\n\t\tcombinations = list(itertools.product(*self.clusters))\n\t\tmin_dist = 1000000\n\t\tmin_combination = None\n\t\tfor combination in combinations:\n\t\t\tdist = super().step(combination)\n\t\t\tif(dist < min_dist):\n\t\t\t\tmin_dist = dist\n\t\t\t\tmin_combination = combination\n\t\treturn (min_combination, min_dist)","def __find_best_split_in_feature(self, feature_and_class):\n\n # sort the feature and class and use changes in the class to reduce\n # number of potential split info gain calculations\n sorted_data = feature_and_class[\n feature_and_class[:, 0].astype(np.int).argsort()]\n potential_splits = self.__find_integers_with_class_change(sorted_data)\n info_gains = self.__info_gain_from_splits(potential_splits,\n sorted_data)\n\n # returning nothing in no information gains are found\n if len(info_gains) == 0:\n return None, None\n\n index = info_gains.index(max(info_gains))\n return info_gains[index], potential_splits[index]","def best_split(self):\n sub_group = []\n\n current_entropy = self.entropy(self._Passengers)\n best_gain = 0 # holds the best entropy difference so far\n best_split = self._Attr[0].get_name()\n relative_entropy = 0 # entropy while taking account for the size of the population\n\n for Attribute in self._Attr:\n relative_entropy = 0\n print(\"Attr considered: \" + Attribute.get_name())\n for Attr_option in Attribute.get_options():\n sub_group = []\n for Passenger in self._Passengers:\n if self.passenger_attr_option_check(Passenger,\n Attribute.get_name(),\n Attr_option): # if P.A = V\n sub_group.append(Passenger)\n if len(sub_group) > 0 and len(self._Passengers) > 0:\n relative_entropy += self.entropy(sub_group) * (len(sub_group)/len(self._Passengers))\n\n if current_entropy - relative_entropy > best_gain:\n best_gain = current_entropy - relative_entropy\n best_split = Attribute.get_name()\n\n print(f\"best split:{best_split} \\n with entropy gain of:\\n {best_gain}\")\n\n return best_split","def _optimal_splits (self, split_axis):\n n = len(self.displays)\n size = self.screen.get_size()\n # sizes in directions of first/second split\n s1 = size[split_axis]\n s2 = size[not split_axis]\n ratio = self.ratio\n # use screen aspect ratio if no preferred one given\n if ratio is None:\n ratio = float(size[0]) / size[1]\n error = []\n for splits in xrange(1, n + 1):\n # maximal number of displays per row/column\n per_split = ceil(float(n) / splits)\n # minimise unused space (as a fraction of the screen)\n space_e = abs(1 - float(n) / (splits * per_split))\n # and ratio (we care about proportionality, so use log)\n disp_ratio = float(s1 * splits) / (s2 * per_split)\n if split_axis == 1:\n # inverted if splitting into columns\n disp_ratio = 1 / disp_ratio\n ratio_e = abs(log(disp_ratio / ratio))\n # adjust using some constants\n e = space_e + ratio_e\n error.append((e, splits))\n return min(error)","def optimal_split(self, ratio = 0.5):\n\n if (sum(self.game_state) == 1):\n if (randint(1,100)<=50):\n return self.game_state, [0]*(self.K+1)\n else:\n return [0]*(self.K+1), self.game_state\n \n else:\n prob = LpProblem(\"Optimal split\",LpMinimize)\n A = []\n for i in range(self.K + 1):\n A += LpVariable(str(i), 0, self.game_state[i], LpInteger)\n prob += sum([2**(-(self.K - i)) * c for c, i in zip(A, range(self.K + 1))]) - ratio * self.potential(self.game_state), \"Objective function\"\n prob += sum([2**(-(self.K - i)) * c for c, i in zip(A, range(self.K + 1))]) >= ratio * self.potential(self.game_state), \"Constraint\"\n #prob.writeLP(\"test.lp\")\n prob.solve()\n Abis = [0]*(self.K+1)\n for v in prob.variables():\n Abis[int(v.name)] = round(v.varValue)\n B = [z - a for z, a in zip(self.game_state, Abis)]\n return Abis, B","def bsp(splits, min_val, max_val):\n if not splits and min_val == max_val:\n return min_val\n if splits[0] in ['F', 'L']:\n return bsp(splits[1:], min_val, math.floor((min_val + max_val)/2))\n elif splits[0] in ['B', 'R']:\n return bsp(splits[1:], math.ceil((min_val + max_val)/2), max_val)","def findBestSplitInDataByInfoGain(self, data, structure, colName):\n colIndex, maxInfoGain, bestSplit = structure[colName]['index'], 0, []\n for i in range(0, len(data)-1):\n split = (float(data[i][colIndex]) + float(data[i+1][colIndex])) / 2\n infoGain = self.calcInfoGainBySplitValue(data, structure, colName, split)\n if infoGain >= maxInfoGain:\n bestSplit = [split, infoGain]\n maxInfoGain = infoGain\n return bestSplit","def get_n_best(self):\n pass","def min_parts():\n # min_parts = 270\n # you must replace this with your own value\n # return -1\n\n return 270","def findBestColumnSplitByGainRatio(self, data, structure):\n maxGainRatio, bestSplit = 0, None\n for colName in list(structure.keys())[:-1]:\n GainRatio = self.calcGainRatioSplitByColumn(data, structure, colName)\n if GainRatio >= maxGainRatio:\n maxGainRatio = GainRatio\n bestSplit = colName\n return bestSplit","def golden_split(n):\n large = n / GOLDEN_RATIO\n small = n - large\n large = int(round(large))\n small = int(round(small))\n return large, small","def _find_split(self, X, y, n_features):\r\n splits_info = []\r\n\r\n # Select features to consider\r\n features = self._feature_selection.get_features(n_features, self._feature_prob)\r\n\r\n # Get candidate splits\r\n for feature_id in features:\r\n for split_value in compute_split_values(X[:, feature_id]):\r\n splits_info.append(\r\n compute_split_info(self._split_criterion, X, y, feature_id, split_value, self._min_samples_leaf))\r\n\r\n splits = []\r\n for split_info in splits_info:\r\n if split_info is not None:\r\n gain, feature_id, split_value = split_info\r\n split = Split(feature_id, value=split_value, gain=gain)\r\n splits.append(split)\r\n else:\r\n continue\r\n\r\n selected_split = self._split_chooser.get_split(splits)\r\n return selected_split","def getSplit(self):\n b_index, b_value, b_score, b_groups = 999, 999, 999, None\n for j in range(len(self[0]) - 1):\n for i in range(len(self)):\n groups = self.splitAttribute(j, self[i][j]) # lit, big\n gini = self.giniIndex(groups)\n if gini < b_score and (j, \"%.1f\" % self[i][j]) not in self.atr:\n b_index, b_value, b_score, b_groups = j, self[i][\n j], gini, groups\n return b_index, b_value, b_groups, b_score","def best_pair(p1,p2,p3):\n left_distance = float(\"inf\")\n right_distance = float(\"inf\")\n split_distance = float(\"inf\")\n if p1:\n left_distance = distance(p1[0], p1[1])\n if p2:\n right_distance = distance(p2[0], p2[1])\n if p3:\n split_distance = distance(p3[0], p3[1])\n\n min_distance = min(left_distance, right_distance, split_distance)\n if min_distance == left_distance:\n return p1\n elif min_distance == right_distance:\n return p2\n else:\n return p3","def find_smallest(num_vars):\n for x in range(10):\n if num_vars <= 2**x:\n return x","def _compute_split_boundaries(split_probs, n_items):\n if len(split_probs) > n_items:\n raise ValueError(\n 'Not enough items for the splits. There are {splits} '\n 'splits while there are only {items} items'.format(\n splits=len(split_probs), items=n_items\n )\n )\n total_probs = sum(p for name, p in split_probs)\n if abs(1 - total_probs) > 1e-8:\n raise ValueError('Probs should sum up to 1. probs={}'.format(split_probs))\n split_boundaries = []\n sum_p = 0.0\n for name, p in split_probs:\n prev = sum_p\n sum_p += p\n split_boundaries.append((name, int(prev * n_items), int(sum_p * n_items)))\n\n # Guard against rounding errors.\n split_boundaries[-1] = (\n split_boundaries[-1][0],\n split_boundaries[-1][1],\n n_items,\n )\n\n return split_boundaries","def best_cutoff(self,\n split_label):\n split_args = self.sub_split_args[split_label]\n split_data = self.sub_split_data[split_label]\n # This criterion for the use_scipy flag is arbitrary and needs\n # further testing\n n_unique = len(np.unique(split_data[~np.isnan(split_data)]))\n use_scipy = True\n if n_unique > len(split_data)/1000:\n use_scipy = False\n idxcut_below, effects_below, rstats_below, ndata_below =\\\n self.u_data(split_label, use_scipy=use_scipy)\n idxcut_above, effects_above, rstats_above, ndata_above =\\\n self.u_data(split_label, above=True, use_scipy=use_scipy)\n\n # Default cutoff is min(split_data) - 1\n cutoff = split_data[split_args[0]] - 1\n value = 0\n # If no cutoff was possible\n if len(idxcut_below) == 0 or len(idxcut_above) == 0:\n return cutoff, value\n\n # All idx_cutoffs and values for cutoffs, for debugging\n for idx in range(len(idxcut_above)):\n idxcut = idxcut_above[idx]\n if idxcut != idxcut_below[idx]:\n raise NameError('Code error, invalid split')\n value_temp = (abs(effects_above[idx] -\n effects_below[idx]) *\n rstats_above[idx] *\n rstats_below[idx] *\n min(ndata_above[idx]) *\n min(ndata_below[idx]))\n if value_temp > value:\n cutoff = (split_data[split_args[int(idxcut)]] +\n split_data[split_args[int(idxcut)+1]])/2\n value = value_temp\n return cutoff, value","def get_n_splits(self):\n pass","def get_optimal_continuous_feature_split(\n self, X: np.ndarray, y: np.ndarray, feature_col: int\n ):\n midpoints = BaseTree.get_valid_midpoints(arr=X[:, feature_col], y=y)\n # If midpoints, get the best one\n if len(midpoints) > 0:\n return BaseTree.get_min_across_splits_continuous(\n arr=X[:, feature_col], y=y, splits=midpoints, eval_func=self.eval_func\n )\n\n # If no split points, return inf (can't split here)\n return (0, np.inf, 1)","def choose_best_split(self, X_subset, y_subset):\n # YOUR CODE HERE\n feature_index = None\n threshold = None\n best_G = np.inf\n N = len(X_subset)\n \n for current_feature in range(X_subset.shape[1]):\n thresholds = np.unique(X_subset[:, current_feature])\n \n for t in thresholds:\n y_left, y_right = self.make_split_only_y(current_feature, t, X_subset, y_subset)\n H_L = self.H(y_left)\n H_R = self.H(y_right)\n \n G = (len(y_left) / N) * H_L + (len(y_right) / N) * H_R\n \n if G < best_G:\n best_G = G\n feature_index = current_feature\n threshold = t\n \n return feature_index, threshold","def split(self,best):\n\t\treturn self.cu_for_split(best,False)","def get_splits(self):\n\t\treturn self.k","def findBestColumnSplitByInfoGain(self, data, structure):\n maxInfoGain, bestSplit = 0, None\n for colName in list(structure.keys())[:-1]:\n infoGain = self.calcInfoGainByColumnSplit(data, structure, colName)\n if infoGain >= maxInfoGain:\n maxInfoGain = infoGain\n bestSplit = colName\n return bestSplit","def get_best_split(rows: list) -> (float, Question):\n best_info_gain = 0\n best_question = None\n current_uncertainty = get_gini_impurity(rows)\n\n # minus 1 because we're ignoring the last column which is the label.\n n_attributes = len(rows[0]) - 1\n\n for col in range(n_attributes):\n\n # get all unique values for an attribute/column\n unique_values = set([row[col] for row in rows])\n\n for value in unique_values:\n question = Question(col, value)\n\n # Split rows depending on the question\n true_rows, false_rows = partition(rows, question)\n\n # We don't want to partition such rows\n if len(true_rows) == 0 or len(false_rows) == 0:\n continue\n\n # Get info gain from this split\n info_gain = get_info_gain(false_rows, true_rows, current_uncertainty)\n\n if info_gain > best_info_gain:\n best_info_gain, best_question = info_gain, question\n\n return best_info_gain, best_question","def find_split(x, y):\n\n # Need the starting entropy so we can measure improvement...\n start_entropy = calculate_entropy(y)\n\n # Best thus far, initialised to a dud that will be replaced immediately...\n best = {'infogain': -np.inf}\n\n # Randomly allocate the splits to be traversed (without replacement)\n feature_total = x.shape[1]\n feature_subset_count = int(np.sqrt(feature_total))\n feature_subset = np.random.permutation(feature_total)[:feature_subset_count]\n\n # Loop every possible split of every feature...\n for feature_index in feature_subset:\n for split in np.unique(x[:, feature_index]):\n\n left_indices = []\n right_indices = []\n\n # Get index of rows where x[row_index,feature_index] <= split\n for row_index,row in enumerate(x):\n left_indices.append(row_index) if x[row_index,feature_index] <= split else right_indices.append(row_index)\n\n left_ys = y[left_indices]\n right_ys = y[right_indices]\n\n nleft = len(left_ys)\n nright = len(right_ys)\n ntotal = nleft + nright\n infogain = start_entropy - (nleft / ntotal) * calculate_entropy(left_ys) - (\n nright / ntotal) * calculate_entropy(right_ys)\n\n if infogain > best['infogain']:\n best = {'feature': feature_index,\n 'split': split,\n 'infogain': infogain,\n 'left_indices': left_indices,\n 'right_indices': right_indices}\n return best","def get_n_out_min(ss):\n n = ss.split(\"_\")[0]\n if n == \"full\":\n n = 1\n else:\n n = int(n)\n return n","def compute_splits(feature_df, target_col, max_num_splits):\n tree_estimator = DecisionTreeClassifier(max_leaf_nodes=max_num_splits+1,\n class_weight='balanced',\n random_state=1407)\n\n tree_estimator.fit(feature_df, target_col)\n thresholds = tree_estimator.tree_.threshold[tree_estimator.tree_.children_left != _tree.TREE_LEAF]\n return sorted(thresholds)","def get_n_splits(self):\n return self.n_splits","def get_n_splits(self):\n return self.n_splits","def get_n_splits(self):\n return self.n_splits","def __get_split_feature(self, data_set, target_feature, tree_features):\n\n if self.__criterion == 'entropy':\n feature_gains = {feature: self.__gain(data_set, feature, target_feature) for (feature) in tree_features}\n split_feature = max(feature_gains, key=feature_gains.get)\n return split_feature\n elif self.__criterion == 'gini':\n feature_ginis = {feature: self.__gini(data_set, feature, target_feature) for (feature) in tree_features}\n split_feature = min(feature_ginis, key=feature_ginis.get)\n return split_feature\n # TODO: I should check this (gini index).","def _bestFeat2split(dataSet, impurity_crit, min_impurity_decrease, min_samples_split):\n\t\tm, n = dataSet.shape\n\t\tbestFeatInd, bestVal = None, DecisionTree._make_leaf(dataSet, impurity_crit)\n\n\t\tif m < min_samples_split or len(set(dataSet[:,-1])) == 1:\n\t\t\treturn bestFeatInd, bestVal\n\n\t\timpurity = m * impurity_crit(dataSet)\n\t\tmin_impurity = np.inf\n\t\t\n\n\t\tfor feat_ind in range(n-1):\n\t\t\tif type(dataSet[:, feat_ind][0]) != str:\n\t\t\t\tuniqVal = set(dataSet[:, feat_ind])\n\t\t\telse:\n\t\t\t\tuniqVal = map(set, subsets(list(dataSet[:, feat_ind])))\n\t\t\tfor val in uniqVal:\n\t\t\t\tD1, D2 = DecisionTree._binarySplit(dataSet, feat_ind, val)\n\t\t\t\tif len(D1) < min_samples_split or len(D2) < min_samples_split:\n\t\t\t\t\tcontinue\n\t\t\t\tnew_impurity = len(D1)*impurity_crit(D1) + len(D2)*impurity_crit(D2)\n\t\t\t\tif impurity - new_impurity < min_impurity_decrease:\n\t\t\t\t\tcontinue\n\t\t\t\tif new_impurity < min_impurity:\n\t\t\t\t\tmin_impurity = new_impurity\n\t\t\t\t\tbestFeatInd = feat_ind; bestVal = val\n\t\treturn bestFeatInd, bestVal","def min_parts():\n # you must replace this with your own value\n return 1155","def min_parts():\n # you must replace this with your own value\n return 1155","def detect_splits(self):\n logg.info(' abstracted graph will have {} nodes'.format(self.n_splits+1))\n indices_all = np.arange(self.X.shape[0], dtype=int)\n segs = [indices_all]\n if False: # this is safe, but not compatible with on-the-fly computation\n tips_all = np.array(np.unravel_index(np.argmax(self.Dchosen), self.Dchosen.shape))\n else:\n if self.iroot is not None:\n tip_0 = np.argmax(self.Dchosen[self.iroot])\n else:\n tip_0 = np.argmax(self.Dchosen[0]) # just a random index, here fixed to \"0\"\n tips_all = np.array([tip_0, np.argmax(self.Dchosen[tip_0])])\n # we keep a list of the tips of each segment\n segs_tips = [tips_all]\n if self.clusters_precomputed_names:\n self.segs_names_original = [', '.join(self.clusters_precomputed_names)]\n segs_undecided = [True]\n segs_adjacency = [[]]\n segs_distances = np.zeros((1, 1))\n segs_adjacency_nodes = [{}]\n # logg.info(' do not consider groups with less than {} points for splitting'\n # .format(self.min_group_size))\n for ibranch in range(self.n_splits):\n if self.clusters == 'unconstrained_segments':\n iseg, new_tips = self.select_segment(segs, segs_tips, segs_undecided)\n if iseg == -1:\n logg.info('... partitioning converged')\n break\n logg.info('... branching {}:'.format(ibranch + 1),\n 'split group', iseg)\n segs_distances = self.do_split(segs, segs_tips,\n segs_undecided,\n segs_adjacency,\n segs_distances,\n iseg, new_tips)\n else:\n logg.msg(' split', ibranch + 1, v=4)\n stop, segs_distances = self.do_split_constrained(segs, segs_tips,\n segs_adjacency,\n segs_adjacency_nodes,\n segs_distances)\n if stop: break\n\n # segments\n self.segs = segs\n self.segs_tips = segs_tips\n self.segs_sizes = []\n for iseg, seg in enumerate(self.segs): self.segs_sizes.append(len(seg))\n\n # the full, unscaled adjacency matrix\n self.segs_adjacency_full_attachedness = 1/segs_distances\n # if self.attachedness_measure == 'connectedness':\n # norm = np.sqrt(np.multiply.outer(self.segs_sizes, self.segs_sizes))\n # self.segs_adjacency_full_attachedness /= norm\n self.segs_adjacency_full_confidence, self.segs_adjacency_tree_confidence \\\n = self.compute_adjacency_confidence(\n self.segs_adjacency_full_attachedness,\n segs_adjacency,\n self.tree_based_confidence)\n np.fill_diagonal(self.segs_adjacency_full_attachedness, 0)","def get_optimal_continuous_feature_split (\n self, feature_matrix: np.ndarray, target_array: np.ndarray, feature_column: int\n ):\n midpoints = BaseTree.get_valid_midpoints ( feature_array = feature_matrix [ :, feature_column ], target_array = target_array )\n # If midpoints, get the best one\n if len ( midpoints ) > 0:\n return BaseTree.get_min_across_splits_continuous (\n feature_array = feature_matrix [ :, feature_column ], target_array = target_array, splits = midpoints, evaluate_function = self.evaluate_function\n )\n\n # If no split points, return inf (can't split here)\n return ( 0, np.inf, 1 )\n # End get_optimal_continuous_feature_split()","def best_B(Ag):\n top = 0\n for i in range(len(Ag)):\n etop = np.min(cf.TD20[int(Ag[i]) - 1])\n top += etop\n return top","def getBestSplitsInDataByInfoGain(self, data, structure, colName, numOfSplits):\n splitsList, newSplitsList = {}, []\n self.fillBestSplitsInDataByInfoGainIntoDict(data, structure, colName, numOfSplits, splitsList, 0)\n for lists in list(splitsList.values())[1:]:\n while len(lists) > 0:\n splitOne, splitTwo = [], []\n if len(lists) > 0:\n splitOne = lists.pop()\n if len(lists) > 0:\n splitTwo = lists.pop()\n if splitOne and splitTwo:\n if splitOne[1] >= splitTwo[1]:\n newSplitsList.append(splitOne[0])\n newSplitsList.append(splitTwo[0])\n else:\n newSplitsList.append(splitTwo[0])\n newSplitsList.append(splitOne[0])\n elif splitOne:\n newSplitsList.append(splitOne[0])\n elif splitTwo:\n newSplitsList.append(splitTwo[0])\n\n newSplitsList.insert(0, splitsList['0'][0][0])\n self.removeDuplicatesInList(newSplitsList)\n return newSplitsList[0:numOfSplits]","def choose_split(data,treshold):\n n_features = len(data[0]) - 1 # number of columns\n quest_gain = [] # keep track of the gains and questions\n\n for col in range(1,n_features): # for each feature\n values = set([row[col] for row in data]) # unique values in the column\n for val in values: # for each value\n question = Question(col, val)\n \n # try splitting the dataset\n true_rows, false_rows = partition(data, question)\n\n # Skip this split if it doesn't divide the dataset.\n if len(true_rows) == 0 or len(false_rows) == 0:\n continue\n\n # Calculate the information gain from this split\n gain = info_gain(data, true_rows, false_rows)\n quest_gain.append(Question_gain(gain,question))\n\n possible_question = [] # possible questions to ask\n n_quest_gain = len(quest_gain)\n\n if n_quest_gain == 0:\n return float('Inf'), float('NaN') #\n\n for x in range(n_quest_gain):\n if (quest_gain[x].gain >= treshold):\n possible_question.append(Question_gain(quest_gain[x].gain,quest_gain[x].question))\n \n n_possible_question = len(possible_question)\n if n_possible_question == 0:\n return float('Inf'), float('NaN')\n\n if n_possible_question>=2:\n [i, j] = random.sample(range(0, n_possible_question), 2)\n else:\n i = j = random.randint(0,n_possible_question-1)\n\n if possible_question[i].gain>=possible_question[j].gain:\n return possible_question[i].gain, possible_question[i].question\n else:\n return possible_question[j].gain, possible_question[j].question","def get_cluster_to_split(clusters):\n\treturn max(clusters.items(), key=lambda x: x[1].get_distortion())[1]","def getSplitFunc(self, splitType):\n if splitType.upper() == \"INFO GAIN\":\n return self.findBestColumnSplitByInfoGain\n elif splitType.upper() == \"GAIN RATIO\":\n return self.findBestColumnSplitByGainRatio\n elif splitType.upper() == \"GINI INDEX\":\n return self.findBestColumnSplitByGini\n return None","def calculate_lower_boundary(self, divisor):\n\n # see how low you can go\n quotas = [0] * self.states\n fair_shares = [0] * self.states\n counter = 0\n lowest_divisor = 0\n prev_divisor = 0\n estimator = 1000000000\n while counter < 1000:\n for i, population in enumerate(self.populations):\n if divisor is None or population is None:\n return None\n quotas[i] = population / divisor\n fair_shares[i] = math.floor(quotas[i])\n if sum(fair_shares) != self.num_seats:\n estimator = estimator / 10\n prev_divisor = divisor\n divisor = lowest_divisor - estimator\n else:\n lowest_divisor = divisor\n divisor = prev_divisor - estimator\n if lowest_divisor == divisor:\n break\n counter += 1\n return math.ceil(lowest_divisor * 1000) / 1000","def get_best_clique(self):\n\t\treturn [i+1 for i in range(self._size) if self._globalMinimumState[i] == 1]","def _get_smallest_sublist(sublists):\r\n smallest_list_id = 0\r\n for list_id, sublist in sublists.items():\r\n if sublist['size'] < sublists[smallest_list_id]['size']:\r\n smallest_list_id = list_id\r\n\r\n return smallest_list_id","def getminmax_linear_search(arr):\n if len(arr) == 0:\n return None, None\n\n if len(arr) == 1:\n return arr[0], arr[0]\n\n min_num = None\n max_num = None\n if arr[0] > arr[1]:\n max_num = arr[0]\n min_num = arr[1]\n else:\n max_num = arr[1]\n min_num = arr[0]\n\n for idx in range(2, len(arr)):\n if min_num > arr[idx]:\n min_num = arr[idx]\n if max_num < arr[idx]:\n max_num = arr[idx]\n\n return min_num, max_num","def get_n_splits(self):\n return self.n_folds","def find_split(data):\n ret = {\"router\": None, \"split_point\": None, \"entropy\": get_entropy(data[:, 7])}\n\n # Create array of unique datapoints\n split_points_list = list()\n\n for i in range(data.shape[1] - 1):\n unique_signal = np.unique(data[:, i])\n split_points = list()\n for j in range(len(unique_signal) - 1):\n split_points.append((unique_signal[j]+unique_signal[j+1])/2)\n split_points_list.append(split_points)\n\n # Split data by split points and calculate entropy\n for feature in range(len(split_points_list)):\n for i in range(len(split_points_list[feature])):\n data_l, data_r = split_data(data, feature + 1, split_points_list[feature][i])\n entropy = get_entropy(data_l[:, 7], data_r[:, 7])\n if entropy < ret[\"entropy\"]:\n ret[\"entropy\"] = entropy\n ret[\"router\"] = feature + 1\n ret[\"split_point\"] = split_points_list[feature][i]\n\n return ret[\"router\"], ret[\"split_point\"], split_data(data, ret[\"router\"], ret[\"split_point\"])","def _compute_best_split_and_push(self, node):\n\n node.split_info = self.splitter.find_node_split(\n node.sample_indices, node.histograms, node.sum_gradients,\n node.sum_hessians)\n\n if node.split_info.gain <= 0: # no valid split\n self._finalize_leaf(node)\n else:\n heappush(self.splittable_nodes, node)","def compute_min_winning_bid(bidders):\r\n min_values = [x.values[0] for x in bidders]\r\n max_min_value = max(min_values)\r\n max_min_value_bidder = np.argmax(min_values)\r\n\r\n max_utility = -1.0\r\n min_winning_bid = -1.0\r\n for i in range(len(bidders)):\r\n for j in range(len(bidders[i].values)):\r\n b = bidders[i].values[j]\r\n if b > max_min_value:\r\n break\r\n winning_prob = 1.0\r\n for k in range(len(bidders)):\r\n if k != max_min_value_bidder:\r\n winning_prob *= sum(\r\n [bidders[k].prob[l] for l in range(len(bidders[k].values)) if bidders[k].values[l] <= b])\r\n utility = winning_prob * (max_min_value - b)\r\n if utility > max_utility - 1e-8:\r\n max_utility = utility\r\n min_winning_bid = b\r\n return min_winning_bid","def _find_min_pair(h5chunks, max_gap=None):\n num_chunks = len(h5chunks)\n\n if num_chunks < 2:\n return None\n\n min_pair = None\n min_dist = None\n\n for i in range(1, num_chunks):\n c1 = h5chunks[i - 1]\n c2 = h5chunks[i]\n d = _chunk_dist(c1, c2)\n if d == 0:\n # short-circuit search and just return this pair\n return (i - 1, i)\n if d > max_gap:\n continue\n if min_dist is None or d < min_dist:\n min_pair = (i - 1, i)\n min_dist = d\n return min_pair","def potential_splits(self, potential_xj):\r\n \r\n self.cur.execute(\"SELECT DISTINCT \" + potential_xj + \" FROM \" + self.table_name + \";\")\r\n potential_splits = [ii[0] for ii in self.cur.fetchall()]\r\n return potential_splits","def __get_min_indexes(num_list, number):\n result = []\n\n num_list = np.array(num_list)\n result = np.argpartition(num_list, number)[:number]\n\n return result","def find_least_number(incoming_list):\n retval = min(incoming_list)\n return retval","def _get_split_sizes(self, n_examples):\n\n min_ex = (int(n_examples // self.n_splits)\n * np.ones(self.n_splits, dtype=np.int8))\n \n rem = np.array(\n [1 if i < n_examples % self.n_splits else 0\n for i in range(self.n_splits)],\n dtype=np.int8)\n\n return np.add(min_ex, rem)","def choose_split_value(attrs, classes):\n indices = np.argsort(attrs)\n classes = classes[indices]\n attrs = attrs[indices]\n max_gain = 0.0\n max_gain_value = None\n for i in range(len(attrs) - 1):\n if classes[i] != classes[i+1]:\n mean = (attrs[i] + attrs[i+1]) / 2.0\n gain = inform_gain(attrs, classes, mean)\n if gain > max_gain:\n max_gain = gain\n max_gain_value = mean\n return max_gain_value, max_gain","def splits(self) -> List[int]:\n if self._splits is None:\n self.RefreshStats()\n return self._splits","def test_chunk_size_priority_over_n_splits(self):\n with self.subTest(input='list', chunk_size=1, n_splits=6):\n self.assertEqual(get_n_chunks(self.test_data, iterable_len=None, chunk_size=1, n_splits=6, n_jobs=None), 13)\n with self.subTest(input='numpy', chunk_size=1, n_splits=6):\n self.assertEqual(get_n_chunks(self.test_data_numpy, iterable_len=None, chunk_size=1, n_splits=6,\n n_jobs=None), 100)\n\n with self.subTest(input='list', chunk_size=3, n_splits=3):\n self.assertEqual(get_n_chunks(self.test_data, iterable_len=None, chunk_size=3, n_splits=3, n_jobs=None), 5)\n with self.subTest(input='numpy', chunk_size=3, n_splits=3):\n self.assertEqual(get_n_chunks(self.test_data_numpy, iterable_len=None, chunk_size=3, n_splits=3,\n n_jobs=None), 34)","def imbalance(A,n,k):\n\n # create k + 1 array s[1], s[2],..., s[n]\n # s[k][i,j] indicate current minimum imbalance for kth part as A[i,j]\n s = {}\n partition = [0]*k\n\n for i in range(1,k+2):\n s[i] = np.zeros((n,n))\n s[i][:] = np.inf\n\n ave = sum(A)/(k+1)\n\n\n # initialize imbalance for the first part\n for j1 in range(len(A)):\n s[1][0,j1] = abs(sum(A[0:j1]) - ave)\n\n for p in range(2,k+2): # each part\n for i in range(1,len(A)):\n for j in range(i,len(A)):\n\n s[p][i,j] = max([min(s[p-1][:,i-1]),abs(sum(A[i:(j+1)])/(k+1)-ave)])\n\n #\n\n # find partition point (possible result)\n\n split_p = n # split should be the start of each part except the first one\n\n for p in range(k+1,1,-1):\n\n split_p = [i for i,ele in enumerate(s[p][:, (split_p-1)])\n if ele == min(s[p][:, (split_p-1)])][0]\n\n partition[p-2] = split_p\n\n return partition\n\n # the minimum imbalance should be min(s[k+1][:,n])\n # return min(s[k+1][:,n-1])","def best_split(self, X, y, attributes):\n if (self.criterion==\"information_gain\"):\n global_if = float('-inf') # the highest value of information gain/gini gain seen so far\n attr = None\n for attribute in attributes:\n attr_val = X[attribute].copy()\n cur_if = information_gain(y,attr_val,self.type)\n if (cur_if>global_if):\n # Update when a better split is receieved\n global_if = cur_if\n attr = attribute\n return attr\n else:\n global_if = float('inf')\n attr = None\n for attribute in attributes:\n attr_val = X[attribute].copy()\n cur_if = gini_gain(y,attr_val)\n if (global_if>cur_if):\n # Update when a better split is receieved\n global_if = cur_if\n attr = attribute\n return attr","def choose_optimal_image_split(im, method='im_size', min_tile_size=360000):\n \n n_cores = os.cpu_count()\n # number of segmented objects, drop the background value\n n_obj = np.unique(im).size - 1\n \n if method == 'im_size':\n # avoid too many splits if image is not so big\n im_size = im.nbytes # slightly different from sys.getsizeof(im)\n # max power of 2\n max_i = int(np.log2(n_cores)) + 1\n n_splits = 1\n for i in range(1, max_i):\n new_split = 2**i\n if im_size / new_split >= min_tile_size:\n n_splits = new_split\n else:\n break\n elif method == 'naive':\n n_splits = n_cores\n \n return n_splits","def get_max_combination(total_cuts):\n max_pieces = 0\n for i in range(total_cuts):\n result = i * (total_cuts - i)\n if result > max_pieces:\n max_pieces = result\n print(max_pieces)","def find_least_number(incoming_list):\n\n least_number = min(incoming_list)\n return least_number","def find_min(ls):\n\n if len(ls) == 1:\n return ls[0]\n elif len(ls) == 2:\n return ls[0] if ls[0] < ls[1] else ls[1]\n else:\n mid = len(ls) // 2\n m1 = find_min(ls[0:mid])\n m2 = find_min(ls[mid:])\n return m1 if m1 < m2 else m2","def better_partition_parallel(graph, part1, part2, independent_set_extraction_strategy):\n\n best = part2\n for i in range(len(part1)):\n if better_partition(graph, part1[i], best, independent_set_extraction_strategy):\n best = part1[i]\n\n return best","def get_reranker_best(self):\n if len(self.parses):\n return min(self, key=lambda parse: parse.reranker_rank)\n else:\n return None","def getListWithBestValueSplitsOfDataByGini(self, data, structure, colIndex, numOfSplits):\n splitsList, newSplitsList = {}, []\n self.fillDictWithBestValueSplitsOfDataByGini(data, structure, colIndex, numOfSplits, splitsList, 0)\n for lists in list(splitsList.values())[1:]:\n while len(lists) > 0:\n splitOne, splitTwo = [], []\n if len(lists) > 0:\n splitOne = lists.pop()\n if len(lists) > 0:\n splitTwo = lists.pop()\n if splitOne and splitTwo:\n if splitOne[1] <= splitTwo[1]:\n newSplitsList.append(splitOne[0])\n newSplitsList.append(splitTwo[0])\n else:\n newSplitsList.append(splitTwo[0])\n newSplitsList.append(splitOne[0])\n elif splitOne:\n newSplitsList.append(splitOne[0])\n elif splitTwo:\n newSplitsList.append(splitTwo[0])\n\n newSplitsList.insert(0, splitsList['0'][0][0])\n self.removeDuplicatesInList(newSplitsList)\n return newSplitsList[0:numOfSplits]","def personal_best(scores: list) -> int:\n return max(scores)","def give_greatest_spart(cls, spart_list):\n if len(spart_list) == 1:\n return spart_list[0]\n sorted_list = cls.sort_by_dominance(spart_list)\n if not(sorted_list[0] > sorted_list[1]):\n print(\"The two largest elements are non-comparable\")\n return []\n else:\n return sorted_list[0]","def find_least_number(incoming_list: list):\n return min(incoming_list)","def compute_optimal_token_minimum(token_counts) -> int:\n q1, q3 = compute_quartiles(token_counts)\n iqr = q3 - q1\n low_threshold = q1 - 1.5 * iqr\n return low_threshold","def find_least_number(incoming_list):\n \n return_value = min(incoming_list)\n return return_value","def min_number_of(g, elt, n_fuel):\n if elt == 'FUEL':\n return n_fuel\n t = sum([g.edges[elt, s]['cost'] * min_number_of(g, s, n_fuel) for s in\n g.successors(elt)])\n return divup(t, g.nodes[elt]['batch_size'])","def best_split1(self,X,attributes):\n if (self.criterion==\"information_gain\"):\n global_if = float('-inf') # the highest value of varience seen so far\n attr , val = None, None\n for attribute in attributes[::-1]:\n attr_val = pd.Series(X[attribute].unique()).sort_values(ignore_index=True)\n last_val = attr_val[0]\n for i in range(1,attr_val.size):\n cur_val = attr_val[i]\n valc = round((last_val+cur_val)/2,4)\n last_val = cur_val\n cur_if = information_gain1(valc,X[attribute],X[\"Output\"],self.type)\n if (cur_if>global_if):\n global_if,attr,val = cur_if,attribute,valc\n return attr,val\n else:\n global_if = float('inf') # the lowest value of varience seen so far\n attr , val = None, None\n for attribute in attributes[::-1]:\n attr_val = pd.Series(X[attribute].unique()).sort_values(ignore_index=True)\n last_val = attr_val[0]\n for i in range(1,attr_val.size):\n cur_val = attr_val[i]\n valc = round((last_val+cur_val)/2,4)\n last_val = cur_val\n cur_if = gini_gain1(X[\"Output\"],X[attribute], valc)\n if (global_if>cur_if):\n global_if,attr,val = cur_if,attribute,valc\n return attr,val","def optimal(count):\n\n return _optimal(start, count)[0]","def smallest_multiple(n):\n return reduce(lowest_common_multiple, range(1, n+1))","def _best_split(cls, X, y):\n n = X.shape[0]\n num_feature = X.shape[1]\n y_types = np.unique(y)\n\n # initialize\n min_score = float(n)\n feature_idx = None\n best_theta = None\n best_idx = None\n\n for feature_idx in xrange(num_feature):\n # counter for y\n cumulate_y = Counter()\n rest_y = Counter()\n for y_type in y_types:\n cnt = np.where(y == y_type)[0].shape[0]\n rest_y[y_type] = cnt\n\n # sorted data\n sorted_idx = np.argsort(X[:, feature_idx])\n sorted_X = np.copy(X)\n sorted_y = np.copy(y)\n sorted_X = sorted_X[sorted_idx]\n sorted_y = sorted_y[sorted_idx]\n #print \"_best_split:\", sorted_X.shape, sorted_y.shape\n\n for idx in xrange(n-1):\n theta = (sorted_X[idx, feature_idx] + sorted_X[idx + 1, feature_idx]) / 2\n y_label = sorted_y[idx]\n cumulate_y[y_label] += 1\n rest_y[y_label] -= 1\n left_cnt = sum(cumulate_y.values())\n right_cnt = sum(rest_y.values())\n w_1 = left_cnt * cls._gini_index(cumulate_y.values())\n w_2 = right_cnt * cls._gini_index(rest_y.values())\n score = w_1 + w_2\n if score < min_score:\n min_score = score\n best_theta = theta\n best_idx = feature_idx\n #print('new min score: %.3f' % score)\n #print('feature: %d, theta: %.3f' % (best_idx, best_theta))\n #print('left: %d, right: %d' % (left_cnt, right_cnt))\n print('feature: %d, theta: %.3f' % (best_idx, best_theta))\n return (best_idx, best_theta)","def _best_split(cls, X, y):\n n = X.shape[0]\n num_feature = X.shape[1]\n y_types = np.unique(y)\n\n # initialize\n min_score = float(n)\n feature_idx = None\n best_theta = None\n best_idx = None\n\n for feature_idx in xrange(num_feature):\n # counter for y\n cumulate_y = Counter()\n rest_y = Counter()\n for y_type in y_types:\n cnt = np.where(y == y_type)[0].shape[0]\n rest_y[y_type] = cnt\n\n # sorted data\n sorted_idx = np.argsort(X[:, feature_idx])\n sorted_X = np.copy(X)\n sorted_y = np.copy(y)\n sorted_X = sorted_X[sorted_idx]\n sorted_y = sorted_y[sorted_idx]\n #print \"_best_split:\", sorted_X.shape, sorted_y.shape\n\n for idx in xrange(n-1):\n theta = (sorted_X[idx, feature_idx] + sorted_X[idx + 1, feature_idx]) / 2\n y_label = sorted_y[idx]\n cumulate_y[y_label] += 1\n rest_y[y_label] -= 1\n left_cnt = sum(cumulate_y.values())\n right_cnt = sum(rest_y.values())\n w_1 = left_cnt * cls._gini_index(cumulate_y.values())\n w_2 = right_cnt * cls._gini_index(rest_y.values())\n score = w_1 + w_2\n if score < min_score:\n min_score = score\n best_theta = theta\n best_idx = feature_idx\n #print('new min score: %.3f' % score)\n #print('feature: %d, theta: %.3f' % (best_idx, best_theta))\n #print('left: %d, right: %d' % (left_cnt, right_cnt))\n print('feature: %d, theta: %.3f' % (best_idx, best_theta))\n return (best_idx, best_theta)","def _min_max(study):\n\n # Iterate pareto-front trials storing mean correlation and std dev\n df = []\n for trial in study.best_trials:\n df.append([trial.number, np.mean(trial.values), np.std(trial.values)])\n\n # Sort dataframe ascending by mean correlation\n df = pd.DataFrame(df).sort_values(by=2, ascending=True)\n\n # Sort df with best trial in first row\n if len(df) > 1 and len(df.iloc[:, 1:3].drop_duplicates()) > 1:\n\n # Create second pareto to maximize correlation and minimize stddev\n # Epsilons define precision, ie dominance over other candidates\n # Dominance is defined as x percent of stddev of stddev\n try:\n nd = pareto.eps_sort([list(df.itertuples(False))], objectives=[1, 2],\n epsilons=[1e-09, np.std(df[1])*.5], maximize=[1])\n except:\n # Something went wrong, return df\n nd = df\n\n # Sort remaining candidates\n nd = pd.DataFrame(nd).sort_values(by=2, ascending=True)\n\n # Only 1st trial so return it\n else:\n nd = df\n\n # Return \"best\" trial index\n return nd.iloc[0, 0]","def _split_threshold(self, node):\n\n # define the score to improve upon\n if self.n_clusters >= self.min_leaves and node.size <= self.max_leaf_size:\n # split only if min(children scores) > node.score\n force_split = False\n best_score = node.score\n else:\n # force split: just take the best (even if children are worse)\n force_split = True\n best_score = None\n\n left, right = None, None\n\n # iterate over embedding dimensions (first ones are more reliable)\n # up to max_n_vec (included), until we found an improving split\n for _vec in range(self.n_vec):\n\n # get the candidate thresholds along this dimension\n threshs = self._get_candidate_thresholds(node, _vec)\n\n # look for an improving best split along this eigenvector\n for _t in threshs:\n # compute the split\n below_thresh = self.E[node.ids, _vec] < _t\n _lids = node.ids[below_thresh]\n _rids = node.ids[np.logical_not(below_thresh)]\n # check if the tubes are not too small\n _nl, _nr = len(_lids), len(_rids)\n is_valid = _nl >= self.min_leaf_size and _nr >= self.min_leaf_size\n if is_valid:\n # compute the score of the new tubes only\n _sl = self.get_tube_score(_lids)\n _sr = self.get_tube_score(_rids)\n # get the score of this split\n split_score = min(_sl, _sr)\n if best_score is None or split_score > best_score:\n # better split\n best_score = split_score\n node.has_children = True\n node.thresh = _t\n left = SpectralNode(\n _lids, _vec, score=_sl, name=node.name + \"0\")\n right = SpectralNode(\n _rids, _vec, score=_sr, name=node.name + \"1\")\n\n # check stopping criterion\n if node.has_children:\n # we found an improving split\n if _vec > 0 or not force_split:\n # found an improving non-forced split: stop here\n break\n\n return left, right","def optimal_min(board):\n if terminal(board):\n return [None, utility(board)]\n\n available_actions = list(actions(board))\n\n # Naive baseline comparison is positive infinity\n global_optimum = [None, math.inf]\n\n for action in available_actions:\n # Anticipates optimal adversarial moves.\n local_optimum = optimal_max(result(board, action))\n\n if global_optimum[1] >= local_optimum[1]:\n global_optimum = [action, local_optimum[1]]\n\n return global_optimum","def get_best( self ):\n if len(self.listScore) < 1:\n if self.bMinimumIsBest: return 9999,\"Unknown\"\n else: return -1,\"Unknown\"\n return self.listScore[0]","def get_best(self):\n scores, ids = self.sort_best()\n return scores[1], ids[1]"],"string":"[\n \"def best_split(self):\\r\\n best_splits = [[0, None, None]]\\r\\n impurity, best_S, best_xj = 0, None, None\\r\\n \\r\\n for xj in self.x_names:\\r\\n for S in self.potential_splits(xj):\\r\\n ir = float(self.impurity_reduction(xj, S))\\r\\n if ir > impurity:\\r\\n impurity, best_S, best_xj = ir, S, xj\\r\\n best_splits.append([S, xj])\\r\\n else: \\r\\n pass\\r\\n \\r\\n return best_S, best_xj\",\n \"def determine_best_split(data, potential_splits, mltask):\\n\\n first_iteration = True\\n for column_index in potential_splits:\\n for value in potential_splits[column_index]:\\n data_below,data_above = split_data(data, column_index, value)\\n \\n if mltask == 'regression':\\n current_overall_metric = calculate_overall_metric(data_below, data_above, metric_function = calculate_mse)\\n \\n # classification\\n else:\\n current_overall_metric = calculate_overall_metric(data_below, data_above, metric_function = calculate_entropy)\\n \\n \\n if first_iteration or current_overall_metric <= best_overall_metric:\\n first_iteration = False\\n \\n best_overall_metric = current_overall_metric\\n best_split_column = column_index\\n best_split_value = value\\n \\n \\n return best_split_column,best_split_value\",\n \"def get_best_split(rows):\\n best_gain = 0\\n best_question = None\\n current_impurity = get_gini(rows)\\n n_features = len(rows[0])\\n\\n for col in range(n_features):\\n\\n for row in rows:\\n question = Question(col, row[col])\\n true_rows, false_rows = partition(rows, question)\\n\\n if len(true_rows) == 0 or len(false_rows) == 0:\\n break\\n\\n question_gain = get_info_gain(true_rows, false_rows, current_impurity)\\n\\n if question_gain >= best_gain:\\n best_gain = question_gain\\n best_question = question\\n\\n print(best_gain)\\n print(best_question)\\n return best_gain, best_question\",\n \"def get_min_across_splits_continuous(\\n arr: np.ndarray, y: np.ndarray, splits: np.ndarray, eval_func: Callable\\n ):\\n n = len(splits)\\n if n > 500:\\n # If many split points, use some threading\\n with multiprocessing.Pool(processes=8) as p:\\n # Get evaluation scores across all the splits\\n post_split_evals = dict(\\n zip(\\n range(len(splits)),\\n p.starmap(\\n BaseTree.get_split_goodness_fit_continuous,\\n zip([arr] * n, [y] * n, splits, [eval_func] * n),\\n ),\\n )\\n )\\n p.close()\\n else:\\n # If not too many split points, get scores across all splits\\n post_split_evals = dict(\\n zip(\\n range(len(splits)),\\n map(\\n lambda x: BaseTree.get_split_goodness_fit_continuous(*x),\\n zip([arr] * n, [y] * n, splits, [eval_func] * n),\\n ),\\n )\\n )\\n # Get the minimum split based on gain ratio\\n min_eval = min(\\n post_split_evals,\\n key=lambda x: pipe(\\n post_split_evals.get(x),\\n lambda results: results[0] / results[1], # entropy / intrinsic value\\n ),\\n )\\n\\n # Return the best split and the splits scores\\n return (splits[min_eval], *post_split_evals.get(min_eval))\",\n \"def find_best_split(self, x, y):\\n\\n # check cornor case: all same x\\n n = y.size\\n\\n if all(x == x[0]):\\n return (0, amin(x) - self.eps)\\n\\n sort_index = argsort(x)\\n x_sorted = x[sort_index]\\n y_sorted = y[sort_index]\\n\\n # build potential split index array\\n split_index_array = array([i for i in range(1, n)\\n if x_sorted[i] != x_sorted[i - 1]\\n and y_sorted[i] != y_sorted[i - 1]])\\n\\n # split_index_array = linspace(\\n # 0, y.size, num=min(5, ceil(n / 5)), endpoint=False, dtype='int')\\n # split_index_array = split_index_array[1:]\\n\\n best_split_index = 0\\n best_gain = 0\\n h_x = self.cur_entropy\\n\\n for split_index in split_index_array:\\n left_entropy = self.entropy(y_sorted[:split_index])\\n right_entropy = self.entropy(y_sorted[split_index:])\\n h_xy = (split_index * left_entropy +\\n (n - split_index) * right_entropy) / n\\n cur_gain = h_x - h_xy\\n\\n if cur_gain > best_gain:\\n best_gain = cur_gain\\n best_split_index = split_index\\n\\n if best_split_index != 0:\\n best_split_point = (x_sorted[best_split_index] +\\n x_sorted[best_split_index - 1]) / 2\\n else:\\n best_split_point = x_sorted[best_split_index] - self.eps\\n\\n return (best_gain, best_split_point)\",\n \"def __find_best_split(self, x, y):\\n data = np.transpose(np.vstack((np.transpose(x), y)))\\n num_features = data.shape[1] - 1\\n\\n # initialise splitting rule components\\n integer_splitting_rule = None\\n feature_index_to_split = None\\n max_info_gain = 0\\n\\n # iterate over all the features and find best splits within these\\n for feature in range(num_features):\\n info_gain, split_int = self.__find_best_split_in_feature(\\n data[:, [feature, -1]])\\n if info_gain is None:\\n continue\\n # update max info gain so far as it iterates over features\\n if info_gain > max_info_gain:\\n max_info_gain = info_gain\\n feature_index_to_split = feature\\n integer_splitting_rule = int(split_int)\\n\\n return feature_index_to_split, integer_splitting_rule\",\n \"def min_parts():\\n # you must replace this with your own value\\n return -1\",\n \"def get_split(data):\\n \\\"\\\"\\\" gets the best feature, and best value \\\"\\\"\\\"\\n\\n best_feature = None\\n best_value = 0.0\\n columns = data.columns\\n gini_base = gini_impurity(data)\\n n_rows = len(data.index) # total number of rows of data before split\\n\\n # Fininding which split yields the best gini gain\\n max_gain = 0\\n\\n for i in range(len(columns)-1): # -1 b.c. class is final column\\n xs = data[columns[i]].unique() # get values to test\\n for x in xs: # test values\\n # split dataset\\n df_left = data[data[columns[i]] < x]\\n df_right = data[data[columns[i]] >= x]\\n\\n # get gini impurities\\n gini_left = gini_impurity(df_left)\\n gini_right = gini_impurity(df_right)\\n \\n\\n # Calculated weighted gini impurity\\n w_left = len(df_left.index) / n_rows\\n w_right = len(df_right.index) / n_rows\\n\\n w_gini = gini_left * w_left + gini_right * w_right\\n \\n\\n # Calculate gini gain (we want to minimize w_gini for the smallest impurity. Ideal split is perfect Left=c1, Right=c2)\\n # why not just find min w_gin instead of uding gini_gain and gini_base vaiables?\\n gini_gain = gini_base - w_gini\\n\\n # check if this is the best split so far, store values, update max_gini\\n if gini_gain > max_gain:\\n best_feature = columns[i]\\n best_value = x\\n max_gain = gini_gain\\n\\n df_left = data.loc[data[best_feature] < best_value]\\n df_right = data.loc[data[best_feature] >= best_value]\\n \\n\\n return best_feature, best_value, df_left, df_right\",\n \"def findBestValueSplitByGini(self, data, structure, colIndex):\\n minGini, bestSplit = 1, []\\n for i in range(0, len(data)-1):\\n split = (float(data[i][colIndex]) + float(data[i+1][colIndex])) / 2\\n giniSplit = self.calcGiniSplitBySplitValue(data, structure, colIndex, split)\\n if giniSplit <= minGini:\\n minGini = giniSplit\\n bestSplit = [split, giniSplit]\\n return bestSplit\",\n \"def get_split(self,X,y):\\n \\n BEST_COL = 0\\n BEST_SPLIT =0\\n BEST_IMPUR = 99\\n for i,feature in enumerate(X.T):\\n arg_sort=np.argsort(feature) #Sort the feature for optimizing the find of splitting points\\n feature= feature[arg_sort]\\n y_sort = y[arg_sort]\\n splits = self.possible_splits(feature,y_sort) #Get \\n\\n impur,splits = self.test_split(feature,y_sort,splits) #Get impurity for splitting points\\n best_idx = np.argmin(impur)\\n best_impur = impur[best_idx]\\n \\n if best_impur==0.0: #Found perfect split, terminate\\n return(i,splits[best_idx])\\n elif best_impur<BEST_IMPUR:\\n BEST_IMPUR=best_impur\\n BEST_SPLIT=splits[best_idx]\\n BEST_COL=i\\n return (BEST_COL,BEST_SPLIT)\",\n \"def get_best_split_all(x, y) -> Tuple[int, float, float]:\\n m = x.shape[1]\\n col_best_gin = np.ones(shape=m)\\n col_best_val = np.ones(shape=m)\\n for c in range(m):\\n best = 1\\n best_x = 0\\n for i in np.unique(x[:, c]):\\n gini = Tree.split(x[:, c], y, i)\\n if gini < best:\\n best = gini\\n best_x = i\\n col_best_gin[c] = best\\n col_best_val[c] = best_x\\n\\n # Select best feature to split on\\n col_idx = np.argmin(col_best_gin)\\n # Convert to bool index\\n col_idx = np.array(range(x.shape[1])) == col_idx\\n\\n return col_idx, col_best_val[col_idx], col_best_gin[col_idx]\",\n \"def minimum_spanning_arborescence(sol):\",\n \"def best_split(values,labels,nonelabels=None):\\n assert len(values) >= 2\\n assert len(values) == len(labels)\\n N = len(values)\\n ilist = sorted((v,l) for (v,l) in zip(values,labels))\\n leftcount = defaultdict(int)\\n rightcount = defaultdict(int)\\n for v,l in ilist:\\n rightcount[l] += 1\\n bestindex = -1\\n bestcost = split_cost([leftcount,rightcount])\\n\\n cost = bestcost\\n #costs = [cost]\\n #print \\\"Split costs:\\\"\\n for i in xrange(len(ilist)):\\n v,l = ilist[i]\\n rightcount[l] -= 1\\n leftcount[l] += 1\\n if i+1 >= len(ilist) or v == ilist[i+1][0]:\\n #no splits when v is equal to the next value\\n continue\\n cost = split_cost([leftcount,rightcount])\\n #print \\\" \\\",v,leftcount.values(),rightcount.values(),cost\\n #costs.append(cost)\\n if cost < bestcost:\\n bestcost = cost\\n bestindex = i\\n #raw_input()\\n if bestindex < 0:\\n #no split found... try splitting in half\\n splitval = (ilist[0][0]+ilist[-1][0])*0.5\\n else:\\n splitval = (ilist[bestindex][0] + ilist[bestindex+1][0])*0.5\\n if nonelabels is None:\\n return (splitval,bestcost)\\n #reevaluate counts\\n leftcount = defaultdict(int)\\n rightcount = defaultdict(int)\\n for l in nonelabels:\\n leftcount[l] += 1\\n rightcount[l] += 1\\n for v,l in ilist:\\n if v <= splitval:\\n leftcount[l] += 1\\n else:\\n rightcount[l] += 1\\n return splitval,split_cost([leftcount,rightcount])\",\n \"def split_workload(workload):\\n diff = sum(workload)\\n minimum = abs(diff), 0\\n for i, work in enumerate(workload, 1):\\n diff -= 2 * work\\n current = abs(diff), i\\n if current < minimum:\\n minimum = current\\n return (None, None) if minimum == (0, 0) else minimum[::-1]\",\n \"def pick_best_split(self,db,labels,ids,features=None):\\n idlabels = [labels[id] for id in ids]\\n if misclassification_error(idlabels) == 0:\\n #base case: no misclassifications\\n self.type = 'v'\\n self.value = idlabels[0]\\n return 0\\n best = None\\n bestCost = 0\\n splitval = None\\n discrete = True\\n if features == None:\\n if len(ids) < db.numFeatures():\\n #look at all present features in the training set\\n features = db.getPresentFeatures(ids)\\n #print len(features),\\\"of\\\",db.numFeatures(),\\\"features selected\\\"\\n else:\\n features = range(db.numFeatures())\\n elif callable(features):\\n features = features()\\n for i in features:\\n if len(db.entryLists[i]) == 0: continue\\n idiscrete = db.discreteFeature[i]\\n if idiscrete:\\n #count number of labels of a certain value\\n splitter = defaultdict(lambda:defaultdict(int))\\n #count of labels for missing values\\n nmissing = defaultdict(int)\\n for id in ids:\\n val = db[i,id]\\n if val is None:\\n #missing values go down to all splits\\n nmissing[labels[id]] += 1\\n continue\\n splitter[val][labels[id]] += 1\\n if len(splitter) > continuous_variable_threshold:\\n #print \\\"Determined to be a continuous variable\\\"\\n idiscrete = False\\n break\\n if idiscrete:\\n if len(splitter) <= 1:\\n #only a single value\\n continue\\n #count number of missing values in all splits\\n cmax = 0\\n for k in splitter:\\n for l,v in nmissing.iteritems():\\n splitter[k][l] += v\\n cmax = max(cmax,sum(splitter[k].values()))\\n #shrink by fraction of (# of ids - largest child)/(# of ids)\\n scale = (1.0-float(cmax)/float(len(ids)))*len(splitter)\\n #evaluate cost\\n cost = split_cost(splitter.values())*scale\\n #print \\\"Split on\\\",i,\\\"information gain\\\",-cost,splitter.values()\\n else:\\n #continuous, need to learn the best split\\n vals = []\\n presentlabels = []\\n nonelabels = []\\n for id in ids:\\n val = db[i,id]\\n if val is None:\\n nonelabels.append(labels[id])\\n continue\\n vals.append(val)\\n presentlabels.append(labels[id])\\n if len(vals) <= 1:\\n print \\\"No values for feature\\\",i,\\\"?\\\"\\n print vals\\n continue\\n #print \\\"Considering continuous split on\\\",i\\n s,cost = best_split(vals,presentlabels,nonelabels)\\n scale = (1.0-float(len(presentlabels)/2+len(nonelabels))/float(len(ids)))*2\\n cost *= scale\\n #print \\\"Result\\\",s,\\\"Information gain\\\",-cost\\n \\n if cost < bestCost:\\n best = i\\n bestCost = cost\\n discrete = idiscrete\\n if not idiscrete:\\n splitval = s\\n \\n if best is None:\\n self.type = 'v'\\n if len(ids) > 0:\\n self.value = vote(idlabels)\\n return misclassification_error(idlabels)\\n else:\\n self.value = None\\n return 0\\n else:\\n self.feature = best\\n #discrete or inequality split\\n if discrete:\\n self.type = 's'\\n else:\\n self.type = 'i'\\n self.value = splitval\\n return bestCost\",\n \"def find_best_split(rows):\\n best_gain = 0 # keep track of the best information gain\\n best_question = None # keep train of the feature / value that produced it\\n current_uncertainty = gini(rows)\\n n_features = len(rows[0]) - 1 # number of columns\\n #print(\\\"n_features:\\\", n_features)\\n\\n for col in range(1,n_features): # for each feature\\n # for each iteration this is the set of all values of a specific column, eg, All pixels number 0\\n values = set([row[col] for row in rows]) # unique values in the column\\n for val in values: # for each value\\n\\n # Create a question object for each val under a column, holding the val and the col number\\n question = Question(col, val)\\n\\n # try splitting the dataset\\n true_rows, false_rows = partition(rows, question)\\n\\n # Skip this split if it doesn't divide the\\n # dataset.\\n if len(true_rows) == 0 or len(false_rows) == 0:\\n continue\\n\\n # Calculate the information gain from this split\\n gain = info_gain(true_rows, false_rows, current_uncertainty)\\n\\n # You actually can use '>' instead of '>=' here\\n # but I wanted the tree to look a certain way for our\\n # toy dataset.\\n if gain >= best_gain:\\n best_gain, best_question = gain, question\\n\\n return best_gain, best_question\",\n \"def find_split(self, X, y):\\n choices = y.size\\n if choices <= 1:\\n return None, None\\n\\n # find the number of each option in the current node.\\n options_parent = [np.sum(y == c) for c in range(self.num_outcomes)]\\n\\n # find the gini of current node.\\n best_gini = 1.0 - sum((n / choices) ** 2 for n in options_parent)\\n best_idx, best_split = None, None\\n\\n # loop through the features to get splits and options.\\n for idx in range(self.num_features):\\n splits, options = zip(*sorted(zip(X[:, idx], y)))\\n\\n num_left = [0] * self.num_outcomes\\n num_right = options_parent.copy()\\n for i in range(1, choices):\\n c = options[i - 1]\\n num_left[c] += 1\\n num_right[c] -= 1\\n gini_left = 1.0 - sum(\\n (num_left[x] / i) ** 2 for x in range(self.num_outcomes)\\n )\\n gini_right = 1.0 - sum(\\n (num_right[x] / i) ** 2 for x in range(self.num_outcomes)\\n )\\n\\n gini = (i * gini_left + (choices - i) * gini_right) / choices\\n\\n if splits[i] == splits[i - 1]:\\n continue\\n\\n if gini < best_gini:\\n best_gini = gini\\n best_idx = idx\\n best_split = (splits[i] + splits[i - 1]) / 2\\n\\n return best_idx, best_split\",\n \"def findBestColumnSplitByGini(self, data, structure):\\n minGini, bestSplit = 1, None\\n for colName in list(structure.keys())[:-1]:\\n giniSplit = self.calcGiniSplitByColumn(data, structure, colName)\\n if giniSplit <= minGini:\\n minGini = giniSplit\\n bestSplit = colName\\n return bestSplit\",\n \"def calculateOptimal(self) -> (list, int):\\n\\t\\tcombinations = list(itertools.product(*self.clusters))\\n\\t\\tmin_dist = 1000000\\n\\t\\tmin_combination = None\\n\\t\\tfor combination in combinations:\\n\\t\\t\\tdist = super().step(combination)\\n\\t\\t\\tif(dist < min_dist):\\n\\t\\t\\t\\tmin_dist = dist\\n\\t\\t\\t\\tmin_combination = combination\\n\\t\\treturn (min_combination, min_dist)\",\n \"def __find_best_split_in_feature(self, feature_and_class):\\n\\n # sort the feature and class and use changes in the class to reduce\\n # number of potential split info gain calculations\\n sorted_data = feature_and_class[\\n feature_and_class[:, 0].astype(np.int).argsort()]\\n potential_splits = self.__find_integers_with_class_change(sorted_data)\\n info_gains = self.__info_gain_from_splits(potential_splits,\\n sorted_data)\\n\\n # returning nothing in no information gains are found\\n if len(info_gains) == 0:\\n return None, None\\n\\n index = info_gains.index(max(info_gains))\\n return info_gains[index], potential_splits[index]\",\n \"def best_split(self):\\n sub_group = []\\n\\n current_entropy = self.entropy(self._Passengers)\\n best_gain = 0 # holds the best entropy difference so far\\n best_split = self._Attr[0].get_name()\\n relative_entropy = 0 # entropy while taking account for the size of the population\\n\\n for Attribute in self._Attr:\\n relative_entropy = 0\\n print(\\\"Attr considered: \\\" + Attribute.get_name())\\n for Attr_option in Attribute.get_options():\\n sub_group = []\\n for Passenger in self._Passengers:\\n if self.passenger_attr_option_check(Passenger,\\n Attribute.get_name(),\\n Attr_option): # if P.A = V\\n sub_group.append(Passenger)\\n if len(sub_group) > 0 and len(self._Passengers) > 0:\\n relative_entropy += self.entropy(sub_group) * (len(sub_group)/len(self._Passengers))\\n\\n if current_entropy - relative_entropy > best_gain:\\n best_gain = current_entropy - relative_entropy\\n best_split = Attribute.get_name()\\n\\n print(f\\\"best split:{best_split} \\\\n with entropy gain of:\\\\n {best_gain}\\\")\\n\\n return best_split\",\n \"def _optimal_splits (self, split_axis):\\n n = len(self.displays)\\n size = self.screen.get_size()\\n # sizes in directions of first/second split\\n s1 = size[split_axis]\\n s2 = size[not split_axis]\\n ratio = self.ratio\\n # use screen aspect ratio if no preferred one given\\n if ratio is None:\\n ratio = float(size[0]) / size[1]\\n error = []\\n for splits in xrange(1, n + 1):\\n # maximal number of displays per row/column\\n per_split = ceil(float(n) / splits)\\n # minimise unused space (as a fraction of the screen)\\n space_e = abs(1 - float(n) / (splits * per_split))\\n # and ratio (we care about proportionality, so use log)\\n disp_ratio = float(s1 * splits) / (s2 * per_split)\\n if split_axis == 1:\\n # inverted if splitting into columns\\n disp_ratio = 1 / disp_ratio\\n ratio_e = abs(log(disp_ratio / ratio))\\n # adjust using some constants\\n e = space_e + ratio_e\\n error.append((e, splits))\\n return min(error)\",\n \"def optimal_split(self, ratio = 0.5):\\n\\n if (sum(self.game_state) == 1):\\n if (randint(1,100)<=50):\\n return self.game_state, [0]*(self.K+1)\\n else:\\n return [0]*(self.K+1), self.game_state\\n \\n else:\\n prob = LpProblem(\\\"Optimal split\\\",LpMinimize)\\n A = []\\n for i in range(self.K + 1):\\n A += LpVariable(str(i), 0, self.game_state[i], LpInteger)\\n prob += sum([2**(-(self.K - i)) * c for c, i in zip(A, range(self.K + 1))]) - ratio * self.potential(self.game_state), \\\"Objective function\\\"\\n prob += sum([2**(-(self.K - i)) * c for c, i in zip(A, range(self.K + 1))]) >= ratio * self.potential(self.game_state), \\\"Constraint\\\"\\n #prob.writeLP(\\\"test.lp\\\")\\n prob.solve()\\n Abis = [0]*(self.K+1)\\n for v in prob.variables():\\n Abis[int(v.name)] = round(v.varValue)\\n B = [z - a for z, a in zip(self.game_state, Abis)]\\n return Abis, B\",\n \"def bsp(splits, min_val, max_val):\\n if not splits and min_val == max_val:\\n return min_val\\n if splits[0] in ['F', 'L']:\\n return bsp(splits[1:], min_val, math.floor((min_val + max_val)/2))\\n elif splits[0] in ['B', 'R']:\\n return bsp(splits[1:], math.ceil((min_val + max_val)/2), max_val)\",\n \"def findBestSplitInDataByInfoGain(self, data, structure, colName):\\n colIndex, maxInfoGain, bestSplit = structure[colName]['index'], 0, []\\n for i in range(0, len(data)-1):\\n split = (float(data[i][colIndex]) + float(data[i+1][colIndex])) / 2\\n infoGain = self.calcInfoGainBySplitValue(data, structure, colName, split)\\n if infoGain >= maxInfoGain:\\n bestSplit = [split, infoGain]\\n maxInfoGain = infoGain\\n return bestSplit\",\n \"def get_n_best(self):\\n pass\",\n \"def min_parts():\\n # min_parts = 270\\n # you must replace this with your own value\\n # return -1\\n\\n return 270\",\n \"def findBestColumnSplitByGainRatio(self, data, structure):\\n maxGainRatio, bestSplit = 0, None\\n for colName in list(structure.keys())[:-1]:\\n GainRatio = self.calcGainRatioSplitByColumn(data, structure, colName)\\n if GainRatio >= maxGainRatio:\\n maxGainRatio = GainRatio\\n bestSplit = colName\\n return bestSplit\",\n \"def golden_split(n):\\n large = n / GOLDEN_RATIO\\n small = n - large\\n large = int(round(large))\\n small = int(round(small))\\n return large, small\",\n \"def _find_split(self, X, y, n_features):\\r\\n splits_info = []\\r\\n\\r\\n # Select features to consider\\r\\n features = self._feature_selection.get_features(n_features, self._feature_prob)\\r\\n\\r\\n # Get candidate splits\\r\\n for feature_id in features:\\r\\n for split_value in compute_split_values(X[:, feature_id]):\\r\\n splits_info.append(\\r\\n compute_split_info(self._split_criterion, X, y, feature_id, split_value, self._min_samples_leaf))\\r\\n\\r\\n splits = []\\r\\n for split_info in splits_info:\\r\\n if split_info is not None:\\r\\n gain, feature_id, split_value = split_info\\r\\n split = Split(feature_id, value=split_value, gain=gain)\\r\\n splits.append(split)\\r\\n else:\\r\\n continue\\r\\n\\r\\n selected_split = self._split_chooser.get_split(splits)\\r\\n return selected_split\",\n \"def getSplit(self):\\n b_index, b_value, b_score, b_groups = 999, 999, 999, None\\n for j in range(len(self[0]) - 1):\\n for i in range(len(self)):\\n groups = self.splitAttribute(j, self[i][j]) # lit, big\\n gini = self.giniIndex(groups)\\n if gini < b_score and (j, \\\"%.1f\\\" % self[i][j]) not in self.atr:\\n b_index, b_value, b_score, b_groups = j, self[i][\\n j], gini, groups\\n return b_index, b_value, b_groups, b_score\",\n \"def best_pair(p1,p2,p3):\\n left_distance = float(\\\"inf\\\")\\n right_distance = float(\\\"inf\\\")\\n split_distance = float(\\\"inf\\\")\\n if p1:\\n left_distance = distance(p1[0], p1[1])\\n if p2:\\n right_distance = distance(p2[0], p2[1])\\n if p3:\\n split_distance = distance(p3[0], p3[1])\\n\\n min_distance = min(left_distance, right_distance, split_distance)\\n if min_distance == left_distance:\\n return p1\\n elif min_distance == right_distance:\\n return p2\\n else:\\n return p3\",\n \"def find_smallest(num_vars):\\n for x in range(10):\\n if num_vars <= 2**x:\\n return x\",\n \"def _compute_split_boundaries(split_probs, n_items):\\n if len(split_probs) > n_items:\\n raise ValueError(\\n 'Not enough items for the splits. There are {splits} '\\n 'splits while there are only {items} items'.format(\\n splits=len(split_probs), items=n_items\\n )\\n )\\n total_probs = sum(p for name, p in split_probs)\\n if abs(1 - total_probs) > 1e-8:\\n raise ValueError('Probs should sum up to 1. probs={}'.format(split_probs))\\n split_boundaries = []\\n sum_p = 0.0\\n for name, p in split_probs:\\n prev = sum_p\\n sum_p += p\\n split_boundaries.append((name, int(prev * n_items), int(sum_p * n_items)))\\n\\n # Guard against rounding errors.\\n split_boundaries[-1] = (\\n split_boundaries[-1][0],\\n split_boundaries[-1][1],\\n n_items,\\n )\\n\\n return split_boundaries\",\n \"def best_cutoff(self,\\n split_label):\\n split_args = self.sub_split_args[split_label]\\n split_data = self.sub_split_data[split_label]\\n # This criterion for the use_scipy flag is arbitrary and needs\\n # further testing\\n n_unique = len(np.unique(split_data[~np.isnan(split_data)]))\\n use_scipy = True\\n if n_unique > len(split_data)/1000:\\n use_scipy = False\\n idxcut_below, effects_below, rstats_below, ndata_below =\\\\\\n self.u_data(split_label, use_scipy=use_scipy)\\n idxcut_above, effects_above, rstats_above, ndata_above =\\\\\\n self.u_data(split_label, above=True, use_scipy=use_scipy)\\n\\n # Default cutoff is min(split_data) - 1\\n cutoff = split_data[split_args[0]] - 1\\n value = 0\\n # If no cutoff was possible\\n if len(idxcut_below) == 0 or len(idxcut_above) == 0:\\n return cutoff, value\\n\\n # All idx_cutoffs and values for cutoffs, for debugging\\n for idx in range(len(idxcut_above)):\\n idxcut = idxcut_above[idx]\\n if idxcut != idxcut_below[idx]:\\n raise NameError('Code error, invalid split')\\n value_temp = (abs(effects_above[idx] -\\n effects_below[idx]) *\\n rstats_above[idx] *\\n rstats_below[idx] *\\n min(ndata_above[idx]) *\\n min(ndata_below[idx]))\\n if value_temp > value:\\n cutoff = (split_data[split_args[int(idxcut)]] +\\n split_data[split_args[int(idxcut)+1]])/2\\n value = value_temp\\n return cutoff, value\",\n \"def get_n_splits(self):\\n pass\",\n \"def get_optimal_continuous_feature_split(\\n self, X: np.ndarray, y: np.ndarray, feature_col: int\\n ):\\n midpoints = BaseTree.get_valid_midpoints(arr=X[:, feature_col], y=y)\\n # If midpoints, get the best one\\n if len(midpoints) > 0:\\n return BaseTree.get_min_across_splits_continuous(\\n arr=X[:, feature_col], y=y, splits=midpoints, eval_func=self.eval_func\\n )\\n\\n # If no split points, return inf (can't split here)\\n return (0, np.inf, 1)\",\n \"def choose_best_split(self, X_subset, y_subset):\\n # YOUR CODE HERE\\n feature_index = None\\n threshold = None\\n best_G = np.inf\\n N = len(X_subset)\\n \\n for current_feature in range(X_subset.shape[1]):\\n thresholds = np.unique(X_subset[:, current_feature])\\n \\n for t in thresholds:\\n y_left, y_right = self.make_split_only_y(current_feature, t, X_subset, y_subset)\\n H_L = self.H(y_left)\\n H_R = self.H(y_right)\\n \\n G = (len(y_left) / N) * H_L + (len(y_right) / N) * H_R\\n \\n if G < best_G:\\n best_G = G\\n feature_index = current_feature\\n threshold = t\\n \\n return feature_index, threshold\",\n \"def split(self,best):\\n\\t\\treturn self.cu_for_split(best,False)\",\n \"def get_splits(self):\\n\\t\\treturn self.k\",\n \"def findBestColumnSplitByInfoGain(self, data, structure):\\n maxInfoGain, bestSplit = 0, None\\n for colName in list(structure.keys())[:-1]:\\n infoGain = self.calcInfoGainByColumnSplit(data, structure, colName)\\n if infoGain >= maxInfoGain:\\n maxInfoGain = infoGain\\n bestSplit = colName\\n return bestSplit\",\n \"def get_best_split(rows: list) -> (float, Question):\\n best_info_gain = 0\\n best_question = None\\n current_uncertainty = get_gini_impurity(rows)\\n\\n # minus 1 because we're ignoring the last column which is the label.\\n n_attributes = len(rows[0]) - 1\\n\\n for col in range(n_attributes):\\n\\n # get all unique values for an attribute/column\\n unique_values = set([row[col] for row in rows])\\n\\n for value in unique_values:\\n question = Question(col, value)\\n\\n # Split rows depending on the question\\n true_rows, false_rows = partition(rows, question)\\n\\n # We don't want to partition such rows\\n if len(true_rows) == 0 or len(false_rows) == 0:\\n continue\\n\\n # Get info gain from this split\\n info_gain = get_info_gain(false_rows, true_rows, current_uncertainty)\\n\\n if info_gain > best_info_gain:\\n best_info_gain, best_question = info_gain, question\\n\\n return best_info_gain, best_question\",\n \"def find_split(x, y):\\n\\n # Need the starting entropy so we can measure improvement...\\n start_entropy = calculate_entropy(y)\\n\\n # Best thus far, initialised to a dud that will be replaced immediately...\\n best = {'infogain': -np.inf}\\n\\n # Randomly allocate the splits to be traversed (without replacement)\\n feature_total = x.shape[1]\\n feature_subset_count = int(np.sqrt(feature_total))\\n feature_subset = np.random.permutation(feature_total)[:feature_subset_count]\\n\\n # Loop every possible split of every feature...\\n for feature_index in feature_subset:\\n for split in np.unique(x[:, feature_index]):\\n\\n left_indices = []\\n right_indices = []\\n\\n # Get index of rows where x[row_index,feature_index] <= split\\n for row_index,row in enumerate(x):\\n left_indices.append(row_index) if x[row_index,feature_index] <= split else right_indices.append(row_index)\\n\\n left_ys = y[left_indices]\\n right_ys = y[right_indices]\\n\\n nleft = len(left_ys)\\n nright = len(right_ys)\\n ntotal = nleft + nright\\n infogain = start_entropy - (nleft / ntotal) * calculate_entropy(left_ys) - (\\n nright / ntotal) * calculate_entropy(right_ys)\\n\\n if infogain > best['infogain']:\\n best = {'feature': feature_index,\\n 'split': split,\\n 'infogain': infogain,\\n 'left_indices': left_indices,\\n 'right_indices': right_indices}\\n return best\",\n \"def get_n_out_min(ss):\\n n = ss.split(\\\"_\\\")[0]\\n if n == \\\"full\\\":\\n n = 1\\n else:\\n n = int(n)\\n return n\",\n \"def compute_splits(feature_df, target_col, max_num_splits):\\n tree_estimator = DecisionTreeClassifier(max_leaf_nodes=max_num_splits+1,\\n class_weight='balanced',\\n random_state=1407)\\n\\n tree_estimator.fit(feature_df, target_col)\\n thresholds = tree_estimator.tree_.threshold[tree_estimator.tree_.children_left != _tree.TREE_LEAF]\\n return sorted(thresholds)\",\n \"def get_n_splits(self):\\n return self.n_splits\",\n \"def get_n_splits(self):\\n return self.n_splits\",\n \"def get_n_splits(self):\\n return self.n_splits\",\n \"def __get_split_feature(self, data_set, target_feature, tree_features):\\n\\n if self.__criterion == 'entropy':\\n feature_gains = {feature: self.__gain(data_set, feature, target_feature) for (feature) in tree_features}\\n split_feature = max(feature_gains, key=feature_gains.get)\\n return split_feature\\n elif self.__criterion == 'gini':\\n feature_ginis = {feature: self.__gini(data_set, feature, target_feature) for (feature) in tree_features}\\n split_feature = min(feature_ginis, key=feature_ginis.get)\\n return split_feature\\n # TODO: I should check this (gini index).\",\n \"def _bestFeat2split(dataSet, impurity_crit, min_impurity_decrease, min_samples_split):\\n\\t\\tm, n = dataSet.shape\\n\\t\\tbestFeatInd, bestVal = None, DecisionTree._make_leaf(dataSet, impurity_crit)\\n\\n\\t\\tif m < min_samples_split or len(set(dataSet[:,-1])) == 1:\\n\\t\\t\\treturn bestFeatInd, bestVal\\n\\n\\t\\timpurity = m * impurity_crit(dataSet)\\n\\t\\tmin_impurity = np.inf\\n\\t\\t\\n\\n\\t\\tfor feat_ind in range(n-1):\\n\\t\\t\\tif type(dataSet[:, feat_ind][0]) != str:\\n\\t\\t\\t\\tuniqVal = set(dataSet[:, feat_ind])\\n\\t\\t\\telse:\\n\\t\\t\\t\\tuniqVal = map(set, subsets(list(dataSet[:, feat_ind])))\\n\\t\\t\\tfor val in uniqVal:\\n\\t\\t\\t\\tD1, D2 = DecisionTree._binarySplit(dataSet, feat_ind, val)\\n\\t\\t\\t\\tif len(D1) < min_samples_split or len(D2) < min_samples_split:\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\tnew_impurity = len(D1)*impurity_crit(D1) + len(D2)*impurity_crit(D2)\\n\\t\\t\\t\\tif impurity - new_impurity < min_impurity_decrease:\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\tif new_impurity < min_impurity:\\n\\t\\t\\t\\t\\tmin_impurity = new_impurity\\n\\t\\t\\t\\t\\tbestFeatInd = feat_ind; bestVal = val\\n\\t\\treturn bestFeatInd, bestVal\",\n \"def min_parts():\\n # you must replace this with your own value\\n return 1155\",\n \"def min_parts():\\n # you must replace this with your own value\\n return 1155\",\n \"def detect_splits(self):\\n logg.info(' abstracted graph will have {} nodes'.format(self.n_splits+1))\\n indices_all = np.arange(self.X.shape[0], dtype=int)\\n segs = [indices_all]\\n if False: # this is safe, but not compatible with on-the-fly computation\\n tips_all = np.array(np.unravel_index(np.argmax(self.Dchosen), self.Dchosen.shape))\\n else:\\n if self.iroot is not None:\\n tip_0 = np.argmax(self.Dchosen[self.iroot])\\n else:\\n tip_0 = np.argmax(self.Dchosen[0]) # just a random index, here fixed to \\\"0\\\"\\n tips_all = np.array([tip_0, np.argmax(self.Dchosen[tip_0])])\\n # we keep a list of the tips of each segment\\n segs_tips = [tips_all]\\n if self.clusters_precomputed_names:\\n self.segs_names_original = [', '.join(self.clusters_precomputed_names)]\\n segs_undecided = [True]\\n segs_adjacency = [[]]\\n segs_distances = np.zeros((1, 1))\\n segs_adjacency_nodes = [{}]\\n # logg.info(' do not consider groups with less than {} points for splitting'\\n # .format(self.min_group_size))\\n for ibranch in range(self.n_splits):\\n if self.clusters == 'unconstrained_segments':\\n iseg, new_tips = self.select_segment(segs, segs_tips, segs_undecided)\\n if iseg == -1:\\n logg.info('... partitioning converged')\\n break\\n logg.info('... branching {}:'.format(ibranch + 1),\\n 'split group', iseg)\\n segs_distances = self.do_split(segs, segs_tips,\\n segs_undecided,\\n segs_adjacency,\\n segs_distances,\\n iseg, new_tips)\\n else:\\n logg.msg(' split', ibranch + 1, v=4)\\n stop, segs_distances = self.do_split_constrained(segs, segs_tips,\\n segs_adjacency,\\n segs_adjacency_nodes,\\n segs_distances)\\n if stop: break\\n\\n # segments\\n self.segs = segs\\n self.segs_tips = segs_tips\\n self.segs_sizes = []\\n for iseg, seg in enumerate(self.segs): self.segs_sizes.append(len(seg))\\n\\n # the full, unscaled adjacency matrix\\n self.segs_adjacency_full_attachedness = 1/segs_distances\\n # if self.attachedness_measure == 'connectedness':\\n # norm = np.sqrt(np.multiply.outer(self.segs_sizes, self.segs_sizes))\\n # self.segs_adjacency_full_attachedness /= norm\\n self.segs_adjacency_full_confidence, self.segs_adjacency_tree_confidence \\\\\\n = self.compute_adjacency_confidence(\\n self.segs_adjacency_full_attachedness,\\n segs_adjacency,\\n self.tree_based_confidence)\\n np.fill_diagonal(self.segs_adjacency_full_attachedness, 0)\",\n \"def get_optimal_continuous_feature_split (\\n self, feature_matrix: np.ndarray, target_array: np.ndarray, feature_column: int\\n ):\\n midpoints = BaseTree.get_valid_midpoints ( feature_array = feature_matrix [ :, feature_column ], target_array = target_array )\\n # If midpoints, get the best one\\n if len ( midpoints ) > 0:\\n return BaseTree.get_min_across_splits_continuous (\\n feature_array = feature_matrix [ :, feature_column ], target_array = target_array, splits = midpoints, evaluate_function = self.evaluate_function\\n )\\n\\n # If no split points, return inf (can't split here)\\n return ( 0, np.inf, 1 )\\n # End get_optimal_continuous_feature_split()\",\n \"def best_B(Ag):\\n top = 0\\n for i in range(len(Ag)):\\n etop = np.min(cf.TD20[int(Ag[i]) - 1])\\n top += etop\\n return top\",\n \"def getBestSplitsInDataByInfoGain(self, data, structure, colName, numOfSplits):\\n splitsList, newSplitsList = {}, []\\n self.fillBestSplitsInDataByInfoGainIntoDict(data, structure, colName, numOfSplits, splitsList, 0)\\n for lists in list(splitsList.values())[1:]:\\n while len(lists) > 0:\\n splitOne, splitTwo = [], []\\n if len(lists) > 0:\\n splitOne = lists.pop()\\n if len(lists) > 0:\\n splitTwo = lists.pop()\\n if splitOne and splitTwo:\\n if splitOne[1] >= splitTwo[1]:\\n newSplitsList.append(splitOne[0])\\n newSplitsList.append(splitTwo[0])\\n else:\\n newSplitsList.append(splitTwo[0])\\n newSplitsList.append(splitOne[0])\\n elif splitOne:\\n newSplitsList.append(splitOne[0])\\n elif splitTwo:\\n newSplitsList.append(splitTwo[0])\\n\\n newSplitsList.insert(0, splitsList['0'][0][0])\\n self.removeDuplicatesInList(newSplitsList)\\n return newSplitsList[0:numOfSplits]\",\n \"def choose_split(data,treshold):\\n n_features = len(data[0]) - 1 # number of columns\\n quest_gain = [] # keep track of the gains and questions\\n\\n for col in range(1,n_features): # for each feature\\n values = set([row[col] for row in data]) # unique values in the column\\n for val in values: # for each value\\n question = Question(col, val)\\n \\n # try splitting the dataset\\n true_rows, false_rows = partition(data, question)\\n\\n # Skip this split if it doesn't divide the dataset.\\n if len(true_rows) == 0 or len(false_rows) == 0:\\n continue\\n\\n # Calculate the information gain from this split\\n gain = info_gain(data, true_rows, false_rows)\\n quest_gain.append(Question_gain(gain,question))\\n\\n possible_question = [] # possible questions to ask\\n n_quest_gain = len(quest_gain)\\n\\n if n_quest_gain == 0:\\n return float('Inf'), float('NaN') #\\n\\n for x in range(n_quest_gain):\\n if (quest_gain[x].gain >= treshold):\\n possible_question.append(Question_gain(quest_gain[x].gain,quest_gain[x].question))\\n \\n n_possible_question = len(possible_question)\\n if n_possible_question == 0:\\n return float('Inf'), float('NaN')\\n\\n if n_possible_question>=2:\\n [i, j] = random.sample(range(0, n_possible_question), 2)\\n else:\\n i = j = random.randint(0,n_possible_question-1)\\n\\n if possible_question[i].gain>=possible_question[j].gain:\\n return possible_question[i].gain, possible_question[i].question\\n else:\\n return possible_question[j].gain, possible_question[j].question\",\n \"def get_cluster_to_split(clusters):\\n\\treturn max(clusters.items(), key=lambda x: x[1].get_distortion())[1]\",\n \"def getSplitFunc(self, splitType):\\n if splitType.upper() == \\\"INFO GAIN\\\":\\n return self.findBestColumnSplitByInfoGain\\n elif splitType.upper() == \\\"GAIN RATIO\\\":\\n return self.findBestColumnSplitByGainRatio\\n elif splitType.upper() == \\\"GINI INDEX\\\":\\n return self.findBestColumnSplitByGini\\n return None\",\n \"def calculate_lower_boundary(self, divisor):\\n\\n # see how low you can go\\n quotas = [0] * self.states\\n fair_shares = [0] * self.states\\n counter = 0\\n lowest_divisor = 0\\n prev_divisor = 0\\n estimator = 1000000000\\n while counter < 1000:\\n for i, population in enumerate(self.populations):\\n if divisor is None or population is None:\\n return None\\n quotas[i] = population / divisor\\n fair_shares[i] = math.floor(quotas[i])\\n if sum(fair_shares) != self.num_seats:\\n estimator = estimator / 10\\n prev_divisor = divisor\\n divisor = lowest_divisor - estimator\\n else:\\n lowest_divisor = divisor\\n divisor = prev_divisor - estimator\\n if lowest_divisor == divisor:\\n break\\n counter += 1\\n return math.ceil(lowest_divisor * 1000) / 1000\",\n \"def get_best_clique(self):\\n\\t\\treturn [i+1 for i in range(self._size) if self._globalMinimumState[i] == 1]\",\n \"def _get_smallest_sublist(sublists):\\r\\n smallest_list_id = 0\\r\\n for list_id, sublist in sublists.items():\\r\\n if sublist['size'] < sublists[smallest_list_id]['size']:\\r\\n smallest_list_id = list_id\\r\\n\\r\\n return smallest_list_id\",\n \"def getminmax_linear_search(arr):\\n if len(arr) == 0:\\n return None, None\\n\\n if len(arr) == 1:\\n return arr[0], arr[0]\\n\\n min_num = None\\n max_num = None\\n if arr[0] > arr[1]:\\n max_num = arr[0]\\n min_num = arr[1]\\n else:\\n max_num = arr[1]\\n min_num = arr[0]\\n\\n for idx in range(2, len(arr)):\\n if min_num > arr[idx]:\\n min_num = arr[idx]\\n if max_num < arr[idx]:\\n max_num = arr[idx]\\n\\n return min_num, max_num\",\n \"def get_n_splits(self):\\n return self.n_folds\",\n \"def find_split(data):\\n ret = {\\\"router\\\": None, \\\"split_point\\\": None, \\\"entropy\\\": get_entropy(data[:, 7])}\\n\\n # Create array of unique datapoints\\n split_points_list = list()\\n\\n for i in range(data.shape[1] - 1):\\n unique_signal = np.unique(data[:, i])\\n split_points = list()\\n for j in range(len(unique_signal) - 1):\\n split_points.append((unique_signal[j]+unique_signal[j+1])/2)\\n split_points_list.append(split_points)\\n\\n # Split data by split points and calculate entropy\\n for feature in range(len(split_points_list)):\\n for i in range(len(split_points_list[feature])):\\n data_l, data_r = split_data(data, feature + 1, split_points_list[feature][i])\\n entropy = get_entropy(data_l[:, 7], data_r[:, 7])\\n if entropy < ret[\\\"entropy\\\"]:\\n ret[\\\"entropy\\\"] = entropy\\n ret[\\\"router\\\"] = feature + 1\\n ret[\\\"split_point\\\"] = split_points_list[feature][i]\\n\\n return ret[\\\"router\\\"], ret[\\\"split_point\\\"], split_data(data, ret[\\\"router\\\"], ret[\\\"split_point\\\"])\",\n \"def _compute_best_split_and_push(self, node):\\n\\n node.split_info = self.splitter.find_node_split(\\n node.sample_indices, node.histograms, node.sum_gradients,\\n node.sum_hessians)\\n\\n if node.split_info.gain <= 0: # no valid split\\n self._finalize_leaf(node)\\n else:\\n heappush(self.splittable_nodes, node)\",\n \"def compute_min_winning_bid(bidders):\\r\\n min_values = [x.values[0] for x in bidders]\\r\\n max_min_value = max(min_values)\\r\\n max_min_value_bidder = np.argmax(min_values)\\r\\n\\r\\n max_utility = -1.0\\r\\n min_winning_bid = -1.0\\r\\n for i in range(len(bidders)):\\r\\n for j in range(len(bidders[i].values)):\\r\\n b = bidders[i].values[j]\\r\\n if b > max_min_value:\\r\\n break\\r\\n winning_prob = 1.0\\r\\n for k in range(len(bidders)):\\r\\n if k != max_min_value_bidder:\\r\\n winning_prob *= sum(\\r\\n [bidders[k].prob[l] for l in range(len(bidders[k].values)) if bidders[k].values[l] <= b])\\r\\n utility = winning_prob * (max_min_value - b)\\r\\n if utility > max_utility - 1e-8:\\r\\n max_utility = utility\\r\\n min_winning_bid = b\\r\\n return min_winning_bid\",\n \"def _find_min_pair(h5chunks, max_gap=None):\\n num_chunks = len(h5chunks)\\n\\n if num_chunks < 2:\\n return None\\n\\n min_pair = None\\n min_dist = None\\n\\n for i in range(1, num_chunks):\\n c1 = h5chunks[i - 1]\\n c2 = h5chunks[i]\\n d = _chunk_dist(c1, c2)\\n if d == 0:\\n # short-circuit search and just return this pair\\n return (i - 1, i)\\n if d > max_gap:\\n continue\\n if min_dist is None or d < min_dist:\\n min_pair = (i - 1, i)\\n min_dist = d\\n return min_pair\",\n \"def potential_splits(self, potential_xj):\\r\\n \\r\\n self.cur.execute(\\\"SELECT DISTINCT \\\" + potential_xj + \\\" FROM \\\" + self.table_name + \\\";\\\")\\r\\n potential_splits = [ii[0] for ii in self.cur.fetchall()]\\r\\n return potential_splits\",\n \"def __get_min_indexes(num_list, number):\\n result = []\\n\\n num_list = np.array(num_list)\\n result = np.argpartition(num_list, number)[:number]\\n\\n return result\",\n \"def find_least_number(incoming_list):\\n retval = min(incoming_list)\\n return retval\",\n \"def _get_split_sizes(self, n_examples):\\n\\n min_ex = (int(n_examples // self.n_splits)\\n * np.ones(self.n_splits, dtype=np.int8))\\n \\n rem = np.array(\\n [1 if i < n_examples % self.n_splits else 0\\n for i in range(self.n_splits)],\\n dtype=np.int8)\\n\\n return np.add(min_ex, rem)\",\n \"def choose_split_value(attrs, classes):\\n indices = np.argsort(attrs)\\n classes = classes[indices]\\n attrs = attrs[indices]\\n max_gain = 0.0\\n max_gain_value = None\\n for i in range(len(attrs) - 1):\\n if classes[i] != classes[i+1]:\\n mean = (attrs[i] + attrs[i+1]) / 2.0\\n gain = inform_gain(attrs, classes, mean)\\n if gain > max_gain:\\n max_gain = gain\\n max_gain_value = mean\\n return max_gain_value, max_gain\",\n \"def splits(self) -> List[int]:\\n if self._splits is None:\\n self.RefreshStats()\\n return self._splits\",\n \"def test_chunk_size_priority_over_n_splits(self):\\n with self.subTest(input='list', chunk_size=1, n_splits=6):\\n self.assertEqual(get_n_chunks(self.test_data, iterable_len=None, chunk_size=1, n_splits=6, n_jobs=None), 13)\\n with self.subTest(input='numpy', chunk_size=1, n_splits=6):\\n self.assertEqual(get_n_chunks(self.test_data_numpy, iterable_len=None, chunk_size=1, n_splits=6,\\n n_jobs=None), 100)\\n\\n with self.subTest(input='list', chunk_size=3, n_splits=3):\\n self.assertEqual(get_n_chunks(self.test_data, iterable_len=None, chunk_size=3, n_splits=3, n_jobs=None), 5)\\n with self.subTest(input='numpy', chunk_size=3, n_splits=3):\\n self.assertEqual(get_n_chunks(self.test_data_numpy, iterable_len=None, chunk_size=3, n_splits=3,\\n n_jobs=None), 34)\",\n \"def imbalance(A,n,k):\\n\\n # create k + 1 array s[1], s[2],..., s[n]\\n # s[k][i,j] indicate current minimum imbalance for kth part as A[i,j]\\n s = {}\\n partition = [0]*k\\n\\n for i in range(1,k+2):\\n s[i] = np.zeros((n,n))\\n s[i][:] = np.inf\\n\\n ave = sum(A)/(k+1)\\n\\n\\n # initialize imbalance for the first part\\n for j1 in range(len(A)):\\n s[1][0,j1] = abs(sum(A[0:j1]) - ave)\\n\\n for p in range(2,k+2): # each part\\n for i in range(1,len(A)):\\n for j in range(i,len(A)):\\n\\n s[p][i,j] = max([min(s[p-1][:,i-1]),abs(sum(A[i:(j+1)])/(k+1)-ave)])\\n\\n #\\n\\n # find partition point (possible result)\\n\\n split_p = n # split should be the start of each part except the first one\\n\\n for p in range(k+1,1,-1):\\n\\n split_p = [i for i,ele in enumerate(s[p][:, (split_p-1)])\\n if ele == min(s[p][:, (split_p-1)])][0]\\n\\n partition[p-2] = split_p\\n\\n return partition\\n\\n # the minimum imbalance should be min(s[k+1][:,n])\\n # return min(s[k+1][:,n-1])\",\n \"def best_split(self, X, y, attributes):\\n if (self.criterion==\\\"information_gain\\\"):\\n global_if = float('-inf') # the highest value of information gain/gini gain seen so far\\n attr = None\\n for attribute in attributes:\\n attr_val = X[attribute].copy()\\n cur_if = information_gain(y,attr_val,self.type)\\n if (cur_if>global_if):\\n # Update when a better split is receieved\\n global_if = cur_if\\n attr = attribute\\n return attr\\n else:\\n global_if = float('inf')\\n attr = None\\n for attribute in attributes:\\n attr_val = X[attribute].copy()\\n cur_if = gini_gain(y,attr_val)\\n if (global_if>cur_if):\\n # Update when a better split is receieved\\n global_if = cur_if\\n attr = attribute\\n return attr\",\n \"def choose_optimal_image_split(im, method='im_size', min_tile_size=360000):\\n \\n n_cores = os.cpu_count()\\n # number of segmented objects, drop the background value\\n n_obj = np.unique(im).size - 1\\n \\n if method == 'im_size':\\n # avoid too many splits if image is not so big\\n im_size = im.nbytes # slightly different from sys.getsizeof(im)\\n # max power of 2\\n max_i = int(np.log2(n_cores)) + 1\\n n_splits = 1\\n for i in range(1, max_i):\\n new_split = 2**i\\n if im_size / new_split >= min_tile_size:\\n n_splits = new_split\\n else:\\n break\\n elif method == 'naive':\\n n_splits = n_cores\\n \\n return n_splits\",\n \"def get_max_combination(total_cuts):\\n max_pieces = 0\\n for i in range(total_cuts):\\n result = i * (total_cuts - i)\\n if result > max_pieces:\\n max_pieces = result\\n print(max_pieces)\",\n \"def find_least_number(incoming_list):\\n\\n least_number = min(incoming_list)\\n return least_number\",\n \"def find_min(ls):\\n\\n if len(ls) == 1:\\n return ls[0]\\n elif len(ls) == 2:\\n return ls[0] if ls[0] < ls[1] else ls[1]\\n else:\\n mid = len(ls) // 2\\n m1 = find_min(ls[0:mid])\\n m2 = find_min(ls[mid:])\\n return m1 if m1 < m2 else m2\",\n \"def better_partition_parallel(graph, part1, part2, independent_set_extraction_strategy):\\n\\n best = part2\\n for i in range(len(part1)):\\n if better_partition(graph, part1[i], best, independent_set_extraction_strategy):\\n best = part1[i]\\n\\n return best\",\n \"def get_reranker_best(self):\\n if len(self.parses):\\n return min(self, key=lambda parse: parse.reranker_rank)\\n else:\\n return None\",\n \"def getListWithBestValueSplitsOfDataByGini(self, data, structure, colIndex, numOfSplits):\\n splitsList, newSplitsList = {}, []\\n self.fillDictWithBestValueSplitsOfDataByGini(data, structure, colIndex, numOfSplits, splitsList, 0)\\n for lists in list(splitsList.values())[1:]:\\n while len(lists) > 0:\\n splitOne, splitTwo = [], []\\n if len(lists) > 0:\\n splitOne = lists.pop()\\n if len(lists) > 0:\\n splitTwo = lists.pop()\\n if splitOne and splitTwo:\\n if splitOne[1] <= splitTwo[1]:\\n newSplitsList.append(splitOne[0])\\n newSplitsList.append(splitTwo[0])\\n else:\\n newSplitsList.append(splitTwo[0])\\n newSplitsList.append(splitOne[0])\\n elif splitOne:\\n newSplitsList.append(splitOne[0])\\n elif splitTwo:\\n newSplitsList.append(splitTwo[0])\\n\\n newSplitsList.insert(0, splitsList['0'][0][0])\\n self.removeDuplicatesInList(newSplitsList)\\n return newSplitsList[0:numOfSplits]\",\n \"def personal_best(scores: list) -> int:\\n return max(scores)\",\n \"def give_greatest_spart(cls, spart_list):\\n if len(spart_list) == 1:\\n return spart_list[0]\\n sorted_list = cls.sort_by_dominance(spart_list)\\n if not(sorted_list[0] > sorted_list[1]):\\n print(\\\"The two largest elements are non-comparable\\\")\\n return []\\n else:\\n return sorted_list[0]\",\n \"def find_least_number(incoming_list: list):\\n return min(incoming_list)\",\n \"def compute_optimal_token_minimum(token_counts) -> int:\\n q1, q3 = compute_quartiles(token_counts)\\n iqr = q3 - q1\\n low_threshold = q1 - 1.5 * iqr\\n return low_threshold\",\n \"def find_least_number(incoming_list):\\n \\n return_value = min(incoming_list)\\n return return_value\",\n \"def min_number_of(g, elt, n_fuel):\\n if elt == 'FUEL':\\n return n_fuel\\n t = sum([g.edges[elt, s]['cost'] * min_number_of(g, s, n_fuel) for s in\\n g.successors(elt)])\\n return divup(t, g.nodes[elt]['batch_size'])\",\n \"def best_split1(self,X,attributes):\\n if (self.criterion==\\\"information_gain\\\"):\\n global_if = float('-inf') # the highest value of varience seen so far\\n attr , val = None, None\\n for attribute in attributes[::-1]:\\n attr_val = pd.Series(X[attribute].unique()).sort_values(ignore_index=True)\\n last_val = attr_val[0]\\n for i in range(1,attr_val.size):\\n cur_val = attr_val[i]\\n valc = round((last_val+cur_val)/2,4)\\n last_val = cur_val\\n cur_if = information_gain1(valc,X[attribute],X[\\\"Output\\\"],self.type)\\n if (cur_if>global_if):\\n global_if,attr,val = cur_if,attribute,valc\\n return attr,val\\n else:\\n global_if = float('inf') # the lowest value of varience seen so far\\n attr , val = None, None\\n for attribute in attributes[::-1]:\\n attr_val = pd.Series(X[attribute].unique()).sort_values(ignore_index=True)\\n last_val = attr_val[0]\\n for i in range(1,attr_val.size):\\n cur_val = attr_val[i]\\n valc = round((last_val+cur_val)/2,4)\\n last_val = cur_val\\n cur_if = gini_gain1(X[\\\"Output\\\"],X[attribute], valc)\\n if (global_if>cur_if):\\n global_if,attr,val = cur_if,attribute,valc\\n return attr,val\",\n \"def optimal(count):\\n\\n return _optimal(start, count)[0]\",\n \"def smallest_multiple(n):\\n return reduce(lowest_common_multiple, range(1, n+1))\",\n \"def _best_split(cls, X, y):\\n n = X.shape[0]\\n num_feature = X.shape[1]\\n y_types = np.unique(y)\\n\\n # initialize\\n min_score = float(n)\\n feature_idx = None\\n best_theta = None\\n best_idx = None\\n\\n for feature_idx in xrange(num_feature):\\n # counter for y\\n cumulate_y = Counter()\\n rest_y = Counter()\\n for y_type in y_types:\\n cnt = np.where(y == y_type)[0].shape[0]\\n rest_y[y_type] = cnt\\n\\n # sorted data\\n sorted_idx = np.argsort(X[:, feature_idx])\\n sorted_X = np.copy(X)\\n sorted_y = np.copy(y)\\n sorted_X = sorted_X[sorted_idx]\\n sorted_y = sorted_y[sorted_idx]\\n #print \\\"_best_split:\\\", sorted_X.shape, sorted_y.shape\\n\\n for idx in xrange(n-1):\\n theta = (sorted_X[idx, feature_idx] + sorted_X[idx + 1, feature_idx]) / 2\\n y_label = sorted_y[idx]\\n cumulate_y[y_label] += 1\\n rest_y[y_label] -= 1\\n left_cnt = sum(cumulate_y.values())\\n right_cnt = sum(rest_y.values())\\n w_1 = left_cnt * cls._gini_index(cumulate_y.values())\\n w_2 = right_cnt * cls._gini_index(rest_y.values())\\n score = w_1 + w_2\\n if score < min_score:\\n min_score = score\\n best_theta = theta\\n best_idx = feature_idx\\n #print('new min score: %.3f' % score)\\n #print('feature: %d, theta: %.3f' % (best_idx, best_theta))\\n #print('left: %d, right: %d' % (left_cnt, right_cnt))\\n print('feature: %d, theta: %.3f' % (best_idx, best_theta))\\n return (best_idx, best_theta)\",\n \"def _best_split(cls, X, y):\\n n = X.shape[0]\\n num_feature = X.shape[1]\\n y_types = np.unique(y)\\n\\n # initialize\\n min_score = float(n)\\n feature_idx = None\\n best_theta = None\\n best_idx = None\\n\\n for feature_idx in xrange(num_feature):\\n # counter for y\\n cumulate_y = Counter()\\n rest_y = Counter()\\n for y_type in y_types:\\n cnt = np.where(y == y_type)[0].shape[0]\\n rest_y[y_type] = cnt\\n\\n # sorted data\\n sorted_idx = np.argsort(X[:, feature_idx])\\n sorted_X = np.copy(X)\\n sorted_y = np.copy(y)\\n sorted_X = sorted_X[sorted_idx]\\n sorted_y = sorted_y[sorted_idx]\\n #print \\\"_best_split:\\\", sorted_X.shape, sorted_y.shape\\n\\n for idx in xrange(n-1):\\n theta = (sorted_X[idx, feature_idx] + sorted_X[idx + 1, feature_idx]) / 2\\n y_label = sorted_y[idx]\\n cumulate_y[y_label] += 1\\n rest_y[y_label] -= 1\\n left_cnt = sum(cumulate_y.values())\\n right_cnt = sum(rest_y.values())\\n w_1 = left_cnt * cls._gini_index(cumulate_y.values())\\n w_2 = right_cnt * cls._gini_index(rest_y.values())\\n score = w_1 + w_2\\n if score < min_score:\\n min_score = score\\n best_theta = theta\\n best_idx = feature_idx\\n #print('new min score: %.3f' % score)\\n #print('feature: %d, theta: %.3f' % (best_idx, best_theta))\\n #print('left: %d, right: %d' % (left_cnt, right_cnt))\\n print('feature: %d, theta: %.3f' % (best_idx, best_theta))\\n return (best_idx, best_theta)\",\n \"def _min_max(study):\\n\\n # Iterate pareto-front trials storing mean correlation and std dev\\n df = []\\n for trial in study.best_trials:\\n df.append([trial.number, np.mean(trial.values), np.std(trial.values)])\\n\\n # Sort dataframe ascending by mean correlation\\n df = pd.DataFrame(df).sort_values(by=2, ascending=True)\\n\\n # Sort df with best trial in first row\\n if len(df) > 1 and len(df.iloc[:, 1:3].drop_duplicates()) > 1:\\n\\n # Create second pareto to maximize correlation and minimize stddev\\n # Epsilons define precision, ie dominance over other candidates\\n # Dominance is defined as x percent of stddev of stddev\\n try:\\n nd = pareto.eps_sort([list(df.itertuples(False))], objectives=[1, 2],\\n epsilons=[1e-09, np.std(df[1])*.5], maximize=[1])\\n except:\\n # Something went wrong, return df\\n nd = df\\n\\n # Sort remaining candidates\\n nd = pd.DataFrame(nd).sort_values(by=2, ascending=True)\\n\\n # Only 1st trial so return it\\n else:\\n nd = df\\n\\n # Return \\\"best\\\" trial index\\n return nd.iloc[0, 0]\",\n \"def _split_threshold(self, node):\\n\\n # define the score to improve upon\\n if self.n_clusters >= self.min_leaves and node.size <= self.max_leaf_size:\\n # split only if min(children scores) > node.score\\n force_split = False\\n best_score = node.score\\n else:\\n # force split: just take the best (even if children are worse)\\n force_split = True\\n best_score = None\\n\\n left, right = None, None\\n\\n # iterate over embedding dimensions (first ones are more reliable)\\n # up to max_n_vec (included), until we found an improving split\\n for _vec in range(self.n_vec):\\n\\n # get the candidate thresholds along this dimension\\n threshs = self._get_candidate_thresholds(node, _vec)\\n\\n # look for an improving best split along this eigenvector\\n for _t in threshs:\\n # compute the split\\n below_thresh = self.E[node.ids, _vec] < _t\\n _lids = node.ids[below_thresh]\\n _rids = node.ids[np.logical_not(below_thresh)]\\n # check if the tubes are not too small\\n _nl, _nr = len(_lids), len(_rids)\\n is_valid = _nl >= self.min_leaf_size and _nr >= self.min_leaf_size\\n if is_valid:\\n # compute the score of the new tubes only\\n _sl = self.get_tube_score(_lids)\\n _sr = self.get_tube_score(_rids)\\n # get the score of this split\\n split_score = min(_sl, _sr)\\n if best_score is None or split_score > best_score:\\n # better split\\n best_score = split_score\\n node.has_children = True\\n node.thresh = _t\\n left = SpectralNode(\\n _lids, _vec, score=_sl, name=node.name + \\\"0\\\")\\n right = SpectralNode(\\n _rids, _vec, score=_sr, name=node.name + \\\"1\\\")\\n\\n # check stopping criterion\\n if node.has_children:\\n # we found an improving split\\n if _vec > 0 or not force_split:\\n # found an improving non-forced split: stop here\\n break\\n\\n return left, right\",\n \"def optimal_min(board):\\n if terminal(board):\\n return [None, utility(board)]\\n\\n available_actions = list(actions(board))\\n\\n # Naive baseline comparison is positive infinity\\n global_optimum = [None, math.inf]\\n\\n for action in available_actions:\\n # Anticipates optimal adversarial moves.\\n local_optimum = optimal_max(result(board, action))\\n\\n if global_optimum[1] >= local_optimum[1]:\\n global_optimum = [action, local_optimum[1]]\\n\\n return global_optimum\",\n \"def get_best( self ):\\n if len(self.listScore) < 1:\\n if self.bMinimumIsBest: return 9999,\\\"Unknown\\\"\\n else: return -1,\\\"Unknown\\\"\\n return self.listScore[0]\",\n \"def get_best(self):\\n scores, ids = self.sort_best()\\n return scores[1], ids[1]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7596094","0.72380716","0.7155916","0.67890745","0.6748498","0.6699499","0.6628864","0.6618509","0.6560878","0.65409684","0.6411355","0.6359434","0.6302224","0.624653","0.6240486","0.62339056","0.622259","0.62120956","0.61381125","0.6124368","0.61219037","0.6113639","0.6107335","0.60992604","0.6089314","0.60661274","0.60628194","0.6061941","0.60484195","0.6025541","0.60169345","0.600628","0.597873","0.5963463","0.59517914","0.59258854","0.59092844","0.59013194","0.5895862","0.5895199","0.5886603","0.58819294","0.5877515","0.5861757","0.58599824","0.58516425","0.58516425","0.58516425","0.5851409","0.58402824","0.5830029","0.5830029","0.58218354","0.5798053","0.57876384","0.5776323","0.575166","0.5729619","0.571198","0.5701104","0.56996953","0.56829214","0.5672755","0.56679213","0.5649026","0.5645094","0.5638244","0.5626017","0.5615803","0.5602274","0.55901194","0.5580524","0.55692476","0.55532473","0.55510676","0.5550917","0.5543804","0.5541661","0.55400497","0.553883","0.55381703","0.55367565","0.55305773","0.55218536","0.5519083","0.5515153","0.5506334","0.5502499","0.550209","0.5501256","0.54853594","0.5484743","0.5471931","0.5471754","0.5471754","0.54707533","0.54619306","0.5441638","0.542042","0.5416408"],"string":"[\n \"0.7596094\",\n \"0.72380716\",\n \"0.7155916\",\n \"0.67890745\",\n \"0.6748498\",\n \"0.6699499\",\n \"0.6628864\",\n \"0.6618509\",\n \"0.6560878\",\n \"0.65409684\",\n \"0.6411355\",\n \"0.6359434\",\n \"0.6302224\",\n \"0.624653\",\n \"0.6240486\",\n \"0.62339056\",\n \"0.622259\",\n \"0.62120956\",\n \"0.61381125\",\n \"0.6124368\",\n \"0.61219037\",\n \"0.6113639\",\n \"0.6107335\",\n \"0.60992604\",\n \"0.6089314\",\n \"0.60661274\",\n \"0.60628194\",\n \"0.6061941\",\n \"0.60484195\",\n \"0.6025541\",\n \"0.60169345\",\n \"0.600628\",\n \"0.597873\",\n \"0.5963463\",\n \"0.59517914\",\n \"0.59258854\",\n \"0.59092844\",\n \"0.59013194\",\n \"0.5895862\",\n \"0.5895199\",\n \"0.5886603\",\n \"0.58819294\",\n \"0.5877515\",\n \"0.5861757\",\n \"0.58599824\",\n \"0.58516425\",\n \"0.58516425\",\n \"0.58516425\",\n \"0.5851409\",\n \"0.58402824\",\n \"0.5830029\",\n \"0.5830029\",\n \"0.58218354\",\n \"0.5798053\",\n \"0.57876384\",\n \"0.5776323\",\n \"0.575166\",\n \"0.5729619\",\n \"0.571198\",\n \"0.5701104\",\n \"0.56996953\",\n \"0.56829214\",\n \"0.5672755\",\n \"0.56679213\",\n \"0.5649026\",\n \"0.5645094\",\n \"0.5638244\",\n \"0.5626017\",\n \"0.5615803\",\n \"0.5602274\",\n \"0.55901194\",\n \"0.5580524\",\n \"0.55692476\",\n \"0.55532473\",\n \"0.55510676\",\n \"0.5550917\",\n \"0.5543804\",\n \"0.5541661\",\n \"0.55400497\",\n \"0.553883\",\n \"0.55381703\",\n \"0.55367565\",\n \"0.55305773\",\n \"0.55218536\",\n \"0.5519083\",\n \"0.5515153\",\n \"0.5506334\",\n \"0.5502499\",\n \"0.550209\",\n \"0.5501256\",\n \"0.54853594\",\n \"0.5484743\",\n \"0.5471931\",\n \"0.5471754\",\n \"0.5471754\",\n \"0.54707533\",\n \"0.54619306\",\n \"0.5441638\",\n \"0.542042\",\n \"0.5416408\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6504366"},"document_rank":{"kind":"string","value":"10"}}},{"rowIdx":78595,"cells":{"query":{"kind":"string","value":"Function to get the best continuous split for a column"},"document":{"kind":"string","value":"def get_optimal_continuous_feature_split (\n self, feature_matrix: np.ndarray, target_array: np.ndarray, feature_column: int\n ):\n midpoints = BaseTree.get_valid_midpoints ( feature_array = feature_matrix [ :, feature_column ], target_array = target_array )\n # If midpoints, get the best one\n if len ( midpoints ) > 0:\n return BaseTree.get_min_across_splits_continuous (\n feature_array = feature_matrix [ :, feature_column ], target_array = target_array, splits = midpoints, evaluate_function = self.evaluate_function\n )\n\n # If no split points, return inf (can't split here)\n return ( 0, np.inf, 1 )\n # End get_optimal_continuous_feature_split()"},"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_optimal_continuous_feature_split(\n self, X: np.ndarray, y: np.ndarray, feature_col: int\n ):\n midpoints = BaseTree.get_valid_midpoints(arr=X[:, feature_col], y=y)\n # If midpoints, get the best one\n if len(midpoints) > 0:\n return BaseTree.get_min_across_splits_continuous(\n arr=X[:, feature_col], y=y, splits=midpoints, eval_func=self.eval_func\n )\n\n # If no split points, return inf (can't split here)\n return (0, np.inf, 1)","def get_split(self,X,y):\n \n BEST_COL = 0\n BEST_SPLIT =0\n BEST_IMPUR = 99\n for i,feature in enumerate(X.T):\n arg_sort=np.argsort(feature) #Sort the feature for optimizing the find of splitting points\n feature= feature[arg_sort]\n y_sort = y[arg_sort]\n splits = self.possible_splits(feature,y_sort) #Get \n\n impur,splits = self.test_split(feature,y_sort,splits) #Get impurity for splitting points\n best_idx = np.argmin(impur)\n best_impur = impur[best_idx]\n \n if best_impur==0.0: #Found perfect split, terminate\n return(i,splits[best_idx])\n elif best_impur<BEST_IMPUR:\n BEST_IMPUR=best_impur\n BEST_SPLIT=splits[best_idx]\n BEST_COL=i\n return (BEST_COL,BEST_SPLIT)","def determine_best_split(data, potential_splits, mltask):\n\n first_iteration = True\n for column_index in potential_splits:\n for value in potential_splits[column_index]:\n data_below,data_above = split_data(data, column_index, value)\n \n if mltask == 'regression':\n current_overall_metric = calculate_overall_metric(data_below, data_above, metric_function = calculate_mse)\n \n # classification\n else:\n current_overall_metric = calculate_overall_metric(data_below, data_above, metric_function = calculate_entropy)\n \n \n if first_iteration or current_overall_metric <= best_overall_metric:\n first_iteration = False\n \n best_overall_metric = current_overall_metric\n best_split_column = column_index\n best_split_value = value\n \n \n return best_split_column,best_split_value","def get_best_split_all(x, y) -> Tuple[int, float, float]:\n m = x.shape[1]\n col_best_gin = np.ones(shape=m)\n col_best_val = np.ones(shape=m)\n for c in range(m):\n best = 1\n best_x = 0\n for i in np.unique(x[:, c]):\n gini = Tree.split(x[:, c], y, i)\n if gini < best:\n best = gini\n best_x = i\n col_best_gin[c] = best\n col_best_val[c] = best_x\n\n # Select best feature to split on\n col_idx = np.argmin(col_best_gin)\n # Convert to bool index\n col_idx = np.array(range(x.shape[1])) == col_idx\n\n return col_idx, col_best_val[col_idx], col_best_gin[col_idx]","def get_split(data):\n \"\"\" gets the best feature, and best value \"\"\"\n\n best_feature = None\n best_value = 0.0\n columns = data.columns\n gini_base = gini_impurity(data)\n n_rows = len(data.index) # total number of rows of data before split\n\n # Fininding which split yields the best gini gain\n max_gain = 0\n\n for i in range(len(columns)-1): # -1 b.c. class is final column\n xs = data[columns[i]].unique() # get values to test\n for x in xs: # test values\n # split dataset\n df_left = data[data[columns[i]] < x]\n df_right = data[data[columns[i]] >= x]\n\n # get gini impurities\n gini_left = gini_impurity(df_left)\n gini_right = gini_impurity(df_right)\n \n\n # Calculated weighted gini impurity\n w_left = len(df_left.index) / n_rows\n w_right = len(df_right.index) / n_rows\n\n w_gini = gini_left * w_left + gini_right * w_right\n \n\n # Calculate gini gain (we want to minimize w_gini for the smallest impurity. Ideal split is perfect Left=c1, Right=c2)\n # why not just find min w_gin instead of uding gini_gain and gini_base vaiables?\n gini_gain = gini_base - w_gini\n\n # check if this is the best split so far, store values, update max_gini\n if gini_gain > max_gain:\n best_feature = columns[i]\n best_value = x\n max_gain = gini_gain\n\n df_left = data.loc[data[best_feature] < best_value]\n df_right = data.loc[data[best_feature] >= best_value]\n \n\n return best_feature, best_value, df_left, df_right","def findBestValueSplitByGini(self, data, structure, colIndex):\n minGini, bestSplit = 1, []\n for i in range(0, len(data)-1):\n split = (float(data[i][colIndex]) + float(data[i+1][colIndex])) / 2\n giniSplit = self.calcGiniSplitBySplitValue(data, structure, colIndex, split)\n if giniSplit <= minGini:\n minGini = giniSplit\n bestSplit = [split, giniSplit]\n return bestSplit","def findBestColumnSplitByGini(self, data, structure):\n minGini, bestSplit = 1, None\n for colName in list(structure.keys())[:-1]:\n giniSplit = self.calcGiniSplitByColumn(data, structure, colName)\n if giniSplit <= minGini:\n minGini = giniSplit\n bestSplit = colName\n return bestSplit","def findBestColumnSplitByGainRatio(self, data, structure):\n maxGainRatio, bestSplit = 0, None\n for colName in list(structure.keys())[:-1]:\n GainRatio = self.calcGainRatioSplitByColumn(data, structure, colName)\n if GainRatio >= maxGainRatio:\n maxGainRatio = GainRatio\n bestSplit = colName\n return bestSplit","def find_splits(col):\n unique = np.unique(sorted(col))\n splits = np.array([np.mean([unique[i], unique[i+1]]) for i in range(len(unique)-1)])\n return splits","def get_best_split(rows):\n best_gain = 0\n best_question = None\n current_impurity = get_gini(rows)\n n_features = len(rows[0])\n\n for col in range(n_features):\n\n for row in rows:\n question = Question(col, row[col])\n true_rows, false_rows = partition(rows, question)\n\n if len(true_rows) == 0 or len(false_rows) == 0:\n break\n\n question_gain = get_info_gain(true_rows, false_rows, current_impurity)\n\n if question_gain >= best_gain:\n best_gain = question_gain\n best_question = question\n\n print(best_gain)\n print(best_question)\n return best_gain, best_question","def find_best_split(rows):\n best_gain = 0 # keep track of the best information gain\n best_question = None # keep train of the feature / value that produced it\n current_uncertainty = gini(rows)\n n_features = len(rows[0]) - 1 # number of columns\n #print(\"n_features:\", n_features)\n\n for col in range(1,n_features): # for each feature\n # for each iteration this is the set of all values of a specific column, eg, All pixels number 0\n values = set([row[col] for row in rows]) # unique values in the column\n for val in values: # for each value\n\n # Create a question object for each val under a column, holding the val and the col number\n question = Question(col, val)\n\n # try splitting the dataset\n true_rows, false_rows = partition(rows, question)\n\n # Skip this split if it doesn't divide the\n # dataset.\n if len(true_rows) == 0 or len(false_rows) == 0:\n continue\n\n # Calculate the information gain from this split\n gain = info_gain(true_rows, false_rows, current_uncertainty)\n\n # You actually can use '>' instead of '>=' here\n # but I wanted the tree to look a certain way for our\n # toy dataset.\n if gain >= best_gain:\n best_gain, best_question = gain, question\n\n return best_gain, best_question","def find_best_split(self, x, y):\n\n # check cornor case: all same x\n n = y.size\n\n if all(x == x[0]):\n return (0, amin(x) - self.eps)\n\n sort_index = argsort(x)\n x_sorted = x[sort_index]\n y_sorted = y[sort_index]\n\n # build potential split index array\n split_index_array = array([i for i in range(1, n)\n if x_sorted[i] != x_sorted[i - 1]\n and y_sorted[i] != y_sorted[i - 1]])\n\n # split_index_array = linspace(\n # 0, y.size, num=min(5, ceil(n / 5)), endpoint=False, dtype='int')\n # split_index_array = split_index_array[1:]\n\n best_split_index = 0\n best_gain = 0\n h_x = self.cur_entropy\n\n for split_index in split_index_array:\n left_entropy = self.entropy(y_sorted[:split_index])\n right_entropy = self.entropy(y_sorted[split_index:])\n h_xy = (split_index * left_entropy +\n (n - split_index) * right_entropy) / n\n cur_gain = h_x - h_xy\n\n if cur_gain > best_gain:\n best_gain = cur_gain\n best_split_index = split_index\n\n if best_split_index != 0:\n best_split_point = (x_sorted[best_split_index] +\n x_sorted[best_split_index - 1]) / 2\n else:\n best_split_point = x_sorted[best_split_index] - self.eps\n\n return (best_gain, best_split_point)","def __find_best_split(self, x, y):\n data = np.transpose(np.vstack((np.transpose(x), y)))\n num_features = data.shape[1] - 1\n\n # initialise splitting rule components\n integer_splitting_rule = None\n feature_index_to_split = None\n max_info_gain = 0\n\n # iterate over all the features and find best splits within these\n for feature in range(num_features):\n info_gain, split_int = self.__find_best_split_in_feature(\n data[:, [feature, -1]])\n if info_gain is None:\n continue\n # update max info gain so far as it iterates over features\n if info_gain > max_info_gain:\n max_info_gain = info_gain\n feature_index_to_split = feature\n integer_splitting_rule = int(split_int)\n\n return feature_index_to_split, integer_splitting_rule","def findBestColumnSplitByInfoGain(self, data, structure):\n maxInfoGain, bestSplit = 0, None\n for colName in list(structure.keys())[:-1]:\n infoGain = self.calcInfoGainByColumnSplit(data, structure, colName)\n if infoGain >= maxInfoGain:\n maxInfoGain = infoGain\n bestSplit = colName\n return bestSplit","def split_data(data,split_column,split_value):\n split_column_value = data[:,split_column]\n type_of_feature = FEATURE_TYPE[split_column]\n\n if type_of_feature == 'continuous':\n data_below = data[split_column_value <= split_value]\n data_above = data[split_column_value > split_value]\n else:\n data_below = data[split_column_value == split_value]\n data_above = data[split_column_value != split_value]\n return data_below,data_above","def findBestSplitInDataByInfoGain(self, data, structure, colName):\n colIndex, maxInfoGain, bestSplit = structure[colName]['index'], 0, []\n for i in range(0, len(data)-1):\n split = (float(data[i][colIndex]) + float(data[i+1][colIndex])) / 2\n infoGain = self.calcInfoGainBySplitValue(data, structure, colName, split)\n if infoGain >= maxInfoGain:\n bestSplit = [split, infoGain]\n maxInfoGain = infoGain\n return bestSplit","def get_next_split ( self, feature_matrix: np.ndarray, target_array: np.ndarray, tree_split: TreeSplits):\n # If only 1 y value, make a leaf node\n if len ( set ( target_array ) ) == 1:\n tree_split.updateTreeValues (\n feature_column = None,\n feature_value = None,\n node_type = None,\n nodes = {},\n children = target_array,\n )\n return tree_split\n\n # Get the presplit entropy\n presplit_entropy = self.evaluate_function ( target_array )\n\n column_values = {}\n for k, v in self.map_column_node_type.items():\n # If there's only one value in feature matrix \"X\", set the split value to infinity\n if len ( set ( feature_matrix [ :, k ] ) ) == 1:\n value = np.inf\n split = None\n class_ratios = 1\n elif v == \"continuous\":\n # Get the best possible continuous split for the column\n split, value, class_ratios = self.get_optimal_continuous_feature_split (\n feature_matrix = feature_matrix, target_array = target_array, feature_column = k\n )\n else:\n # Get the split value for the discrete column\n value, class_ratios = self.get_optimal_discrete_feature_split (\n feature_matrix = feature_matrix, target_array = target_array, feature_column = k\n )\n split = None\n\n column_values [ k ] = ( split, value, class_ratios )\n\n # Get the column with the largest gain ratio\n col_idx_with_min_value = max (\n column_values,\n key = lambda x: ( presplit_entropy - column_values.get ( x ) [ 1 ] )\n / column_values.get ( x ) [ 2 ],\n )\n\n # If stopping criteria are met or all splits are infinite, terminate the process\n if (\n self.early_stopping_comparison (\n column_values.get ( col_idx_with_min_value ) [ 1 ], self.early_stopping_value\n )\n ) or not np.isfinite ( column_values.get ( col_idx_with_min_value ) [ 1 ] ):\n self.get_terminal_node (\n feature_column = col_idx_with_min_value,\n feature_value = column_values [ col_idx_with_min_value ] [ 0 ],\n node = tree_split,\n feature_matrix = feature_matrix ,\n target_array = target_array,\n )\n return tree_split\n\n # If the best split is continuous, add a continuous node\n if self.map_column_node_type.get ( col_idx_with_min_value ) == \"continuous\":\n return self.get_continuous_node (\n feature_column = col_idx_with_min_value,\n feature_value = column_values [col_idx_with_min_value ] [ 0 ],\n feature_matrix = feature_matrix,\n target_array = target_array,\n node = tree_split,\n )\n\n # Otherwise, add a discrete node.\n else:\n return self.get_discrete_node (\n feature_matrix = feature_matrix,\n target_array = target_array,\n feature_value = column_values [ col_idx_with_min_value ] [ 0 ],\n feature_column = col_idx_with_min_value,\n node = tree_split,\n )\n # End get_next_split","def get_possible_splits( df , attribute ):\n ds = df.loc[:,attribute]\n \n # First sort the values \n ds = ds.sort_values().drop_duplicates()\n \n # Compute averages of consecutive values \n ds = ds.rolling(2).sum().divide(2)\n splits = ds[1:].tolist()\n \n # return the possible splits \n return splits","def best_split(self):\r\n best_splits = [[0, None, None]]\r\n impurity, best_S, best_xj = 0, None, None\r\n \r\n for xj in self.x_names:\r\n for S in self.potential_splits(xj):\r\n ir = float(self.impurity_reduction(xj, S))\r\n if ir > impurity:\r\n impurity, best_S, best_xj = ir, S, xj\r\n best_splits.append([S, xj])\r\n else: \r\n pass\r\n \r\n return best_S, best_xj","def getSplitFunc(self, splitType):\n if splitType.upper() == \"INFO GAIN\":\n return self.findBestColumnSplitByInfoGain\n elif splitType.upper() == \"GAIN RATIO\":\n return self.findBestColumnSplitByGainRatio\n elif splitType.upper() == \"GINI INDEX\":\n return self.findBestColumnSplitByGini\n return None","def find_split(self, X, y):\n choices = y.size\n if choices <= 1:\n return None, None\n\n # find the number of each option in the current node.\n options_parent = [np.sum(y == c) for c in range(self.num_outcomes)]\n\n # find the gini of current node.\n best_gini = 1.0 - sum((n / choices) ** 2 for n in options_parent)\n best_idx, best_split = None, None\n\n # loop through the features to get splits and options.\n for idx in range(self.num_features):\n splits, options = zip(*sorted(zip(X[:, idx], y)))\n\n num_left = [0] * self.num_outcomes\n num_right = options_parent.copy()\n for i in range(1, choices):\n c = options[i - 1]\n num_left[c] += 1\n num_right[c] -= 1\n gini_left = 1.0 - sum(\n (num_left[x] / i) ** 2 for x in range(self.num_outcomes)\n )\n gini_right = 1.0 - sum(\n (num_right[x] / i) ** 2 for x in range(self.num_outcomes)\n )\n\n gini = (i * gini_left + (choices - i) * gini_right) / choices\n\n if splits[i] == splits[i - 1]:\n continue\n\n if gini < best_gini:\n best_gini = gini\n best_idx = idx\n best_split = (splits[i] + splits[i - 1]) / 2\n\n return best_idx, best_split","def calcGiniSplitByColumn(self, data, structure, colIName):\n colIndex, giniSplit = structure[colIName]['index'], 0\n for value in structure[colIName][\"values\"]:\n newData = list(filter(lambda x: x[colIndex] == value, data))\n p = len(newData) / len(data)\n giniSplit += self.calcDataGini(newData, structure) * p\n return round(giniSplit, 3)","def find_split(x, y):\n\n # Need the starting entropy so we can measure improvement...\n start_entropy = calculate_entropy(y)\n\n # Best thus far, initialised to a dud that will be replaced immediately...\n best = {'infogain': -np.inf}\n\n # Randomly allocate the splits to be traversed (without replacement)\n feature_total = x.shape[1]\n feature_subset_count = int(np.sqrt(feature_total))\n feature_subset = np.random.permutation(feature_total)[:feature_subset_count]\n\n # Loop every possible split of every feature...\n for feature_index in feature_subset:\n for split in np.unique(x[:, feature_index]):\n\n left_indices = []\n right_indices = []\n\n # Get index of rows where x[row_index,feature_index] <= split\n for row_index,row in enumerate(x):\n left_indices.append(row_index) if x[row_index,feature_index] <= split else right_indices.append(row_index)\n\n left_ys = y[left_indices]\n right_ys = y[right_indices]\n\n nleft = len(left_ys)\n nright = len(right_ys)\n ntotal = nleft + nright\n infogain = start_entropy - (nleft / ntotal) * calculate_entropy(left_ys) - (\n nright / ntotal) * calculate_entropy(right_ys)\n\n if infogain > best['infogain']:\n best = {'feature': feature_index,\n 'split': split,\n 'infogain': infogain,\n 'left_indices': left_indices,\n 'right_indices': right_indices}\n return best","def possible_splits(self,feature,y):\n\n yi = y[:-1]\n yi1= y[1:]\n idx=np.argwhere((yi1-yi)!=0)\n return idx.flatten()","def split(self,best):\n\t\treturn self.cu_for_split(best,False)","def get_min_across_splits_continuous(\n arr: np.ndarray, y: np.ndarray, splits: np.ndarray, eval_func: Callable\n ):\n n = len(splits)\n if n > 500:\n # If many split points, use some threading\n with multiprocessing.Pool(processes=8) as p:\n # Get evaluation scores across all the splits\n post_split_evals = dict(\n zip(\n range(len(splits)),\n p.starmap(\n BaseTree.get_split_goodness_fit_continuous,\n zip([arr] * n, [y] * n, splits, [eval_func] * n),\n ),\n )\n )\n p.close()\n else:\n # If not too many split points, get scores across all splits\n post_split_evals = dict(\n zip(\n range(len(splits)),\n map(\n lambda x: BaseTree.get_split_goodness_fit_continuous(*x),\n zip([arr] * n, [y] * n, splits, [eval_func] * n),\n ),\n )\n )\n # Get the minimum split based on gain ratio\n min_eval = min(\n post_split_evals,\n key=lambda x: pipe(\n post_split_evals.get(x),\n lambda results: results[0] / results[1], # entropy / intrinsic value\n ),\n )\n\n # Return the best split and the splits scores\n return (splits[min_eval], *post_split_evals.get(min_eval))","def get_optimal_discrete_feature_split(\n self, X: np.ndarray, y: np.ndarray, feature_col: int\n ):\n return BaseTree.get_discrete_split_value(\n X[:, feature_col], y, eval_func=self.eval_func\n )","def pred_from_split(X, y, col_idx, split_value): \n col = X[:,col_idx]\n idx_n1, idx_n2 = col <= split_value, col > split_value\n node1_y, node2_y = y[idx_n1], y[idx_n2]\n \n node1_c1, node1_c2 = sum(node1_y == 0), sum(node1_y == 1)\n node2_c1, node2_c2 = sum(node2_y == 0), sum(node2_y == 1)\n \n if node1_c1 == node1_c2:\n right_pred = 0 if node2_c1 > node2_c2 else 1\n left_pred = 1 - right_pred\n \n elif node2_c1 == node2_c2:\n left_pred = 0 if node1_c1 > node2_c2 else 1\n right_pred = 1 - left_pred\n \n else:\n left_pred = 0 if node1_c1 > node2_c2 else 1\n right_pred = 0 if node2_c1 > node2_c2 else 1\n \n return (left_pred, right_pred)","def getSplit(self):\n b_index, b_value, b_score, b_groups = 999, 999, 999, None\n for j in range(len(self[0]) - 1):\n for i in range(len(self)):\n groups = self.splitAttribute(j, self[i][j]) # lit, big\n gini = self.giniIndex(groups)\n if gini < b_score and (j, \"%.1f\" % self[i][j]) not in self.atr:\n b_index, b_value, b_score, b_groups = j, self[i][\n j], gini, groups\n return b_index, b_value, b_groups, b_score","def calcGiniSplitBySplitValue(self, data, structure, colIndex, splitValue):\n dataBellow = list(filter(lambda x: float(x[colIndex]) <= splitValue, data))\n dataAbove = list(filter(lambda x: float(x[colIndex]) > splitValue, data))\n giniSplit = (len(dataBellow) / len(data)) * self.calcDataGini(dataBellow, structure) +\\\n (len(dataAbove) / len(data)) * self.calcDataGini(dataAbove, structure)\n return round(giniSplit, 3)","def split(self, X, y, feature_array):\n n, p = X.shape\n\n best_gain = 0\n best_split_point = 0\n best_feature_id = -1\n for feature_id in feature_array:\n cur_gain, cur_split_point = self.find_best_split(\n X[:, feature_id], y)\n if cur_gain > best_gain - self.eps:\n best_gain = cur_gain\n best_split_point = cur_split_point\n best_feature_id = feature_id\n\n assert(best_feature_id != -1)\n\n x = X[:, best_feature_id]\n left_index = x < best_split_point\n right_index = x >= best_split_point\n\n self.split_id = best_feature_id\n self.split_val = best_split_point\n\n return (left_index, right_index)","def fit(self, col):\n self.find_max_min(col)","def _bestFeat2split(dataSet, impurity_crit, min_impurity_decrease, min_samples_split):\n\t\tm, n = dataSet.shape\n\t\tbestFeatInd, bestVal = None, DecisionTree._make_leaf(dataSet, impurity_crit)\n\n\t\tif m < min_samples_split or len(set(dataSet[:,-1])) == 1:\n\t\t\treturn bestFeatInd, bestVal\n\n\t\timpurity = m * impurity_crit(dataSet)\n\t\tmin_impurity = np.inf\n\t\t\n\n\t\tfor feat_ind in range(n-1):\n\t\t\tif type(dataSet[:, feat_ind][0]) != str:\n\t\t\t\tuniqVal = set(dataSet[:, feat_ind])\n\t\t\telse:\n\t\t\t\tuniqVal = map(set, subsets(list(dataSet[:, feat_ind])))\n\t\t\tfor val in uniqVal:\n\t\t\t\tD1, D2 = DecisionTree._binarySplit(dataSet, feat_ind, val)\n\t\t\t\tif len(D1) < min_samples_split or len(D2) < min_samples_split:\n\t\t\t\t\tcontinue\n\t\t\t\tnew_impurity = len(D1)*impurity_crit(D1) + len(D2)*impurity_crit(D2)\n\t\t\t\tif impurity - new_impurity < min_impurity_decrease:\n\t\t\t\t\tcontinue\n\t\t\t\tif new_impurity < min_impurity:\n\t\t\t\t\tmin_impurity = new_impurity\n\t\t\t\t\tbestFeatInd = feat_ind; bestVal = val\n\t\treturn bestFeatInd, bestVal","def find_split(data):\n ret = {\"router\": None, \"split_point\": None, \"entropy\": get_entropy(data[:, 7])}\n\n # Create array of unique datapoints\n split_points_list = list()\n\n for i in range(data.shape[1] - 1):\n unique_signal = np.unique(data[:, i])\n split_points = list()\n for j in range(len(unique_signal) - 1):\n split_points.append((unique_signal[j]+unique_signal[j+1])/2)\n split_points_list.append(split_points)\n\n # Split data by split points and calculate entropy\n for feature in range(len(split_points_list)):\n for i in range(len(split_points_list[feature])):\n data_l, data_r = split_data(data, feature + 1, split_points_list[feature][i])\n entropy = get_entropy(data_l[:, 7], data_r[:, 7])\n if entropy < ret[\"entropy\"]:\n ret[\"entropy\"] = entropy\n ret[\"router\"] = feature + 1\n ret[\"split_point\"] = split_points_list[feature][i]\n\n return ret[\"router\"], ret[\"split_point\"], split_data(data, ret[\"router\"], ret[\"split_point\"])","def _find_split(self, X, y, n_features):\r\n splits_info = []\r\n\r\n # Select features to consider\r\n features = self._feature_selection.get_features(n_features, self._feature_prob)\r\n\r\n # Get candidate splits\r\n for feature_id in features:\r\n for split_value in compute_split_values(X[:, feature_id]):\r\n splits_info.append(\r\n compute_split_info(self._split_criterion, X, y, feature_id, split_value, self._min_samples_leaf))\r\n\r\n splits = []\r\n for split_info in splits_info:\r\n if split_info is not None:\r\n gain, feature_id, split_value = split_info\r\n split = Split(feature_id, value=split_value, gain=gain)\r\n splits.append(split)\r\n else:\r\n continue\r\n\r\n selected_split = self._split_chooser.get_split(splits)\r\n return selected_split","def get_optimal_discrete_feature_split (\n self, feature_matrix: np.ndarray, target_array: np.ndarray, feature_column: int\n ):\n return BaseTree.get_discrete_split_value (\n feature_matrix [ :, feature_column ], target_array, evaluate_function = self.evaluate_function\n ) # End get_optimal_discrete_feature_split","def compute_splits(feature_df, target_col, max_num_splits):\n tree_estimator = DecisionTreeClassifier(max_leaf_nodes=max_num_splits+1,\n class_weight='balanced',\n random_state=1407)\n\n tree_estimator.fit(feature_df, target_col)\n thresholds = tree_estimator.tree_.threshold[tree_estimator.tree_.children_left != _tree.TREE_LEAF]\n return sorted(thresholds)","def _optimal_splits (self, split_axis):\n n = len(self.displays)\n size = self.screen.get_size()\n # sizes in directions of first/second split\n s1 = size[split_axis]\n s2 = size[not split_axis]\n ratio = self.ratio\n # use screen aspect ratio if no preferred one given\n if ratio is None:\n ratio = float(size[0]) / size[1]\n error = []\n for splits in xrange(1, n + 1):\n # maximal number of displays per row/column\n per_split = ceil(float(n) / splits)\n # minimise unused space (as a fraction of the screen)\n space_e = abs(1 - float(n) / (splits * per_split))\n # and ratio (we care about proportionality, so use log)\n disp_ratio = float(s1 * splits) / (s2 * per_split)\n if split_axis == 1:\n # inverted if splitting into columns\n disp_ratio = 1 / disp_ratio\n ratio_e = abs(log(disp_ratio / ratio))\n # adjust using some constants\n e = space_e + ratio_e\n error.append((e, splits))\n return min(error)","def potential_splits(self, potential_xj):\r\n \r\n self.cur.execute(\"SELECT DISTINCT \" + potential_xj + \" FROM \" + self.table_name + \";\")\r\n potential_splits = [ii[0] for ii in self.cur.fetchall()]\r\n return potential_splits","def find_split(self, X, Y):\n split_col = np.random.randint(X.shape[1])\n return split_col, np.median(X[:,split_col])","def title_based_split(df, split_val):\n # retrieve split title and get the minimum id with that title\n split_title = df['title'].iloc[int(split_val * len(df)) - 1]\n split_index = df[df['title'] == split_title].index.min()\n return df.iloc[:split_index], df.iloc[split_index:]","def _compute_best_split_and_push(self, node):\n\n node.split_info = self.splitter.find_node_split(\n node.sample_indices, node.histograms, node.sum_gradients,\n node.sum_hessians)\n\n if node.split_info.gain <= 0: # no valid split\n self._finalize_leaf(node)\n else:\n heappush(self.splittable_nodes, node)","def pick_best_split(self,db,labels,ids,features=None):\n idlabels = [labels[id] for id in ids]\n if misclassification_error(idlabels) == 0:\n #base case: no misclassifications\n self.type = 'v'\n self.value = idlabels[0]\n return 0\n best = None\n bestCost = 0\n splitval = None\n discrete = True\n if features == None:\n if len(ids) < db.numFeatures():\n #look at all present features in the training set\n features = db.getPresentFeatures(ids)\n #print len(features),\"of\",db.numFeatures(),\"features selected\"\n else:\n features = range(db.numFeatures())\n elif callable(features):\n features = features()\n for i in features:\n if len(db.entryLists[i]) == 0: continue\n idiscrete = db.discreteFeature[i]\n if idiscrete:\n #count number of labels of a certain value\n splitter = defaultdict(lambda:defaultdict(int))\n #count of labels for missing values\n nmissing = defaultdict(int)\n for id in ids:\n val = db[i,id]\n if val is None:\n #missing values go down to all splits\n nmissing[labels[id]] += 1\n continue\n splitter[val][labels[id]] += 1\n if len(splitter) > continuous_variable_threshold:\n #print \"Determined to be a continuous variable\"\n idiscrete = False\n break\n if idiscrete:\n if len(splitter) <= 1:\n #only a single value\n continue\n #count number of missing values in all splits\n cmax = 0\n for k in splitter:\n for l,v in nmissing.iteritems():\n splitter[k][l] += v\n cmax = max(cmax,sum(splitter[k].values()))\n #shrink by fraction of (# of ids - largest child)/(# of ids)\n scale = (1.0-float(cmax)/float(len(ids)))*len(splitter)\n #evaluate cost\n cost = split_cost(splitter.values())*scale\n #print \"Split on\",i,\"information gain\",-cost,splitter.values()\n else:\n #continuous, need to learn the best split\n vals = []\n presentlabels = []\n nonelabels = []\n for id in ids:\n val = db[i,id]\n if val is None:\n nonelabels.append(labels[id])\n continue\n vals.append(val)\n presentlabels.append(labels[id])\n if len(vals) <= 1:\n print \"No values for feature\",i,\"?\"\n print vals\n continue\n #print \"Considering continuous split on\",i\n s,cost = best_split(vals,presentlabels,nonelabels)\n scale = (1.0-float(len(presentlabels)/2+len(nonelabels))/float(len(ids)))*2\n cost *= scale\n #print \"Result\",s,\"Information gain\",-cost\n \n if cost < bestCost:\n best = i\n bestCost = cost\n discrete = idiscrete\n if not idiscrete:\n splitval = s\n \n if best is None:\n self.type = 'v'\n if len(ids) > 0:\n self.value = vote(idlabels)\n return misclassification_error(idlabels)\n else:\n self.value = None\n return 0\n else:\n self.feature = best\n #discrete or inequality split\n if discrete:\n self.type = 's'\n else:\n self.type = 'i'\n self.value = splitval\n return bestCost","def get_min_across_splits_continuous (\n feature_array: np.ndarray, target_array: np.ndarray, splits: np.ndarray, evaluate_function: Callable\n ):\n n = len ( splits )\n if n > 500:\n # If many split points, use some threading\n with multiprocessing.Pool ( processes = 8 ) as p:\n # Get evaluation scores across all the splits\n post_split_evals = dict (\n zip (\n range ( len ( splits ) ),\n p.starmap (\n BaseTree.get_split_goodness_fit_continuous,\n zip ( [ feature_array] * n, [ target_array ] * n, splits, [ evaluate_function ] * n ),\n ),\n )\n )\n p.close()\n else:\n # If not too many split points, get scores across all splits\n post_split_evals = dict (\n zip (\n range ( len ( splits ) ),\n map (\n lambda x: BaseTree.get_split_goodness_fit_continuous ( * x ),\n zip ( [ feature_array ] * n, [ target_array ] * n, splits, [ evaluate_function ] * n ),\n ),\n )\n )\n # Get the minimum split based on gain ratio\n min_eval = min (\n post_split_evals,\n key = lambda x: pipe (\n post_split_evals.get ( x ),\n lambda results: results [ 0 ] / results [ 1 ], # entropy / intrinsic value\n ),\n )\n\n # Return the best split and the splits scores\n return ( splits [ min_eval ], * post_split_evals.get ( min_eval ) )\n # End get_min_across_splits_continuous()","def __get_split_feature(self, data_set, target_feature, tree_features):\n\n if self.__criterion == 'entropy':\n feature_gains = {feature: self.__gain(data_set, feature, target_feature) for (feature) in tree_features}\n split_feature = max(feature_gains, key=feature_gains.get)\n return split_feature\n elif self.__criterion == 'gini':\n feature_ginis = {feature: self.__gini(data_set, feature, target_feature) for (feature) in tree_features}\n split_feature = min(feature_ginis, key=feature_ginis.get)\n return split_feature\n # TODO: I should check this (gini index).","def choose_best_split(self, X_subset, y_subset):\n # YOUR CODE HERE\n feature_index = None\n threshold = None\n best_G = np.inf\n N = len(X_subset)\n \n for current_feature in range(X_subset.shape[1]):\n thresholds = np.unique(X_subset[:, current_feature])\n \n for t in thresholds:\n y_left, y_right = self.make_split_only_y(current_feature, t, X_subset, y_subset)\n H_L = self.H(y_left)\n H_R = self.H(y_right)\n \n G = (len(y_left) / N) * H_L + (len(y_right) / N) * H_R\n \n if G < best_G:\n best_G = G\n feature_index = current_feature\n threshold = t\n \n return feature_index, threshold","def get_best_split(rows: list) -> (float, Question):\n best_info_gain = 0\n best_question = None\n current_uncertainty = get_gini_impurity(rows)\n\n # minus 1 because we're ignoring the last column which is the label.\n n_attributes = len(rows[0]) - 1\n\n for col in range(n_attributes):\n\n # get all unique values for an attribute/column\n unique_values = set([row[col] for row in rows])\n\n for value in unique_values:\n question = Question(col, value)\n\n # Split rows depending on the question\n true_rows, false_rows = partition(rows, question)\n\n # We don't want to partition such rows\n if len(true_rows) == 0 or len(false_rows) == 0:\n continue\n\n # Get info gain from this split\n info_gain = get_info_gain(false_rows, true_rows, current_uncertainty)\n\n if info_gain > best_info_gain:\n best_info_gain, best_question = info_gain, question\n\n return best_info_gain, best_question","def _split_threshold(self, node):\n\n # define the score to improve upon\n if self.n_clusters >= self.min_leaves and node.size <= self.max_leaf_size:\n # split only if min(children scores) > node.score\n force_split = False\n best_score = node.score\n else:\n # force split: just take the best (even if children are worse)\n force_split = True\n best_score = None\n\n left, right = None, None\n\n # iterate over embedding dimensions (first ones are more reliable)\n # up to max_n_vec (included), until we found an improving split\n for _vec in range(self.n_vec):\n\n # get the candidate thresholds along this dimension\n threshs = self._get_candidate_thresholds(node, _vec)\n\n # look for an improving best split along this eigenvector\n for _t in threshs:\n # compute the split\n below_thresh = self.E[node.ids, _vec] < _t\n _lids = node.ids[below_thresh]\n _rids = node.ids[np.logical_not(below_thresh)]\n # check if the tubes are not too small\n _nl, _nr = len(_lids), len(_rids)\n is_valid = _nl >= self.min_leaf_size and _nr >= self.min_leaf_size\n if is_valid:\n # compute the score of the new tubes only\n _sl = self.get_tube_score(_lids)\n _sr = self.get_tube_score(_rids)\n # get the score of this split\n split_score = min(_sl, _sr)\n if best_score is None or split_score > best_score:\n # better split\n best_score = split_score\n node.has_children = True\n node.thresh = _t\n left = SpectralNode(\n _lids, _vec, score=_sl, name=node.name + \"0\")\n right = SpectralNode(\n _rids, _vec, score=_sr, name=node.name + \"1\")\n\n # check stopping criterion\n if node.has_children:\n # we found an improving split\n if _vec > 0 or not force_split:\n # found an improving non-forced split: stop here\n break\n\n return left, right","def best_split(values,labels,nonelabels=None):\n assert len(values) >= 2\n assert len(values) == len(labels)\n N = len(values)\n ilist = sorted((v,l) for (v,l) in zip(values,labels))\n leftcount = defaultdict(int)\n rightcount = defaultdict(int)\n for v,l in ilist:\n rightcount[l] += 1\n bestindex = -1\n bestcost = split_cost([leftcount,rightcount])\n\n cost = bestcost\n #costs = [cost]\n #print \"Split costs:\"\n for i in xrange(len(ilist)):\n v,l = ilist[i]\n rightcount[l] -= 1\n leftcount[l] += 1\n if i+1 >= len(ilist) or v == ilist[i+1][0]:\n #no splits when v is equal to the next value\n continue\n cost = split_cost([leftcount,rightcount])\n #print \" \",v,leftcount.values(),rightcount.values(),cost\n #costs.append(cost)\n if cost < bestcost:\n bestcost = cost\n bestindex = i\n #raw_input()\n if bestindex < 0:\n #no split found... try splitting in half\n splitval = (ilist[0][0]+ilist[-1][0])*0.5\n else:\n splitval = (ilist[bestindex][0] + ilist[bestindex+1][0])*0.5\n if nonelabels is None:\n return (splitval,bestcost)\n #reevaluate counts\n leftcount = defaultdict(int)\n rightcount = defaultdict(int)\n for l in nonelabels:\n leftcount[l] += 1\n rightcount[l] += 1\n for v,l in ilist:\n if v <= splitval:\n leftcount[l] += 1\n else:\n rightcount[l] += 1\n return splitval,split_cost([leftcount,rightcount])","def get_cluster_to_split(clusters):\n\treturn max(clusters.items(), key=lambda x: x[1].get_distortion())[1]","def minimum_spanning_arborescence(sol):","def getBestSplitsInDataByInfoGain(self, data, structure, colName, numOfSplits):\n splitsList, newSplitsList = {}, []\n self.fillBestSplitsInDataByInfoGainIntoDict(data, structure, colName, numOfSplits, splitsList, 0)\n for lists in list(splitsList.values())[1:]:\n while len(lists) > 0:\n splitOne, splitTwo = [], []\n if len(lists) > 0:\n splitOne = lists.pop()\n if len(lists) > 0:\n splitTwo = lists.pop()\n if splitOne and splitTwo:\n if splitOne[1] >= splitTwo[1]:\n newSplitsList.append(splitOne[0])\n newSplitsList.append(splitTwo[0])\n else:\n newSplitsList.append(splitTwo[0])\n newSplitsList.append(splitOne[0])\n elif splitOne:\n newSplitsList.append(splitOne[0])\n elif splitTwo:\n newSplitsList.append(splitTwo[0])\n\n newSplitsList.insert(0, splitsList['0'][0][0])\n self.removeDuplicatesInList(newSplitsList)\n return newSplitsList[0:numOfSplits]","def detect_splits(self):\n logg.info(' abstracted graph will have {} nodes'.format(self.n_splits+1))\n indices_all = np.arange(self.X.shape[0], dtype=int)\n segs = [indices_all]\n if False: # this is safe, but not compatible with on-the-fly computation\n tips_all = np.array(np.unravel_index(np.argmax(self.Dchosen), self.Dchosen.shape))\n else:\n if self.iroot is not None:\n tip_0 = np.argmax(self.Dchosen[self.iroot])\n else:\n tip_0 = np.argmax(self.Dchosen[0]) # just a random index, here fixed to \"0\"\n tips_all = np.array([tip_0, np.argmax(self.Dchosen[tip_0])])\n # we keep a list of the tips of each segment\n segs_tips = [tips_all]\n if self.clusters_precomputed_names:\n self.segs_names_original = [', '.join(self.clusters_precomputed_names)]\n segs_undecided = [True]\n segs_adjacency = [[]]\n segs_distances = np.zeros((1, 1))\n segs_adjacency_nodes = [{}]\n # logg.info(' do not consider groups with less than {} points for splitting'\n # .format(self.min_group_size))\n for ibranch in range(self.n_splits):\n if self.clusters == 'unconstrained_segments':\n iseg, new_tips = self.select_segment(segs, segs_tips, segs_undecided)\n if iseg == -1:\n logg.info('... partitioning converged')\n break\n logg.info('... branching {}:'.format(ibranch + 1),\n 'split group', iseg)\n segs_distances = self.do_split(segs, segs_tips,\n segs_undecided,\n segs_adjacency,\n segs_distances,\n iseg, new_tips)\n else:\n logg.msg(' split', ibranch + 1, v=4)\n stop, segs_distances = self.do_split_constrained(segs, segs_tips,\n segs_adjacency,\n segs_adjacency_nodes,\n segs_distances)\n if stop: break\n\n # segments\n self.segs = segs\n self.segs_tips = segs_tips\n self.segs_sizes = []\n for iseg, seg in enumerate(self.segs): self.segs_sizes.append(len(seg))\n\n # the full, unscaled adjacency matrix\n self.segs_adjacency_full_attachedness = 1/segs_distances\n # if self.attachedness_measure == 'connectedness':\n # norm = np.sqrt(np.multiply.outer(self.segs_sizes, self.segs_sizes))\n # self.segs_adjacency_full_attachedness /= norm\n self.segs_adjacency_full_confidence, self.segs_adjacency_tree_confidence \\\n = self.compute_adjacency_confidence(\n self.segs_adjacency_full_attachedness,\n segs_adjacency,\n self.tree_based_confidence)\n np.fill_diagonal(self.segs_adjacency_full_attachedness, 0)","def get_splits(self):\n\t\treturn self.k","def _best_split(cls, X, y):\n n = X.shape[0]\n num_feature = X.shape[1]\n y_types = np.unique(y)\n\n # initialize\n min_score = float(n)\n feature_idx = None\n best_theta = None\n best_idx = None\n\n for feature_idx in xrange(num_feature):\n # counter for y\n cumulate_y = Counter()\n rest_y = Counter()\n for y_type in y_types:\n cnt = np.where(y == y_type)[0].shape[0]\n rest_y[y_type] = cnt\n\n # sorted data\n sorted_idx = np.argsort(X[:, feature_idx])\n sorted_X = np.copy(X)\n sorted_y = np.copy(y)\n sorted_X = sorted_X[sorted_idx]\n sorted_y = sorted_y[sorted_idx]\n #print \"_best_split:\", sorted_X.shape, sorted_y.shape\n\n for idx in xrange(n-1):\n theta = (sorted_X[idx, feature_idx] + sorted_X[idx + 1, feature_idx]) / 2\n y_label = sorted_y[idx]\n cumulate_y[y_label] += 1\n rest_y[y_label] -= 1\n left_cnt = sum(cumulate_y.values())\n right_cnt = sum(rest_y.values())\n w_1 = left_cnt * cls._gini_index(cumulate_y.values())\n w_2 = right_cnt * cls._gini_index(rest_y.values())\n score = w_1 + w_2\n if score < min_score:\n min_score = score\n best_theta = theta\n best_idx = feature_idx\n #print('new min score: %.3f' % score)\n #print('feature: %d, theta: %.3f' % (best_idx, best_theta))\n #print('left: %d, right: %d' % (left_cnt, right_cnt))\n print('feature: %d, theta: %.3f' % (best_idx, best_theta))\n return (best_idx, best_theta)","def _best_split(cls, X, y):\n n = X.shape[0]\n num_feature = X.shape[1]\n y_types = np.unique(y)\n\n # initialize\n min_score = float(n)\n feature_idx = None\n best_theta = None\n best_idx = None\n\n for feature_idx in xrange(num_feature):\n # counter for y\n cumulate_y = Counter()\n rest_y = Counter()\n for y_type in y_types:\n cnt = np.where(y == y_type)[0].shape[0]\n rest_y[y_type] = cnt\n\n # sorted data\n sorted_idx = np.argsort(X[:, feature_idx])\n sorted_X = np.copy(X)\n sorted_y = np.copy(y)\n sorted_X = sorted_X[sorted_idx]\n sorted_y = sorted_y[sorted_idx]\n #print \"_best_split:\", sorted_X.shape, sorted_y.shape\n\n for idx in xrange(n-1):\n theta = (sorted_X[idx, feature_idx] + sorted_X[idx + 1, feature_idx]) / 2\n y_label = sorted_y[idx]\n cumulate_y[y_label] += 1\n rest_y[y_label] -= 1\n left_cnt = sum(cumulate_y.values())\n right_cnt = sum(rest_y.values())\n w_1 = left_cnt * cls._gini_index(cumulate_y.values())\n w_2 = right_cnt * cls._gini_index(rest_y.values())\n score = w_1 + w_2\n if score < min_score:\n min_score = score\n best_theta = theta\n best_idx = feature_idx\n #print('new min score: %.3f' % score)\n #print('feature: %d, theta: %.3f' % (best_idx, best_theta))\n #print('left: %d, right: %d' % (left_cnt, right_cnt))\n print('feature: %d, theta: %.3f' % (best_idx, best_theta))\n return (best_idx, best_theta)","def entropyWithBestSplit(attr, X, y):\n df = X[attr]\n maxVal = df.max()\n minVal = df.min()\n\n # Square root decomposition\n r = math.ceil(math.sqrt(maxVal - minVal))\n entropyVal = float('inf')\n splitAt = -1\n\n iterNum = 0\n while r > MIN_BIN_SIZE and iterNum < MAX_ITER:\n iterNum += 1\n i = minVal\n while i < maxVal:\n leftSplit = df[df < i].index.tolist()\n rightSplit = df[df >= i].index.tolist()\n buff_entropy = entropy(df, leftSplit) *\\\n (len(leftSplit) / (len(leftSplit) + len(rightSplit)))\n buff_entropy += entropy(df, rightSplit) *\\\n (len(rightSplit) / (len(leftSplit) + len(rightSplit)))\n if entropyVal >= buff_entropy:\n entropyVal = buff_entropy\n splitAt = i\n i += r\n minVal = min([splitAt - r, minVal])\n maxVal = max([splitAt + r, maxVal])\n r_buff = math.ceil(math.sqrt(maxVal - minVal))\n if r_buff >= r:\n break\n else:\n r = r_buff\n finalIdxLists = [\n df[df < splitAt].index.tolist(),\n df[df >= splitAt].index.tolist()\n ]\n return [splitAt], finalIdxLists, entropyVal","def splitData(df, split):\n train = df.iloc[:int(len(df)*split)]\n test = df.iloc[int(len(df)*split):]\n \n return train, test","def split(self,X,y=None):\n all_idx = pd.Series(np.arange(X.shape[0])) \n mbrg = int(X.shape[0]*self.embargo_pct)\n test_starts=[(i[0],i[-1]+1) for i in np.array_split(all_idx.values,self.n_splits)]\n for i, j in test_starts:\n t0 = all_idx.index[i] # start of test set\n test_indices = all_idx.values[i:j]\n maxT1Idx = all_idx.index.searchsorted(all_idx[test_indices].max())\n train_indices = all_idx.index.searchsorted(all_idx[all_idx<=t0].index)\n if maxT1Idx < X.shape[0]: \n train_indices=np.concatenate((train_indices,all_idx[maxT1Idx+mbrg:]))\n yield train_indices,test_indices","def best_cat_brute_force_split(self, ind, dep):\n split = Split(None, None, None, None, 0)\n all_dep = np.unique(dep.arr)\n for i, ind_var in enumerate(ind):\n ind_var = ind_var.deep_copy()\n unique = np.unique(ind_var.arr)\n\n freq = {}\n if dep.weights is None:\n for col in unique:\n counts = np.unique(np.compress(ind_var.arr == col, dep.arr), return_counts=True)\n freq[col] = cl.defaultdict(int)\n freq[col].update(np.transpose(counts))\n else:\n for col in unique:\n counts = np.unique(np.compress(ind_var.arr == col, dep.arr), return_counts=True)\n freq[col] = cl.defaultdict(int)\n for dep_v in all_dep:\n freq[col][dep_v] = dep.weights[(ind_var.arr == col) * (dep.arr == dep_v)].sum()\n\n if len(list(ind_var.possible_groupings())) == 0:\n split.invalid_reason = InvalidSplitReason.PURE_NODE\n\n choice, highest_p_join, split_chi, dof = None, None, None, None\n for comb in ind_var.all_combinations():\n freqs = [ sum( [ cl.Counter(freq[key]) for key in c ], cl.Counter()) for c in comb ]\n\n if sum([ (sum(x.values()) < self.min_child_node_size) for x in freqs ] ) > 0:\n continue\n keys = set(sum([ list(f.keys()) for f in freqs ], []))\n\n n_ij = np.array(\n [ [ col.get(k, 0) for k in keys ] for col in freqs ]\n )\n\n chi, p_split, dof = chisquare(n_ij, dep.weights is not None)\n\n if (choice is None or p_split < highest_p_join or (p_split == highest_p_join and chi > split_chi)) and p_split < self.alpha_merge:\n choice, highest_p_join, split_chi = comb, p_split, chi\n\n temp_split = Split(i, choice, split_chi, highest_p_join, dof, split_name=ind_var.name)\n better_split = (not split.valid() or p_split < split.p or (p_split == split.p and chi > split.score)) and choice is not None\n if better_split: split, temp_split = temp_split, split\n\n if split.valid() and choice is not None:\n chi_threshold = self.split_threshold * split.score\n\n if temp_split.valid() and temp_split.score >= chi_threshold:\n for sur in temp_split.surrogates:\n if sur.column_id != i and sur.score >= chi_threshold:\n split.surrogates.append(sur)\n\n temp_split.surrogates = []\n split.surrogates.append(temp_split)\n\n split.sub_split_values(ind[split.column_id].metadata)\n\n return split","def getListWithBestValueSplitsOfDataByGini(self, data, structure, colIndex, numOfSplits):\n splitsList, newSplitsList = {}, []\n self.fillDictWithBestValueSplitsOfDataByGini(data, structure, colIndex, numOfSplits, splitsList, 0)\n for lists in list(splitsList.values())[1:]:\n while len(lists) > 0:\n splitOne, splitTwo = [], []\n if len(lists) > 0:\n splitOne = lists.pop()\n if len(lists) > 0:\n splitTwo = lists.pop()\n if splitOne and splitTwo:\n if splitOne[1] <= splitTwo[1]:\n newSplitsList.append(splitOne[0])\n newSplitsList.append(splitTwo[0])\n else:\n newSplitsList.append(splitTwo[0])\n newSplitsList.append(splitOne[0])\n elif splitOne:\n newSplitsList.append(splitOne[0])\n elif splitTwo:\n newSplitsList.append(splitTwo[0])\n\n newSplitsList.insert(0, splitsList['0'][0][0])\n self.removeDuplicatesInList(newSplitsList)\n return newSplitsList[0:numOfSplits]","def getSplits(df, train_size, val_size, test_size, seed=None):\n size = len(df)\n\n # size is considered a percentage if less than 1:\n train_size = int(train_size * size) if train_size < 1 else train_size\n val_size = int(val_size * size) if val_size < 1 else val_size\n test_size = int(test_size * size) if test_size < 1 else test_size\n\n if not seed is None:\n np.random.seed(seed)\n\n train_val_idx = np.random.choice(\n a=range(size),\n size=train_size + val_size,\n replace=False\n )\n train_idx = train_val_idx[:train_size]\n val_idx = train_val_idx[train_size:]\n\n train = df.iloc[train_idx]\n val = df.iloc[val_idx]\n test = df.drop(train.index).drop(val.index) # test is equal to the leftover\n\n assert len(train) + len(val) + len(test) == len(df)\n\n return train, val, test","def split ( self, y, X = None ):\n # Make sure y is an array\n y = np.array ( y ) if isinstance ( y, list ) else y\n\n # Groupby y and add integer indices.\n df_with_split = (\n pd.DataFrame ( { \"y\": y, \"index\": np.arange ( len ( y ) ) } )\n .groupby ( \"y\" ) [ \"index\" ]\n .apply ( self.add_split_col ) # Add col for split for instance\n )\n\n # For each fold, get train and test indices (based on col for split)\n for cv_split in np.arange ( self.number_of_folds - 1, -1, -1 ):\n train_bool = df_with_split [ \"split\" ] != cv_split\n test_bool = ~ train_bool\n # Yield index values of not cv_split and cv_split for train, test\n yield df_with_split [ \"index\" ].values [ train_bool.values ], df_with_split [\n \"index\"\n ].values [ test_bool.values ]\n # End split()","def split_data(data, feature, split_point):\n data_l = data[data[:, feature - 1] < split_point]\n data_r = data[data[:, feature - 1] >= split_point]\n\n return data_l, data_r","def min_parts():\n # you must replace this with your own value\n return -1","def get_split_goodness_fit_continuous(\n arr: np.ndarray, y: np.ndarray, split: float, eval_func: Callable\n ):\n # Get above and below the split value\n above = arr >= split\n below = arr < split\n\n # get weighted average eval_func on the splits\n n_above = np.sum(above)\n above_eval = (\n eval_func(y[above]) * n_above / len(y)\n ) # weight = frac points in above\n below_eval = (\n eval_func(y[below]) * (len(y) - n_above) / len(y)\n ) # weight = frac points not in above\n\n # returns weighted sum of eval_func across splits, and the gain ratio denominator\n return (\n above_eval + below_eval,\n -1\n * sum(\n map(\n lambda x: x * np.log(x),\n [n_above / len(y), (len(y) - n_above) / len(y)],\n )\n ),\n )","def select_randomly(self, val_split: float, test_split: float) -> {str: int}:\n\n def _select(start, n, label) -> int:\n \"\"\"\n Label all columns in [start, start+n) with label.\n \"\"\"\n n_selected = 0\n for i in range(start, int(start + n)):\n x = self._x_positions[i]\n n_selected += self._cols[x].mark_as(label)\n return n_selected\n\n def _remove_overlaps(start, end) -> int:\n \"\"\"\n Remove unlabelled columns in [start-col_width, end+col_width].\n \"\"\"\n start = self._x_positions[start % self.n_cols]\n end = self._x_positions[int(end) % self.n_cols]\n n_removed = 0\n for x, col in self._cols.items():\n if start - self.col_width <= x <= start or end <= x <= end + self.col_width:\n if col.label is None:\n n_removed += col.mark_as('ignore')\n return n_removed\n\n def _next_unlabelled_col(x):\n \"\"\"\n Return index of first unlabelled column after x.\n \"\"\"\n for i in range(self.n_cols):\n idx = (x + i) % self.n_cols\n x_current = self._x_positions[idx]\n if self._cols[x_current].label is None:\n return idx\n\n # When computing number of columns per split we must take into account\n # that some columns will be removed, i.e. we want to compute the split\n # sizes as fraction of the number of actual selected columns, not of\n # the total number of columns.\n delta_x = self._x_positions[1] - self._x_positions[0]\n n_to_remove_per_split = self.col_width / delta_x\n # * 2 because 2 gaps between 3 splits\n n_to_keep = self.n_cols - n_to_remove_per_split * 2\n n_val = round(n_to_keep * val_split)\n n_test = round(n_to_keep * test_split)\n n_train = n_to_keep - n_val - n_test\n\n n_selected_crops_per_split = dict.fromkeys(['training', 'validation', 'test', 'ignore'], 0)\n\n # Place patches in arbitrary order\n start = 0\n for n, label in random.sample(list(zip([n_train, n_val, n_test], ['training', 'validation', 'test'])), k=3):\n # Mark patch\n n_selected_crops_per_split[label] += _select(start, n, label)\n # Remove columns overlapping this patch\n n_selected_crops_per_split['ignore'] += _remove_overlaps(start, start + n - 1)\n # Next patch starts at next unlabelled column\n start = _next_unlabelled_col(start)\n\n return n_selected_crops_per_split","def _compute_split_boundaries(split_probs, n_items):\n if len(split_probs) > n_items:\n raise ValueError(\n 'Not enough items for the splits. There are {splits} '\n 'splits while there are only {items} items'.format(\n splits=len(split_probs), items=n_items\n )\n )\n total_probs = sum(p for name, p in split_probs)\n if abs(1 - total_probs) > 1e-8:\n raise ValueError('Probs should sum up to 1. probs={}'.format(split_probs))\n split_boundaries = []\n sum_p = 0.0\n for name, p in split_probs:\n prev = sum_p\n sum_p += p\n split_boundaries.append((name, int(prev * n_items), int(sum_p * n_items)))\n\n # Guard against rounding errors.\n split_boundaries[-1] = (\n split_boundaries[-1][0],\n split_boundaries[-1][1],\n n_items,\n )\n\n return split_boundaries","def _split_branch(self,t,em):\n\n max_t = t[np.argmax(em)]\n return t[t<=max_t],em[t<=max_t],t[t>max_t],em[t>max_t]","def __find_best_split_in_feature(self, feature_and_class):\n\n # sort the feature and class and use changes in the class to reduce\n # number of potential split info gain calculations\n sorted_data = feature_and_class[\n feature_and_class[:, 0].astype(np.int).argsort()]\n potential_splits = self.__find_integers_with_class_change(sorted_data)\n info_gains = self.__info_gain_from_splits(potential_splits,\n sorted_data)\n\n # returning nothing in no information gains are found\n if len(info_gains) == 0:\n return None, None\n\n index = info_gains.index(max(info_gains))\n return info_gains[index], potential_splits[index]","def calcGainRatioSplitByColumn(self, data, structure, colIName):\n splitInfo, colIndex = 0, structure[colIName]['index']\n for value in structure[colIName]['values']:\n newData = list(filter(lambda x: x[colIndex] == value, data))\n p = len(newData) / len(data) if len(newData) != 0 else 1\n splitInfo += (-1) * p * log2(p)\n splitInfo = 1 if splitInfo == 0 else splitInfo\n return round(self.calcInfoGainByColumnSplit(data, structure, colIName) / splitInfo, 3)","def best_cutoff(self,\n split_label):\n split_args = self.sub_split_args[split_label]\n split_data = self.sub_split_data[split_label]\n # This criterion for the use_scipy flag is arbitrary and needs\n # further testing\n n_unique = len(np.unique(split_data[~np.isnan(split_data)]))\n use_scipy = True\n if n_unique > len(split_data)/1000:\n use_scipy = False\n idxcut_below, effects_below, rstats_below, ndata_below =\\\n self.u_data(split_label, use_scipy=use_scipy)\n idxcut_above, effects_above, rstats_above, ndata_above =\\\n self.u_data(split_label, above=True, use_scipy=use_scipy)\n\n # Default cutoff is min(split_data) - 1\n cutoff = split_data[split_args[0]] - 1\n value = 0\n # If no cutoff was possible\n if len(idxcut_below) == 0 or len(idxcut_above) == 0:\n return cutoff, value\n\n # All idx_cutoffs and values for cutoffs, for debugging\n for idx in range(len(idxcut_above)):\n idxcut = idxcut_above[idx]\n if idxcut != idxcut_below[idx]:\n raise NameError('Code error, invalid split')\n value_temp = (abs(effects_above[idx] -\n effects_below[idx]) *\n rstats_above[idx] *\n rstats_below[idx] *\n min(ndata_above[idx]) *\n min(ndata_below[idx]))\n if value_temp > value:\n cutoff = (split_data[split_args[int(idxcut)]] +\n split_data[split_args[int(idxcut)+1]])/2\n value = value_temp\n return cutoff, value","def segment_bf(seq, score_func):\n maxsc = float('-inf') # necessary for log prob\n bestseg = None\n for seg in segment_r(seq):\n score = sum([score_func(w) for w in seg]) # np.prod([score_func(w) for w in seg])\n if score > maxsc:\n bestseg = seg\n maxsc = score\n return maxsc, bestseg","def find_large_separation2(self):\n\n ind = (self.modes['l'] == 0).flat\n n = self.modes['n'].compress(ind)\n if (len(n) < 2): return np.nan\n freq = self.modes['freq'].compress(ind)\n coeff = np.polyfit(n,freq,1)\n return coeff[0]","def load_partition_1d(counts, n_dom, split_fac):\n count_sums = np.cumsum(counts)\n # If we split at n+1, how many points on left and right?\n ptsL = count_sums[1:].astype(np.float64)\n ptsR = np.empty_like(ptsL)\n ptsR[:] = count_sums[-1] \n ptsR[1:] -= count_sums[:-2]\n\n\n # Best split of domains (+/- 1)\n left0 = np.clip(((n_dom * ptsL)/(ptsL+ptsR)).astype(np.int32), 1, n_dom-1)\n right0 = n_dom-left0\n\n left1 = np.minimum(left0+1,n_dom-1)\n right1 = n_dom-left1\n\n # whats the worst (left/right) load balance?\n p_per_proc0 = np.maximum((1+split_fac*np.log(left0))*ptsL/left0, (1+split_fac*np.log(right0))*ptsR/right0)\n p_per_proc1 = np.maximum((1+split_fac*np.log(left1))*ptsL/left1, (1+split_fac*np.log(right1))*ptsR/right1)\n\n idx_min0 = np.argmin(p_per_proc0)\n idx_min1 = np.argmin(p_per_proc1)\n \n if p_per_proc0[idx_min0] < p_per_proc1[idx_min1]:\n split = idx_min0\n n_left = left0[idx_min0]\n pval = p_per_proc0[idx_min0]\n else:\n split = idx_min1\n n_left = left1[idx_min1]\n pval = p_per_proc1[idx_min1]\n\n if split==0 or split==len(counts)-2:\n raise Exception('Tried to make a domain of pure ghosts. Something bad happened?')\n\n\n return split, n_left, pval","def random_splittable_value(self, variable: int) -> Any:\n #print(\"enter bartpy/bartpy/data.py CovariateMatrix random_splittable_value\")\n \n if variable not in self.splittable_variables():\n raise NoSplittableVariableException()\n max_value = self.max_value_of_column(variable)\n candidate = np.random.choice(self.get_column(variable))\n while candidate == max_value:\n candidate = np.random.choice(self.get_column(variable))\n #print(\"-exit bartpy/bartpy/data.py CovariateMatrix random_splittable_value\")\n return candidate","def greedy_split(arr, n, axis=0):\n length = arr.shape[axis]\n # compute the size of each of the first n-1 blocks\n block_size = int(np.ceil(length / float(n)))\n # the indices at which the splits will occur\n ix = np.arange(block_size, length, block_size)\n return np.array(np.split(arr, ix, axis))","def find_shape(items: int):\n for columns in range(1, MAX_COLUMNS + 1):\n if columns / math.ceil(items / columns) >= MIN_RATIO:\n return math.ceil(items / columns), columns\n return math.ceil(items / MAX_COLUMNS), MAX_COLUMNS","def best_B(Ag):\n top = 0\n for i in range(len(Ag)):\n etop = np.min(cf.TD20[int(Ag[i]) - 1])\n top += etop\n return top","def class_split(x):\r\n return np.split(x, [19,43])","def best_split(self, X, y, attributes):\n if (self.criterion==\"information_gain\"):\n global_if = float('-inf') # the highest value of information gain/gini gain seen so far\n attr = None\n for attribute in attributes:\n attr_val = X[attribute].copy()\n cur_if = information_gain(y,attr_val,self.type)\n if (cur_if>global_if):\n # Update when a better split is receieved\n global_if = cur_if\n attr = attribute\n return attr\n else:\n global_if = float('inf')\n attr = None\n for attribute in attributes:\n attr_val = X[attribute].copy()\n cur_if = gini_gain(y,attr_val)\n if (global_if>cur_if):\n # Update when a better split is receieved\n global_if = cur_if\n attr = attribute\n return attr","def splitbylo(self,lo):\n ind=np.where(self.lo==lo)[0]\n self.splitbyind(ind)","def _get_best_level_for_downsample(downsample, arr):\n L = np.array(arr)\n diff = np.absolute(L-downsample)\n index = np.argmin(diff)\n return index","def split_workload(workload):\n diff = sum(workload)\n minimum = abs(diff), 0\n for i, work in enumerate(workload, 1):\n diff -= 2 * work\n current = abs(diff), i\n if current < minimum:\n minimum = current\n return (None, None) if minimum == (0, 0) else minimum[::-1]","def choose_split(data,treshold):\n n_features = len(data[0]) - 1 # number of columns\n quest_gain = [] # keep track of the gains and questions\n\n for col in range(1,n_features): # for each feature\n values = set([row[col] for row in data]) # unique values in the column\n for val in values: # for each value\n question = Question(col, val)\n \n # try splitting the dataset\n true_rows, false_rows = partition(data, question)\n\n # Skip this split if it doesn't divide the dataset.\n if len(true_rows) == 0 or len(false_rows) == 0:\n continue\n\n # Calculate the information gain from this split\n gain = info_gain(data, true_rows, false_rows)\n quest_gain.append(Question_gain(gain,question))\n\n possible_question = [] # possible questions to ask\n n_quest_gain = len(quest_gain)\n\n if n_quest_gain == 0:\n return float('Inf'), float('NaN') #\n\n for x in range(n_quest_gain):\n if (quest_gain[x].gain >= treshold):\n possible_question.append(Question_gain(quest_gain[x].gain,quest_gain[x].question))\n \n n_possible_question = len(possible_question)\n if n_possible_question == 0:\n return float('Inf'), float('NaN')\n\n if n_possible_question>=2:\n [i, j] = random.sample(range(0, n_possible_question), 2)\n else:\n i = j = random.randint(0,n_possible_question-1)\n\n if possible_question[i].gain>=possible_question[j].gain:\n return possible_question[i].gain, possible_question[i].question\n else:\n return possible_question[j].gain, possible_question[j].question","def get_bucket_boundaries(feature):\n return np.unique(np.percentile(feature, range(0, 100))).tolist()","def get_partition_boundaries(cls, session: Session):\n rows = session.execute(\"select pg_class.relname, pg_get_expr(pg_class.relpartbound, pg_class.oid, true) from pg_class where relname SIMILAR TO 'peptides_[0-9]{3}';\").fetchall()\n num_regex = re.compile(r\"\\d+\")\n partition_boundaries = []\n for row in rows:\n matches = re.findall(num_regex, row[1])\n partition_boundaries.append((row[0], int(matches[0]), int(matches[1])))\n return partition_boundaries","def choose_optimal_image_split(im, method='im_size', min_tile_size=360000):\n \n n_cores = os.cpu_count()\n # number of segmented objects, drop the background value\n n_obj = np.unique(im).size - 1\n \n if method == 'im_size':\n # avoid too many splits if image is not so big\n im_size = im.nbytes # slightly different from sys.getsizeof(im)\n # max power of 2\n max_i = int(np.log2(n_cores)) + 1\n n_splits = 1\n for i in range(1, max_i):\n new_split = 2**i\n if im_size / new_split >= min_tile_size:\n n_splits = new_split\n else:\n break\n elif method == 'naive':\n n_splits = n_cores\n \n return n_splits","def split_data_set(data_set, index, value, part=0):\n # save the subdataset\n res_data_set = []\n \n for entry in data_set:\n # find the data set to the left of the partition point\n if part == 0 and float(entry[index])<= value: #求划分点左侧的数据集\n reduced_entry = entry[:index]\n # after partitioning, the value of the index column in the data is removed\n reduced_entry.extend(entry[index + 1:]) \n res_data_set.append(reduced_entry)\n # find the data set to the right of the partition point\n if part ==1 and float(entry[index])> value: \n reduced_entry = entry[:index]\n reduced_entry.extend(entry[index + 1:])\n res_data_set.append(reduced_entry)\n return res_data_set","def lowest_rank_approx(A,e):","def split_next(self):\n # Consider the node with the highest loss reduction (a.k.a. gain)\n node = heappop(self.splittable_nodes)\n\n tic = time()\n (sample_indices_left,\n sample_indices_right,\n right_child_pos) = self.splitter.split_indices(node.split_info,\n node.sample_indices)\n self.total_apply_split_time += time() - tic\n\n depth = node.depth + 1\n n_leaf_nodes = len(self.finalized_leaves) + len(self.splittable_nodes)\n n_leaf_nodes += 2\n\n left_child_node = TreeNode(depth,\n sample_indices_left,\n node.split_info.sum_gradient_left,\n node.split_info.sum_hessian_left,\n parent=node)\n right_child_node = TreeNode(depth,\n sample_indices_right,\n node.split_info.sum_gradient_right,\n node.split_info.sum_hessian_right,\n parent=node)\n left_child_node.sibling = right_child_node\n right_child_node.sibling = left_child_node\n node.right_child = right_child_node\n node.left_child = left_child_node\n\n # set start and stop indices\n left_child_node.partition_start = node.partition_start\n left_child_node.partition_stop = node.partition_start + right_child_pos\n right_child_node.partition_start = left_child_node.partition_stop\n right_child_node.partition_stop = node.partition_stop\n\n self.n_nodes += 2\n\n if self.max_depth is not None and depth == self.max_depth:\n self._finalize_leaf(left_child_node)\n self._finalize_leaf(right_child_node)\n return left_child_node, right_child_node\n\n if (self.max_leaf_nodes is not None\n and n_leaf_nodes == self.max_leaf_nodes):\n self._finalize_leaf(left_child_node)\n self._finalize_leaf(right_child_node)\n self._finalize_splittable_nodes()\n return left_child_node, right_child_node\n\n if left_child_node.n_samples < self.min_samples_leaf * 2:\n self._finalize_leaf(left_child_node)\n if right_child_node.n_samples < self.min_samples_leaf * 2:\n self._finalize_leaf(right_child_node)\n\n # Compute histograms of childs, and compute their best possible split\n # (if needed)\n should_split_left = left_child_node.value is None # node isn't a leaf\n should_split_right = right_child_node.value is None\n if should_split_left or should_split_right:\n\n # We will compute the histograms of both nodes even if one of them\n # is a leaf, since computing the second histogram is very cheap\n # (using histogram subtraction).\n n_samples_left = left_child_node.sample_indices.shape[0]\n n_samples_right = right_child_node.sample_indices.shape[0]\n if n_samples_left < n_samples_right:\n smallest_child = left_child_node\n largest_child = right_child_node\n else:\n smallest_child = right_child_node\n largest_child = left_child_node\n\n # We use the brute O(n_samples) method on the child that has the\n # smallest number of samples, and the subtraction trick O(n_bins)\n # on the other one.\n tic = time()\n smallest_child.histograms = \\\n self.histogram_builder.compute_histograms_brute(\n smallest_child.sample_indices)\n largest_child.histograms = \\\n self.histogram_builder.compute_histograms_subtraction(\n node.histograms, smallest_child.histograms)\n self.total_compute_hist_time += time() - tic\n\n tic = time()\n if should_split_left:\n self._compute_best_split_and_push(left_child_node)\n if should_split_right:\n self._compute_best_split_and_push(right_child_node)\n self.total_find_split_time += time() - tic\n\n return left_child_node, right_child_node","def get_n_splits(self):\n pass","def near_split(x, num_bins=None, size_bins=None):\n if num_bins:\n quotient, remainder = divmod(x, num_bins)\n return [quotient + 1] * remainder + [quotient] * (num_bins - remainder)\n elif size_bins:\n return near_split(x, num_bins=int(np.ceil(x / size_bins)))","def near_split(x, num_bins=None, size_bins=None):\n if num_bins:\n quotient, remainder = divmod(x, num_bins)\n return [quotient + 1] * remainder + [quotient] * (num_bins - remainder)\n elif size_bins:\n return near_split(x, num_bins=int(np.ceil(x / size_bins)))","def get_n_splits(self):\n return self.n_folds","def segment_top_k(x, I, ratio):\n rt = tf.RaggedTensor.from_value_rowids(x, I)\n row_lengths = rt.row_lengths()\n dense = rt.to_tensor(default_value=-np.inf)\n indices = tf.cast(tf.argsort(dense, direction=\"DESCENDING\"), tf.int64)\n row_starts = tf.cast(rt.row_starts(), tf.int64)\n indices = indices + tf.expand_dims(row_starts, 1)\n row_lengths = tf.cast(\n tf.math.ceil(ratio * tf.cast(row_lengths, tf.float32)), tf.int32\n )\n return tf.RaggedTensor.from_tensor(indices, row_lengths).values","def get_x_limits(line, line_header, column_header):\n if not my_strcomp(line_header, line.content):\n return None\n else:\n words_line = line_header.split(\" \")\n words_column = column_header.split(\" \")\n for i in range(len(words_line) - len(words_column) + 1):\n start = i\n end = i + len(words_column) - 1\n if words_column == words_line[start:end + 1]:\n if start == 0:\n x_min = 0\n else:\n # x_min is the initial x of the first word of the column_header (left-aligned)\n x_min = line.word_boxes[start].position[0][0]\n\n # x_min is the initial x of the first word of the column_header (left-aligned)\n x_min = 0.5 * (line.word_boxes[start].position[0][0] +\n line.word_boxes[start - 1].position[1][0])\n\n if end >= len(words_line) - 1:\n x_max = 99999\n else:\n # x_max is the initial x of the first word AFTER the column_header (left-aligned)\n x_max = line.word_boxes[end + 1].position[0][0]\n\n # x_max is the average of the final of the current word and the initial x of the first word AFTER the column_header (left-aligned)\n x_max = 0.5 * (line.word_boxes[end + 1].position[0][0] +\n line.word_boxes[end].position[1][0])\n\n return x_min, x_max","def _split_forced(self, node):\n # compute the split\n _vec = 0\n sorted_idxs = np.argsort(self.E[node.ids, _vec]).squeeze()\n n = len(sorted_idxs) // 2\n _lids = node.ids[sorted_idxs[:n]]\n _rids = node.ids[sorted_idxs[n:]]\n # compute the score of the new tubes only\n _sl = self.get_tube_score(_lids)\n _sr = self.get_tube_score(_rids)\n # register the split\n node.has_children = True\n node.thresh = np.median(self.E[node.ids, _vec]) # arbitrary\n # Note: median would not ensure equal size (because of duplicate values)\n left = SpectralNode(_lids, _vec, score=_sl, name=node.name + \"0\")\n right = SpectralNode(_rids, _vec, score=_sr, name=node.name + \"1\")\n\n return left, right","def best_split(self):\n sub_group = []\n\n current_entropy = self.entropy(self._Passengers)\n best_gain = 0 # holds the best entropy difference so far\n best_split = self._Attr[0].get_name()\n relative_entropy = 0 # entropy while taking account for the size of the population\n\n for Attribute in self._Attr:\n relative_entropy = 0\n print(\"Attr considered: \" + Attribute.get_name())\n for Attr_option in Attribute.get_options():\n sub_group = []\n for Passenger in self._Passengers:\n if self.passenger_attr_option_check(Passenger,\n Attribute.get_name(),\n Attr_option): # if P.A = V\n sub_group.append(Passenger)\n if len(sub_group) > 0 and len(self._Passengers) > 0:\n relative_entropy += self.entropy(sub_group) * (len(sub_group)/len(self._Passengers))\n\n if current_entropy - relative_entropy > best_gain:\n best_gain = current_entropy - relative_entropy\n best_split = Attribute.get_name()\n\n print(f\"best split:{best_split} \\n with entropy gain of:\\n {best_gain}\")\n\n return best_split","def getKSplits(df, n_splits, seed = None):\n\n result = []\n\n # None random seed is same as not setting it\n df_shuffled = df.sample(len(df), random_state = seed)\n\n fold_size = int(len(df) / n_splits)\n\n for i in range(n_splits):\n if i == n_splits - 1: # last iteration\n df_fold = df_shuffled[fold_size * (i): len(df)] # gets remainder\n else:\n df_fold = df_shuffled[fold_size * (i):fold_size * (i + 1) ] # python starts indexing at 0\n result.append(df_fold)\n\n return result"],"string":"[\n \"def get_optimal_continuous_feature_split(\\n self, X: np.ndarray, y: np.ndarray, feature_col: int\\n ):\\n midpoints = BaseTree.get_valid_midpoints(arr=X[:, feature_col], y=y)\\n # If midpoints, get the best one\\n if len(midpoints) > 0:\\n return BaseTree.get_min_across_splits_continuous(\\n arr=X[:, feature_col], y=y, splits=midpoints, eval_func=self.eval_func\\n )\\n\\n # If no split points, return inf (can't split here)\\n return (0, np.inf, 1)\",\n \"def get_split(self,X,y):\\n \\n BEST_COL = 0\\n BEST_SPLIT =0\\n BEST_IMPUR = 99\\n for i,feature in enumerate(X.T):\\n arg_sort=np.argsort(feature) #Sort the feature for optimizing the find of splitting points\\n feature= feature[arg_sort]\\n y_sort = y[arg_sort]\\n splits = self.possible_splits(feature,y_sort) #Get \\n\\n impur,splits = self.test_split(feature,y_sort,splits) #Get impurity for splitting points\\n best_idx = np.argmin(impur)\\n best_impur = impur[best_idx]\\n \\n if best_impur==0.0: #Found perfect split, terminate\\n return(i,splits[best_idx])\\n elif best_impur<BEST_IMPUR:\\n BEST_IMPUR=best_impur\\n BEST_SPLIT=splits[best_idx]\\n BEST_COL=i\\n return (BEST_COL,BEST_SPLIT)\",\n \"def determine_best_split(data, potential_splits, mltask):\\n\\n first_iteration = True\\n for column_index in potential_splits:\\n for value in potential_splits[column_index]:\\n data_below,data_above = split_data(data, column_index, value)\\n \\n if mltask == 'regression':\\n current_overall_metric = calculate_overall_metric(data_below, data_above, metric_function = calculate_mse)\\n \\n # classification\\n else:\\n current_overall_metric = calculate_overall_metric(data_below, data_above, metric_function = calculate_entropy)\\n \\n \\n if first_iteration or current_overall_metric <= best_overall_metric:\\n first_iteration = False\\n \\n best_overall_metric = current_overall_metric\\n best_split_column = column_index\\n best_split_value = value\\n \\n \\n return best_split_column,best_split_value\",\n \"def get_best_split_all(x, y) -> Tuple[int, float, float]:\\n m = x.shape[1]\\n col_best_gin = np.ones(shape=m)\\n col_best_val = np.ones(shape=m)\\n for c in range(m):\\n best = 1\\n best_x = 0\\n for i in np.unique(x[:, c]):\\n gini = Tree.split(x[:, c], y, i)\\n if gini < best:\\n best = gini\\n best_x = i\\n col_best_gin[c] = best\\n col_best_val[c] = best_x\\n\\n # Select best feature to split on\\n col_idx = np.argmin(col_best_gin)\\n # Convert to bool index\\n col_idx = np.array(range(x.shape[1])) == col_idx\\n\\n return col_idx, col_best_val[col_idx], col_best_gin[col_idx]\",\n \"def get_split(data):\\n \\\"\\\"\\\" gets the best feature, and best value \\\"\\\"\\\"\\n\\n best_feature = None\\n best_value = 0.0\\n columns = data.columns\\n gini_base = gini_impurity(data)\\n n_rows = len(data.index) # total number of rows of data before split\\n\\n # Fininding which split yields the best gini gain\\n max_gain = 0\\n\\n for i in range(len(columns)-1): # -1 b.c. class is final column\\n xs = data[columns[i]].unique() # get values to test\\n for x in xs: # test values\\n # split dataset\\n df_left = data[data[columns[i]] < x]\\n df_right = data[data[columns[i]] >= x]\\n\\n # get gini impurities\\n gini_left = gini_impurity(df_left)\\n gini_right = gini_impurity(df_right)\\n \\n\\n # Calculated weighted gini impurity\\n w_left = len(df_left.index) / n_rows\\n w_right = len(df_right.index) / n_rows\\n\\n w_gini = gini_left * w_left + gini_right * w_right\\n \\n\\n # Calculate gini gain (we want to minimize w_gini for the smallest impurity. Ideal split is perfect Left=c1, Right=c2)\\n # why not just find min w_gin instead of uding gini_gain and gini_base vaiables?\\n gini_gain = gini_base - w_gini\\n\\n # check if this is the best split so far, store values, update max_gini\\n if gini_gain > max_gain:\\n best_feature = columns[i]\\n best_value = x\\n max_gain = gini_gain\\n\\n df_left = data.loc[data[best_feature] < best_value]\\n df_right = data.loc[data[best_feature] >= best_value]\\n \\n\\n return best_feature, best_value, df_left, df_right\",\n \"def findBestValueSplitByGini(self, data, structure, colIndex):\\n minGini, bestSplit = 1, []\\n for i in range(0, len(data)-1):\\n split = (float(data[i][colIndex]) + float(data[i+1][colIndex])) / 2\\n giniSplit = self.calcGiniSplitBySplitValue(data, structure, colIndex, split)\\n if giniSplit <= minGini:\\n minGini = giniSplit\\n bestSplit = [split, giniSplit]\\n return bestSplit\",\n \"def findBestColumnSplitByGini(self, data, structure):\\n minGini, bestSplit = 1, None\\n for colName in list(structure.keys())[:-1]:\\n giniSplit = self.calcGiniSplitByColumn(data, structure, colName)\\n if giniSplit <= minGini:\\n minGini = giniSplit\\n bestSplit = colName\\n return bestSplit\",\n \"def findBestColumnSplitByGainRatio(self, data, structure):\\n maxGainRatio, bestSplit = 0, None\\n for colName in list(structure.keys())[:-1]:\\n GainRatio = self.calcGainRatioSplitByColumn(data, structure, colName)\\n if GainRatio >= maxGainRatio:\\n maxGainRatio = GainRatio\\n bestSplit = colName\\n return bestSplit\",\n \"def find_splits(col):\\n unique = np.unique(sorted(col))\\n splits = np.array([np.mean([unique[i], unique[i+1]]) for i in range(len(unique)-1)])\\n return splits\",\n \"def get_best_split(rows):\\n best_gain = 0\\n best_question = None\\n current_impurity = get_gini(rows)\\n n_features = len(rows[0])\\n\\n for col in range(n_features):\\n\\n for row in rows:\\n question = Question(col, row[col])\\n true_rows, false_rows = partition(rows, question)\\n\\n if len(true_rows) == 0 or len(false_rows) == 0:\\n break\\n\\n question_gain = get_info_gain(true_rows, false_rows, current_impurity)\\n\\n if question_gain >= best_gain:\\n best_gain = question_gain\\n best_question = question\\n\\n print(best_gain)\\n print(best_question)\\n return best_gain, best_question\",\n \"def find_best_split(rows):\\n best_gain = 0 # keep track of the best information gain\\n best_question = None # keep train of the feature / value that produced it\\n current_uncertainty = gini(rows)\\n n_features = len(rows[0]) - 1 # number of columns\\n #print(\\\"n_features:\\\", n_features)\\n\\n for col in range(1,n_features): # for each feature\\n # for each iteration this is the set of all values of a specific column, eg, All pixels number 0\\n values = set([row[col] for row in rows]) # unique values in the column\\n for val in values: # for each value\\n\\n # Create a question object for each val under a column, holding the val and the col number\\n question = Question(col, val)\\n\\n # try splitting the dataset\\n true_rows, false_rows = partition(rows, question)\\n\\n # Skip this split if it doesn't divide the\\n # dataset.\\n if len(true_rows) == 0 or len(false_rows) == 0:\\n continue\\n\\n # Calculate the information gain from this split\\n gain = info_gain(true_rows, false_rows, current_uncertainty)\\n\\n # You actually can use '>' instead of '>=' here\\n # but I wanted the tree to look a certain way for our\\n # toy dataset.\\n if gain >= best_gain:\\n best_gain, best_question = gain, question\\n\\n return best_gain, best_question\",\n \"def find_best_split(self, x, y):\\n\\n # check cornor case: all same x\\n n = y.size\\n\\n if all(x == x[0]):\\n return (0, amin(x) - self.eps)\\n\\n sort_index = argsort(x)\\n x_sorted = x[sort_index]\\n y_sorted = y[sort_index]\\n\\n # build potential split index array\\n split_index_array = array([i for i in range(1, n)\\n if x_sorted[i] != x_sorted[i - 1]\\n and y_sorted[i] != y_sorted[i - 1]])\\n\\n # split_index_array = linspace(\\n # 0, y.size, num=min(5, ceil(n / 5)), endpoint=False, dtype='int')\\n # split_index_array = split_index_array[1:]\\n\\n best_split_index = 0\\n best_gain = 0\\n h_x = self.cur_entropy\\n\\n for split_index in split_index_array:\\n left_entropy = self.entropy(y_sorted[:split_index])\\n right_entropy = self.entropy(y_sorted[split_index:])\\n h_xy = (split_index * left_entropy +\\n (n - split_index) * right_entropy) / n\\n cur_gain = h_x - h_xy\\n\\n if cur_gain > best_gain:\\n best_gain = cur_gain\\n best_split_index = split_index\\n\\n if best_split_index != 0:\\n best_split_point = (x_sorted[best_split_index] +\\n x_sorted[best_split_index - 1]) / 2\\n else:\\n best_split_point = x_sorted[best_split_index] - self.eps\\n\\n return (best_gain, best_split_point)\",\n \"def __find_best_split(self, x, y):\\n data = np.transpose(np.vstack((np.transpose(x), y)))\\n num_features = data.shape[1] - 1\\n\\n # initialise splitting rule components\\n integer_splitting_rule = None\\n feature_index_to_split = None\\n max_info_gain = 0\\n\\n # iterate over all the features and find best splits within these\\n for feature in range(num_features):\\n info_gain, split_int = self.__find_best_split_in_feature(\\n data[:, [feature, -1]])\\n if info_gain is None:\\n continue\\n # update max info gain so far as it iterates over features\\n if info_gain > max_info_gain:\\n max_info_gain = info_gain\\n feature_index_to_split = feature\\n integer_splitting_rule = int(split_int)\\n\\n return feature_index_to_split, integer_splitting_rule\",\n \"def findBestColumnSplitByInfoGain(self, data, structure):\\n maxInfoGain, bestSplit = 0, None\\n for colName in list(structure.keys())[:-1]:\\n infoGain = self.calcInfoGainByColumnSplit(data, structure, colName)\\n if infoGain >= maxInfoGain:\\n maxInfoGain = infoGain\\n bestSplit = colName\\n return bestSplit\",\n \"def split_data(data,split_column,split_value):\\n split_column_value = data[:,split_column]\\n type_of_feature = FEATURE_TYPE[split_column]\\n\\n if type_of_feature == 'continuous':\\n data_below = data[split_column_value <= split_value]\\n data_above = data[split_column_value > split_value]\\n else:\\n data_below = data[split_column_value == split_value]\\n data_above = data[split_column_value != split_value]\\n return data_below,data_above\",\n \"def findBestSplitInDataByInfoGain(self, data, structure, colName):\\n colIndex, maxInfoGain, bestSplit = structure[colName]['index'], 0, []\\n for i in range(0, len(data)-1):\\n split = (float(data[i][colIndex]) + float(data[i+1][colIndex])) / 2\\n infoGain = self.calcInfoGainBySplitValue(data, structure, colName, split)\\n if infoGain >= maxInfoGain:\\n bestSplit = [split, infoGain]\\n maxInfoGain = infoGain\\n return bestSplit\",\n \"def get_next_split ( self, feature_matrix: np.ndarray, target_array: np.ndarray, tree_split: TreeSplits):\\n # If only 1 y value, make a leaf node\\n if len ( set ( target_array ) ) == 1:\\n tree_split.updateTreeValues (\\n feature_column = None,\\n feature_value = None,\\n node_type = None,\\n nodes = {},\\n children = target_array,\\n )\\n return tree_split\\n\\n # Get the presplit entropy\\n presplit_entropy = self.evaluate_function ( target_array )\\n\\n column_values = {}\\n for k, v in self.map_column_node_type.items():\\n # If there's only one value in feature matrix \\\"X\\\", set the split value to infinity\\n if len ( set ( feature_matrix [ :, k ] ) ) == 1:\\n value = np.inf\\n split = None\\n class_ratios = 1\\n elif v == \\\"continuous\\\":\\n # Get the best possible continuous split for the column\\n split, value, class_ratios = self.get_optimal_continuous_feature_split (\\n feature_matrix = feature_matrix, target_array = target_array, feature_column = k\\n )\\n else:\\n # Get the split value for the discrete column\\n value, class_ratios = self.get_optimal_discrete_feature_split (\\n feature_matrix = feature_matrix, target_array = target_array, feature_column = k\\n )\\n split = None\\n\\n column_values [ k ] = ( split, value, class_ratios )\\n\\n # Get the column with the largest gain ratio\\n col_idx_with_min_value = max (\\n column_values,\\n key = lambda x: ( presplit_entropy - column_values.get ( x ) [ 1 ] )\\n / column_values.get ( x ) [ 2 ],\\n )\\n\\n # If stopping criteria are met or all splits are infinite, terminate the process\\n if (\\n self.early_stopping_comparison (\\n column_values.get ( col_idx_with_min_value ) [ 1 ], self.early_stopping_value\\n )\\n ) or not np.isfinite ( column_values.get ( col_idx_with_min_value ) [ 1 ] ):\\n self.get_terminal_node (\\n feature_column = col_idx_with_min_value,\\n feature_value = column_values [ col_idx_with_min_value ] [ 0 ],\\n node = tree_split,\\n feature_matrix = feature_matrix ,\\n target_array = target_array,\\n )\\n return tree_split\\n\\n # If the best split is continuous, add a continuous node\\n if self.map_column_node_type.get ( col_idx_with_min_value ) == \\\"continuous\\\":\\n return self.get_continuous_node (\\n feature_column = col_idx_with_min_value,\\n feature_value = column_values [col_idx_with_min_value ] [ 0 ],\\n feature_matrix = feature_matrix,\\n target_array = target_array,\\n node = tree_split,\\n )\\n\\n # Otherwise, add a discrete node.\\n else:\\n return self.get_discrete_node (\\n feature_matrix = feature_matrix,\\n target_array = target_array,\\n feature_value = column_values [ col_idx_with_min_value ] [ 0 ],\\n feature_column = col_idx_with_min_value,\\n node = tree_split,\\n )\\n # End get_next_split\",\n \"def get_possible_splits( df , attribute ):\\n ds = df.loc[:,attribute]\\n \\n # First sort the values \\n ds = ds.sort_values().drop_duplicates()\\n \\n # Compute averages of consecutive values \\n ds = ds.rolling(2).sum().divide(2)\\n splits = ds[1:].tolist()\\n \\n # return the possible splits \\n return splits\",\n \"def best_split(self):\\r\\n best_splits = [[0, None, None]]\\r\\n impurity, best_S, best_xj = 0, None, None\\r\\n \\r\\n for xj in self.x_names:\\r\\n for S in self.potential_splits(xj):\\r\\n ir = float(self.impurity_reduction(xj, S))\\r\\n if ir > impurity:\\r\\n impurity, best_S, best_xj = ir, S, xj\\r\\n best_splits.append([S, xj])\\r\\n else: \\r\\n pass\\r\\n \\r\\n return best_S, best_xj\",\n \"def getSplitFunc(self, splitType):\\n if splitType.upper() == \\\"INFO GAIN\\\":\\n return self.findBestColumnSplitByInfoGain\\n elif splitType.upper() == \\\"GAIN RATIO\\\":\\n return self.findBestColumnSplitByGainRatio\\n elif splitType.upper() == \\\"GINI INDEX\\\":\\n return self.findBestColumnSplitByGini\\n return None\",\n \"def find_split(self, X, y):\\n choices = y.size\\n if choices <= 1:\\n return None, None\\n\\n # find the number of each option in the current node.\\n options_parent = [np.sum(y == c) for c in range(self.num_outcomes)]\\n\\n # find the gini of current node.\\n best_gini = 1.0 - sum((n / choices) ** 2 for n in options_parent)\\n best_idx, best_split = None, None\\n\\n # loop through the features to get splits and options.\\n for idx in range(self.num_features):\\n splits, options = zip(*sorted(zip(X[:, idx], y)))\\n\\n num_left = [0] * self.num_outcomes\\n num_right = options_parent.copy()\\n for i in range(1, choices):\\n c = options[i - 1]\\n num_left[c] += 1\\n num_right[c] -= 1\\n gini_left = 1.0 - sum(\\n (num_left[x] / i) ** 2 for x in range(self.num_outcomes)\\n )\\n gini_right = 1.0 - sum(\\n (num_right[x] / i) ** 2 for x in range(self.num_outcomes)\\n )\\n\\n gini = (i * gini_left + (choices - i) * gini_right) / choices\\n\\n if splits[i] == splits[i - 1]:\\n continue\\n\\n if gini < best_gini:\\n best_gini = gini\\n best_idx = idx\\n best_split = (splits[i] + splits[i - 1]) / 2\\n\\n return best_idx, best_split\",\n \"def calcGiniSplitByColumn(self, data, structure, colIName):\\n colIndex, giniSplit = structure[colIName]['index'], 0\\n for value in structure[colIName][\\\"values\\\"]:\\n newData = list(filter(lambda x: x[colIndex] == value, data))\\n p = len(newData) / len(data)\\n giniSplit += self.calcDataGini(newData, structure) * p\\n return round(giniSplit, 3)\",\n \"def find_split(x, y):\\n\\n # Need the starting entropy so we can measure improvement...\\n start_entropy = calculate_entropy(y)\\n\\n # Best thus far, initialised to a dud that will be replaced immediately...\\n best = {'infogain': -np.inf}\\n\\n # Randomly allocate the splits to be traversed (without replacement)\\n feature_total = x.shape[1]\\n feature_subset_count = int(np.sqrt(feature_total))\\n feature_subset = np.random.permutation(feature_total)[:feature_subset_count]\\n\\n # Loop every possible split of every feature...\\n for feature_index in feature_subset:\\n for split in np.unique(x[:, feature_index]):\\n\\n left_indices = []\\n right_indices = []\\n\\n # Get index of rows where x[row_index,feature_index] <= split\\n for row_index,row in enumerate(x):\\n left_indices.append(row_index) if x[row_index,feature_index] <= split else right_indices.append(row_index)\\n\\n left_ys = y[left_indices]\\n right_ys = y[right_indices]\\n\\n nleft = len(left_ys)\\n nright = len(right_ys)\\n ntotal = nleft + nright\\n infogain = start_entropy - (nleft / ntotal) * calculate_entropy(left_ys) - (\\n nright / ntotal) * calculate_entropy(right_ys)\\n\\n if infogain > best['infogain']:\\n best = {'feature': feature_index,\\n 'split': split,\\n 'infogain': infogain,\\n 'left_indices': left_indices,\\n 'right_indices': right_indices}\\n return best\",\n \"def possible_splits(self,feature,y):\\n\\n yi = y[:-1]\\n yi1= y[1:]\\n idx=np.argwhere((yi1-yi)!=0)\\n return idx.flatten()\",\n \"def split(self,best):\\n\\t\\treturn self.cu_for_split(best,False)\",\n \"def get_min_across_splits_continuous(\\n arr: np.ndarray, y: np.ndarray, splits: np.ndarray, eval_func: Callable\\n ):\\n n = len(splits)\\n if n > 500:\\n # If many split points, use some threading\\n with multiprocessing.Pool(processes=8) as p:\\n # Get evaluation scores across all the splits\\n post_split_evals = dict(\\n zip(\\n range(len(splits)),\\n p.starmap(\\n BaseTree.get_split_goodness_fit_continuous,\\n zip([arr] * n, [y] * n, splits, [eval_func] * n),\\n ),\\n )\\n )\\n p.close()\\n else:\\n # If not too many split points, get scores across all splits\\n post_split_evals = dict(\\n zip(\\n range(len(splits)),\\n map(\\n lambda x: BaseTree.get_split_goodness_fit_continuous(*x),\\n zip([arr] * n, [y] * n, splits, [eval_func] * n),\\n ),\\n )\\n )\\n # Get the minimum split based on gain ratio\\n min_eval = min(\\n post_split_evals,\\n key=lambda x: pipe(\\n post_split_evals.get(x),\\n lambda results: results[0] / results[1], # entropy / intrinsic value\\n ),\\n )\\n\\n # Return the best split and the splits scores\\n return (splits[min_eval], *post_split_evals.get(min_eval))\",\n \"def get_optimal_discrete_feature_split(\\n self, X: np.ndarray, y: np.ndarray, feature_col: int\\n ):\\n return BaseTree.get_discrete_split_value(\\n X[:, feature_col], y, eval_func=self.eval_func\\n )\",\n \"def pred_from_split(X, y, col_idx, split_value): \\n col = X[:,col_idx]\\n idx_n1, idx_n2 = col <= split_value, col > split_value\\n node1_y, node2_y = y[idx_n1], y[idx_n2]\\n \\n node1_c1, node1_c2 = sum(node1_y == 0), sum(node1_y == 1)\\n node2_c1, node2_c2 = sum(node2_y == 0), sum(node2_y == 1)\\n \\n if node1_c1 == node1_c2:\\n right_pred = 0 if node2_c1 > node2_c2 else 1\\n left_pred = 1 - right_pred\\n \\n elif node2_c1 == node2_c2:\\n left_pred = 0 if node1_c1 > node2_c2 else 1\\n right_pred = 1 - left_pred\\n \\n else:\\n left_pred = 0 if node1_c1 > node2_c2 else 1\\n right_pred = 0 if node2_c1 > node2_c2 else 1\\n \\n return (left_pred, right_pred)\",\n \"def getSplit(self):\\n b_index, b_value, b_score, b_groups = 999, 999, 999, None\\n for j in range(len(self[0]) - 1):\\n for i in range(len(self)):\\n groups = self.splitAttribute(j, self[i][j]) # lit, big\\n gini = self.giniIndex(groups)\\n if gini < b_score and (j, \\\"%.1f\\\" % self[i][j]) not in self.atr:\\n b_index, b_value, b_score, b_groups = j, self[i][\\n j], gini, groups\\n return b_index, b_value, b_groups, b_score\",\n \"def calcGiniSplitBySplitValue(self, data, structure, colIndex, splitValue):\\n dataBellow = list(filter(lambda x: float(x[colIndex]) <= splitValue, data))\\n dataAbove = list(filter(lambda x: float(x[colIndex]) > splitValue, data))\\n giniSplit = (len(dataBellow) / len(data)) * self.calcDataGini(dataBellow, structure) +\\\\\\n (len(dataAbove) / len(data)) * self.calcDataGini(dataAbove, structure)\\n return round(giniSplit, 3)\",\n \"def split(self, X, y, feature_array):\\n n, p = X.shape\\n\\n best_gain = 0\\n best_split_point = 0\\n best_feature_id = -1\\n for feature_id in feature_array:\\n cur_gain, cur_split_point = self.find_best_split(\\n X[:, feature_id], y)\\n if cur_gain > best_gain - self.eps:\\n best_gain = cur_gain\\n best_split_point = cur_split_point\\n best_feature_id = feature_id\\n\\n assert(best_feature_id != -1)\\n\\n x = X[:, best_feature_id]\\n left_index = x < best_split_point\\n right_index = x >= best_split_point\\n\\n self.split_id = best_feature_id\\n self.split_val = best_split_point\\n\\n return (left_index, right_index)\",\n \"def fit(self, col):\\n self.find_max_min(col)\",\n \"def _bestFeat2split(dataSet, impurity_crit, min_impurity_decrease, min_samples_split):\\n\\t\\tm, n = dataSet.shape\\n\\t\\tbestFeatInd, bestVal = None, DecisionTree._make_leaf(dataSet, impurity_crit)\\n\\n\\t\\tif m < min_samples_split or len(set(dataSet[:,-1])) == 1:\\n\\t\\t\\treturn bestFeatInd, bestVal\\n\\n\\t\\timpurity = m * impurity_crit(dataSet)\\n\\t\\tmin_impurity = np.inf\\n\\t\\t\\n\\n\\t\\tfor feat_ind in range(n-1):\\n\\t\\t\\tif type(dataSet[:, feat_ind][0]) != str:\\n\\t\\t\\t\\tuniqVal = set(dataSet[:, feat_ind])\\n\\t\\t\\telse:\\n\\t\\t\\t\\tuniqVal = map(set, subsets(list(dataSet[:, feat_ind])))\\n\\t\\t\\tfor val in uniqVal:\\n\\t\\t\\t\\tD1, D2 = DecisionTree._binarySplit(dataSet, feat_ind, val)\\n\\t\\t\\t\\tif len(D1) < min_samples_split or len(D2) < min_samples_split:\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\tnew_impurity = len(D1)*impurity_crit(D1) + len(D2)*impurity_crit(D2)\\n\\t\\t\\t\\tif impurity - new_impurity < min_impurity_decrease:\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\tif new_impurity < min_impurity:\\n\\t\\t\\t\\t\\tmin_impurity = new_impurity\\n\\t\\t\\t\\t\\tbestFeatInd = feat_ind; bestVal = val\\n\\t\\treturn bestFeatInd, bestVal\",\n \"def find_split(data):\\n ret = {\\\"router\\\": None, \\\"split_point\\\": None, \\\"entropy\\\": get_entropy(data[:, 7])}\\n\\n # Create array of unique datapoints\\n split_points_list = list()\\n\\n for i in range(data.shape[1] - 1):\\n unique_signal = np.unique(data[:, i])\\n split_points = list()\\n for j in range(len(unique_signal) - 1):\\n split_points.append((unique_signal[j]+unique_signal[j+1])/2)\\n split_points_list.append(split_points)\\n\\n # Split data by split points and calculate entropy\\n for feature in range(len(split_points_list)):\\n for i in range(len(split_points_list[feature])):\\n data_l, data_r = split_data(data, feature + 1, split_points_list[feature][i])\\n entropy = get_entropy(data_l[:, 7], data_r[:, 7])\\n if entropy < ret[\\\"entropy\\\"]:\\n ret[\\\"entropy\\\"] = entropy\\n ret[\\\"router\\\"] = feature + 1\\n ret[\\\"split_point\\\"] = split_points_list[feature][i]\\n\\n return ret[\\\"router\\\"], ret[\\\"split_point\\\"], split_data(data, ret[\\\"router\\\"], ret[\\\"split_point\\\"])\",\n \"def _find_split(self, X, y, n_features):\\r\\n splits_info = []\\r\\n\\r\\n # Select features to consider\\r\\n features = self._feature_selection.get_features(n_features, self._feature_prob)\\r\\n\\r\\n # Get candidate splits\\r\\n for feature_id in features:\\r\\n for split_value in compute_split_values(X[:, feature_id]):\\r\\n splits_info.append(\\r\\n compute_split_info(self._split_criterion, X, y, feature_id, split_value, self._min_samples_leaf))\\r\\n\\r\\n splits = []\\r\\n for split_info in splits_info:\\r\\n if split_info is not None:\\r\\n gain, feature_id, split_value = split_info\\r\\n split = Split(feature_id, value=split_value, gain=gain)\\r\\n splits.append(split)\\r\\n else:\\r\\n continue\\r\\n\\r\\n selected_split = self._split_chooser.get_split(splits)\\r\\n return selected_split\",\n \"def get_optimal_discrete_feature_split (\\n self, feature_matrix: np.ndarray, target_array: np.ndarray, feature_column: int\\n ):\\n return BaseTree.get_discrete_split_value (\\n feature_matrix [ :, feature_column ], target_array, evaluate_function = self.evaluate_function\\n ) # End get_optimal_discrete_feature_split\",\n \"def compute_splits(feature_df, target_col, max_num_splits):\\n tree_estimator = DecisionTreeClassifier(max_leaf_nodes=max_num_splits+1,\\n class_weight='balanced',\\n random_state=1407)\\n\\n tree_estimator.fit(feature_df, target_col)\\n thresholds = tree_estimator.tree_.threshold[tree_estimator.tree_.children_left != _tree.TREE_LEAF]\\n return sorted(thresholds)\",\n \"def _optimal_splits (self, split_axis):\\n n = len(self.displays)\\n size = self.screen.get_size()\\n # sizes in directions of first/second split\\n s1 = size[split_axis]\\n s2 = size[not split_axis]\\n ratio = self.ratio\\n # use screen aspect ratio if no preferred one given\\n if ratio is None:\\n ratio = float(size[0]) / size[1]\\n error = []\\n for splits in xrange(1, n + 1):\\n # maximal number of displays per row/column\\n per_split = ceil(float(n) / splits)\\n # minimise unused space (as a fraction of the screen)\\n space_e = abs(1 - float(n) / (splits * per_split))\\n # and ratio (we care about proportionality, so use log)\\n disp_ratio = float(s1 * splits) / (s2 * per_split)\\n if split_axis == 1:\\n # inverted if splitting into columns\\n disp_ratio = 1 / disp_ratio\\n ratio_e = abs(log(disp_ratio / ratio))\\n # adjust using some constants\\n e = space_e + ratio_e\\n error.append((e, splits))\\n return min(error)\",\n \"def potential_splits(self, potential_xj):\\r\\n \\r\\n self.cur.execute(\\\"SELECT DISTINCT \\\" + potential_xj + \\\" FROM \\\" + self.table_name + \\\";\\\")\\r\\n potential_splits = [ii[0] for ii in self.cur.fetchall()]\\r\\n return potential_splits\",\n \"def find_split(self, X, Y):\\n split_col = np.random.randint(X.shape[1])\\n return split_col, np.median(X[:,split_col])\",\n \"def title_based_split(df, split_val):\\n # retrieve split title and get the minimum id with that title\\n split_title = df['title'].iloc[int(split_val * len(df)) - 1]\\n split_index = df[df['title'] == split_title].index.min()\\n return df.iloc[:split_index], df.iloc[split_index:]\",\n \"def _compute_best_split_and_push(self, node):\\n\\n node.split_info = self.splitter.find_node_split(\\n node.sample_indices, node.histograms, node.sum_gradients,\\n node.sum_hessians)\\n\\n if node.split_info.gain <= 0: # no valid split\\n self._finalize_leaf(node)\\n else:\\n heappush(self.splittable_nodes, node)\",\n \"def pick_best_split(self,db,labels,ids,features=None):\\n idlabels = [labels[id] for id in ids]\\n if misclassification_error(idlabels) == 0:\\n #base case: no misclassifications\\n self.type = 'v'\\n self.value = idlabels[0]\\n return 0\\n best = None\\n bestCost = 0\\n splitval = None\\n discrete = True\\n if features == None:\\n if len(ids) < db.numFeatures():\\n #look at all present features in the training set\\n features = db.getPresentFeatures(ids)\\n #print len(features),\\\"of\\\",db.numFeatures(),\\\"features selected\\\"\\n else:\\n features = range(db.numFeatures())\\n elif callable(features):\\n features = features()\\n for i in features:\\n if len(db.entryLists[i]) == 0: continue\\n idiscrete = db.discreteFeature[i]\\n if idiscrete:\\n #count number of labels of a certain value\\n splitter = defaultdict(lambda:defaultdict(int))\\n #count of labels for missing values\\n nmissing = defaultdict(int)\\n for id in ids:\\n val = db[i,id]\\n if val is None:\\n #missing values go down to all splits\\n nmissing[labels[id]] += 1\\n continue\\n splitter[val][labels[id]] += 1\\n if len(splitter) > continuous_variable_threshold:\\n #print \\\"Determined to be a continuous variable\\\"\\n idiscrete = False\\n break\\n if idiscrete:\\n if len(splitter) <= 1:\\n #only a single value\\n continue\\n #count number of missing values in all splits\\n cmax = 0\\n for k in splitter:\\n for l,v in nmissing.iteritems():\\n splitter[k][l] += v\\n cmax = max(cmax,sum(splitter[k].values()))\\n #shrink by fraction of (# of ids - largest child)/(# of ids)\\n scale = (1.0-float(cmax)/float(len(ids)))*len(splitter)\\n #evaluate cost\\n cost = split_cost(splitter.values())*scale\\n #print \\\"Split on\\\",i,\\\"information gain\\\",-cost,splitter.values()\\n else:\\n #continuous, need to learn the best split\\n vals = []\\n presentlabels = []\\n nonelabels = []\\n for id in ids:\\n val = db[i,id]\\n if val is None:\\n nonelabels.append(labels[id])\\n continue\\n vals.append(val)\\n presentlabels.append(labels[id])\\n if len(vals) <= 1:\\n print \\\"No values for feature\\\",i,\\\"?\\\"\\n print vals\\n continue\\n #print \\\"Considering continuous split on\\\",i\\n s,cost = best_split(vals,presentlabels,nonelabels)\\n scale = (1.0-float(len(presentlabels)/2+len(nonelabels))/float(len(ids)))*2\\n cost *= scale\\n #print \\\"Result\\\",s,\\\"Information gain\\\",-cost\\n \\n if cost < bestCost:\\n best = i\\n bestCost = cost\\n discrete = idiscrete\\n if not idiscrete:\\n splitval = s\\n \\n if best is None:\\n self.type = 'v'\\n if len(ids) > 0:\\n self.value = vote(idlabels)\\n return misclassification_error(idlabels)\\n else:\\n self.value = None\\n return 0\\n else:\\n self.feature = best\\n #discrete or inequality split\\n if discrete:\\n self.type = 's'\\n else:\\n self.type = 'i'\\n self.value = splitval\\n return bestCost\",\n \"def get_min_across_splits_continuous (\\n feature_array: np.ndarray, target_array: np.ndarray, splits: np.ndarray, evaluate_function: Callable\\n ):\\n n = len ( splits )\\n if n > 500:\\n # If many split points, use some threading\\n with multiprocessing.Pool ( processes = 8 ) as p:\\n # Get evaluation scores across all the splits\\n post_split_evals = dict (\\n zip (\\n range ( len ( splits ) ),\\n p.starmap (\\n BaseTree.get_split_goodness_fit_continuous,\\n zip ( [ feature_array] * n, [ target_array ] * n, splits, [ evaluate_function ] * n ),\\n ),\\n )\\n )\\n p.close()\\n else:\\n # If not too many split points, get scores across all splits\\n post_split_evals = dict (\\n zip (\\n range ( len ( splits ) ),\\n map (\\n lambda x: BaseTree.get_split_goodness_fit_continuous ( * x ),\\n zip ( [ feature_array ] * n, [ target_array ] * n, splits, [ evaluate_function ] * n ),\\n ),\\n )\\n )\\n # Get the minimum split based on gain ratio\\n min_eval = min (\\n post_split_evals,\\n key = lambda x: pipe (\\n post_split_evals.get ( x ),\\n lambda results: results [ 0 ] / results [ 1 ], # entropy / intrinsic value\\n ),\\n )\\n\\n # Return the best split and the splits scores\\n return ( splits [ min_eval ], * post_split_evals.get ( min_eval ) )\\n # End get_min_across_splits_continuous()\",\n \"def __get_split_feature(self, data_set, target_feature, tree_features):\\n\\n if self.__criterion == 'entropy':\\n feature_gains = {feature: self.__gain(data_set, feature, target_feature) for (feature) in tree_features}\\n split_feature = max(feature_gains, key=feature_gains.get)\\n return split_feature\\n elif self.__criterion == 'gini':\\n feature_ginis = {feature: self.__gini(data_set, feature, target_feature) for (feature) in tree_features}\\n split_feature = min(feature_ginis, key=feature_ginis.get)\\n return split_feature\\n # TODO: I should check this (gini index).\",\n \"def choose_best_split(self, X_subset, y_subset):\\n # YOUR CODE HERE\\n feature_index = None\\n threshold = None\\n best_G = np.inf\\n N = len(X_subset)\\n \\n for current_feature in range(X_subset.shape[1]):\\n thresholds = np.unique(X_subset[:, current_feature])\\n \\n for t in thresholds:\\n y_left, y_right = self.make_split_only_y(current_feature, t, X_subset, y_subset)\\n H_L = self.H(y_left)\\n H_R = self.H(y_right)\\n \\n G = (len(y_left) / N) * H_L + (len(y_right) / N) * H_R\\n \\n if G < best_G:\\n best_G = G\\n feature_index = current_feature\\n threshold = t\\n \\n return feature_index, threshold\",\n \"def get_best_split(rows: list) -> (float, Question):\\n best_info_gain = 0\\n best_question = None\\n current_uncertainty = get_gini_impurity(rows)\\n\\n # minus 1 because we're ignoring the last column which is the label.\\n n_attributes = len(rows[0]) - 1\\n\\n for col in range(n_attributes):\\n\\n # get all unique values for an attribute/column\\n unique_values = set([row[col] for row in rows])\\n\\n for value in unique_values:\\n question = Question(col, value)\\n\\n # Split rows depending on the question\\n true_rows, false_rows = partition(rows, question)\\n\\n # We don't want to partition such rows\\n if len(true_rows) == 0 or len(false_rows) == 0:\\n continue\\n\\n # Get info gain from this split\\n info_gain = get_info_gain(false_rows, true_rows, current_uncertainty)\\n\\n if info_gain > best_info_gain:\\n best_info_gain, best_question = info_gain, question\\n\\n return best_info_gain, best_question\",\n \"def _split_threshold(self, node):\\n\\n # define the score to improve upon\\n if self.n_clusters >= self.min_leaves and node.size <= self.max_leaf_size:\\n # split only if min(children scores) > node.score\\n force_split = False\\n best_score = node.score\\n else:\\n # force split: just take the best (even if children are worse)\\n force_split = True\\n best_score = None\\n\\n left, right = None, None\\n\\n # iterate over embedding dimensions (first ones are more reliable)\\n # up to max_n_vec (included), until we found an improving split\\n for _vec in range(self.n_vec):\\n\\n # get the candidate thresholds along this dimension\\n threshs = self._get_candidate_thresholds(node, _vec)\\n\\n # look for an improving best split along this eigenvector\\n for _t in threshs:\\n # compute the split\\n below_thresh = self.E[node.ids, _vec] < _t\\n _lids = node.ids[below_thresh]\\n _rids = node.ids[np.logical_not(below_thresh)]\\n # check if the tubes are not too small\\n _nl, _nr = len(_lids), len(_rids)\\n is_valid = _nl >= self.min_leaf_size and _nr >= self.min_leaf_size\\n if is_valid:\\n # compute the score of the new tubes only\\n _sl = self.get_tube_score(_lids)\\n _sr = self.get_tube_score(_rids)\\n # get the score of this split\\n split_score = min(_sl, _sr)\\n if best_score is None or split_score > best_score:\\n # better split\\n best_score = split_score\\n node.has_children = True\\n node.thresh = _t\\n left = SpectralNode(\\n _lids, _vec, score=_sl, name=node.name + \\\"0\\\")\\n right = SpectralNode(\\n _rids, _vec, score=_sr, name=node.name + \\\"1\\\")\\n\\n # check stopping criterion\\n if node.has_children:\\n # we found an improving split\\n if _vec > 0 or not force_split:\\n # found an improving non-forced split: stop here\\n break\\n\\n return left, right\",\n \"def best_split(values,labels,nonelabels=None):\\n assert len(values) >= 2\\n assert len(values) == len(labels)\\n N = len(values)\\n ilist = sorted((v,l) for (v,l) in zip(values,labels))\\n leftcount = defaultdict(int)\\n rightcount = defaultdict(int)\\n for v,l in ilist:\\n rightcount[l] += 1\\n bestindex = -1\\n bestcost = split_cost([leftcount,rightcount])\\n\\n cost = bestcost\\n #costs = [cost]\\n #print \\\"Split costs:\\\"\\n for i in xrange(len(ilist)):\\n v,l = ilist[i]\\n rightcount[l] -= 1\\n leftcount[l] += 1\\n if i+1 >= len(ilist) or v == ilist[i+1][0]:\\n #no splits when v is equal to the next value\\n continue\\n cost = split_cost([leftcount,rightcount])\\n #print \\\" \\\",v,leftcount.values(),rightcount.values(),cost\\n #costs.append(cost)\\n if cost < bestcost:\\n bestcost = cost\\n bestindex = i\\n #raw_input()\\n if bestindex < 0:\\n #no split found... try splitting in half\\n splitval = (ilist[0][0]+ilist[-1][0])*0.5\\n else:\\n splitval = (ilist[bestindex][0] + ilist[bestindex+1][0])*0.5\\n if nonelabels is None:\\n return (splitval,bestcost)\\n #reevaluate counts\\n leftcount = defaultdict(int)\\n rightcount = defaultdict(int)\\n for l in nonelabels:\\n leftcount[l] += 1\\n rightcount[l] += 1\\n for v,l in ilist:\\n if v <= splitval:\\n leftcount[l] += 1\\n else:\\n rightcount[l] += 1\\n return splitval,split_cost([leftcount,rightcount])\",\n \"def get_cluster_to_split(clusters):\\n\\treturn max(clusters.items(), key=lambda x: x[1].get_distortion())[1]\",\n \"def minimum_spanning_arborescence(sol):\",\n \"def getBestSplitsInDataByInfoGain(self, data, structure, colName, numOfSplits):\\n splitsList, newSplitsList = {}, []\\n self.fillBestSplitsInDataByInfoGainIntoDict(data, structure, colName, numOfSplits, splitsList, 0)\\n for lists in list(splitsList.values())[1:]:\\n while len(lists) > 0:\\n splitOne, splitTwo = [], []\\n if len(lists) > 0:\\n splitOne = lists.pop()\\n if len(lists) > 0:\\n splitTwo = lists.pop()\\n if splitOne and splitTwo:\\n if splitOne[1] >= splitTwo[1]:\\n newSplitsList.append(splitOne[0])\\n newSplitsList.append(splitTwo[0])\\n else:\\n newSplitsList.append(splitTwo[0])\\n newSplitsList.append(splitOne[0])\\n elif splitOne:\\n newSplitsList.append(splitOne[0])\\n elif splitTwo:\\n newSplitsList.append(splitTwo[0])\\n\\n newSplitsList.insert(0, splitsList['0'][0][0])\\n self.removeDuplicatesInList(newSplitsList)\\n return newSplitsList[0:numOfSplits]\",\n \"def detect_splits(self):\\n logg.info(' abstracted graph will have {} nodes'.format(self.n_splits+1))\\n indices_all = np.arange(self.X.shape[0], dtype=int)\\n segs = [indices_all]\\n if False: # this is safe, but not compatible with on-the-fly computation\\n tips_all = np.array(np.unravel_index(np.argmax(self.Dchosen), self.Dchosen.shape))\\n else:\\n if self.iroot is not None:\\n tip_0 = np.argmax(self.Dchosen[self.iroot])\\n else:\\n tip_0 = np.argmax(self.Dchosen[0]) # just a random index, here fixed to \\\"0\\\"\\n tips_all = np.array([tip_0, np.argmax(self.Dchosen[tip_0])])\\n # we keep a list of the tips of each segment\\n segs_tips = [tips_all]\\n if self.clusters_precomputed_names:\\n self.segs_names_original = [', '.join(self.clusters_precomputed_names)]\\n segs_undecided = [True]\\n segs_adjacency = [[]]\\n segs_distances = np.zeros((1, 1))\\n segs_adjacency_nodes = [{}]\\n # logg.info(' do not consider groups with less than {} points for splitting'\\n # .format(self.min_group_size))\\n for ibranch in range(self.n_splits):\\n if self.clusters == 'unconstrained_segments':\\n iseg, new_tips = self.select_segment(segs, segs_tips, segs_undecided)\\n if iseg == -1:\\n logg.info('... partitioning converged')\\n break\\n logg.info('... branching {}:'.format(ibranch + 1),\\n 'split group', iseg)\\n segs_distances = self.do_split(segs, segs_tips,\\n segs_undecided,\\n segs_adjacency,\\n segs_distances,\\n iseg, new_tips)\\n else:\\n logg.msg(' split', ibranch + 1, v=4)\\n stop, segs_distances = self.do_split_constrained(segs, segs_tips,\\n segs_adjacency,\\n segs_adjacency_nodes,\\n segs_distances)\\n if stop: break\\n\\n # segments\\n self.segs = segs\\n self.segs_tips = segs_tips\\n self.segs_sizes = []\\n for iseg, seg in enumerate(self.segs): self.segs_sizes.append(len(seg))\\n\\n # the full, unscaled adjacency matrix\\n self.segs_adjacency_full_attachedness = 1/segs_distances\\n # if self.attachedness_measure == 'connectedness':\\n # norm = np.sqrt(np.multiply.outer(self.segs_sizes, self.segs_sizes))\\n # self.segs_adjacency_full_attachedness /= norm\\n self.segs_adjacency_full_confidence, self.segs_adjacency_tree_confidence \\\\\\n = self.compute_adjacency_confidence(\\n self.segs_adjacency_full_attachedness,\\n segs_adjacency,\\n self.tree_based_confidence)\\n np.fill_diagonal(self.segs_adjacency_full_attachedness, 0)\",\n \"def get_splits(self):\\n\\t\\treturn self.k\",\n \"def _best_split(cls, X, y):\\n n = X.shape[0]\\n num_feature = X.shape[1]\\n y_types = np.unique(y)\\n\\n # initialize\\n min_score = float(n)\\n feature_idx = None\\n best_theta = None\\n best_idx = None\\n\\n for feature_idx in xrange(num_feature):\\n # counter for y\\n cumulate_y = Counter()\\n rest_y = Counter()\\n for y_type in y_types:\\n cnt = np.where(y == y_type)[0].shape[0]\\n rest_y[y_type] = cnt\\n\\n # sorted data\\n sorted_idx = np.argsort(X[:, feature_idx])\\n sorted_X = np.copy(X)\\n sorted_y = np.copy(y)\\n sorted_X = sorted_X[sorted_idx]\\n sorted_y = sorted_y[sorted_idx]\\n #print \\\"_best_split:\\\", sorted_X.shape, sorted_y.shape\\n\\n for idx in xrange(n-1):\\n theta = (sorted_X[idx, feature_idx] + sorted_X[idx + 1, feature_idx]) / 2\\n y_label = sorted_y[idx]\\n cumulate_y[y_label] += 1\\n rest_y[y_label] -= 1\\n left_cnt = sum(cumulate_y.values())\\n right_cnt = sum(rest_y.values())\\n w_1 = left_cnt * cls._gini_index(cumulate_y.values())\\n w_2 = right_cnt * cls._gini_index(rest_y.values())\\n score = w_1 + w_2\\n if score < min_score:\\n min_score = score\\n best_theta = theta\\n best_idx = feature_idx\\n #print('new min score: %.3f' % score)\\n #print('feature: %d, theta: %.3f' % (best_idx, best_theta))\\n #print('left: %d, right: %d' % (left_cnt, right_cnt))\\n print('feature: %d, theta: %.3f' % (best_idx, best_theta))\\n return (best_idx, best_theta)\",\n \"def _best_split(cls, X, y):\\n n = X.shape[0]\\n num_feature = X.shape[1]\\n y_types = np.unique(y)\\n\\n # initialize\\n min_score = float(n)\\n feature_idx = None\\n best_theta = None\\n best_idx = None\\n\\n for feature_idx in xrange(num_feature):\\n # counter for y\\n cumulate_y = Counter()\\n rest_y = Counter()\\n for y_type in y_types:\\n cnt = np.where(y == y_type)[0].shape[0]\\n rest_y[y_type] = cnt\\n\\n # sorted data\\n sorted_idx = np.argsort(X[:, feature_idx])\\n sorted_X = np.copy(X)\\n sorted_y = np.copy(y)\\n sorted_X = sorted_X[sorted_idx]\\n sorted_y = sorted_y[sorted_idx]\\n #print \\\"_best_split:\\\", sorted_X.shape, sorted_y.shape\\n\\n for idx in xrange(n-1):\\n theta = (sorted_X[idx, feature_idx] + sorted_X[idx + 1, feature_idx]) / 2\\n y_label = sorted_y[idx]\\n cumulate_y[y_label] += 1\\n rest_y[y_label] -= 1\\n left_cnt = sum(cumulate_y.values())\\n right_cnt = sum(rest_y.values())\\n w_1 = left_cnt * cls._gini_index(cumulate_y.values())\\n w_2 = right_cnt * cls._gini_index(rest_y.values())\\n score = w_1 + w_2\\n if score < min_score:\\n min_score = score\\n best_theta = theta\\n best_idx = feature_idx\\n #print('new min score: %.3f' % score)\\n #print('feature: %d, theta: %.3f' % (best_idx, best_theta))\\n #print('left: %d, right: %d' % (left_cnt, right_cnt))\\n print('feature: %d, theta: %.3f' % (best_idx, best_theta))\\n return (best_idx, best_theta)\",\n \"def entropyWithBestSplit(attr, X, y):\\n df = X[attr]\\n maxVal = df.max()\\n minVal = df.min()\\n\\n # Square root decomposition\\n r = math.ceil(math.sqrt(maxVal - minVal))\\n entropyVal = float('inf')\\n splitAt = -1\\n\\n iterNum = 0\\n while r > MIN_BIN_SIZE and iterNum < MAX_ITER:\\n iterNum += 1\\n i = minVal\\n while i < maxVal:\\n leftSplit = df[df < i].index.tolist()\\n rightSplit = df[df >= i].index.tolist()\\n buff_entropy = entropy(df, leftSplit) *\\\\\\n (len(leftSplit) / (len(leftSplit) + len(rightSplit)))\\n buff_entropy += entropy(df, rightSplit) *\\\\\\n (len(rightSplit) / (len(leftSplit) + len(rightSplit)))\\n if entropyVal >= buff_entropy:\\n entropyVal = buff_entropy\\n splitAt = i\\n i += r\\n minVal = min([splitAt - r, minVal])\\n maxVal = max([splitAt + r, maxVal])\\n r_buff = math.ceil(math.sqrt(maxVal - minVal))\\n if r_buff >= r:\\n break\\n else:\\n r = r_buff\\n finalIdxLists = [\\n df[df < splitAt].index.tolist(),\\n df[df >= splitAt].index.tolist()\\n ]\\n return [splitAt], finalIdxLists, entropyVal\",\n \"def splitData(df, split):\\n train = df.iloc[:int(len(df)*split)]\\n test = df.iloc[int(len(df)*split):]\\n \\n return train, test\",\n \"def split(self,X,y=None):\\n all_idx = pd.Series(np.arange(X.shape[0])) \\n mbrg = int(X.shape[0]*self.embargo_pct)\\n test_starts=[(i[0],i[-1]+1) for i in np.array_split(all_idx.values,self.n_splits)]\\n for i, j in test_starts:\\n t0 = all_idx.index[i] # start of test set\\n test_indices = all_idx.values[i:j]\\n maxT1Idx = all_idx.index.searchsorted(all_idx[test_indices].max())\\n train_indices = all_idx.index.searchsorted(all_idx[all_idx<=t0].index)\\n if maxT1Idx < X.shape[0]: \\n train_indices=np.concatenate((train_indices,all_idx[maxT1Idx+mbrg:]))\\n yield train_indices,test_indices\",\n \"def best_cat_brute_force_split(self, ind, dep):\\n split = Split(None, None, None, None, 0)\\n all_dep = np.unique(dep.arr)\\n for i, ind_var in enumerate(ind):\\n ind_var = ind_var.deep_copy()\\n unique = np.unique(ind_var.arr)\\n\\n freq = {}\\n if dep.weights is None:\\n for col in unique:\\n counts = np.unique(np.compress(ind_var.arr == col, dep.arr), return_counts=True)\\n freq[col] = cl.defaultdict(int)\\n freq[col].update(np.transpose(counts))\\n else:\\n for col in unique:\\n counts = np.unique(np.compress(ind_var.arr == col, dep.arr), return_counts=True)\\n freq[col] = cl.defaultdict(int)\\n for dep_v in all_dep:\\n freq[col][dep_v] = dep.weights[(ind_var.arr == col) * (dep.arr == dep_v)].sum()\\n\\n if len(list(ind_var.possible_groupings())) == 0:\\n split.invalid_reason = InvalidSplitReason.PURE_NODE\\n\\n choice, highest_p_join, split_chi, dof = None, None, None, None\\n for comb in ind_var.all_combinations():\\n freqs = [ sum( [ cl.Counter(freq[key]) for key in c ], cl.Counter()) for c in comb ]\\n\\n if sum([ (sum(x.values()) < self.min_child_node_size) for x in freqs ] ) > 0:\\n continue\\n keys = set(sum([ list(f.keys()) for f in freqs ], []))\\n\\n n_ij = np.array(\\n [ [ col.get(k, 0) for k in keys ] for col in freqs ]\\n )\\n\\n chi, p_split, dof = chisquare(n_ij, dep.weights is not None)\\n\\n if (choice is None or p_split < highest_p_join or (p_split == highest_p_join and chi > split_chi)) and p_split < self.alpha_merge:\\n choice, highest_p_join, split_chi = comb, p_split, chi\\n\\n temp_split = Split(i, choice, split_chi, highest_p_join, dof, split_name=ind_var.name)\\n better_split = (not split.valid() or p_split < split.p or (p_split == split.p and chi > split.score)) and choice is not None\\n if better_split: split, temp_split = temp_split, split\\n\\n if split.valid() and choice is not None:\\n chi_threshold = self.split_threshold * split.score\\n\\n if temp_split.valid() and temp_split.score >= chi_threshold:\\n for sur in temp_split.surrogates:\\n if sur.column_id != i and sur.score >= chi_threshold:\\n split.surrogates.append(sur)\\n\\n temp_split.surrogates = []\\n split.surrogates.append(temp_split)\\n\\n split.sub_split_values(ind[split.column_id].metadata)\\n\\n return split\",\n \"def getListWithBestValueSplitsOfDataByGini(self, data, structure, colIndex, numOfSplits):\\n splitsList, newSplitsList = {}, []\\n self.fillDictWithBestValueSplitsOfDataByGini(data, structure, colIndex, numOfSplits, splitsList, 0)\\n for lists in list(splitsList.values())[1:]:\\n while len(lists) > 0:\\n splitOne, splitTwo = [], []\\n if len(lists) > 0:\\n splitOne = lists.pop()\\n if len(lists) > 0:\\n splitTwo = lists.pop()\\n if splitOne and splitTwo:\\n if splitOne[1] <= splitTwo[1]:\\n newSplitsList.append(splitOne[0])\\n newSplitsList.append(splitTwo[0])\\n else:\\n newSplitsList.append(splitTwo[0])\\n newSplitsList.append(splitOne[0])\\n elif splitOne:\\n newSplitsList.append(splitOne[0])\\n elif splitTwo:\\n newSplitsList.append(splitTwo[0])\\n\\n newSplitsList.insert(0, splitsList['0'][0][0])\\n self.removeDuplicatesInList(newSplitsList)\\n return newSplitsList[0:numOfSplits]\",\n \"def getSplits(df, train_size, val_size, test_size, seed=None):\\n size = len(df)\\n\\n # size is considered a percentage if less than 1:\\n train_size = int(train_size * size) if train_size < 1 else train_size\\n val_size = int(val_size * size) if val_size < 1 else val_size\\n test_size = int(test_size * size) if test_size < 1 else test_size\\n\\n if not seed is None:\\n np.random.seed(seed)\\n\\n train_val_idx = np.random.choice(\\n a=range(size),\\n size=train_size + val_size,\\n replace=False\\n )\\n train_idx = train_val_idx[:train_size]\\n val_idx = train_val_idx[train_size:]\\n\\n train = df.iloc[train_idx]\\n val = df.iloc[val_idx]\\n test = df.drop(train.index).drop(val.index) # test is equal to the leftover\\n\\n assert len(train) + len(val) + len(test) == len(df)\\n\\n return train, val, test\",\n \"def split ( self, y, X = None ):\\n # Make sure y is an array\\n y = np.array ( y ) if isinstance ( y, list ) else y\\n\\n # Groupby y and add integer indices.\\n df_with_split = (\\n pd.DataFrame ( { \\\"y\\\": y, \\\"index\\\": np.arange ( len ( y ) ) } )\\n .groupby ( \\\"y\\\" ) [ \\\"index\\\" ]\\n .apply ( self.add_split_col ) # Add col for split for instance\\n )\\n\\n # For each fold, get train and test indices (based on col for split)\\n for cv_split in np.arange ( self.number_of_folds - 1, -1, -1 ):\\n train_bool = df_with_split [ \\\"split\\\" ] != cv_split\\n test_bool = ~ train_bool\\n # Yield index values of not cv_split and cv_split for train, test\\n yield df_with_split [ \\\"index\\\" ].values [ train_bool.values ], df_with_split [\\n \\\"index\\\"\\n ].values [ test_bool.values ]\\n # End split()\",\n \"def split_data(data, feature, split_point):\\n data_l = data[data[:, feature - 1] < split_point]\\n data_r = data[data[:, feature - 1] >= split_point]\\n\\n return data_l, data_r\",\n \"def min_parts():\\n # you must replace this with your own value\\n return -1\",\n \"def get_split_goodness_fit_continuous(\\n arr: np.ndarray, y: np.ndarray, split: float, eval_func: Callable\\n ):\\n # Get above and below the split value\\n above = arr >= split\\n below = arr < split\\n\\n # get weighted average eval_func on the splits\\n n_above = np.sum(above)\\n above_eval = (\\n eval_func(y[above]) * n_above / len(y)\\n ) # weight = frac points in above\\n below_eval = (\\n eval_func(y[below]) * (len(y) - n_above) / len(y)\\n ) # weight = frac points not in above\\n\\n # returns weighted sum of eval_func across splits, and the gain ratio denominator\\n return (\\n above_eval + below_eval,\\n -1\\n * sum(\\n map(\\n lambda x: x * np.log(x),\\n [n_above / len(y), (len(y) - n_above) / len(y)],\\n )\\n ),\\n )\",\n \"def select_randomly(self, val_split: float, test_split: float) -> {str: int}:\\n\\n def _select(start, n, label) -> int:\\n \\\"\\\"\\\"\\n Label all columns in [start, start+n) with label.\\n \\\"\\\"\\\"\\n n_selected = 0\\n for i in range(start, int(start + n)):\\n x = self._x_positions[i]\\n n_selected += self._cols[x].mark_as(label)\\n return n_selected\\n\\n def _remove_overlaps(start, end) -> int:\\n \\\"\\\"\\\"\\n Remove unlabelled columns in [start-col_width, end+col_width].\\n \\\"\\\"\\\"\\n start = self._x_positions[start % self.n_cols]\\n end = self._x_positions[int(end) % self.n_cols]\\n n_removed = 0\\n for x, col in self._cols.items():\\n if start - self.col_width <= x <= start or end <= x <= end + self.col_width:\\n if col.label is None:\\n n_removed += col.mark_as('ignore')\\n return n_removed\\n\\n def _next_unlabelled_col(x):\\n \\\"\\\"\\\"\\n Return index of first unlabelled column after x.\\n \\\"\\\"\\\"\\n for i in range(self.n_cols):\\n idx = (x + i) % self.n_cols\\n x_current = self._x_positions[idx]\\n if self._cols[x_current].label is None:\\n return idx\\n\\n # When computing number of columns per split we must take into account\\n # that some columns will be removed, i.e. we want to compute the split\\n # sizes as fraction of the number of actual selected columns, not of\\n # the total number of columns.\\n delta_x = self._x_positions[1] - self._x_positions[0]\\n n_to_remove_per_split = self.col_width / delta_x\\n # * 2 because 2 gaps between 3 splits\\n n_to_keep = self.n_cols - n_to_remove_per_split * 2\\n n_val = round(n_to_keep * val_split)\\n n_test = round(n_to_keep * test_split)\\n n_train = n_to_keep - n_val - n_test\\n\\n n_selected_crops_per_split = dict.fromkeys(['training', 'validation', 'test', 'ignore'], 0)\\n\\n # Place patches in arbitrary order\\n start = 0\\n for n, label in random.sample(list(zip([n_train, n_val, n_test], ['training', 'validation', 'test'])), k=3):\\n # Mark patch\\n n_selected_crops_per_split[label] += _select(start, n, label)\\n # Remove columns overlapping this patch\\n n_selected_crops_per_split['ignore'] += _remove_overlaps(start, start + n - 1)\\n # Next patch starts at next unlabelled column\\n start = _next_unlabelled_col(start)\\n\\n return n_selected_crops_per_split\",\n \"def _compute_split_boundaries(split_probs, n_items):\\n if len(split_probs) > n_items:\\n raise ValueError(\\n 'Not enough items for the splits. There are {splits} '\\n 'splits while there are only {items} items'.format(\\n splits=len(split_probs), items=n_items\\n )\\n )\\n total_probs = sum(p for name, p in split_probs)\\n if abs(1 - total_probs) > 1e-8:\\n raise ValueError('Probs should sum up to 1. probs={}'.format(split_probs))\\n split_boundaries = []\\n sum_p = 0.0\\n for name, p in split_probs:\\n prev = sum_p\\n sum_p += p\\n split_boundaries.append((name, int(prev * n_items), int(sum_p * n_items)))\\n\\n # Guard against rounding errors.\\n split_boundaries[-1] = (\\n split_boundaries[-1][0],\\n split_boundaries[-1][1],\\n n_items,\\n )\\n\\n return split_boundaries\",\n \"def _split_branch(self,t,em):\\n\\n max_t = t[np.argmax(em)]\\n return t[t<=max_t],em[t<=max_t],t[t>max_t],em[t>max_t]\",\n \"def __find_best_split_in_feature(self, feature_and_class):\\n\\n # sort the feature and class and use changes in the class to reduce\\n # number of potential split info gain calculations\\n sorted_data = feature_and_class[\\n feature_and_class[:, 0].astype(np.int).argsort()]\\n potential_splits = self.__find_integers_with_class_change(sorted_data)\\n info_gains = self.__info_gain_from_splits(potential_splits,\\n sorted_data)\\n\\n # returning nothing in no information gains are found\\n if len(info_gains) == 0:\\n return None, None\\n\\n index = info_gains.index(max(info_gains))\\n return info_gains[index], potential_splits[index]\",\n \"def calcGainRatioSplitByColumn(self, data, structure, colIName):\\n splitInfo, colIndex = 0, structure[colIName]['index']\\n for value in structure[colIName]['values']:\\n newData = list(filter(lambda x: x[colIndex] == value, data))\\n p = len(newData) / len(data) if len(newData) != 0 else 1\\n splitInfo += (-1) * p * log2(p)\\n splitInfo = 1 if splitInfo == 0 else splitInfo\\n return round(self.calcInfoGainByColumnSplit(data, structure, colIName) / splitInfo, 3)\",\n \"def best_cutoff(self,\\n split_label):\\n split_args = self.sub_split_args[split_label]\\n split_data = self.sub_split_data[split_label]\\n # This criterion for the use_scipy flag is arbitrary and needs\\n # further testing\\n n_unique = len(np.unique(split_data[~np.isnan(split_data)]))\\n use_scipy = True\\n if n_unique > len(split_data)/1000:\\n use_scipy = False\\n idxcut_below, effects_below, rstats_below, ndata_below =\\\\\\n self.u_data(split_label, use_scipy=use_scipy)\\n idxcut_above, effects_above, rstats_above, ndata_above =\\\\\\n self.u_data(split_label, above=True, use_scipy=use_scipy)\\n\\n # Default cutoff is min(split_data) - 1\\n cutoff = split_data[split_args[0]] - 1\\n value = 0\\n # If no cutoff was possible\\n if len(idxcut_below) == 0 or len(idxcut_above) == 0:\\n return cutoff, value\\n\\n # All idx_cutoffs and values for cutoffs, for debugging\\n for idx in range(len(idxcut_above)):\\n idxcut = idxcut_above[idx]\\n if idxcut != idxcut_below[idx]:\\n raise NameError('Code error, invalid split')\\n value_temp = (abs(effects_above[idx] -\\n effects_below[idx]) *\\n rstats_above[idx] *\\n rstats_below[idx] *\\n min(ndata_above[idx]) *\\n min(ndata_below[idx]))\\n if value_temp > value:\\n cutoff = (split_data[split_args[int(idxcut)]] +\\n split_data[split_args[int(idxcut)+1]])/2\\n value = value_temp\\n return cutoff, value\",\n \"def segment_bf(seq, score_func):\\n maxsc = float('-inf') # necessary for log prob\\n bestseg = None\\n for seg in segment_r(seq):\\n score = sum([score_func(w) for w in seg]) # np.prod([score_func(w) for w in seg])\\n if score > maxsc:\\n bestseg = seg\\n maxsc = score\\n return maxsc, bestseg\",\n \"def find_large_separation2(self):\\n\\n ind = (self.modes['l'] == 0).flat\\n n = self.modes['n'].compress(ind)\\n if (len(n) < 2): return np.nan\\n freq = self.modes['freq'].compress(ind)\\n coeff = np.polyfit(n,freq,1)\\n return coeff[0]\",\n \"def load_partition_1d(counts, n_dom, split_fac):\\n count_sums = np.cumsum(counts)\\n # If we split at n+1, how many points on left and right?\\n ptsL = count_sums[1:].astype(np.float64)\\n ptsR = np.empty_like(ptsL)\\n ptsR[:] = count_sums[-1] \\n ptsR[1:] -= count_sums[:-2]\\n\\n\\n # Best split of domains (+/- 1)\\n left0 = np.clip(((n_dom * ptsL)/(ptsL+ptsR)).astype(np.int32), 1, n_dom-1)\\n right0 = n_dom-left0\\n\\n left1 = np.minimum(left0+1,n_dom-1)\\n right1 = n_dom-left1\\n\\n # whats the worst (left/right) load balance?\\n p_per_proc0 = np.maximum((1+split_fac*np.log(left0))*ptsL/left0, (1+split_fac*np.log(right0))*ptsR/right0)\\n p_per_proc1 = np.maximum((1+split_fac*np.log(left1))*ptsL/left1, (1+split_fac*np.log(right1))*ptsR/right1)\\n\\n idx_min0 = np.argmin(p_per_proc0)\\n idx_min1 = np.argmin(p_per_proc1)\\n \\n if p_per_proc0[idx_min0] < p_per_proc1[idx_min1]:\\n split = idx_min0\\n n_left = left0[idx_min0]\\n pval = p_per_proc0[idx_min0]\\n else:\\n split = idx_min1\\n n_left = left1[idx_min1]\\n pval = p_per_proc1[idx_min1]\\n\\n if split==0 or split==len(counts)-2:\\n raise Exception('Tried to make a domain of pure ghosts. Something bad happened?')\\n\\n\\n return split, n_left, pval\",\n \"def random_splittable_value(self, variable: int) -> Any:\\n #print(\\\"enter bartpy/bartpy/data.py CovariateMatrix random_splittable_value\\\")\\n \\n if variable not in self.splittable_variables():\\n raise NoSplittableVariableException()\\n max_value = self.max_value_of_column(variable)\\n candidate = np.random.choice(self.get_column(variable))\\n while candidate == max_value:\\n candidate = np.random.choice(self.get_column(variable))\\n #print(\\\"-exit bartpy/bartpy/data.py CovariateMatrix random_splittable_value\\\")\\n return candidate\",\n \"def greedy_split(arr, n, axis=0):\\n length = arr.shape[axis]\\n # compute the size of each of the first n-1 blocks\\n block_size = int(np.ceil(length / float(n)))\\n # the indices at which the splits will occur\\n ix = np.arange(block_size, length, block_size)\\n return np.array(np.split(arr, ix, axis))\",\n \"def find_shape(items: int):\\n for columns in range(1, MAX_COLUMNS + 1):\\n if columns / math.ceil(items / columns) >= MIN_RATIO:\\n return math.ceil(items / columns), columns\\n return math.ceil(items / MAX_COLUMNS), MAX_COLUMNS\",\n \"def best_B(Ag):\\n top = 0\\n for i in range(len(Ag)):\\n etop = np.min(cf.TD20[int(Ag[i]) - 1])\\n top += etop\\n return top\",\n \"def class_split(x):\\r\\n return np.split(x, [19,43])\",\n \"def best_split(self, X, y, attributes):\\n if (self.criterion==\\\"information_gain\\\"):\\n global_if = float('-inf') # the highest value of information gain/gini gain seen so far\\n attr = None\\n for attribute in attributes:\\n attr_val = X[attribute].copy()\\n cur_if = information_gain(y,attr_val,self.type)\\n if (cur_if>global_if):\\n # Update when a better split is receieved\\n global_if = cur_if\\n attr = attribute\\n return attr\\n else:\\n global_if = float('inf')\\n attr = None\\n for attribute in attributes:\\n attr_val = X[attribute].copy()\\n cur_if = gini_gain(y,attr_val)\\n if (global_if>cur_if):\\n # Update when a better split is receieved\\n global_if = cur_if\\n attr = attribute\\n return attr\",\n \"def splitbylo(self,lo):\\n ind=np.where(self.lo==lo)[0]\\n self.splitbyind(ind)\",\n \"def _get_best_level_for_downsample(downsample, arr):\\n L = np.array(arr)\\n diff = np.absolute(L-downsample)\\n index = np.argmin(diff)\\n return index\",\n \"def split_workload(workload):\\n diff = sum(workload)\\n minimum = abs(diff), 0\\n for i, work in enumerate(workload, 1):\\n diff -= 2 * work\\n current = abs(diff), i\\n if current < minimum:\\n minimum = current\\n return (None, None) if minimum == (0, 0) else minimum[::-1]\",\n \"def choose_split(data,treshold):\\n n_features = len(data[0]) - 1 # number of columns\\n quest_gain = [] # keep track of the gains and questions\\n\\n for col in range(1,n_features): # for each feature\\n values = set([row[col] for row in data]) # unique values in the column\\n for val in values: # for each value\\n question = Question(col, val)\\n \\n # try splitting the dataset\\n true_rows, false_rows = partition(data, question)\\n\\n # Skip this split if it doesn't divide the dataset.\\n if len(true_rows) == 0 or len(false_rows) == 0:\\n continue\\n\\n # Calculate the information gain from this split\\n gain = info_gain(data, true_rows, false_rows)\\n quest_gain.append(Question_gain(gain,question))\\n\\n possible_question = [] # possible questions to ask\\n n_quest_gain = len(quest_gain)\\n\\n if n_quest_gain == 0:\\n return float('Inf'), float('NaN') #\\n\\n for x in range(n_quest_gain):\\n if (quest_gain[x].gain >= treshold):\\n possible_question.append(Question_gain(quest_gain[x].gain,quest_gain[x].question))\\n \\n n_possible_question = len(possible_question)\\n if n_possible_question == 0:\\n return float('Inf'), float('NaN')\\n\\n if n_possible_question>=2:\\n [i, j] = random.sample(range(0, n_possible_question), 2)\\n else:\\n i = j = random.randint(0,n_possible_question-1)\\n\\n if possible_question[i].gain>=possible_question[j].gain:\\n return possible_question[i].gain, possible_question[i].question\\n else:\\n return possible_question[j].gain, possible_question[j].question\",\n \"def get_bucket_boundaries(feature):\\n return np.unique(np.percentile(feature, range(0, 100))).tolist()\",\n \"def get_partition_boundaries(cls, session: Session):\\n rows = session.execute(\\\"select pg_class.relname, pg_get_expr(pg_class.relpartbound, pg_class.oid, true) from pg_class where relname SIMILAR TO 'peptides_[0-9]{3}';\\\").fetchall()\\n num_regex = re.compile(r\\\"\\\\d+\\\")\\n partition_boundaries = []\\n for row in rows:\\n matches = re.findall(num_regex, row[1])\\n partition_boundaries.append((row[0], int(matches[0]), int(matches[1])))\\n return partition_boundaries\",\n \"def choose_optimal_image_split(im, method='im_size', min_tile_size=360000):\\n \\n n_cores = os.cpu_count()\\n # number of segmented objects, drop the background value\\n n_obj = np.unique(im).size - 1\\n \\n if method == 'im_size':\\n # avoid too many splits if image is not so big\\n im_size = im.nbytes # slightly different from sys.getsizeof(im)\\n # max power of 2\\n max_i = int(np.log2(n_cores)) + 1\\n n_splits = 1\\n for i in range(1, max_i):\\n new_split = 2**i\\n if im_size / new_split >= min_tile_size:\\n n_splits = new_split\\n else:\\n break\\n elif method == 'naive':\\n n_splits = n_cores\\n \\n return n_splits\",\n \"def split_data_set(data_set, index, value, part=0):\\n # save the subdataset\\n res_data_set = []\\n \\n for entry in data_set:\\n # find the data set to the left of the partition point\\n if part == 0 and float(entry[index])<= value: #求划分点左侧的数据集\\n reduced_entry = entry[:index]\\n # after partitioning, the value of the index column in the data is removed\\n reduced_entry.extend(entry[index + 1:]) \\n res_data_set.append(reduced_entry)\\n # find the data set to the right of the partition point\\n if part ==1 and float(entry[index])> value: \\n reduced_entry = entry[:index]\\n reduced_entry.extend(entry[index + 1:])\\n res_data_set.append(reduced_entry)\\n return res_data_set\",\n \"def lowest_rank_approx(A,e):\",\n \"def split_next(self):\\n # Consider the node with the highest loss reduction (a.k.a. gain)\\n node = heappop(self.splittable_nodes)\\n\\n tic = time()\\n (sample_indices_left,\\n sample_indices_right,\\n right_child_pos) = self.splitter.split_indices(node.split_info,\\n node.sample_indices)\\n self.total_apply_split_time += time() - tic\\n\\n depth = node.depth + 1\\n n_leaf_nodes = len(self.finalized_leaves) + len(self.splittable_nodes)\\n n_leaf_nodes += 2\\n\\n left_child_node = TreeNode(depth,\\n sample_indices_left,\\n node.split_info.sum_gradient_left,\\n node.split_info.sum_hessian_left,\\n parent=node)\\n right_child_node = TreeNode(depth,\\n sample_indices_right,\\n node.split_info.sum_gradient_right,\\n node.split_info.sum_hessian_right,\\n parent=node)\\n left_child_node.sibling = right_child_node\\n right_child_node.sibling = left_child_node\\n node.right_child = right_child_node\\n node.left_child = left_child_node\\n\\n # set start and stop indices\\n left_child_node.partition_start = node.partition_start\\n left_child_node.partition_stop = node.partition_start + right_child_pos\\n right_child_node.partition_start = left_child_node.partition_stop\\n right_child_node.partition_stop = node.partition_stop\\n\\n self.n_nodes += 2\\n\\n if self.max_depth is not None and depth == self.max_depth:\\n self._finalize_leaf(left_child_node)\\n self._finalize_leaf(right_child_node)\\n return left_child_node, right_child_node\\n\\n if (self.max_leaf_nodes is not None\\n and n_leaf_nodes == self.max_leaf_nodes):\\n self._finalize_leaf(left_child_node)\\n self._finalize_leaf(right_child_node)\\n self._finalize_splittable_nodes()\\n return left_child_node, right_child_node\\n\\n if left_child_node.n_samples < self.min_samples_leaf * 2:\\n self._finalize_leaf(left_child_node)\\n if right_child_node.n_samples < self.min_samples_leaf * 2:\\n self._finalize_leaf(right_child_node)\\n\\n # Compute histograms of childs, and compute their best possible split\\n # (if needed)\\n should_split_left = left_child_node.value is None # node isn't a leaf\\n should_split_right = right_child_node.value is None\\n if should_split_left or should_split_right:\\n\\n # We will compute the histograms of both nodes even if one of them\\n # is a leaf, since computing the second histogram is very cheap\\n # (using histogram subtraction).\\n n_samples_left = left_child_node.sample_indices.shape[0]\\n n_samples_right = right_child_node.sample_indices.shape[0]\\n if n_samples_left < n_samples_right:\\n smallest_child = left_child_node\\n largest_child = right_child_node\\n else:\\n smallest_child = right_child_node\\n largest_child = left_child_node\\n\\n # We use the brute O(n_samples) method on the child that has the\\n # smallest number of samples, and the subtraction trick O(n_bins)\\n # on the other one.\\n tic = time()\\n smallest_child.histograms = \\\\\\n self.histogram_builder.compute_histograms_brute(\\n smallest_child.sample_indices)\\n largest_child.histograms = \\\\\\n self.histogram_builder.compute_histograms_subtraction(\\n node.histograms, smallest_child.histograms)\\n self.total_compute_hist_time += time() - tic\\n\\n tic = time()\\n if should_split_left:\\n self._compute_best_split_and_push(left_child_node)\\n if should_split_right:\\n self._compute_best_split_and_push(right_child_node)\\n self.total_find_split_time += time() - tic\\n\\n return left_child_node, right_child_node\",\n \"def get_n_splits(self):\\n pass\",\n \"def near_split(x, num_bins=None, size_bins=None):\\n if num_bins:\\n quotient, remainder = divmod(x, num_bins)\\n return [quotient + 1] * remainder + [quotient] * (num_bins - remainder)\\n elif size_bins:\\n return near_split(x, num_bins=int(np.ceil(x / size_bins)))\",\n \"def near_split(x, num_bins=None, size_bins=None):\\n if num_bins:\\n quotient, remainder = divmod(x, num_bins)\\n return [quotient + 1] * remainder + [quotient] * (num_bins - remainder)\\n elif size_bins:\\n return near_split(x, num_bins=int(np.ceil(x / size_bins)))\",\n \"def get_n_splits(self):\\n return self.n_folds\",\n \"def segment_top_k(x, I, ratio):\\n rt = tf.RaggedTensor.from_value_rowids(x, I)\\n row_lengths = rt.row_lengths()\\n dense = rt.to_tensor(default_value=-np.inf)\\n indices = tf.cast(tf.argsort(dense, direction=\\\"DESCENDING\\\"), tf.int64)\\n row_starts = tf.cast(rt.row_starts(), tf.int64)\\n indices = indices + tf.expand_dims(row_starts, 1)\\n row_lengths = tf.cast(\\n tf.math.ceil(ratio * tf.cast(row_lengths, tf.float32)), tf.int32\\n )\\n return tf.RaggedTensor.from_tensor(indices, row_lengths).values\",\n \"def get_x_limits(line, line_header, column_header):\\n if not my_strcomp(line_header, line.content):\\n return None\\n else:\\n words_line = line_header.split(\\\" \\\")\\n words_column = column_header.split(\\\" \\\")\\n for i in range(len(words_line) - len(words_column) + 1):\\n start = i\\n end = i + len(words_column) - 1\\n if words_column == words_line[start:end + 1]:\\n if start == 0:\\n x_min = 0\\n else:\\n # x_min is the initial x of the first word of the column_header (left-aligned)\\n x_min = line.word_boxes[start].position[0][0]\\n\\n # x_min is the initial x of the first word of the column_header (left-aligned)\\n x_min = 0.5 * (line.word_boxes[start].position[0][0] +\\n line.word_boxes[start - 1].position[1][0])\\n\\n if end >= len(words_line) - 1:\\n x_max = 99999\\n else:\\n # x_max is the initial x of the first word AFTER the column_header (left-aligned)\\n x_max = line.word_boxes[end + 1].position[0][0]\\n\\n # x_max is the average of the final of the current word and the initial x of the first word AFTER the column_header (left-aligned)\\n x_max = 0.5 * (line.word_boxes[end + 1].position[0][0] +\\n line.word_boxes[end].position[1][0])\\n\\n return x_min, x_max\",\n \"def _split_forced(self, node):\\n # compute the split\\n _vec = 0\\n sorted_idxs = np.argsort(self.E[node.ids, _vec]).squeeze()\\n n = len(sorted_idxs) // 2\\n _lids = node.ids[sorted_idxs[:n]]\\n _rids = node.ids[sorted_idxs[n:]]\\n # compute the score of the new tubes only\\n _sl = self.get_tube_score(_lids)\\n _sr = self.get_tube_score(_rids)\\n # register the split\\n node.has_children = True\\n node.thresh = np.median(self.E[node.ids, _vec]) # arbitrary\\n # Note: median would not ensure equal size (because of duplicate values)\\n left = SpectralNode(_lids, _vec, score=_sl, name=node.name + \\\"0\\\")\\n right = SpectralNode(_rids, _vec, score=_sr, name=node.name + \\\"1\\\")\\n\\n return left, right\",\n \"def best_split(self):\\n sub_group = []\\n\\n current_entropy = self.entropy(self._Passengers)\\n best_gain = 0 # holds the best entropy difference so far\\n best_split = self._Attr[0].get_name()\\n relative_entropy = 0 # entropy while taking account for the size of the population\\n\\n for Attribute in self._Attr:\\n relative_entropy = 0\\n print(\\\"Attr considered: \\\" + Attribute.get_name())\\n for Attr_option in Attribute.get_options():\\n sub_group = []\\n for Passenger in self._Passengers:\\n if self.passenger_attr_option_check(Passenger,\\n Attribute.get_name(),\\n Attr_option): # if P.A = V\\n sub_group.append(Passenger)\\n if len(sub_group) > 0 and len(self._Passengers) > 0:\\n relative_entropy += self.entropy(sub_group) * (len(sub_group)/len(self._Passengers))\\n\\n if current_entropy - relative_entropy > best_gain:\\n best_gain = current_entropy - relative_entropy\\n best_split = Attribute.get_name()\\n\\n print(f\\\"best split:{best_split} \\\\n with entropy gain of:\\\\n {best_gain}\\\")\\n\\n return best_split\",\n \"def getKSplits(df, n_splits, seed = None):\\n\\n result = []\\n\\n # None random seed is same as not setting it\\n df_shuffled = df.sample(len(df), random_state = seed)\\n\\n fold_size = int(len(df) / n_splits)\\n\\n for i in range(n_splits):\\n if i == n_splits - 1: # last iteration\\n df_fold = df_shuffled[fold_size * (i): len(df)] # gets remainder\\n else:\\n df_fold = df_shuffled[fold_size * (i):fold_size * (i + 1) ] # python starts indexing at 0\\n result.append(df_fold)\\n\\n return result\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7231365","0.7075939","0.68824524","0.68168825","0.6810663","0.67609465","0.6757198","0.6710196","0.6624161","0.64982873","0.648198","0.6418159","0.64083916","0.64015394","0.63641125","0.63524777","0.62306863","0.62056756","0.61384755","0.60775584","0.607103","0.60419834","0.60220134","0.598051","0.59713763","0.5947856","0.591183","0.58984923","0.5858018","0.58275455","0.5820291","0.57639956","0.5758791","0.5679884","0.5674746","0.56616175","0.56172085","0.55935395","0.55578405","0.5556809","0.5540111","0.5539486","0.55302894","0.5517065","0.5511611","0.5488144","0.5477822","0.54580986","0.5454252","0.5446263","0.54423577","0.54406595","0.54399","0.5422685","0.54102474","0.54102474","0.53971326","0.5395943","0.5379926","0.5377695","0.5353594","0.53466594","0.533185","0.5327736","0.53185034","0.52887523","0.52748996","0.52679515","0.52656186","0.52629906","0.52561927","0.52495754","0.5246184","0.5218643","0.52063936","0.5189111","0.5180287","0.5172731","0.5159735","0.5158275","0.51562065","0.51546466","0.5150887","0.51320416","0.5129424","0.512157","0.508713","0.5087042","0.5084663","0.50835","0.50826055","0.5081957","0.5075643","0.5075643","0.5070316","0.50662166","0.50594085","0.5056366","0.5049718","0.5048582"],"string":"[\n \"0.7231365\",\n \"0.7075939\",\n \"0.68824524\",\n \"0.68168825\",\n \"0.6810663\",\n \"0.67609465\",\n \"0.6757198\",\n \"0.6710196\",\n \"0.6624161\",\n \"0.64982873\",\n \"0.648198\",\n \"0.6418159\",\n \"0.64083916\",\n \"0.64015394\",\n \"0.63641125\",\n \"0.63524777\",\n \"0.62306863\",\n \"0.62056756\",\n \"0.61384755\",\n \"0.60775584\",\n \"0.607103\",\n \"0.60419834\",\n \"0.60220134\",\n \"0.598051\",\n \"0.59713763\",\n \"0.5947856\",\n \"0.591183\",\n \"0.58984923\",\n \"0.5858018\",\n \"0.58275455\",\n \"0.5820291\",\n \"0.57639956\",\n \"0.5758791\",\n \"0.5679884\",\n \"0.5674746\",\n \"0.56616175\",\n \"0.56172085\",\n \"0.55935395\",\n \"0.55578405\",\n \"0.5556809\",\n \"0.5540111\",\n \"0.5539486\",\n \"0.55302894\",\n \"0.5517065\",\n \"0.5511611\",\n \"0.5488144\",\n \"0.5477822\",\n \"0.54580986\",\n \"0.5454252\",\n \"0.5446263\",\n \"0.54423577\",\n \"0.54406595\",\n \"0.54399\",\n \"0.5422685\",\n \"0.54102474\",\n \"0.54102474\",\n \"0.53971326\",\n \"0.5395943\",\n \"0.5379926\",\n \"0.5377695\",\n \"0.5353594\",\n \"0.53466594\",\n \"0.533185\",\n \"0.5327736\",\n \"0.53185034\",\n \"0.52887523\",\n \"0.52748996\",\n \"0.52679515\",\n \"0.52656186\",\n \"0.52629906\",\n \"0.52561927\",\n \"0.52495754\",\n \"0.5246184\",\n \"0.5218643\",\n \"0.52063936\",\n \"0.5189111\",\n \"0.5180287\",\n \"0.5172731\",\n \"0.5159735\",\n \"0.5158275\",\n \"0.51562065\",\n \"0.51546466\",\n \"0.5150887\",\n \"0.51320416\",\n \"0.5129424\",\n \"0.512157\",\n \"0.508713\",\n \"0.5087042\",\n \"0.5084663\",\n \"0.50835\",\n \"0.50826055\",\n \"0.5081957\",\n \"0.5075643\",\n \"0.5075643\",\n \"0.5070316\",\n \"0.50662166\",\n \"0.50594085\",\n \"0.5056366\",\n \"0.5049718\",\n \"0.5048582\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6824757"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":78596,"cells":{"query":{"kind":"string","value":"Function to get the value of making a discrete split."},"document":{"kind":"string","value":"def get_discrete_split_value ( feature_array: np.ndarray, target_array: np.ndarray, evaluate_function: Callable ):\n\n # First element is the weighted average evaluate_function of the split\n # Second term is the intrinsic value to penalize many splits.\n return (\n sum (\n [\n evaluate_function ( target_array [ feature_array == value ] ) * np.sum ( feature_array == value ) / len ( target_array )\n for value in set ( feature_array )\n ]\n ),\n -1\n * sum (\n [\n pipe (\n np.sum ( feature_array == value ) / len ( target_array ),\n lambda ratio: ratio * np.log ( ratio ),\n )\n for value in set ( feature_array )\n ]\n ),\n ) # End get_discrete_split_value()"},"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_discrete_split_value(arr: np.ndarray, y: np.ndarray, eval_func: Callable):\n\n # First element is the weighted average eval_func of the split\n # Second term is the intrinsic value to penalize many splits.\n return (\n sum(\n [\n eval_func(y[arr == value]) * np.sum(arr == value) / len(y)\n for value in set(arr)\n ]\n ),\n -1\n * sum(\n [\n pipe(\n np.sum(arr == value) / len(y),\n lambda ratio: ratio * np.log(ratio),\n )\n for value in set(arr)\n ]\n ),\n )","def get_factors():","def get_divide(self, ):\n return self.get_parameter('divide')","def num (self):\n return self.value[0]/self.value[1]","def get_optimal_discrete_feature_split(\n self, X: np.ndarray, y: np.ndarray, feature_col: int\n ):\n return BaseTree.get_discrete_split_value(\n X[:, feature_col], y, eval_func=self.eval_func\n )","def getSplitDetectorSignal(self):\r\n\t\treturn self.splitData","def split(axis: int) -> SplitDistribute:\n assert type(axis) is int\n assert str(axis) in _axis_str2split_axis_obj, \"not a valid split. expected: [0, 11)\"\n return _axis_str2split_axis_obj[str(axis)]","def get_discrete_distribution():\n random_int = random.randint(1, 4)\n if (random_int == 1) | (random_int == 2):\n return 0\n if random_int == 3:\n return 3\n if random_int == 4:\n return 5\n raise ValueError(\"Unable to generate discrete distribution with \", random_int)","def ipart(x):\n return np.floor(x)","def getSplit(self):\n b_index, b_value, b_score, b_groups = 999, 999, 999, None\n for j in range(len(self[0]) - 1):\n for i in range(len(self)):\n groups = self.splitAttribute(j, self[i][j]) # lit, big\n gini = self.giniIndex(groups)\n if gini < b_score and (j, \"%.1f\" % self[i][j]) not in self.atr:\n b_index, b_value, b_score, b_groups = j, self[i][\n j], gini, groups\n return b_index, b_value, b_groups, b_score","def curve_number(self):","def get_factors(val):\n N = np.sqrt(val)\n N = np.floor(N)\n M = val/N\n\n while (val % N != 0):\n N = N-1\n M = val/N\n\n return int(M), int(N)","def _discrete_log(self,x):\n # EVEN DUMBER IMPLEMENTATION!\n from sage.rings.infinity import Infinity\n if self.order() == Infinity:\n raise NotImplementedError(\"No black-box discrete log for infinite abelian groups\")\n u = [y for y in self.list() if y.element() == x]\n if len(u) == 0: raise TypeError(\"Not in group\")\n if len(u) > 1: raise NotImplementedError\n return u[0].vector()","def get_partition_rate(self):\n\t\treturn float(self.data_split)","def getDc(s):\n\treturn float(s.split(\"=\")[-1])*0.1","def get_optimal_discrete_feature_split (\n self, feature_matrix: np.ndarray, target_array: np.ndarray, feature_column: int\n ):\n return BaseTree.get_discrete_split_value (\n feature_matrix [ :, feature_column ], target_array, evaluate_function = self.evaluate_function\n ) # End get_optimal_discrete_feature_split","def test_get_prior_string_discrete(self):\n dim = Integer(\"yolo\", \"uniform\", 1, 2)\n assert dim.get_prior_string() == \"uniform(1, 3, discrete=True)\"","def get_div(self):\n if self.FDISTR == 1:\n return (self.HDIV1, self.HDIV2, self.VDIV1, self.VDIV2)\n elif self.FDISTR == 5:\n return (self.CONE_MIN, self.CONE_MAX)\n else:\n return None","def divide(self):\n return self._do_calc(self.divider)","def divide(self):\n return self._do_calc(self.divider)","def divide(self):\n return self._do_calc(self.divider)","def determine(value):\n i = -2\n for v in base_values:\n if value == v:\n return (value, 0, 1, 1)\n if value < v:\n break\n i += 1\n scaled = float(value) / 2 ** i\n if scaled >= 0.9375: # base value\n return (base_values[i], 0, 1, 1)\n elif scaled >= 0.8125:\n # septuplet: scaled = 0.875\n return (base_values[i + 1], 0, 7, 4)\n elif scaled >= 17 / 24.0:\n # triplet: scaled = 0.75\n return (base_values[i + 1], 0, 3, 2)\n elif scaled >= 31 / 48.0:\n # dotted note (one dot): scaled = 2/3.0\n return (v, 1, 1, 1)\n elif scaled >= 67 / 112.0:\n # quintuplet: scaled = 0.625\n return (base_values[i + 1], 0, 5, 4)\n d = 3\n for x in range(2, 5):\n d += 2 ** x\n if scaled == 2.0 ** x / d:\n return (v, x, 1, 1)\n return (base_values[i + 1], 0, 1, 1)","def SplitValues(self, *args):\n return _ShapeUpgrade.ShapeUpgrade_SplitCurve_SplitValues(self, *args)","def denominator(self, ???):","def fpart(x):\n return x - np.floor(x)","def discrete(self) -> bool:\n pass","def class_split(x):\r\n return np.split(x, [19,43])","def discrete_dataset(data):\n dataset = [0] * 10\n for value in data:\n dataset[value] += 1\n return dataset","def rfpart(x):\n return 1 - Util.fpart(x)","def _getSeparationWeightingForBlob(self, dataBlob):\n return self._separationWeighting_Random.valueForIntegerId(dataBlob.agentId)","def at (self, x):\n try:\n len (x)\n arr = True\n except:\n arr = False\n x = [x]\n i = np.digitize (np.asarray (x), self.bins) - 1\n if arr:\n return self.values[i]\n else:\n return float (self.values[i])","def splitmetric(self, dataset, attr, target_attr):\n freq = {}\n splitinfo = 0.0\n \n #Call information gain\n gain = ID3.splitmetric(self, dataset, attr, target_attr);\n samplenumbers = len(dataset)\n # Calculate the frequency of each of the values in the split attribute\n for record in dataset:\n if (record[attr] in freq):\n freq[record[attr]] += 1.0\n else:\n freq[record[attr]] = 1.0\n \n #Calculate split info, entropy of splitter\n for val in list(freq.values()):\n splitinfo += (- val / samplenumbers) * math.log(val / samplenumbers, 2)\n \n #Split info equals 0 when there only one class in data set\n if splitinfo == 0:\n splitinfo = 0.00000001\n \n return gain / splitinfo","def get_splits(self):\n\t\treturn self.k","def get_th_values(self):\n return (\n float(self.data[2]) / 10,\n int(self.data[3]),\n float(self.data[4]) / 10,\n )","def get_label_vals(self, line, getvals=1):\n # either split whole line (for whitespace) or go after specific separator\n if self.separator == 'ws':\n fields = line.split()\n label = fields.pop(0)\n vals = fields\n if label == '': return 0, '', []\n \n else:\n cind = line.find(self.separator)\n if cind < 0: return 0, '', []\n\n label = line[0:cind].strip()\n vals = line[cind+self.seplen:].split()\n\n if self.verb > 4:\n print('-- GLV: label %s, vals %s' % (label, vals))\n\n return 1, label, vals","def step_constant(step):\n return step","def rf_discrete(self, x, y):\n res = np.array([0] * x.shape[-1], dtype=int)\n interval_list = []\n x = np.column_stack((x, res))\n # model = RandomForestRegressor(n_estimators=60, max_depth=10)\n model = DecisionTreeRegressor(max_depth=10)\n model.fit(x, y)\n prediction, bias, contribution = ti.predict(model, x)\n # print(prediction, \"\\n\", bias, \"\\n\", contribution)\n '''\n for i in range(n):\n point1, point2 = stats.scoreatpercentile(x, [i*100/n, (i+1)*100/n])\n x1 = x[np.where((x >= point1) & (x <= point2))]\n mask = np.in1d(x, x1)\n res[mask] = (i + 1)\n # logging.info(\"discrete: \" + str(res) + str((point1, point2)))\n # logging.info(\"mask: \" + str(mask))\n # logging.info(\"discrete_main: \" + str(res)) \n '''\n # raise ValueError\n return res, interval_list","def return_category_from_value_HML(val):\n val = int(val.values[0])\n if val == 5:\n return 'H'\n elif val == 4:\n return 'M'\n else:\n return 'L'","def sd(vals):","def _get_one_split ( split_indices, number_of_split ):\n \n # Given the split indices, get the `number_of_split` element of the indices.\n return ( np.delete ( np.concatenate ( split_indices ), split_indices [ number_of_split ] ), # Drops the test from the train\n split_indices [ number_of_split ],) # Gets the train\n # End get_one_split","def _get_one_split ( split_indices, number_of_split ):\n \n # Given the split indices, get the `number_of_split` element of the indices.\n return ( np.delete ( np.concatenate ( split_indices ), split_indices [ number_of_split ] ), # Drops the test from the train\n split_indices [ number_of_split ],) # Gets the train\n # End get_one_split","def getstartingshape(vals):\n \n return 1","def discrete_rv(p):\n u = np.random.uniform()\n cdf = np.cumsum(p)\n j = np.searchsorted(cdf, u)\n return j","def dots(value, nr=1):\n return (0.5 * value) / (1.0 - 0.5 ** (nr + 1))","def div_value(self, lv, rv):","def random_splittable_variable(self) -> str:\n #print(\"enter bartpy/bartpy/data.py CovariateMatrix random_splittable_variable\")\n \n if self.is_at_least_one_splittable_variable():\n output = np.random.choice(np.array(self.splittable_variables()), 1)[0]\n #print(\"-exit bartpy/bartpy/data.py CovariateMatrix random_splittable_variable\")\n return output\n else:\n raise NoSplittableVariableException()\n #print(\"-exit bartpy/bartpy/data.py CovariateMatrix random_splittable_variable\")","def discrete_uniform_sampler(upper_value):\n return int(np.random.random() * upper_value)","def getSplit(self, array, left, right, epsilon):\r\n if epsilon < 10 ** (-6):\r\n return (left + right) / 2\r\n else:\r\n return self.getNoisyMedian(array, left, right, epsilon)","def ppcm_denominateurs(self):\n\t\tl = []\n\t\tn = 1\n\t\tif self.__valide:\n\t\t\tfor m in self.liste_decroissante():\n\t\t\t\t\"\"\" les denominateurs sont positifs \"\"\"\n\t\t\t\te = m.get_coefficient().get_denom().valeur()\n\t\t\t\tif not (e in l):\n\t\t\t\t\tl.append(e)\n\t\t\t\tn *= e\n\t\treturn n / pgcd_liste(l)","def process_env_action(self, discrete):\n discrete = np.array(discrete, dtype=np.float32)\n if discrete.shape[0] == self.space.bins.shape[0]:\n print(\"Already is continuous space:\", discrete)\n return discrete\n continuous = np.zeros([self.space.bins.shape[0]], dtype=np.float32)\n idx = 0\n for i in range(self.space.bins.shape[0]):\n for j in range(self.space.bins[i]):\n if discrete[idx + j] > 0:\n continuous[i] = j * self.space.intervals[i] + \\\n self.space.ranges[i, 0]\n break\n idx += self.space.bins[i]\n return continuous","def _discrete_exp(self, v):\n from six.moves import range\n v = self.V()(v)\n verbose(\"Calling discrete exp on %s\" % v)\n # DUMB IMPLEMENTATION!\n return sum([self._gen_elements[i] * ZZ(v[i]) for i in range(len(v))], self.universe()(0))","def getDivisors(n):","def ent_from_split(col, split_value, labels):\n idx_n1, idx_n2 = col <= split_value, col > split_value\n node1_x, node2_x = col[idx_n1], col[idx_n2]\n node1_y, node2_y = labels[idx_n1], labels[idx_n2]\n \n p_node1 = len(node1_x) / len(col)\n p_node2 = len(node2_x) / len(col)\n assert p_node1 + p_node2 == 1\n \n ent_node1 = entropy(sum(node1_y == 0), sum(node1_y == 1))\n ent_node2 = entropy(sum(node2_y == 0), sum(node2_y == 1))\n return float(p_node1*ent_node1 + p_node2*ent_node2)","def get_nominal(self, key):\n return ((hash(key) % 12) + 6.0) * 3","def discrete_scalar(n: int) -> TensorType:\n return TensorType(shape=(), eltype=Discrete(n))","def split_fraction(self):\n return np.array([self.__train_fraction, self.__test_fraction, self.__validation_fraction])","def intensity(self) -> int:","def value(self): \r\n c = self.nd1() * self.s * math.exp(-self.div * self.t)\r\n c -= self.nd2() * self.x * math.exp(-self.rf * self.t)\r\n \r\n return c","def getFactor(currency):","def FMScore(x,p,d):\n \n if x <= d[p][0.20]:\n return 1\n elif x <= d[p][0.4]:\n return 2\n elif x <= d[p][0.6]: \n return 3\n elif x <= d[p][0.8]:\n return 4\n else:\n return 5","def FMScore(x,p,d):\n \n if x <= d[p][0.20]:\n return 1\n elif x <= d[p][0.4]:\n return 2\n elif x <= d[p][0.6]: \n return 3\n elif x <= d[p][0.8]:\n return 4\n else:\n return 5","def getSplitFunc(self, splitType):\n if splitType.upper() == \"INFO GAIN\":\n return self.findBestColumnSplitByInfoGain\n elif splitType.upper() == \"GAIN RATIO\":\n return self.findBestColumnSplitByGainRatio\n elif splitType.upper() == \"GINI INDEX\":\n return self.findBestColumnSplitByGini\n return None","def value(self) -> float:","def test_basis_categorical():\n cat_data = ['sand'] * 20 + [np.nan] * 5 + ['cement'] * 10 + [np.nan] * 5\n curve_cat = Curve(cat_data, index=range(0, 40))\n curve_new = curve_cat.to_basis(start=5, stop=30, step=1)\n assert len(curve_new) == 26","def item_dois(n):\n if n <= 0.333:\n return 0\n elif n > 0.333 and n <= 0.667:\n return 1\n elif n > 0.667 and n <= 1.000:\n return 2","def bar(self):\n return self.val * 1.0","def value(self, step):\n raise NotImplementedError","def process_ml_action(self, continuous):\n continuous = np.array(continuous, dtype=np.float32)\n if continuous.shape[0] == self.space.n:\n print(\"Already in discrete space:\", continuous)\n return continuous\n discrete = np.zeros([self.space.n], dtype=np.float32)\n offsets = np.cumsum(np.concatenate([np.array([0]), self.space.bins[:-1]]))\n for i in range(continuous.shape[0]):\n if continuous[i] < self.space.ranges[i, 0]:\n continuous[i] = self.space.ranges[i, 0]\n elif continuous[i] > self.space.ranges[i, 1]:\n continuous[i] = self.space.ranges[i, 1]\n binidx = int(round((continuous[i] - self.space.ranges[i, 0]) /\n self.space.intervals[i]))\n if binidx < 0:\n binidx = 0\n elif binidx >= self.space.bins[i] - 1:\n binidx = self.space.bins[i] - 1\n discrete[binidx + offsets[i]] = 1.0\n return discrete","def general(self):\n return -self.line[[0, 2]] / self.line[1]","def __float__(self):\n return self.num / self.denom # result of / is of type float","def __float__(self):\n if (self.nvar == 0): return self.t[0]\n else: raise ValueError(\"Factor is not a scalar; scope {}\".format(self.v))","def Values(self) -> _n_1_t_4:","def denominator(self):\n return 1","def factor(P):\n cd = P[-1]\n if P.deg == 0:\n return (cd, defaultdict(int))\n P = P * (1 / cd)\n return (cd, P.factor_unit())","def division(self):\n return self._division","def get_split(self,X,y):\n \n BEST_COL = 0\n BEST_SPLIT =0\n BEST_IMPUR = 99\n for i,feature in enumerate(X.T):\n arg_sort=np.argsort(feature) #Sort the feature for optimizing the find of splitting points\n feature= feature[arg_sort]\n y_sort = y[arg_sort]\n splits = self.possible_splits(feature,y_sort) #Get \n\n impur,splits = self.test_split(feature,y_sort,splits) #Get impurity for splitting points\n best_idx = np.argmin(impur)\n best_impur = impur[best_idx]\n \n if best_impur==0.0: #Found perfect split, terminate\n return(i,splits[best_idx])\n elif best_impur<BEST_IMPUR:\n BEST_IMPUR=best_impur\n BEST_SPLIT=splits[best_idx]\n BEST_COL=i\n return (BEST_COL,BEST_SPLIT)","def item_tres(n):\n if n <= 0.167:\n return 0\n elif n > 0.167 and n <= 0.333:\n return 1\n elif n > 0.333 and n <= 0.500:\n return 2\n elif n > 0.500 and n <= 0.667:\n return 3\n elif n > 0.667 and n <= 0.834:\n return 4\n elif n > 0.834 and n <= 1.000:\n return 5","def Value(self) -> _n_0_t_14:","def value(self, x):\n if isinstance(x, (float,int)):\n return self._values[x >= self._boundaries[:-1]][-1]\n else:\n a = array([self._values[xi >= self._boundaries[:-1]][-1]\n for xi in x])\n return a","def bessel_value(m, x):\n return (1 / math.pi) * trapezium_rule(bessel, m, x, 0, math.pi, 10000)","def return_category_from_value_HL(val):\n val = int(val.values[0])\n if val >= 4:\n return 'H'\n else:\n return 'L'","def getSolRatioSteps( self, var, type = \"all\" ):\n\n values = self.getSolRatioData( var, type )\n return values[0]","def __float__(self):\n return self.num/self.denom","def __float__(self):\n return self.num/self.denom","def getInterval(self) -> float:\n\t\treturn self[self._bcni]","def get_chandelier(data):\n if data is None:\n raise EmptyDataError('[!] Invalid data value')\n\n result = TA.CHANDELIER(data)\n if result is None:\n raise IndicatorException\n return result","def div(self):\n a = self.nums()\n x = LibraryFunctions.per(a, 0.9) - LibraryFunctions.per(a, 0.1)\n return x / 2.58","def mid(self):\n return LibraryFunctions.per(self.nums(), 0.5)","def split_data(data,split_column,split_value):\n split_column_value = data[:,split_column]\n type_of_feature = FEATURE_TYPE[split_column]\n\n if type_of_feature == 'continuous':\n data_below = data[split_column_value <= split_value]\n data_above = data[split_column_value > split_value]\n else:\n data_below = data[split_column_value == split_value]\n data_above = data[split_column_value != split_value]\n return data_below,data_above","def split(self):\n return self.dataset_split","def valor(self):\n nbits = len(self.gens)\n dec = int(self.gens,2)\n real = self.min+dec*((self.max-self.min)/(math.pow(2,nbits)-1))\n return real","def dividir(value, arg):\n return int(value) /int(arg)","def random_splittable_value(self, variable: int) -> Any:\n #print(\"enter bartpy/bartpy/data.py CovariateMatrix random_splittable_value\")\n \n if variable not in self.splittable_variables():\n raise NoSplittableVariableException()\n max_value = self.max_value_of_column(variable)\n candidate = np.random.choice(self.get_column(variable))\n while candidate == max_value:\n candidate = np.random.choice(self.get_column(variable))\n #print(\"-exit bartpy/bartpy/data.py CovariateMatrix random_splittable_value\")\n return candidate","def convertToDiscreteFunction(doubleArray: typing.List[float]) -> cern.japc.value.DiscreteFunction:\n ...","def disc(x):\n return int(round(x))","def division(self, num, denom):\n inverse = self.extended_euclides(denom, self.prime)[0] # Apply our extended euclidean algo and obtain the first item of the list, this sould be the inverse\n return num * inverse # Multiply the inverse for the numerator to obtain quotient","def rfpart(x):\n return 1 - fpart(x)","def cut_conversion(string):\n if (string == 'Fair'):\n return 0.2\n if (string == 'Good'):\n return 0.4\n if (string == 'Very Good'):\n return 0.6\n if (string == 'Premium'):\n return 0.8\n if (string == 'Ideal'):\n return 1","def contrast(self, value: int, /) -> None:","def partition(self, sep):\n return asarray(partition(self, sep))"],"string":"[\n \"def get_discrete_split_value(arr: np.ndarray, y: np.ndarray, eval_func: Callable):\\n\\n # First element is the weighted average eval_func of the split\\n # Second term is the intrinsic value to penalize many splits.\\n return (\\n sum(\\n [\\n eval_func(y[arr == value]) * np.sum(arr == value) / len(y)\\n for value in set(arr)\\n ]\\n ),\\n -1\\n * sum(\\n [\\n pipe(\\n np.sum(arr == value) / len(y),\\n lambda ratio: ratio * np.log(ratio),\\n )\\n for value in set(arr)\\n ]\\n ),\\n )\",\n \"def get_factors():\",\n \"def get_divide(self, ):\\n return self.get_parameter('divide')\",\n \"def num (self):\\n return self.value[0]/self.value[1]\",\n \"def get_optimal_discrete_feature_split(\\n self, X: np.ndarray, y: np.ndarray, feature_col: int\\n ):\\n return BaseTree.get_discrete_split_value(\\n X[:, feature_col], y, eval_func=self.eval_func\\n )\",\n \"def getSplitDetectorSignal(self):\\r\\n\\t\\treturn self.splitData\",\n \"def split(axis: int) -> SplitDistribute:\\n assert type(axis) is int\\n assert str(axis) in _axis_str2split_axis_obj, \\\"not a valid split. expected: [0, 11)\\\"\\n return _axis_str2split_axis_obj[str(axis)]\",\n \"def get_discrete_distribution():\\n random_int = random.randint(1, 4)\\n if (random_int == 1) | (random_int == 2):\\n return 0\\n if random_int == 3:\\n return 3\\n if random_int == 4:\\n return 5\\n raise ValueError(\\\"Unable to generate discrete distribution with \\\", random_int)\",\n \"def ipart(x):\\n return np.floor(x)\",\n \"def getSplit(self):\\n b_index, b_value, b_score, b_groups = 999, 999, 999, None\\n for j in range(len(self[0]) - 1):\\n for i in range(len(self)):\\n groups = self.splitAttribute(j, self[i][j]) # lit, big\\n gini = self.giniIndex(groups)\\n if gini < b_score and (j, \\\"%.1f\\\" % self[i][j]) not in self.atr:\\n b_index, b_value, b_score, b_groups = j, self[i][\\n j], gini, groups\\n return b_index, b_value, b_groups, b_score\",\n \"def curve_number(self):\",\n \"def get_factors(val):\\n N = np.sqrt(val)\\n N = np.floor(N)\\n M = val/N\\n\\n while (val % N != 0):\\n N = N-1\\n M = val/N\\n\\n return int(M), int(N)\",\n \"def _discrete_log(self,x):\\n # EVEN DUMBER IMPLEMENTATION!\\n from sage.rings.infinity import Infinity\\n if self.order() == Infinity:\\n raise NotImplementedError(\\\"No black-box discrete log for infinite abelian groups\\\")\\n u = [y for y in self.list() if y.element() == x]\\n if len(u) == 0: raise TypeError(\\\"Not in group\\\")\\n if len(u) > 1: raise NotImplementedError\\n return u[0].vector()\",\n \"def get_partition_rate(self):\\n\\t\\treturn float(self.data_split)\",\n \"def getDc(s):\\n\\treturn float(s.split(\\\"=\\\")[-1])*0.1\",\n \"def get_optimal_discrete_feature_split (\\n self, feature_matrix: np.ndarray, target_array: np.ndarray, feature_column: int\\n ):\\n return BaseTree.get_discrete_split_value (\\n feature_matrix [ :, feature_column ], target_array, evaluate_function = self.evaluate_function\\n ) # End get_optimal_discrete_feature_split\",\n \"def test_get_prior_string_discrete(self):\\n dim = Integer(\\\"yolo\\\", \\\"uniform\\\", 1, 2)\\n assert dim.get_prior_string() == \\\"uniform(1, 3, discrete=True)\\\"\",\n \"def get_div(self):\\n if self.FDISTR == 1:\\n return (self.HDIV1, self.HDIV2, self.VDIV1, self.VDIV2)\\n elif self.FDISTR == 5:\\n return (self.CONE_MIN, self.CONE_MAX)\\n else:\\n return None\",\n \"def divide(self):\\n return self._do_calc(self.divider)\",\n \"def divide(self):\\n return self._do_calc(self.divider)\",\n \"def divide(self):\\n return self._do_calc(self.divider)\",\n \"def determine(value):\\n i = -2\\n for v in base_values:\\n if value == v:\\n return (value, 0, 1, 1)\\n if value < v:\\n break\\n i += 1\\n scaled = float(value) / 2 ** i\\n if scaled >= 0.9375: # base value\\n return (base_values[i], 0, 1, 1)\\n elif scaled >= 0.8125:\\n # septuplet: scaled = 0.875\\n return (base_values[i + 1], 0, 7, 4)\\n elif scaled >= 17 / 24.0:\\n # triplet: scaled = 0.75\\n return (base_values[i + 1], 0, 3, 2)\\n elif scaled >= 31 / 48.0:\\n # dotted note (one dot): scaled = 2/3.0\\n return (v, 1, 1, 1)\\n elif scaled >= 67 / 112.0:\\n # quintuplet: scaled = 0.625\\n return (base_values[i + 1], 0, 5, 4)\\n d = 3\\n for x in range(2, 5):\\n d += 2 ** x\\n if scaled == 2.0 ** x / d:\\n return (v, x, 1, 1)\\n return (base_values[i + 1], 0, 1, 1)\",\n \"def SplitValues(self, *args):\\n return _ShapeUpgrade.ShapeUpgrade_SplitCurve_SplitValues(self, *args)\",\n \"def denominator(self, ???):\",\n \"def fpart(x):\\n return x - np.floor(x)\",\n \"def discrete(self) -> bool:\\n pass\",\n \"def class_split(x):\\r\\n return np.split(x, [19,43])\",\n \"def discrete_dataset(data):\\n dataset = [0] * 10\\n for value in data:\\n dataset[value] += 1\\n return dataset\",\n \"def rfpart(x):\\n return 1 - Util.fpart(x)\",\n \"def _getSeparationWeightingForBlob(self, dataBlob):\\n return self._separationWeighting_Random.valueForIntegerId(dataBlob.agentId)\",\n \"def at (self, x):\\n try:\\n len (x)\\n arr = True\\n except:\\n arr = False\\n x = [x]\\n i = np.digitize (np.asarray (x), self.bins) - 1\\n if arr:\\n return self.values[i]\\n else:\\n return float (self.values[i])\",\n \"def splitmetric(self, dataset, attr, target_attr):\\n freq = {}\\n splitinfo = 0.0\\n \\n #Call information gain\\n gain = ID3.splitmetric(self, dataset, attr, target_attr);\\n samplenumbers = len(dataset)\\n # Calculate the frequency of each of the values in the split attribute\\n for record in dataset:\\n if (record[attr] in freq):\\n freq[record[attr]] += 1.0\\n else:\\n freq[record[attr]] = 1.0\\n \\n #Calculate split info, entropy of splitter\\n for val in list(freq.values()):\\n splitinfo += (- val / samplenumbers) * math.log(val / samplenumbers, 2)\\n \\n #Split info equals 0 when there only one class in data set\\n if splitinfo == 0:\\n splitinfo = 0.00000001\\n \\n return gain / splitinfo\",\n \"def get_splits(self):\\n\\t\\treturn self.k\",\n \"def get_th_values(self):\\n return (\\n float(self.data[2]) / 10,\\n int(self.data[3]),\\n float(self.data[4]) / 10,\\n )\",\n \"def get_label_vals(self, line, getvals=1):\\n # either split whole line (for whitespace) or go after specific separator\\n if self.separator == 'ws':\\n fields = line.split()\\n label = fields.pop(0)\\n vals = fields\\n if label == '': return 0, '', []\\n \\n else:\\n cind = line.find(self.separator)\\n if cind < 0: return 0, '', []\\n\\n label = line[0:cind].strip()\\n vals = line[cind+self.seplen:].split()\\n\\n if self.verb > 4:\\n print('-- GLV: label %s, vals %s' % (label, vals))\\n\\n return 1, label, vals\",\n \"def step_constant(step):\\n return step\",\n \"def rf_discrete(self, x, y):\\n res = np.array([0] * x.shape[-1], dtype=int)\\n interval_list = []\\n x = np.column_stack((x, res))\\n # model = RandomForestRegressor(n_estimators=60, max_depth=10)\\n model = DecisionTreeRegressor(max_depth=10)\\n model.fit(x, y)\\n prediction, bias, contribution = ti.predict(model, x)\\n # print(prediction, \\\"\\\\n\\\", bias, \\\"\\\\n\\\", contribution)\\n '''\\n for i in range(n):\\n point1, point2 = stats.scoreatpercentile(x, [i*100/n, (i+1)*100/n])\\n x1 = x[np.where((x >= point1) & (x <= point2))]\\n mask = np.in1d(x, x1)\\n res[mask] = (i + 1)\\n # logging.info(\\\"discrete: \\\" + str(res) + str((point1, point2)))\\n # logging.info(\\\"mask: \\\" + str(mask))\\n # logging.info(\\\"discrete_main: \\\" + str(res)) \\n '''\\n # raise ValueError\\n return res, interval_list\",\n \"def return_category_from_value_HML(val):\\n val = int(val.values[0])\\n if val == 5:\\n return 'H'\\n elif val == 4:\\n return 'M'\\n else:\\n return 'L'\",\n \"def sd(vals):\",\n \"def _get_one_split ( split_indices, number_of_split ):\\n \\n # Given the split indices, get the `number_of_split` element of the indices.\\n return ( np.delete ( np.concatenate ( split_indices ), split_indices [ number_of_split ] ), # Drops the test from the train\\n split_indices [ number_of_split ],) # Gets the train\\n # End get_one_split\",\n \"def _get_one_split ( split_indices, number_of_split ):\\n \\n # Given the split indices, get the `number_of_split` element of the indices.\\n return ( np.delete ( np.concatenate ( split_indices ), split_indices [ number_of_split ] ), # Drops the test from the train\\n split_indices [ number_of_split ],) # Gets the train\\n # End get_one_split\",\n \"def getstartingshape(vals):\\n \\n return 1\",\n \"def discrete_rv(p):\\n u = np.random.uniform()\\n cdf = np.cumsum(p)\\n j = np.searchsorted(cdf, u)\\n return j\",\n \"def dots(value, nr=1):\\n return (0.5 * value) / (1.0 - 0.5 ** (nr + 1))\",\n \"def div_value(self, lv, rv):\",\n \"def random_splittable_variable(self) -> str:\\n #print(\\\"enter bartpy/bartpy/data.py CovariateMatrix random_splittable_variable\\\")\\n \\n if self.is_at_least_one_splittable_variable():\\n output = np.random.choice(np.array(self.splittable_variables()), 1)[0]\\n #print(\\\"-exit bartpy/bartpy/data.py CovariateMatrix random_splittable_variable\\\")\\n return output\\n else:\\n raise NoSplittableVariableException()\\n #print(\\\"-exit bartpy/bartpy/data.py CovariateMatrix random_splittable_variable\\\")\",\n \"def discrete_uniform_sampler(upper_value):\\n return int(np.random.random() * upper_value)\",\n \"def getSplit(self, array, left, right, epsilon):\\r\\n if epsilon < 10 ** (-6):\\r\\n return (left + right) / 2\\r\\n else:\\r\\n return self.getNoisyMedian(array, left, right, epsilon)\",\n \"def ppcm_denominateurs(self):\\n\\t\\tl = []\\n\\t\\tn = 1\\n\\t\\tif self.__valide:\\n\\t\\t\\tfor m in self.liste_decroissante():\\n\\t\\t\\t\\t\\\"\\\"\\\" les denominateurs sont positifs \\\"\\\"\\\"\\n\\t\\t\\t\\te = m.get_coefficient().get_denom().valeur()\\n\\t\\t\\t\\tif not (e in l):\\n\\t\\t\\t\\t\\tl.append(e)\\n\\t\\t\\t\\tn *= e\\n\\t\\treturn n / pgcd_liste(l)\",\n \"def process_env_action(self, discrete):\\n discrete = np.array(discrete, dtype=np.float32)\\n if discrete.shape[0] == self.space.bins.shape[0]:\\n print(\\\"Already is continuous space:\\\", discrete)\\n return discrete\\n continuous = np.zeros([self.space.bins.shape[0]], dtype=np.float32)\\n idx = 0\\n for i in range(self.space.bins.shape[0]):\\n for j in range(self.space.bins[i]):\\n if discrete[idx + j] > 0:\\n continuous[i] = j * self.space.intervals[i] + \\\\\\n self.space.ranges[i, 0]\\n break\\n idx += self.space.bins[i]\\n return continuous\",\n \"def _discrete_exp(self, v):\\n from six.moves import range\\n v = self.V()(v)\\n verbose(\\\"Calling discrete exp on %s\\\" % v)\\n # DUMB IMPLEMENTATION!\\n return sum([self._gen_elements[i] * ZZ(v[i]) for i in range(len(v))], self.universe()(0))\",\n \"def getDivisors(n):\",\n \"def ent_from_split(col, split_value, labels):\\n idx_n1, idx_n2 = col <= split_value, col > split_value\\n node1_x, node2_x = col[idx_n1], col[idx_n2]\\n node1_y, node2_y = labels[idx_n1], labels[idx_n2]\\n \\n p_node1 = len(node1_x) / len(col)\\n p_node2 = len(node2_x) / len(col)\\n assert p_node1 + p_node2 == 1\\n \\n ent_node1 = entropy(sum(node1_y == 0), sum(node1_y == 1))\\n ent_node2 = entropy(sum(node2_y == 0), sum(node2_y == 1))\\n return float(p_node1*ent_node1 + p_node2*ent_node2)\",\n \"def get_nominal(self, key):\\n return ((hash(key) % 12) + 6.0) * 3\",\n \"def discrete_scalar(n: int) -> TensorType:\\n return TensorType(shape=(), eltype=Discrete(n))\",\n \"def split_fraction(self):\\n return np.array([self.__train_fraction, self.__test_fraction, self.__validation_fraction])\",\n \"def intensity(self) -> int:\",\n \"def value(self): \\r\\n c = self.nd1() * self.s * math.exp(-self.div * self.t)\\r\\n c -= self.nd2() * self.x * math.exp(-self.rf * self.t)\\r\\n \\r\\n return c\",\n \"def getFactor(currency):\",\n \"def FMScore(x,p,d):\\n \\n if x <= d[p][0.20]:\\n return 1\\n elif x <= d[p][0.4]:\\n return 2\\n elif x <= d[p][0.6]: \\n return 3\\n elif x <= d[p][0.8]:\\n return 4\\n else:\\n return 5\",\n \"def FMScore(x,p,d):\\n \\n if x <= d[p][0.20]:\\n return 1\\n elif x <= d[p][0.4]:\\n return 2\\n elif x <= d[p][0.6]: \\n return 3\\n elif x <= d[p][0.8]:\\n return 4\\n else:\\n return 5\",\n \"def getSplitFunc(self, splitType):\\n if splitType.upper() == \\\"INFO GAIN\\\":\\n return self.findBestColumnSplitByInfoGain\\n elif splitType.upper() == \\\"GAIN RATIO\\\":\\n return self.findBestColumnSplitByGainRatio\\n elif splitType.upper() == \\\"GINI INDEX\\\":\\n return self.findBestColumnSplitByGini\\n return None\",\n \"def value(self) -> float:\",\n \"def test_basis_categorical():\\n cat_data = ['sand'] * 20 + [np.nan] * 5 + ['cement'] * 10 + [np.nan] * 5\\n curve_cat = Curve(cat_data, index=range(0, 40))\\n curve_new = curve_cat.to_basis(start=5, stop=30, step=1)\\n assert len(curve_new) == 26\",\n \"def item_dois(n):\\n if n <= 0.333:\\n return 0\\n elif n > 0.333 and n <= 0.667:\\n return 1\\n elif n > 0.667 and n <= 1.000:\\n return 2\",\n \"def bar(self):\\n return self.val * 1.0\",\n \"def value(self, step):\\n raise NotImplementedError\",\n \"def process_ml_action(self, continuous):\\n continuous = np.array(continuous, dtype=np.float32)\\n if continuous.shape[0] == self.space.n:\\n print(\\\"Already in discrete space:\\\", continuous)\\n return continuous\\n discrete = np.zeros([self.space.n], dtype=np.float32)\\n offsets = np.cumsum(np.concatenate([np.array([0]), self.space.bins[:-1]]))\\n for i in range(continuous.shape[0]):\\n if continuous[i] < self.space.ranges[i, 0]:\\n continuous[i] = self.space.ranges[i, 0]\\n elif continuous[i] > self.space.ranges[i, 1]:\\n continuous[i] = self.space.ranges[i, 1]\\n binidx = int(round((continuous[i] - self.space.ranges[i, 0]) /\\n self.space.intervals[i]))\\n if binidx < 0:\\n binidx = 0\\n elif binidx >= self.space.bins[i] - 1:\\n binidx = self.space.bins[i] - 1\\n discrete[binidx + offsets[i]] = 1.0\\n return discrete\",\n \"def general(self):\\n return -self.line[[0, 2]] / self.line[1]\",\n \"def __float__(self):\\n return self.num / self.denom # result of / is of type float\",\n \"def __float__(self):\\n if (self.nvar == 0): return self.t[0]\\n else: raise ValueError(\\\"Factor is not a scalar; scope {}\\\".format(self.v))\",\n \"def Values(self) -> _n_1_t_4:\",\n \"def denominator(self):\\n return 1\",\n \"def factor(P):\\n cd = P[-1]\\n if P.deg == 0:\\n return (cd, defaultdict(int))\\n P = P * (1 / cd)\\n return (cd, P.factor_unit())\",\n \"def division(self):\\n return self._division\",\n \"def get_split(self,X,y):\\n \\n BEST_COL = 0\\n BEST_SPLIT =0\\n BEST_IMPUR = 99\\n for i,feature in enumerate(X.T):\\n arg_sort=np.argsort(feature) #Sort the feature for optimizing the find of splitting points\\n feature= feature[arg_sort]\\n y_sort = y[arg_sort]\\n splits = self.possible_splits(feature,y_sort) #Get \\n\\n impur,splits = self.test_split(feature,y_sort,splits) #Get impurity for splitting points\\n best_idx = np.argmin(impur)\\n best_impur = impur[best_idx]\\n \\n if best_impur==0.0: #Found perfect split, terminate\\n return(i,splits[best_idx])\\n elif best_impur<BEST_IMPUR:\\n BEST_IMPUR=best_impur\\n BEST_SPLIT=splits[best_idx]\\n BEST_COL=i\\n return (BEST_COL,BEST_SPLIT)\",\n \"def item_tres(n):\\n if n <= 0.167:\\n return 0\\n elif n > 0.167 and n <= 0.333:\\n return 1\\n elif n > 0.333 and n <= 0.500:\\n return 2\\n elif n > 0.500 and n <= 0.667:\\n return 3\\n elif n > 0.667 and n <= 0.834:\\n return 4\\n elif n > 0.834 and n <= 1.000:\\n return 5\",\n \"def Value(self) -> _n_0_t_14:\",\n \"def value(self, x):\\n if isinstance(x, (float,int)):\\n return self._values[x >= self._boundaries[:-1]][-1]\\n else:\\n a = array([self._values[xi >= self._boundaries[:-1]][-1]\\n for xi in x])\\n return a\",\n \"def bessel_value(m, x):\\n return (1 / math.pi) * trapezium_rule(bessel, m, x, 0, math.pi, 10000)\",\n \"def return_category_from_value_HL(val):\\n val = int(val.values[0])\\n if val >= 4:\\n return 'H'\\n else:\\n return 'L'\",\n \"def getSolRatioSteps( self, var, type = \\\"all\\\" ):\\n\\n values = self.getSolRatioData( var, type )\\n return values[0]\",\n \"def __float__(self):\\n return self.num/self.denom\",\n \"def __float__(self):\\n return self.num/self.denom\",\n \"def getInterval(self) -> float:\\n\\t\\treturn self[self._bcni]\",\n \"def get_chandelier(data):\\n if data is None:\\n raise EmptyDataError('[!] Invalid data value')\\n\\n result = TA.CHANDELIER(data)\\n if result is None:\\n raise IndicatorException\\n return result\",\n \"def div(self):\\n a = self.nums()\\n x = LibraryFunctions.per(a, 0.9) - LibraryFunctions.per(a, 0.1)\\n return x / 2.58\",\n \"def mid(self):\\n return LibraryFunctions.per(self.nums(), 0.5)\",\n \"def split_data(data,split_column,split_value):\\n split_column_value = data[:,split_column]\\n type_of_feature = FEATURE_TYPE[split_column]\\n\\n if type_of_feature == 'continuous':\\n data_below = data[split_column_value <= split_value]\\n data_above = data[split_column_value > split_value]\\n else:\\n data_below = data[split_column_value == split_value]\\n data_above = data[split_column_value != split_value]\\n return data_below,data_above\",\n \"def split(self):\\n return self.dataset_split\",\n \"def valor(self):\\n nbits = len(self.gens)\\n dec = int(self.gens,2)\\n real = self.min+dec*((self.max-self.min)/(math.pow(2,nbits)-1))\\n return real\",\n \"def dividir(value, arg):\\n return int(value) /int(arg)\",\n \"def random_splittable_value(self, variable: int) -> Any:\\n #print(\\\"enter bartpy/bartpy/data.py CovariateMatrix random_splittable_value\\\")\\n \\n if variable not in self.splittable_variables():\\n raise NoSplittableVariableException()\\n max_value = self.max_value_of_column(variable)\\n candidate = np.random.choice(self.get_column(variable))\\n while candidate == max_value:\\n candidate = np.random.choice(self.get_column(variable))\\n #print(\\\"-exit bartpy/bartpy/data.py CovariateMatrix random_splittable_value\\\")\\n return candidate\",\n \"def convertToDiscreteFunction(doubleArray: typing.List[float]) -> cern.japc.value.DiscreteFunction:\\n ...\",\n \"def disc(x):\\n return int(round(x))\",\n \"def division(self, num, denom):\\n inverse = self.extended_euclides(denom, self.prime)[0] # Apply our extended euclidean algo and obtain the first item of the list, this sould be the inverse\\n return num * inverse # Multiply the inverse for the numerator to obtain quotient\",\n \"def rfpart(x):\\n return 1 - fpart(x)\",\n \"def cut_conversion(string):\\n if (string == 'Fair'):\\n return 0.2\\n if (string == 'Good'):\\n return 0.4\\n if (string == 'Very Good'):\\n return 0.6\\n if (string == 'Premium'):\\n return 0.8\\n if (string == 'Ideal'):\\n return 1\",\n \"def contrast(self, value: int, /) -> None:\",\n \"def partition(self, sep):\\n return asarray(partition(self, sep))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65154564","0.5932024","0.5635929","0.56241894","0.5608168","0.5515022","0.5504383","0.54864615","0.53911495","0.5371303","0.53537226","0.5306154","0.5295001","0.5242035","0.5230267","0.5224207","0.52195615","0.52148545","0.5210651","0.5210651","0.5210651","0.5161574","0.51558036","0.5140249","0.512983","0.51196396","0.5116109","0.51132274","0.51000243","0.50970453","0.50925064","0.50857455","0.5064693","0.50645506","0.5060543","0.5047388","0.50402415","0.50359046","0.50233066","0.5018202","0.5018202","0.50129294","0.5006778","0.5003789","0.49913737","0.49606642","0.49542415","0.49534693","0.49452662","0.49445137","0.4935138","0.49303922","0.492935","0.49142","0.49080202","0.49057576","0.49048817","0.4902183","0.49012727","0.4889592","0.4889592","0.48878154","0.4887451","0.48818183","0.4881496","0.48803717","0.4875515","0.48744","0.48706982","0.4866095","0.48639897","0.48470095","0.48417073","0.48404026","0.48386487","0.48374352","0.48367834","0.48355544","0.48302484","0.4825516","0.48209897","0.48135033","0.48122564","0.48122564","0.48096958","0.48023096","0.48001522","0.4793753","0.47911125","0.47871667","0.47557253","0.47551453","0.4753607","0.4751491","0.47495613","0.4736886","0.4735405","0.4728853","0.47165436","0.47126135"],"string":"[\n \"0.65154564\",\n \"0.5932024\",\n \"0.5635929\",\n \"0.56241894\",\n \"0.5608168\",\n \"0.5515022\",\n \"0.5504383\",\n \"0.54864615\",\n \"0.53911495\",\n \"0.5371303\",\n \"0.53537226\",\n \"0.5306154\",\n \"0.5295001\",\n \"0.5242035\",\n \"0.5230267\",\n \"0.5224207\",\n \"0.52195615\",\n \"0.52148545\",\n \"0.5210651\",\n \"0.5210651\",\n \"0.5210651\",\n \"0.5161574\",\n \"0.51558036\",\n \"0.5140249\",\n \"0.512983\",\n \"0.51196396\",\n \"0.5116109\",\n \"0.51132274\",\n \"0.51000243\",\n \"0.50970453\",\n \"0.50925064\",\n \"0.50857455\",\n \"0.5064693\",\n \"0.50645506\",\n \"0.5060543\",\n \"0.5047388\",\n \"0.50402415\",\n \"0.50359046\",\n \"0.50233066\",\n \"0.5018202\",\n \"0.5018202\",\n \"0.50129294\",\n \"0.5006778\",\n \"0.5003789\",\n \"0.49913737\",\n \"0.49606642\",\n \"0.49542415\",\n \"0.49534693\",\n \"0.49452662\",\n \"0.49445137\",\n \"0.4935138\",\n \"0.49303922\",\n \"0.492935\",\n \"0.49142\",\n \"0.49080202\",\n \"0.49057576\",\n \"0.49048817\",\n \"0.4902183\",\n \"0.49012727\",\n \"0.4889592\",\n \"0.4889592\",\n \"0.48878154\",\n \"0.4887451\",\n \"0.48818183\",\n \"0.4881496\",\n \"0.48803717\",\n \"0.4875515\",\n \"0.48744\",\n \"0.48706982\",\n \"0.4866095\",\n \"0.48639897\",\n \"0.48470095\",\n \"0.48417073\",\n \"0.48404026\",\n \"0.48386487\",\n \"0.48374352\",\n \"0.48367834\",\n \"0.48355544\",\n \"0.48302484\",\n \"0.4825516\",\n \"0.48209897\",\n \"0.48135033\",\n \"0.48122564\",\n \"0.48122564\",\n \"0.48096958\",\n \"0.48023096\",\n \"0.48001522\",\n \"0.4793753\",\n \"0.47911125\",\n \"0.47871667\",\n \"0.47557253\",\n \"0.47551453\",\n \"0.4753607\",\n \"0.4751491\",\n \"0.47495613\",\n \"0.4736886\",\n \"0.4735405\",\n \"0.4728853\",\n \"0.47165436\",\n \"0.47126135\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.64066917"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":78597,"cells":{"query":{"kind":"string","value":"Function to get the best split value for a discrete columns"},"document":{"kind":"string","value":"def get_optimal_discrete_feature_split (\n self, feature_matrix: np.ndarray, target_array: np.ndarray, feature_column: int\n ):\n return BaseTree.get_discrete_split_value (\n feature_matrix [ :, feature_column ], target_array, evaluate_function = self.evaluate_function\n ) # End get_optimal_discrete_feature_split"},"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 determine_best_split(data, potential_splits, mltask):\n\n first_iteration = True\n for column_index in potential_splits:\n for value in potential_splits[column_index]:\n data_below,data_above = split_data(data, column_index, value)\n \n if mltask == 'regression':\n current_overall_metric = calculate_overall_metric(data_below, data_above, metric_function = calculate_mse)\n \n # classification\n else:\n current_overall_metric = calculate_overall_metric(data_below, data_above, metric_function = calculate_entropy)\n \n \n if first_iteration or current_overall_metric <= best_overall_metric:\n first_iteration = False\n \n best_overall_metric = current_overall_metric\n best_split_column = column_index\n best_split_value = value\n \n \n return best_split_column,best_split_value","def get_best_split_all(x, y) -> Tuple[int, float, float]:\n m = x.shape[1]\n col_best_gin = np.ones(shape=m)\n col_best_val = np.ones(shape=m)\n for c in range(m):\n best = 1\n best_x = 0\n for i in np.unique(x[:, c]):\n gini = Tree.split(x[:, c], y, i)\n if gini < best:\n best = gini\n best_x = i\n col_best_gin[c] = best\n col_best_val[c] = best_x\n\n # Select best feature to split on\n col_idx = np.argmin(col_best_gin)\n # Convert to bool index\n col_idx = np.array(range(x.shape[1])) == col_idx\n\n return col_idx, col_best_val[col_idx], col_best_gin[col_idx]","def get_split(data):\n \"\"\" gets the best feature, and best value \"\"\"\n\n best_feature = None\n best_value = 0.0\n columns = data.columns\n gini_base = gini_impurity(data)\n n_rows = len(data.index) # total number of rows of data before split\n\n # Fininding which split yields the best gini gain\n max_gain = 0\n\n for i in range(len(columns)-1): # -1 b.c. class is final column\n xs = data[columns[i]].unique() # get values to test\n for x in xs: # test values\n # split dataset\n df_left = data[data[columns[i]] < x]\n df_right = data[data[columns[i]] >= x]\n\n # get gini impurities\n gini_left = gini_impurity(df_left)\n gini_right = gini_impurity(df_right)\n \n\n # Calculated weighted gini impurity\n w_left = len(df_left.index) / n_rows\n w_right = len(df_right.index) / n_rows\n\n w_gini = gini_left * w_left + gini_right * w_right\n \n\n # Calculate gini gain (we want to minimize w_gini for the smallest impurity. Ideal split is perfect Left=c1, Right=c2)\n # why not just find min w_gin instead of uding gini_gain and gini_base vaiables?\n gini_gain = gini_base - w_gini\n\n # check if this is the best split so far, store values, update max_gini\n if gini_gain > max_gain:\n best_feature = columns[i]\n best_value = x\n max_gain = gini_gain\n\n df_left = data.loc[data[best_feature] < best_value]\n df_right = data.loc[data[best_feature] >= best_value]\n \n\n return best_feature, best_value, df_left, df_right","def find_best_split(rows):\n best_gain = 0 # keep track of the best information gain\n best_question = None # keep train of the feature / value that produced it\n current_uncertainty = gini(rows)\n n_features = len(rows[0]) - 1 # number of columns\n #print(\"n_features:\", n_features)\n\n for col in range(1,n_features): # for each feature\n # for each iteration this is the set of all values of a specific column, eg, All pixels number 0\n values = set([row[col] for row in rows]) # unique values in the column\n for val in values: # for each value\n\n # Create a question object for each val under a column, holding the val and the col number\n question = Question(col, val)\n\n # try splitting the dataset\n true_rows, false_rows = partition(rows, question)\n\n # Skip this split if it doesn't divide the\n # dataset.\n if len(true_rows) == 0 or len(false_rows) == 0:\n continue\n\n # Calculate the information gain from this split\n gain = info_gain(true_rows, false_rows, current_uncertainty)\n\n # You actually can use '>' instead of '>=' here\n # but I wanted the tree to look a certain way for our\n # toy dataset.\n if gain >= best_gain:\n best_gain, best_question = gain, question\n\n return best_gain, best_question","def get_best_split(rows):\n best_gain = 0\n best_question = None\n current_impurity = get_gini(rows)\n n_features = len(rows[0])\n\n for col in range(n_features):\n\n for row in rows:\n question = Question(col, row[col])\n true_rows, false_rows = partition(rows, question)\n\n if len(true_rows) == 0 or len(false_rows) == 0:\n break\n\n question_gain = get_info_gain(true_rows, false_rows, current_impurity)\n\n if question_gain >= best_gain:\n best_gain = question_gain\n best_question = question\n\n print(best_gain)\n print(best_question)\n return best_gain, best_question","def findBestColumnSplitByGainRatio(self, data, structure):\n maxGainRatio, bestSplit = 0, None\n for colName in list(structure.keys())[:-1]:\n GainRatio = self.calcGainRatioSplitByColumn(data, structure, colName)\n if GainRatio >= maxGainRatio:\n maxGainRatio = GainRatio\n bestSplit = colName\n return bestSplit","def get_split(self,X,y):\n \n BEST_COL = 0\n BEST_SPLIT =0\n BEST_IMPUR = 99\n for i,feature in enumerate(X.T):\n arg_sort=np.argsort(feature) #Sort the feature for optimizing the find of splitting points\n feature= feature[arg_sort]\n y_sort = y[arg_sort]\n splits = self.possible_splits(feature,y_sort) #Get \n\n impur,splits = self.test_split(feature,y_sort,splits) #Get impurity for splitting points\n best_idx = np.argmin(impur)\n best_impur = impur[best_idx]\n \n if best_impur==0.0: #Found perfect split, terminate\n return(i,splits[best_idx])\n elif best_impur<BEST_IMPUR:\n BEST_IMPUR=best_impur\n BEST_SPLIT=splits[best_idx]\n BEST_COL=i\n return (BEST_COL,BEST_SPLIT)","def getSplitFunc(self, splitType):\n if splitType.upper() == \"INFO GAIN\":\n return self.findBestColumnSplitByInfoGain\n elif splitType.upper() == \"GAIN RATIO\":\n return self.findBestColumnSplitByGainRatio\n elif splitType.upper() == \"GINI INDEX\":\n return self.findBestColumnSplitByGini\n return None","def findBestColumnSplitByGini(self, data, structure):\n minGini, bestSplit = 1, None\n for colName in list(structure.keys())[:-1]:\n giniSplit = self.calcGiniSplitByColumn(data, structure, colName)\n if giniSplit <= minGini:\n minGini = giniSplit\n bestSplit = colName\n return bestSplit","def findBestColumnSplitByInfoGain(self, data, structure):\n maxInfoGain, bestSplit = 0, None\n for colName in list(structure.keys())[:-1]:\n infoGain = self.calcInfoGainByColumnSplit(data, structure, colName)\n if infoGain >= maxInfoGain:\n maxInfoGain = infoGain\n bestSplit = colName\n return bestSplit","def pick_best_split(self,db,labels,ids,features=None):\n idlabels = [labels[id] for id in ids]\n if misclassification_error(idlabels) == 0:\n #base case: no misclassifications\n self.type = 'v'\n self.value = idlabels[0]\n return 0\n best = None\n bestCost = 0\n splitval = None\n discrete = True\n if features == None:\n if len(ids) < db.numFeatures():\n #look at all present features in the training set\n features = db.getPresentFeatures(ids)\n #print len(features),\"of\",db.numFeatures(),\"features selected\"\n else:\n features = range(db.numFeatures())\n elif callable(features):\n features = features()\n for i in features:\n if len(db.entryLists[i]) == 0: continue\n idiscrete = db.discreteFeature[i]\n if idiscrete:\n #count number of labels of a certain value\n splitter = defaultdict(lambda:defaultdict(int))\n #count of labels for missing values\n nmissing = defaultdict(int)\n for id in ids:\n val = db[i,id]\n if val is None:\n #missing values go down to all splits\n nmissing[labels[id]] += 1\n continue\n splitter[val][labels[id]] += 1\n if len(splitter) > continuous_variable_threshold:\n #print \"Determined to be a continuous variable\"\n idiscrete = False\n break\n if idiscrete:\n if len(splitter) <= 1:\n #only a single value\n continue\n #count number of missing values in all splits\n cmax = 0\n for k in splitter:\n for l,v in nmissing.iteritems():\n splitter[k][l] += v\n cmax = max(cmax,sum(splitter[k].values()))\n #shrink by fraction of (# of ids - largest child)/(# of ids)\n scale = (1.0-float(cmax)/float(len(ids)))*len(splitter)\n #evaluate cost\n cost = split_cost(splitter.values())*scale\n #print \"Split on\",i,\"information gain\",-cost,splitter.values()\n else:\n #continuous, need to learn the best split\n vals = []\n presentlabels = []\n nonelabels = []\n for id in ids:\n val = db[i,id]\n if val is None:\n nonelabels.append(labels[id])\n continue\n vals.append(val)\n presentlabels.append(labels[id])\n if len(vals) <= 1:\n print \"No values for feature\",i,\"?\"\n print vals\n continue\n #print \"Considering continuous split on\",i\n s,cost = best_split(vals,presentlabels,nonelabels)\n scale = (1.0-float(len(presentlabels)/2+len(nonelabels))/float(len(ids)))*2\n cost *= scale\n #print \"Result\",s,\"Information gain\",-cost\n \n if cost < bestCost:\n best = i\n bestCost = cost\n discrete = idiscrete\n if not idiscrete:\n splitval = s\n \n if best is None:\n self.type = 'v'\n if len(ids) > 0:\n self.value = vote(idlabels)\n return misclassification_error(idlabels)\n else:\n self.value = None\n return 0\n else:\n self.feature = best\n #discrete or inequality split\n if discrete:\n self.type = 's'\n else:\n self.type = 'i'\n self.value = splitval\n return bestCost","def findBestValueSplitByGini(self, data, structure, colIndex):\n minGini, bestSplit = 1, []\n for i in range(0, len(data)-1):\n split = (float(data[i][colIndex]) + float(data[i+1][colIndex])) / 2\n giniSplit = self.calcGiniSplitBySplitValue(data, structure, colIndex, split)\n if giniSplit <= minGini:\n minGini = giniSplit\n bestSplit = [split, giniSplit]\n return bestSplit","def get_optimal_continuous_feature_split(\n self, X: np.ndarray, y: np.ndarray, feature_col: int\n ):\n midpoints = BaseTree.get_valid_midpoints(arr=X[:, feature_col], y=y)\n # If midpoints, get the best one\n if len(midpoints) > 0:\n return BaseTree.get_min_across_splits_continuous(\n arr=X[:, feature_col], y=y, splits=midpoints, eval_func=self.eval_func\n )\n\n # If no split points, return inf (can't split here)\n return (0, np.inf, 1)","def get_best_split(rows: list) -> (float, Question):\n best_info_gain = 0\n best_question = None\n current_uncertainty = get_gini_impurity(rows)\n\n # minus 1 because we're ignoring the last column which is the label.\n n_attributes = len(rows[0]) - 1\n\n for col in range(n_attributes):\n\n # get all unique values for an attribute/column\n unique_values = set([row[col] for row in rows])\n\n for value in unique_values:\n question = Question(col, value)\n\n # Split rows depending on the question\n true_rows, false_rows = partition(rows, question)\n\n # We don't want to partition such rows\n if len(true_rows) == 0 or len(false_rows) == 0:\n continue\n\n # Get info gain from this split\n info_gain = get_info_gain(false_rows, true_rows, current_uncertainty)\n\n if info_gain > best_info_gain:\n best_info_gain, best_question = info_gain, question\n\n return best_info_gain, best_question","def __find_best_split(self, x, y):\n data = np.transpose(np.vstack((np.transpose(x), y)))\n num_features = data.shape[1] - 1\n\n # initialise splitting rule components\n integer_splitting_rule = None\n feature_index_to_split = None\n max_info_gain = 0\n\n # iterate over all the features and find best splits within these\n for feature in range(num_features):\n info_gain, split_int = self.__find_best_split_in_feature(\n data[:, [feature, -1]])\n if info_gain is None:\n continue\n # update max info gain so far as it iterates over features\n if info_gain > max_info_gain:\n max_info_gain = info_gain\n feature_index_to_split = feature\n integer_splitting_rule = int(split_int)\n\n return feature_index_to_split, integer_splitting_rule","def best_split(self):\r\n best_splits = [[0, None, None]]\r\n impurity, best_S, best_xj = 0, None, None\r\n \r\n for xj in self.x_names:\r\n for S in self.potential_splits(xj):\r\n ir = float(self.impurity_reduction(xj, S))\r\n if ir > impurity:\r\n impurity, best_S, best_xj = ir, S, xj\r\n best_splits.append([S, xj])\r\n else: \r\n pass\r\n \r\n return best_S, best_xj","def get_optimal_discrete_feature_split(\n self, X: np.ndarray, y: np.ndarray, feature_col: int\n ):\n return BaseTree.get_discrete_split_value(\n X[:, feature_col], y, eval_func=self.eval_func\n )","def best_split(values,labels,nonelabels=None):\n assert len(values) >= 2\n assert len(values) == len(labels)\n N = len(values)\n ilist = sorted((v,l) for (v,l) in zip(values,labels))\n leftcount = defaultdict(int)\n rightcount = defaultdict(int)\n for v,l in ilist:\n rightcount[l] += 1\n bestindex = -1\n bestcost = split_cost([leftcount,rightcount])\n\n cost = bestcost\n #costs = [cost]\n #print \"Split costs:\"\n for i in xrange(len(ilist)):\n v,l = ilist[i]\n rightcount[l] -= 1\n leftcount[l] += 1\n if i+1 >= len(ilist) or v == ilist[i+1][0]:\n #no splits when v is equal to the next value\n continue\n cost = split_cost([leftcount,rightcount])\n #print \" \",v,leftcount.values(),rightcount.values(),cost\n #costs.append(cost)\n if cost < bestcost:\n bestcost = cost\n bestindex = i\n #raw_input()\n if bestindex < 0:\n #no split found... try splitting in half\n splitval = (ilist[0][0]+ilist[-1][0])*0.5\n else:\n splitval = (ilist[bestindex][0] + ilist[bestindex+1][0])*0.5\n if nonelabels is None:\n return (splitval,bestcost)\n #reevaluate counts\n leftcount = defaultdict(int)\n rightcount = defaultdict(int)\n for l in nonelabels:\n leftcount[l] += 1\n rightcount[l] += 1\n for v,l in ilist:\n if v <= splitval:\n leftcount[l] += 1\n else:\n rightcount[l] += 1\n return splitval,split_cost([leftcount,rightcount])","def findBestSplitInDataByInfoGain(self, data, structure, colName):\n colIndex, maxInfoGain, bestSplit = structure[colName]['index'], 0, []\n for i in range(0, len(data)-1):\n split = (float(data[i][colIndex]) + float(data[i+1][colIndex])) / 2\n infoGain = self.calcInfoGainBySplitValue(data, structure, colName, split)\n if infoGain >= maxInfoGain:\n bestSplit = [split, infoGain]\n maxInfoGain = infoGain\n return bestSplit","def split_data(data,split_column,split_value):\n split_column_value = data[:,split_column]\n type_of_feature = FEATURE_TYPE[split_column]\n\n if type_of_feature == 'continuous':\n data_below = data[split_column_value <= split_value]\n data_above = data[split_column_value > split_value]\n else:\n data_below = data[split_column_value == split_value]\n data_above = data[split_column_value != split_value]\n return data_below,data_above","def random_splittable_value(self, variable: int) -> Any:\n #print(\"enter bartpy/bartpy/data.py CovariateMatrix random_splittable_value\")\n \n if variable not in self.splittable_variables():\n raise NoSplittableVariableException()\n max_value = self.max_value_of_column(variable)\n candidate = np.random.choice(self.get_column(variable))\n while candidate == max_value:\n candidate = np.random.choice(self.get_column(variable))\n #print(\"-exit bartpy/bartpy/data.py CovariateMatrix random_splittable_value\")\n return candidate","def getSplit(self):\n b_index, b_value, b_score, b_groups = 999, 999, 999, None\n for j in range(len(self[0]) - 1):\n for i in range(len(self)):\n groups = self.splitAttribute(j, self[i][j]) # lit, big\n gini = self.giniIndex(groups)\n if gini < b_score and (j, \"%.1f\" % self[i][j]) not in self.atr:\n b_index, b_value, b_score, b_groups = j, self[i][\n j], gini, groups\n return b_index, b_value, b_groups, b_score","def _optimal_splits (self, split_axis):\n n = len(self.displays)\n size = self.screen.get_size()\n # sizes in directions of first/second split\n s1 = size[split_axis]\n s2 = size[not split_axis]\n ratio = self.ratio\n # use screen aspect ratio if no preferred one given\n if ratio is None:\n ratio = float(size[0]) / size[1]\n error = []\n for splits in xrange(1, n + 1):\n # maximal number of displays per row/column\n per_split = ceil(float(n) / splits)\n # minimise unused space (as a fraction of the screen)\n space_e = abs(1 - float(n) / (splits * per_split))\n # and ratio (we care about proportionality, so use log)\n disp_ratio = float(s1 * splits) / (s2 * per_split)\n if split_axis == 1:\n # inverted if splitting into columns\n disp_ratio = 1 / disp_ratio\n ratio_e = abs(log(disp_ratio / ratio))\n # adjust using some constants\n e = space_e + ratio_e\n error.append((e, splits))\n return min(error)","def find_splits(col):\n unique = np.unique(sorted(col))\n splits = np.array([np.mean([unique[i], unique[i+1]]) for i in range(len(unique)-1)])\n return splits","def _bestFeat2split(dataSet, impurity_crit, min_impurity_decrease, min_samples_split):\n\t\tm, n = dataSet.shape\n\t\tbestFeatInd, bestVal = None, DecisionTree._make_leaf(dataSet, impurity_crit)\n\n\t\tif m < min_samples_split or len(set(dataSet[:,-1])) == 1:\n\t\t\treturn bestFeatInd, bestVal\n\n\t\timpurity = m * impurity_crit(dataSet)\n\t\tmin_impurity = np.inf\n\t\t\n\n\t\tfor feat_ind in range(n-1):\n\t\t\tif type(dataSet[:, feat_ind][0]) != str:\n\t\t\t\tuniqVal = set(dataSet[:, feat_ind])\n\t\t\telse:\n\t\t\t\tuniqVal = map(set, subsets(list(dataSet[:, feat_ind])))\n\t\t\tfor val in uniqVal:\n\t\t\t\tD1, D2 = DecisionTree._binarySplit(dataSet, feat_ind, val)\n\t\t\t\tif len(D1) < min_samples_split or len(D2) < min_samples_split:\n\t\t\t\t\tcontinue\n\t\t\t\tnew_impurity = len(D1)*impurity_crit(D1) + len(D2)*impurity_crit(D2)\n\t\t\t\tif impurity - new_impurity < min_impurity_decrease:\n\t\t\t\t\tcontinue\n\t\t\t\tif new_impurity < min_impurity:\n\t\t\t\t\tmin_impurity = new_impurity\n\t\t\t\t\tbestFeatInd = feat_ind; bestVal = val\n\t\treturn bestFeatInd, bestVal","def split(self,best):\n\t\treturn self.cu_for_split(best,False)","def get_next_split ( self, feature_matrix: np.ndarray, target_array: np.ndarray, tree_split: TreeSplits):\n # If only 1 y value, make a leaf node\n if len ( set ( target_array ) ) == 1:\n tree_split.updateTreeValues (\n feature_column = None,\n feature_value = None,\n node_type = None,\n nodes = {},\n children = target_array,\n )\n return tree_split\n\n # Get the presplit entropy\n presplit_entropy = self.evaluate_function ( target_array )\n\n column_values = {}\n for k, v in self.map_column_node_type.items():\n # If there's only one value in feature matrix \"X\", set the split value to infinity\n if len ( set ( feature_matrix [ :, k ] ) ) == 1:\n value = np.inf\n split = None\n class_ratios = 1\n elif v == \"continuous\":\n # Get the best possible continuous split for the column\n split, value, class_ratios = self.get_optimal_continuous_feature_split (\n feature_matrix = feature_matrix, target_array = target_array, feature_column = k\n )\n else:\n # Get the split value for the discrete column\n value, class_ratios = self.get_optimal_discrete_feature_split (\n feature_matrix = feature_matrix, target_array = target_array, feature_column = k\n )\n split = None\n\n column_values [ k ] = ( split, value, class_ratios )\n\n # Get the column with the largest gain ratio\n col_idx_with_min_value = max (\n column_values,\n key = lambda x: ( presplit_entropy - column_values.get ( x ) [ 1 ] )\n / column_values.get ( x ) [ 2 ],\n )\n\n # If stopping criteria are met or all splits are infinite, terminate the process\n if (\n self.early_stopping_comparison (\n column_values.get ( col_idx_with_min_value ) [ 1 ], self.early_stopping_value\n )\n ) or not np.isfinite ( column_values.get ( col_idx_with_min_value ) [ 1 ] ):\n self.get_terminal_node (\n feature_column = col_idx_with_min_value,\n feature_value = column_values [ col_idx_with_min_value ] [ 0 ],\n node = tree_split,\n feature_matrix = feature_matrix ,\n target_array = target_array,\n )\n return tree_split\n\n # If the best split is continuous, add a continuous node\n if self.map_column_node_type.get ( col_idx_with_min_value ) == \"continuous\":\n return self.get_continuous_node (\n feature_column = col_idx_with_min_value,\n feature_value = column_values [col_idx_with_min_value ] [ 0 ],\n feature_matrix = feature_matrix,\n target_array = target_array,\n node = tree_split,\n )\n\n # Otherwise, add a discrete node.\n else:\n return self.get_discrete_node (\n feature_matrix = feature_matrix,\n target_array = target_array,\n feature_value = column_values [ col_idx_with_min_value ] [ 0 ],\n feature_column = col_idx_with_min_value,\n node = tree_split,\n )\n # End get_next_split","def find_best_split(self, x, y):\n\n # check cornor case: all same x\n n = y.size\n\n if all(x == x[0]):\n return (0, amin(x) - self.eps)\n\n sort_index = argsort(x)\n x_sorted = x[sort_index]\n y_sorted = y[sort_index]\n\n # build potential split index array\n split_index_array = array([i for i in range(1, n)\n if x_sorted[i] != x_sorted[i - 1]\n and y_sorted[i] != y_sorted[i - 1]])\n\n # split_index_array = linspace(\n # 0, y.size, num=min(5, ceil(n / 5)), endpoint=False, dtype='int')\n # split_index_array = split_index_array[1:]\n\n best_split_index = 0\n best_gain = 0\n h_x = self.cur_entropy\n\n for split_index in split_index_array:\n left_entropy = self.entropy(y_sorted[:split_index])\n right_entropy = self.entropy(y_sorted[split_index:])\n h_xy = (split_index * left_entropy +\n (n - split_index) * right_entropy) / n\n cur_gain = h_x - h_xy\n\n if cur_gain > best_gain:\n best_gain = cur_gain\n best_split_index = split_index\n\n if best_split_index != 0:\n best_split_point = (x_sorted[best_split_index] +\n x_sorted[best_split_index - 1]) / 2\n else:\n best_split_point = x_sorted[best_split_index] - self.eps\n\n return (best_gain, best_split_point)","def get_optimal_continuous_feature_split (\n self, feature_matrix: np.ndarray, target_array: np.ndarray, feature_column: int\n ):\n midpoints = BaseTree.get_valid_midpoints ( feature_array = feature_matrix [ :, feature_column ], target_array = target_array )\n # If midpoints, get the best one\n if len ( midpoints ) > 0:\n return BaseTree.get_min_across_splits_continuous (\n feature_array = feature_matrix [ :, feature_column ], target_array = target_array, splits = midpoints, evaluate_function = self.evaluate_function\n )\n\n # If no split points, return inf (can't split here)\n return ( 0, np.inf, 1 )\n # End get_optimal_continuous_feature_split()","def pred_from_split(X, y, col_idx, split_value): \n col = X[:,col_idx]\n idx_n1, idx_n2 = col <= split_value, col > split_value\n node1_y, node2_y = y[idx_n1], y[idx_n2]\n \n node1_c1, node1_c2 = sum(node1_y == 0), sum(node1_y == 1)\n node2_c1, node2_c2 = sum(node2_y == 0), sum(node2_y == 1)\n \n if node1_c1 == node1_c2:\n right_pred = 0 if node2_c1 > node2_c2 else 1\n left_pred = 1 - right_pred\n \n elif node2_c1 == node2_c2:\n left_pred = 0 if node1_c1 > node2_c2 else 1\n right_pred = 1 - left_pred\n \n else:\n left_pred = 0 if node1_c1 > node2_c2 else 1\n right_pred = 0 if node2_c1 > node2_c2 else 1\n \n return (left_pred, right_pred)","def __get_split_feature(self, data_set, target_feature, tree_features):\n\n if self.__criterion == 'entropy':\n feature_gains = {feature: self.__gain(data_set, feature, target_feature) for (feature) in tree_features}\n split_feature = max(feature_gains, key=feature_gains.get)\n return split_feature\n elif self.__criterion == 'gini':\n feature_ginis = {feature: self.__gini(data_set, feature, target_feature) for (feature) in tree_features}\n split_feature = min(feature_ginis, key=feature_ginis.get)\n return split_feature\n # TODO: I should check this (gini index).","def best_cutoff(self,\n split_label):\n split_args = self.sub_split_args[split_label]\n split_data = self.sub_split_data[split_label]\n # This criterion for the use_scipy flag is arbitrary and needs\n # further testing\n n_unique = len(np.unique(split_data[~np.isnan(split_data)]))\n use_scipy = True\n if n_unique > len(split_data)/1000:\n use_scipy = False\n idxcut_below, effects_below, rstats_below, ndata_below =\\\n self.u_data(split_label, use_scipy=use_scipy)\n idxcut_above, effects_above, rstats_above, ndata_above =\\\n self.u_data(split_label, above=True, use_scipy=use_scipy)\n\n # Default cutoff is min(split_data) - 1\n cutoff = split_data[split_args[0]] - 1\n value = 0\n # If no cutoff was possible\n if len(idxcut_below) == 0 or len(idxcut_above) == 0:\n return cutoff, value\n\n # All idx_cutoffs and values for cutoffs, for debugging\n for idx in range(len(idxcut_above)):\n idxcut = idxcut_above[idx]\n if idxcut != idxcut_below[idx]:\n raise NameError('Code error, invalid split')\n value_temp = (abs(effects_above[idx] -\n effects_below[idx]) *\n rstats_above[idx] *\n rstats_below[idx] *\n min(ndata_above[idx]) *\n min(ndata_below[idx]))\n if value_temp > value:\n cutoff = (split_data[split_args[int(idxcut)]] +\n split_data[split_args[int(idxcut)+1]])/2\n value = value_temp\n return cutoff, value","def get_possible_splits( df , attribute ):\n ds = df.loc[:,attribute]\n \n # First sort the values \n ds = ds.sort_values().drop_duplicates()\n \n # Compute averages of consecutive values \n ds = ds.rolling(2).sum().divide(2)\n splits = ds[1:].tolist()\n \n # return the possible splits \n return splits","def compute_splits(feature_df, target_col, max_num_splits):\n tree_estimator = DecisionTreeClassifier(max_leaf_nodes=max_num_splits+1,\n class_weight='balanced',\n random_state=1407)\n\n tree_estimator.fit(feature_df, target_col)\n thresholds = tree_estimator.tree_.threshold[tree_estimator.tree_.children_left != _tree.TREE_LEAF]\n return sorted(thresholds)","def find_split(data):\n ret = {\"router\": None, \"split_point\": None, \"entropy\": get_entropy(data[:, 7])}\n\n # Create array of unique datapoints\n split_points_list = list()\n\n for i in range(data.shape[1] - 1):\n unique_signal = np.unique(data[:, i])\n split_points = list()\n for j in range(len(unique_signal) - 1):\n split_points.append((unique_signal[j]+unique_signal[j+1])/2)\n split_points_list.append(split_points)\n\n # Split data by split points and calculate entropy\n for feature in range(len(split_points_list)):\n for i in range(len(split_points_list[feature])):\n data_l, data_r = split_data(data, feature + 1, split_points_list[feature][i])\n entropy = get_entropy(data_l[:, 7], data_r[:, 7])\n if entropy < ret[\"entropy\"]:\n ret[\"entropy\"] = entropy\n ret[\"router\"] = feature + 1\n ret[\"split_point\"] = split_points_list[feature][i]\n\n return ret[\"router\"], ret[\"split_point\"], split_data(data, ret[\"router\"], ret[\"split_point\"])","def choose_split(data,treshold):\n n_features = len(data[0]) - 1 # number of columns\n quest_gain = [] # keep track of the gains and questions\n\n for col in range(1,n_features): # for each feature\n values = set([row[col] for row in data]) # unique values in the column\n for val in values: # for each value\n question = Question(col, val)\n \n # try splitting the dataset\n true_rows, false_rows = partition(data, question)\n\n # Skip this split if it doesn't divide the dataset.\n if len(true_rows) == 0 or len(false_rows) == 0:\n continue\n\n # Calculate the information gain from this split\n gain = info_gain(data, true_rows, false_rows)\n quest_gain.append(Question_gain(gain,question))\n\n possible_question = [] # possible questions to ask\n n_quest_gain = len(quest_gain)\n\n if n_quest_gain == 0:\n return float('Inf'), float('NaN') #\n\n for x in range(n_quest_gain):\n if (quest_gain[x].gain >= treshold):\n possible_question.append(Question_gain(quest_gain[x].gain,quest_gain[x].question))\n \n n_possible_question = len(possible_question)\n if n_possible_question == 0:\n return float('Inf'), float('NaN')\n\n if n_possible_question>=2:\n [i, j] = random.sample(range(0, n_possible_question), 2)\n else:\n i = j = random.randint(0,n_possible_question-1)\n\n if possible_question[i].gain>=possible_question[j].gain:\n return possible_question[i].gain, possible_question[i].question\n else:\n return possible_question[j].gain, possible_question[j].question","def find_split(x, y):\n\n # Need the starting entropy so we can measure improvement...\n start_entropy = calculate_entropy(y)\n\n # Best thus far, initialised to a dud that will be replaced immediately...\n best = {'infogain': -np.inf}\n\n # Randomly allocate the splits to be traversed (without replacement)\n feature_total = x.shape[1]\n feature_subset_count = int(np.sqrt(feature_total))\n feature_subset = np.random.permutation(feature_total)[:feature_subset_count]\n\n # Loop every possible split of every feature...\n for feature_index in feature_subset:\n for split in np.unique(x[:, feature_index]):\n\n left_indices = []\n right_indices = []\n\n # Get index of rows where x[row_index,feature_index] <= split\n for row_index,row in enumerate(x):\n left_indices.append(row_index) if x[row_index,feature_index] <= split else right_indices.append(row_index)\n\n left_ys = y[left_indices]\n right_ys = y[right_indices]\n\n nleft = len(left_ys)\n nright = len(right_ys)\n ntotal = nleft + nright\n infogain = start_entropy - (nleft / ntotal) * calculate_entropy(left_ys) - (\n nright / ntotal) * calculate_entropy(right_ys)\n\n if infogain > best['infogain']:\n best = {'feature': feature_index,\n 'split': split,\n 'infogain': infogain,\n 'left_indices': left_indices,\n 'right_indices': right_indices}\n return best","def find_split(self, X, Y):\n split_col = np.random.randint(X.shape[1])\n return split_col, np.median(X[:,split_col])","def best_cat_brute_force_split(self, ind, dep):\n split = Split(None, None, None, None, 0)\n all_dep = np.unique(dep.arr)\n for i, ind_var in enumerate(ind):\n ind_var = ind_var.deep_copy()\n unique = np.unique(ind_var.arr)\n\n freq = {}\n if dep.weights is None:\n for col in unique:\n counts = np.unique(np.compress(ind_var.arr == col, dep.arr), return_counts=True)\n freq[col] = cl.defaultdict(int)\n freq[col].update(np.transpose(counts))\n else:\n for col in unique:\n counts = np.unique(np.compress(ind_var.arr == col, dep.arr), return_counts=True)\n freq[col] = cl.defaultdict(int)\n for dep_v in all_dep:\n freq[col][dep_v] = dep.weights[(ind_var.arr == col) * (dep.arr == dep_v)].sum()\n\n if len(list(ind_var.possible_groupings())) == 0:\n split.invalid_reason = InvalidSplitReason.PURE_NODE\n\n choice, highest_p_join, split_chi, dof = None, None, None, None\n for comb in ind_var.all_combinations():\n freqs = [ sum( [ cl.Counter(freq[key]) for key in c ], cl.Counter()) for c in comb ]\n\n if sum([ (sum(x.values()) < self.min_child_node_size) for x in freqs ] ) > 0:\n continue\n keys = set(sum([ list(f.keys()) for f in freqs ], []))\n\n n_ij = np.array(\n [ [ col.get(k, 0) for k in keys ] for col in freqs ]\n )\n\n chi, p_split, dof = chisquare(n_ij, dep.weights is not None)\n\n if (choice is None or p_split < highest_p_join or (p_split == highest_p_join and chi > split_chi)) and p_split < self.alpha_merge:\n choice, highest_p_join, split_chi = comb, p_split, chi\n\n temp_split = Split(i, choice, split_chi, highest_p_join, dof, split_name=ind_var.name)\n better_split = (not split.valid() or p_split < split.p or (p_split == split.p and chi > split.score)) and choice is not None\n if better_split: split, temp_split = temp_split, split\n\n if split.valid() and choice is not None:\n chi_threshold = self.split_threshold * split.score\n\n if temp_split.valid() and temp_split.score >= chi_threshold:\n for sur in temp_split.surrogates:\n if sur.column_id != i and sur.score >= chi_threshold:\n split.surrogates.append(sur)\n\n temp_split.surrogates = []\n split.surrogates.append(temp_split)\n\n split.sub_split_values(ind[split.column_id].metadata)\n\n return split","def choose_best_split(self, X_subset, y_subset):\n # YOUR CODE HERE\n feature_index = None\n threshold = None\n best_G = np.inf\n N = len(X_subset)\n \n for current_feature in range(X_subset.shape[1]):\n thresholds = np.unique(X_subset[:, current_feature])\n \n for t in thresholds:\n y_left, y_right = self.make_split_only_y(current_feature, t, X_subset, y_subset)\n H_L = self.H(y_left)\n H_R = self.H(y_right)\n \n G = (len(y_left) / N) * H_L + (len(y_right) / N) * H_R\n \n if G < best_G:\n best_G = G\n feature_index = current_feature\n threshold = t\n \n return feature_index, threshold","def find_split(self, X, y):\n choices = y.size\n if choices <= 1:\n return None, None\n\n # find the number of each option in the current node.\n options_parent = [np.sum(y == c) for c in range(self.num_outcomes)]\n\n # find the gini of current node.\n best_gini = 1.0 - sum((n / choices) ** 2 for n in options_parent)\n best_idx, best_split = None, None\n\n # loop through the features to get splits and options.\n for idx in range(self.num_features):\n splits, options = zip(*sorted(zip(X[:, idx], y)))\n\n num_left = [0] * self.num_outcomes\n num_right = options_parent.copy()\n for i in range(1, choices):\n c = options[i - 1]\n num_left[c] += 1\n num_right[c] -= 1\n gini_left = 1.0 - sum(\n (num_left[x] / i) ** 2 for x in range(self.num_outcomes)\n )\n gini_right = 1.0 - sum(\n (num_right[x] / i) ** 2 for x in range(self.num_outcomes)\n )\n\n gini = (i * gini_left + (choices - i) * gini_right) / choices\n\n if splits[i] == splits[i - 1]:\n continue\n\n if gini < best_gini:\n best_gini = gini\n best_idx = idx\n best_split = (splits[i] + splits[i - 1]) / 2\n\n return best_idx, best_split","def choose_split_value(attrs, classes):\n indices = np.argsort(attrs)\n classes = classes[indices]\n attrs = attrs[indices]\n max_gain = 0.0\n max_gain_value = None\n for i in range(len(attrs) - 1):\n if classes[i] != classes[i+1]:\n mean = (attrs[i] + attrs[i+1]) / 2.0\n gain = inform_gain(attrs, classes, mean)\n if gain > max_gain:\n max_gain = gain\n max_gain_value = mean\n return max_gain_value, max_gain","def select_randomly(self, val_split: float, test_split: float) -> {str: int}:\n\n def _select(start, n, label) -> int:\n \"\"\"\n Label all columns in [start, start+n) with label.\n \"\"\"\n n_selected = 0\n for i in range(start, int(start + n)):\n x = self._x_positions[i]\n n_selected += self._cols[x].mark_as(label)\n return n_selected\n\n def _remove_overlaps(start, end) -> int:\n \"\"\"\n Remove unlabelled columns in [start-col_width, end+col_width].\n \"\"\"\n start = self._x_positions[start % self.n_cols]\n end = self._x_positions[int(end) % self.n_cols]\n n_removed = 0\n for x, col in self._cols.items():\n if start - self.col_width <= x <= start or end <= x <= end + self.col_width:\n if col.label is None:\n n_removed += col.mark_as('ignore')\n return n_removed\n\n def _next_unlabelled_col(x):\n \"\"\"\n Return index of first unlabelled column after x.\n \"\"\"\n for i in range(self.n_cols):\n idx = (x + i) % self.n_cols\n x_current = self._x_positions[idx]\n if self._cols[x_current].label is None:\n return idx\n\n # When computing number of columns per split we must take into account\n # that some columns will be removed, i.e. we want to compute the split\n # sizes as fraction of the number of actual selected columns, not of\n # the total number of columns.\n delta_x = self._x_positions[1] - self._x_positions[0]\n n_to_remove_per_split = self.col_width / delta_x\n # * 2 because 2 gaps between 3 splits\n n_to_keep = self.n_cols - n_to_remove_per_split * 2\n n_val = round(n_to_keep * val_split)\n n_test = round(n_to_keep * test_split)\n n_train = n_to_keep - n_val - n_test\n\n n_selected_crops_per_split = dict.fromkeys(['training', 'validation', 'test', 'ignore'], 0)\n\n # Place patches in arbitrary order\n start = 0\n for n, label in random.sample(list(zip([n_train, n_val, n_test], ['training', 'validation', 'test'])), k=3):\n # Mark patch\n n_selected_crops_per_split[label] += _select(start, n, label)\n # Remove columns overlapping this patch\n n_selected_crops_per_split['ignore'] += _remove_overlaps(start, start + n - 1)\n # Next patch starts at next unlabelled column\n start = _next_unlabelled_col(start)\n\n return n_selected_crops_per_split","def best_split(self, X, y, attributes):\n if (self.criterion==\"information_gain\"):\n global_if = float('-inf') # the highest value of information gain/gini gain seen so far\n attr = None\n for attribute in attributes:\n attr_val = X[attribute].copy()\n cur_if = information_gain(y,attr_val,self.type)\n if (cur_if>global_if):\n # Update when a better split is receieved\n global_if = cur_if\n attr = attribute\n return attr\n else:\n global_if = float('inf')\n attr = None\n for attribute in attributes:\n attr_val = X[attribute].copy()\n cur_if = gini_gain(y,attr_val)\n if (global_if>cur_if):\n # Update when a better split is receieved\n global_if = cur_if\n attr = attribute\n return attr","def find_shape(items: int):\n for columns in range(1, MAX_COLUMNS + 1):\n if columns / math.ceil(items / columns) >= MIN_RATIO:\n return math.ceil(items / columns), columns\n return math.ceil(items / MAX_COLUMNS), MAX_COLUMNS","def get_cluster_to_split(clusters):\n\treturn max(clusters.items(), key=lambda x: x[1].get_distortion())[1]","def getSplits(df, train_size, val_size, test_size, seed=None):\n size = len(df)\n\n # size is considered a percentage if less than 1:\n train_size = int(train_size * size) if train_size < 1 else train_size\n val_size = int(val_size * size) if val_size < 1 else val_size\n test_size = int(test_size * size) if test_size < 1 else test_size\n\n if not seed is None:\n np.random.seed(seed)\n\n train_val_idx = np.random.choice(\n a=range(size),\n size=train_size + val_size,\n replace=False\n )\n train_idx = train_val_idx[:train_size]\n val_idx = train_val_idx[train_size:]\n\n train = df.iloc[train_idx]\n val = df.iloc[val_idx]\n test = df.drop(train.index).drop(val.index) # test is equal to the leftover\n\n assert len(train) + len(val) + len(test) == len(df)\n\n return train, val, test","def best_split1(self,X,attributes):\n if (self.criterion==\"information_gain\"):\n global_if = float('-inf') # the highest value of varience seen so far\n attr , val = None, None\n for attribute in attributes[::-1]:\n attr_val = pd.Series(X[attribute].unique()).sort_values(ignore_index=True)\n last_val = attr_val[0]\n for i in range(1,attr_val.size):\n cur_val = attr_val[i]\n valc = round((last_val+cur_val)/2,4)\n last_val = cur_val\n cur_if = information_gain1(valc,X[attribute],X[\"Output\"],self.type)\n if (cur_if>global_if):\n global_if,attr,val = cur_if,attribute,valc\n return attr,val\n else:\n global_if = float('inf') # the lowest value of varience seen so far\n attr , val = None, None\n for attribute in attributes[::-1]:\n attr_val = pd.Series(X[attribute].unique()).sort_values(ignore_index=True)\n last_val = attr_val[0]\n for i in range(1,attr_val.size):\n cur_val = attr_val[i]\n valc = round((last_val+cur_val)/2,4)\n last_val = cur_val\n cur_if = gini_gain1(X[\"Output\"],X[attribute], valc)\n if (global_if>cur_if):\n global_if,attr,val = cur_if,attribute,valc\n return attr,val","def calcGiniSplitByColumn(self, data, structure, colIName):\n colIndex, giniSplit = structure[colIName]['index'], 0\n for value in structure[colIName][\"values\"]:\n newData = list(filter(lambda x: x[colIndex] == value, data))\n p = len(newData) / len(data)\n giniSplit += self.calcDataGini(newData, structure) * p\n return round(giniSplit, 3)","def entropyWithBestSplit(attr, X, y):\n df = X[attr]\n maxVal = df.max()\n minVal = df.min()\n\n # Square root decomposition\n r = math.ceil(math.sqrt(maxVal - minVal))\n entropyVal = float('inf')\n splitAt = -1\n\n iterNum = 0\n while r > MIN_BIN_SIZE and iterNum < MAX_ITER:\n iterNum += 1\n i = minVal\n while i < maxVal:\n leftSplit = df[df < i].index.tolist()\n rightSplit = df[df >= i].index.tolist()\n buff_entropy = entropy(df, leftSplit) *\\\n (len(leftSplit) / (len(leftSplit) + len(rightSplit)))\n buff_entropy += entropy(df, rightSplit) *\\\n (len(rightSplit) / (len(leftSplit) + len(rightSplit)))\n if entropyVal >= buff_entropy:\n entropyVal = buff_entropy\n splitAt = i\n i += r\n minVal = min([splitAt - r, minVal])\n maxVal = max([splitAt + r, maxVal])\n r_buff = math.ceil(math.sqrt(maxVal - minVal))\n if r_buff >= r:\n break\n else:\n r = r_buff\n finalIdxLists = [\n df[df < splitAt].index.tolist(),\n df[df >= splitAt].index.tolist()\n ]\n return [splitAt], finalIdxLists, entropyVal","def get_min_across_splits_continuous(\n arr: np.ndarray, y: np.ndarray, splits: np.ndarray, eval_func: Callable\n ):\n n = len(splits)\n if n > 500:\n # If many split points, use some threading\n with multiprocessing.Pool(processes=8) as p:\n # Get evaluation scores across all the splits\n post_split_evals = dict(\n zip(\n range(len(splits)),\n p.starmap(\n BaseTree.get_split_goodness_fit_continuous,\n zip([arr] * n, [y] * n, splits, [eval_func] * n),\n ),\n )\n )\n p.close()\n else:\n # If not too many split points, get scores across all splits\n post_split_evals = dict(\n zip(\n range(len(splits)),\n map(\n lambda x: BaseTree.get_split_goodness_fit_continuous(*x),\n zip([arr] * n, [y] * n, splits, [eval_func] * n),\n ),\n )\n )\n # Get the minimum split based on gain ratio\n min_eval = min(\n post_split_evals,\n key=lambda x: pipe(\n post_split_evals.get(x),\n lambda results: results[0] / results[1], # entropy / intrinsic value\n ),\n )\n\n # Return the best split and the splits scores\n return (splits[min_eval], *post_split_evals.get(min_eval))","def splitData(df, split):\n train = df.iloc[:int(len(df)*split)]\n test = df.iloc[int(len(df)*split):]\n \n return train, test","def __find_best_split_in_feature(self, feature_and_class):\n\n # sort the feature and class and use changes in the class to reduce\n # number of potential split info gain calculations\n sorted_data = feature_and_class[\n feature_and_class[:, 0].astype(np.int).argsort()]\n potential_splits = self.__find_integers_with_class_change(sorted_data)\n info_gains = self.__info_gain_from_splits(potential_splits,\n sorted_data)\n\n # returning nothing in no information gains are found\n if len(info_gains) == 0:\n return None, None\n\n index = info_gains.index(max(info_gains))\n return info_gains[index], potential_splits[index]","def _calc_optimal_subset(fracs: pd.DataFrame,\r\n match_col: str) -> Tuple[pd.DataFrame, float, float]:\r\n\r\n fracs = fracs.copy(deep=True)\r\n fracs['control_sample_fraction_naive'] = fracs['treatment']/fracs['control']\r\n scale_factor = fracs.control_sample_fraction_naive.max()**-1\r\n logging.getLogger(__name__).info(\"scale factor is {scale_factor:.2f} (coeffs for treatment w/ no drops\".format(scale_factor=scale_factor))\r\n\r\n # if no subscaling is necessary return fracs as is\r\n if scale_factor >= 1:\r\n logging.getLogger(__name__).info(\"can use all treatments safely, returning early\")\r\n fracs['control_scaled_sample_fraction'] = fracs['control_sample_fraction_naive']\r\n fracs['treatment_scaled_sample_fraction'] = 1\r\n fracs = fracs[[match_col, 'treatment_scaled_sample_fraction', 'control_scaled_sample_fraction']]\r\n return fracs, float(1), float(0)\r\n\r\n options = _create_options_grid(fracs, scale_factor)\r\n options['utility'] = options.apply(_calc_util_wrapper, axis=1)\r\n\r\n # pick best\r\n max_util = options.utility.max()\r\n best_row = options[options.utility == max_util].iloc[0]\r\n winning_scale = float(best_row['scale'])\r\n winning_drop = float(best_row['percent_dropped'])\r\n\r\n logging.getLogger(__name__).info(\"max_util:{mu:.2f}\\twinning_scale:{ws:.2f}\\twinning_drop:{wd:.2f}\".format(mu=max_util, ws=winning_scale, wd=winning_drop))\r\n\r\n fracs['control_scaled_sample_fraction'] = np.min([(fracs['treatment'] * winning_scale/fracs['control']).values, [1]*len(fracs)], axis=0)\r\n fracs['treatment_scaled_sample_fraction'] = fracs['control_scaled_sample_fraction'] * fracs['control']/fracs['treatment']\r\n fracs = fracs[[match_col, 'treatment_scaled_sample_fraction', 'control_scaled_sample_fraction']]\r\n\r\n return fracs, winning_scale, winning_drop","def branching(self, df, layer, side):\n min_err = 1\n # Search for the best cut\n for i in range(self.dim):\n ddf = df.sort_values(i)\n Y = ddf.y.values\n\n for j in range(1, len(ddf)):\n err = self.impurity(Y, j)\n if err < min_err:\n best_d, best_val, min_err = i, ddf.iloc[j][i], err\n\n # Record the best branching parameters at this node\n self.Branch[(layer, side)] = best_d, best_val\n return best_d, best_val","def best_B(Ag):\n top = 0\n for i in range(len(Ag)):\n etop = np.min(cf.TD20[int(Ag[i]) - 1])\n top += etop\n return top","def best_split(self):\n sub_group = []\n\n current_entropy = self.entropy(self._Passengers)\n best_gain = 0 # holds the best entropy difference so far\n best_split = self._Attr[0].get_name()\n relative_entropy = 0 # entropy while taking account for the size of the population\n\n for Attribute in self._Attr:\n relative_entropy = 0\n print(\"Attr considered: \" + Attribute.get_name())\n for Attr_option in Attribute.get_options():\n sub_group = []\n for Passenger in self._Passengers:\n if self.passenger_attr_option_check(Passenger,\n Attribute.get_name(),\n Attr_option): # if P.A = V\n sub_group.append(Passenger)\n if len(sub_group) > 0 and len(self._Passengers) > 0:\n relative_entropy += self.entropy(sub_group) * (len(sub_group)/len(self._Passengers))\n\n if current_entropy - relative_entropy > best_gain:\n best_gain = current_entropy - relative_entropy\n best_split = Attribute.get_name()\n\n print(f\"best split:{best_split} \\n with entropy gain of:\\n {best_gain}\")\n\n return best_split","def calcGainRatioSplitByColumn(self, data, structure, colIName):\n splitInfo, colIndex = 0, structure[colIName]['index']\n for value in structure[colIName]['values']:\n newData = list(filter(lambda x: x[colIndex] == value, data))\n p = len(newData) / len(data) if len(newData) != 0 else 1\n splitInfo += (-1) * p * log2(p)\n splitInfo = 1 if splitInfo == 0 else splitInfo\n return round(self.calcInfoGainByColumnSplit(data, structure, colIName) / splitInfo, 3)","def getBestSplitsInDataByInfoGain(self, data, structure, colName, numOfSplits):\n splitsList, newSplitsList = {}, []\n self.fillBestSplitsInDataByInfoGainIntoDict(data, structure, colName, numOfSplits, splitsList, 0)\n for lists in list(splitsList.values())[1:]:\n while len(lists) > 0:\n splitOne, splitTwo = [], []\n if len(lists) > 0:\n splitOne = lists.pop()\n if len(lists) > 0:\n splitTwo = lists.pop()\n if splitOne and splitTwo:\n if splitOne[1] >= splitTwo[1]:\n newSplitsList.append(splitOne[0])\n newSplitsList.append(splitTwo[0])\n else:\n newSplitsList.append(splitTwo[0])\n newSplitsList.append(splitOne[0])\n elif splitOne:\n newSplitsList.append(splitOne[0])\n elif splitTwo:\n newSplitsList.append(splitTwo[0])\n\n newSplitsList.insert(0, splitsList['0'][0][0])\n self.removeDuplicatesInList(newSplitsList)\n return newSplitsList[0:numOfSplits]","def _best_split(cls, X, y):\n n = X.shape[0]\n num_feature = X.shape[1]\n y_types = np.unique(y)\n\n # initialize\n min_score = float(n)\n feature_idx = None\n best_theta = None\n best_idx = None\n\n for feature_idx in xrange(num_feature):\n # counter for y\n cumulate_y = Counter()\n rest_y = Counter()\n for y_type in y_types:\n cnt = np.where(y == y_type)[0].shape[0]\n rest_y[y_type] = cnt\n\n # sorted data\n sorted_idx = np.argsort(X[:, feature_idx])\n sorted_X = np.copy(X)\n sorted_y = np.copy(y)\n sorted_X = sorted_X[sorted_idx]\n sorted_y = sorted_y[sorted_idx]\n #print \"_best_split:\", sorted_X.shape, sorted_y.shape\n\n for idx in xrange(n-1):\n theta = (sorted_X[idx, feature_idx] + sorted_X[idx + 1, feature_idx]) / 2\n y_label = sorted_y[idx]\n cumulate_y[y_label] += 1\n rest_y[y_label] -= 1\n left_cnt = sum(cumulate_y.values())\n right_cnt = sum(rest_y.values())\n w_1 = left_cnt * cls._gini_index(cumulate_y.values())\n w_2 = right_cnt * cls._gini_index(rest_y.values())\n score = w_1 + w_2\n if score < min_score:\n min_score = score\n best_theta = theta\n best_idx = feature_idx\n #print('new min score: %.3f' % score)\n #print('feature: %d, theta: %.3f' % (best_idx, best_theta))\n #print('left: %d, right: %d' % (left_cnt, right_cnt))\n print('feature: %d, theta: %.3f' % (best_idx, best_theta))\n return (best_idx, best_theta)","def _best_split(cls, X, y):\n n = X.shape[0]\n num_feature = X.shape[1]\n y_types = np.unique(y)\n\n # initialize\n min_score = float(n)\n feature_idx = None\n best_theta = None\n best_idx = None\n\n for feature_idx in xrange(num_feature):\n # counter for y\n cumulate_y = Counter()\n rest_y = Counter()\n for y_type in y_types:\n cnt = np.where(y == y_type)[0].shape[0]\n rest_y[y_type] = cnt\n\n # sorted data\n sorted_idx = np.argsort(X[:, feature_idx])\n sorted_X = np.copy(X)\n sorted_y = np.copy(y)\n sorted_X = sorted_X[sorted_idx]\n sorted_y = sorted_y[sorted_idx]\n #print \"_best_split:\", sorted_X.shape, sorted_y.shape\n\n for idx in xrange(n-1):\n theta = (sorted_X[idx, feature_idx] + sorted_X[idx + 1, feature_idx]) / 2\n y_label = sorted_y[idx]\n cumulate_y[y_label] += 1\n rest_y[y_label] -= 1\n left_cnt = sum(cumulate_y.values())\n right_cnt = sum(rest_y.values())\n w_1 = left_cnt * cls._gini_index(cumulate_y.values())\n w_2 = right_cnt * cls._gini_index(rest_y.values())\n score = w_1 + w_2\n if score < min_score:\n min_score = score\n best_theta = theta\n best_idx = feature_idx\n #print('new min score: %.3f' % score)\n #print('feature: %d, theta: %.3f' % (best_idx, best_theta))\n #print('left: %d, right: %d' % (left_cnt, right_cnt))\n print('feature: %d, theta: %.3f' % (best_idx, best_theta))\n return (best_idx, best_theta)","def fit(self, col):\n self.find_max_min(col)","def _find_split(self, X, y, n_features):\r\n splits_info = []\r\n\r\n # Select features to consider\r\n features = self._feature_selection.get_features(n_features, self._feature_prob)\r\n\r\n # Get candidate splits\r\n for feature_id in features:\r\n for split_value in compute_split_values(X[:, feature_id]):\r\n splits_info.append(\r\n compute_split_info(self._split_criterion, X, y, feature_id, split_value, self._min_samples_leaf))\r\n\r\n splits = []\r\n for split_info in splits_info:\r\n if split_info is not None:\r\n gain, feature_id, split_value = split_info\r\n split = Split(feature_id, value=split_value, gain=gain)\r\n splits.append(split)\r\n else:\r\n continue\r\n\r\n selected_split = self._split_chooser.get_split(splits)\r\n return selected_split","def calcGiniSplitBySplitValue(self, data, structure, colIndex, splitValue):\n dataBellow = list(filter(lambda x: float(x[colIndex]) <= splitValue, data))\n dataAbove = list(filter(lambda x: float(x[colIndex]) > splitValue, data))\n giniSplit = (len(dataBellow) / len(data)) * self.calcDataGini(dataBellow, structure) +\\\n (len(dataAbove) / len(data)) * self.calcDataGini(dataAbove, structure)\n return round(giniSplit, 3)","def get_bestparameter(self):\n if self._df_test is None:\n raise RuntimeError('get_bestparameter: please the '\n 'train model first')\n mean = self._df_test.mean(axis=1)\n if len(mean) == 1:\n result = mean.idxmax()\n elif len(mean) == 2:\n result = mean.loc[mean.index > 1].idxmax()\n else:\n result = mean.loc[mean.index > 2].idxmax()\n return result","def get_bestparameter(self):\n if self._df_test is None:\n raise RuntimeError('get_bestparameter: please the '\n 'train model first')\n mean = self._df_test.mean(axis=1)\n if len(mean) == 1:\n result = mean.idxmax()\n elif len(mean) == 2:\n result = mean.loc[mean.index > 1].idxmax()\n else:\n result = mean.loc[mean.index > 2].idxmax()\n return result","def possible_splits(self,feature,y):\n\n yi = y[:-1]\n yi1= y[1:]\n idx=np.argwhere((yi1-yi)!=0)\n return idx.flatten()","def get_splits(self):\n\t\treturn self.k","def getListWithBestValueSplitsOfDataByGini(self, data, structure, colIndex, numOfSplits):\n splitsList, newSplitsList = {}, []\n self.fillDictWithBestValueSplitsOfDataByGini(data, structure, colIndex, numOfSplits, splitsList, 0)\n for lists in list(splitsList.values())[1:]:\n while len(lists) > 0:\n splitOne, splitTwo = [], []\n if len(lists) > 0:\n splitOne = lists.pop()\n if len(lists) > 0:\n splitTwo = lists.pop()\n if splitOne and splitTwo:\n if splitOne[1] <= splitTwo[1]:\n newSplitsList.append(splitOne[0])\n newSplitsList.append(splitTwo[0])\n else:\n newSplitsList.append(splitTwo[0])\n newSplitsList.append(splitOne[0])\n elif splitOne:\n newSplitsList.append(splitOne[0])\n elif splitTwo:\n newSplitsList.append(splitTwo[0])\n\n newSplitsList.insert(0, splitsList['0'][0][0])\n self.removeDuplicatesInList(newSplitsList)\n return newSplitsList[0:numOfSplits]","def MaxColumn(I, E, d, ro):\n # http://en.wikipedia.org/wiki/Buckling\n B = 1.86635\n g = 9.81\n h = (9 * B**2 * E*I / (4*ro*g*np.pi * (d/2)**2))**(1/3)\n return h","def choose_best_feature(data_set):\n feature_size = len(data_set[0]) - 1\n base_entropy = calc_entropy(data_set)\n best_info_gain = 0.0; best_feature = -1\n for i in xrange(feature_size):\n feat_list = [eg[i] for eg in data_set]\n unique_values = set(feat_list)\n new_entropy = 0.0\n for value in unique_values:\n sub_ds = splite_dataset(data_set, i, value)\n prob = len(sub_ds) / float(len(data_set))\n new_entropy += prob * calc_entropy(sub_ds)\n info_gain = base_entropy - new_entropy\n if info_gain > best_info_gain:\n best_info_gain = info_gain\n best_feature = i\n\n return best_feature","def optimal_2split(data, dicrete=True, equidistant=True, verbose=False):\n if dicrete and equidistant:\n uniqs = np.unique(data)\n uniqs = np.sort(uniqs)\n delta_ = (uniqs[1:] - uniqs[:-1]).min()\n rho_crit = 10\n n0 = data.shape[0]\n l = uniqs.max() - uniqs.min()\n rho_cur = n0 / (l / delta_)\n delta = np.ceil(rho_crit / rho_cur) * delta_\n bbs = np.arange(\n uniqs.min() - 0.5 * delta, uniqs.max() + 0.5 * delta + 1e-6 * delta, delta\n )\n # n_actual = (bbs[-1] - bbs[0])/delta\n if verbose:\n print(bbs)\n else:\n bbs = 10\n cnts, bbs = histogram(data, bbs)\n diff = cnts[1:] - cnts[:-1]\n ddif = diff[1:] - diff[:-1]\n if verbose:\n print(cnts, bbs)\n print(list(zip(range(len(cnts)), cnts)), bbs)\n print(\"f prime:\", diff)\n print(\"f double prime:\", ddif)\n # either diff == 0, or\n derivative_change = diff[1:] * diff[:-1]\n # sign change indices\n ii = flatnonzero((derivative_change < 0) & (ddif > 0))\n jj = flatnonzero(diff == 0)\n concats = np.concatenate([ii, jj])\n if verbose:\n print(\"candidate indices\")\n print(1 + ii, 1 + jj)\n print(concats)\n print(\"candidate cnts\")\n print(cnts[1 + concats])\n if concats.size > 0:\n arg_glo_min = argmin(cnts[1 + concats])\n if arg_glo_min < len(ii):\n lbbs, rbbs = bbs[1 + concats[arg_glo_min]], bbs[2 + concats[arg_glo_min]]\n optimal_split = 0.5 * (lbbs + rbbs)\n else:\n # two conseq. equal values, optinal split is between them\n optimal_split = bbs[2 + concats[arg_glo_min]]\n if verbose:\n print(\n arg_glo_min,\n 1 + concats[arg_glo_min],\n cnts[1 + concats[arg_glo_min]],\n optimal_split,\n )\n else:\n return np.nan\n return optimal_split","def data_splitting_tool(feature_cols = None, label_col = None ,val_size = 0.2, test_size = 0.2, random_state = 13):\n if (val_size != ''):\n total_test_size = val_size + test_size\n test_ratio = test_size/total_test_size\n X_train, X_test, y_train, y_test = train_test_split(feature_cols, label_col, test_size = total_test_size, random_state=random_state)\n X_val, X_test, y_val, y_test = train_test_split(X_test, y_test, test_size=test_ratio, random_state=random_state)\n return(X_train, y_train, X_val,y_val, X_test, y_test)\n else:\n X_train, X_test, y_train, y_test = train_test_split(feature_cols, label_col, test_size = test_size, random_state=random_state)\n return(X_train, y_train, X_test, y_test)","def _compute_best_split_and_push(self, node):\n\n node.split_info = self.splitter.find_node_split(\n node.sample_indices, node.histograms, node.sum_gradients,\n node.sum_hessians)\n\n if node.split_info.gain <= 0: # no valid split\n self._finalize_leaf(node)\n else:\n heappush(self.splittable_nodes, node)","def _find_largest_candidate(self, reduced):\n nbr_counts = np.count_nonzero(reduced == 0, axis=0) # = [1, 1, 4, 2,...] where each value is the number of neighbours for the variant at that index.\n count_max = nbr_counts.max()\n if count_max == 0: # Indicates there are no available variants close enough\n return None, [] # to the remaining unassigned. Usually raises an error.\n max_inds = np.nonzero(nbr_counts == count_max)[0] # Array containing the indices of all variants with the max number of neighbours.\n if len(max_inds) == 1: # A single largest cluster\n best_center = max_inds[0]\n best_clstr = np.nonzero(reduced[:,best_center] == 0)[0]\n else: # A tie for largest cluster. Broken by smallest sum of full scores\n # This was tested with the below more accurate and true scoring function. Unfortunately it became hideously slow (clustered_inds and centre_inds were given as args):\n # clstr_inds = np.nonzero(reduced[:,max_ind] == 0)[0]\n # covered_inds = list(clustered_inds | set(clstr_inds))\n # centre_inds.append(max_ind)\n # score = np.sum(np.min(self.orig_dists[np.ix_(covered_inds,centre_inds)], axis=1))\n # centre_inds.pop()\n best_center, best_clstr, best_score = None, [], np.inf\n for max_ind in max_inds:\n clstr_inds = np.nonzero(reduced[:,max_ind] == 0)[0]\n score = np.sum(self.orig_dists[clstr_inds,max_ind])\n if score < best_score:\n best_center, best_clstr, best_score = max_ind, clstr_inds, score\n return best_center, best_clstr","def potential_splits(self, potential_xj):\r\n \r\n self.cur.execute(\"SELECT DISTINCT \" + potential_xj + \" FROM \" + self.table_name + \";\")\r\n potential_splits = [ii[0] for ii in self.cur.fetchall()]\r\n return potential_splits","def get_discrete_split_value(arr: np.ndarray, y: np.ndarray, eval_func: Callable):\n\n # First element is the weighted average eval_func of the split\n # Second term is the intrinsic value to penalize many splits.\n return (\n sum(\n [\n eval_func(y[arr == value]) * np.sum(arr == value) / len(y)\n for value in set(arr)\n ]\n ),\n -1\n * sum(\n [\n pipe(\n np.sum(arr == value) / len(y),\n lambda ratio: ratio * np.log(ratio),\n )\n for value in set(arr)\n ]\n ),\n )","def bsp(splits, min_val, max_val):\n if not splits and min_val == max_val:\n return min_val\n if splits[0] in ['F', 'L']:\n return bsp(splits[1:], min_val, math.floor((min_val + max_val)/2))\n elif splits[0] in ['B', 'R']:\n return bsp(splits[1:], math.ceil((min_val + max_val)/2), max_val)","def bisect_anyaxis(counts, ndomains, split_fac):\n # split along any axis \n splits = {}\n pvals = []\n for axis in range(len(counts.shape)):\n # Sum over other axes\n sum_axes = list(np.arange(len(counts.shape)))\n sum_axes.pop(axis)\n sum_axes = tuple(sum_axes)\n\n # split into left and right \n counts1d = np.sum(counts, axis=sum_axes, dtype=np.int64)\n \n split_idx, n_L, pval = load_partition_1d(counts1d, ndomains, split_fac)\n\n splits[axis] = (split_idx, n_L)\n\n pvals.append(pval)\n\n axis = int(np.argmin(pvals))\n split_idx, n_L = splits[axis]\n return axis, split_idx, n_L","def _split_threshold(self, node):\n\n # define the score to improve upon\n if self.n_clusters >= self.min_leaves and node.size <= self.max_leaf_size:\n # split only if min(children scores) > node.score\n force_split = False\n best_score = node.score\n else:\n # force split: just take the best (even if children are worse)\n force_split = True\n best_score = None\n\n left, right = None, None\n\n # iterate over embedding dimensions (first ones are more reliable)\n # up to max_n_vec (included), until we found an improving split\n for _vec in range(self.n_vec):\n\n # get the candidate thresholds along this dimension\n threshs = self._get_candidate_thresholds(node, _vec)\n\n # look for an improving best split along this eigenvector\n for _t in threshs:\n # compute the split\n below_thresh = self.E[node.ids, _vec] < _t\n _lids = node.ids[below_thresh]\n _rids = node.ids[np.logical_not(below_thresh)]\n # check if the tubes are not too small\n _nl, _nr = len(_lids), len(_rids)\n is_valid = _nl >= self.min_leaf_size and _nr >= self.min_leaf_size\n if is_valid:\n # compute the score of the new tubes only\n _sl = self.get_tube_score(_lids)\n _sr = self.get_tube_score(_rids)\n # get the score of this split\n split_score = min(_sl, _sr)\n if best_score is None or split_score > best_score:\n # better split\n best_score = split_score\n node.has_children = True\n node.thresh = _t\n left = SpectralNode(\n _lids, _vec, score=_sl, name=node.name + \"0\")\n right = SpectralNode(\n _rids, _vec, score=_sr, name=node.name + \"1\")\n\n # check stopping criterion\n if node.has_children:\n # we found an improving split\n if _vec > 0 or not force_split:\n # found an improving non-forced split: stop here\n break\n\n return left, right","def splittable_variables(self) -> List[int]:\n #print(\"enter bartpy/bartpy/data.py CovariateMatrix splittable_variables\")\n \n for i in range(0, self._n_features):\n if self._splittable_variables[i] is None:\n self._splittable_variables[i] = is_not_constant(self.get_column(i))\n \n output = [i for (i, x) in enumerate(self._splittable_variables) if x is True] \n #print(\"-exit bartpy/bartpy/data.py CovariateMatrix splittable_variables\")\n return output","def get_split_col_names():\n return ['dna_%d' % (idx+1) for idx in range(60)]","def ent_from_split(col, split_value, labels):\n idx_n1, idx_n2 = col <= split_value, col > split_value\n node1_x, node2_x = col[idx_n1], col[idx_n2]\n node1_y, node2_y = labels[idx_n1], labels[idx_n2]\n \n p_node1 = len(node1_x) / len(col)\n p_node2 = len(node2_x) / len(col)\n assert p_node1 + p_node2 == 1\n \n ent_node1 = entropy(sum(node1_y == 0), sum(node1_y == 1))\n ent_node2 = entropy(sum(node2_y == 0), sum(node2_y == 1))\n return float(p_node1*ent_node1 + p_node2*ent_node2)","def optimal_split(self, ratio = 0.5):\n\n if (sum(self.game_state) == 1):\n if (randint(1,100)<=50):\n return self.game_state, [0]*(self.K+1)\n else:\n return [0]*(self.K+1), self.game_state\n \n else:\n prob = LpProblem(\"Optimal split\",LpMinimize)\n A = []\n for i in range(self.K + 1):\n A += LpVariable(str(i), 0, self.game_state[i], LpInteger)\n prob += sum([2**(-(self.K - i)) * c for c, i in zip(A, range(self.K + 1))]) - ratio * self.potential(self.game_state), \"Objective function\"\n prob += sum([2**(-(self.K - i)) * c for c, i in zip(A, range(self.K + 1))]) >= ratio * self.potential(self.game_state), \"Constraint\"\n #prob.writeLP(\"test.lp\")\n prob.solve()\n Abis = [0]*(self.K+1)\n for v in prob.variables():\n Abis[int(v.name)] = round(v.varValue)\n B = [z - a for z, a in zip(self.game_state, Abis)]\n return Abis, B","def dataset_splits(self):\n # 10% evaluation data\n return [{\n \"split\": problem.DatasetSplit.TRAIN,\n \"shards\": 799,\n }, {\n \"split\": problem.DatasetSplit.EVAL,\n \"shards\": 1,\n }]","def train_val_test_split(df):\n from sklearn.model_selction import train_test_split\n train, test = train_test_split(df, train_size = 0.80, test_size=0.20,\n random_state = 42)\n train, val = train_test_split(train, train_size = 0.70, val_size=0.30)\n print(train.shape, val.shape, test.shape)\n\n return train, val, test","def split(self, X, y, feature_array):\n n, p = X.shape\n\n best_gain = 0\n best_split_point = 0\n best_feature_id = -1\n for feature_id in feature_array:\n cur_gain, cur_split_point = self.find_best_split(\n X[:, feature_id], y)\n if cur_gain > best_gain - self.eps:\n best_gain = cur_gain\n best_split_point = cur_split_point\n best_feature_id = feature_id\n\n assert(best_feature_id != -1)\n\n x = X[:, best_feature_id]\n left_index = x < best_split_point\n right_index = x >= best_split_point\n\n self.split_id = best_feature_id\n self.split_val = best_split_point\n\n return (left_index, right_index)","def title_based_split(df, split_val):\n # retrieve split title and get the minimum id with that title\n split_title = df['title'].iloc[int(split_val * len(df)) - 1]\n split_index = df[df['title'] == split_title].index.min()\n return df.iloc[:split_index], df.iloc[split_index:]","def fold_column(self):\n return self._parms.get(\"fold_column\")","def getColMinMax(table, col):\n\tvmin = None\n\tvmax = None\n\tfor rec in table:\n\t\tvalue = rec[col]\n\t\tif vmin is None:\n\t\t\tvmin = value\n\t\t\tvmax = value\n\t\telse:\n\t\t\tif value < vmin:\n\t\t\t\tvmin = value\n\t\t\telif value > vmax:\n\t\t\t\tvmax = value\n\treturn (vmin, vmax, vmax - vmin)","def __divideset(rows, column, value):\n split_function = None #Initialize a variable split function.\n if isinstance(value, int) or isinstance(value, float): #Check if value is a number\n #True = the observation's value >= to the splitting criteria. False otherwise\n split_function = lambda row: row[column] >= value\n else:\n #If value is a string, True is where the observation's value == the criteria\n split_function = lambda row:row[column] == value\n \n #Divide the rows into two sets and return them\n set1 = [row for row in rows if split_function(row)]\n set2 = [row for row in rows if not split_function(row)]\n return (set1, set2)","def _compute_best_value(self):\n asgt = self._neighbors_values.copy()\n best_cost, best_val = None, []\n\n for v in self._variable.domain:\n asgt[self.variable.name] = v\n c = self._compute_cost(**asgt)\n if (\n best_cost is None\n or (best_cost > c and self._mode == \"min\")\n or (best_cost < c and self._mode == \"max\")\n ):\n best_cost = c\n best_val = [v]\n elif best_cost == c:\n best_val.append(v)\n\n return best_val, best_cost","def split(df, stratify_by=None):\n \n if stratify_by == None:\n train, test = train_test_split(df, test_size=.3, random_state=123)\n train, validate = train_test_split(df, test_size=.3, random_state=123)\n else:\n train, test = train_test_split(df, test_size=.2, random_state=123, stratify=df[stratify_by])\n train, validate = train_test_split(df, test_size=.3, random_state=123, stratify=train[stratify_by])\n \n return train, validate, test","def single_cv(df, n_splits=3, val_size=2, seed=0xBadCafe):\n folds = sorted(df.fold.unique())\n split = []\n for f in folds:\n idx_b = df[df.fold == f].index.tolist()\n cv_b = train_val_test_split(idx_b, val_size=val_size, n_splits=n_splits, random_state=seed)\n for cv in cv_b:\n split.append(cv)\n return split","def _mode(x, def_fill=ImputerMixin._def_fill):\n idx = x.as_data_frame(use_pandas=True)[x.columns[0]].value_counts().index\n\n # if the most common is null, then return the next most common.\n # if there is no next common (i.e., 100% null) then we return the def_fill\n return idx[0] if not pd.isnull(idx[0]) else idx[1] if idx.shape[0] > 1 else def_fill","def max_score_column(self, scores):\r\n m = max(scores)\r\n lc = []\r\n for i in range(len(scores)):\r\n if scores[i] == m:\r\n lc += [i]\r\n if len(lc) > 1:\r\n if self.tiebreak == \"LEFT\":\r\n column = lc[0]\r\n elif self.tiebreak == \"RIGHT\":\r\n column = lc[-1]\r\n else:\r\n column = random.choice(lc)\r\n return column\r\n else:\r\n return lc[0]","def dataset_splits(self):\n return [{\n \"split\": problem.DatasetSplit.TRAIN,\n \"shards\": 80,\n }, {\n \"split\": problem.DatasetSplit.EVAL,\n \"shards\": 2,\n }]","def calcEntropyBySplitValue(self, data, structure, colName, splitVal):\n colIndex, entropy = structure[colName]['index'], 0\n newDataBellowSplit = list(filter(lambda y: float(y[colIndex]) <= splitVal, data))\n newDataAboveSplit = list(filter(lambda y: float(y[colIndex]) > splitVal, data))\n entropyOfNewDataBellowSplit = self.calcDataEntropy(newDataBellowSplit, structure)\n entropyOfNewAboveSplit = self.calcDataEntropy(newDataAboveSplit, structure)\n entropy += (len(newDataBellowSplit) / len(data)) * entropyOfNewDataBellowSplit\n entropy += (len(newDataAboveSplit) / len(data)) * entropyOfNewAboveSplit\n return round(entropy, 3)","def optimal_perturbed_splitting(self,acc=1.e-12,rmax=50.01,tol=1.e-13,algorithm='split'):\n from nodepy.utils import bisect\n try:\n import cvxpy as cvx\n except:\n algorithm = 'split'\n\n if algorithm == 'LP':\n r=bisect(0,rmax,acc,tol,self.lp_perturb)\n elif algorithm == 'split':\n r=bisect(0,rmax,acc,tol,self.is_splittable)\n\n d,alpha,alphatilde=self.resplit(r,tol=tol)\n return r,d,alpha,alphatilde","def get_cols_dummy():"],"string":"[\n \"def determine_best_split(data, potential_splits, mltask):\\n\\n first_iteration = True\\n for column_index in potential_splits:\\n for value in potential_splits[column_index]:\\n data_below,data_above = split_data(data, column_index, value)\\n \\n if mltask == 'regression':\\n current_overall_metric = calculate_overall_metric(data_below, data_above, metric_function = calculate_mse)\\n \\n # classification\\n else:\\n current_overall_metric = calculate_overall_metric(data_below, data_above, metric_function = calculate_entropy)\\n \\n \\n if first_iteration or current_overall_metric <= best_overall_metric:\\n first_iteration = False\\n \\n best_overall_metric = current_overall_metric\\n best_split_column = column_index\\n best_split_value = value\\n \\n \\n return best_split_column,best_split_value\",\n \"def get_best_split_all(x, y) -> Tuple[int, float, float]:\\n m = x.shape[1]\\n col_best_gin = np.ones(shape=m)\\n col_best_val = np.ones(shape=m)\\n for c in range(m):\\n best = 1\\n best_x = 0\\n for i in np.unique(x[:, c]):\\n gini = Tree.split(x[:, c], y, i)\\n if gini < best:\\n best = gini\\n best_x = i\\n col_best_gin[c] = best\\n col_best_val[c] = best_x\\n\\n # Select best feature to split on\\n col_idx = np.argmin(col_best_gin)\\n # Convert to bool index\\n col_idx = np.array(range(x.shape[1])) == col_idx\\n\\n return col_idx, col_best_val[col_idx], col_best_gin[col_idx]\",\n \"def get_split(data):\\n \\\"\\\"\\\" gets the best feature, and best value \\\"\\\"\\\"\\n\\n best_feature = None\\n best_value = 0.0\\n columns = data.columns\\n gini_base = gini_impurity(data)\\n n_rows = len(data.index) # total number of rows of data before split\\n\\n # Fininding which split yields the best gini gain\\n max_gain = 0\\n\\n for i in range(len(columns)-1): # -1 b.c. class is final column\\n xs = data[columns[i]].unique() # get values to test\\n for x in xs: # test values\\n # split dataset\\n df_left = data[data[columns[i]] < x]\\n df_right = data[data[columns[i]] >= x]\\n\\n # get gini impurities\\n gini_left = gini_impurity(df_left)\\n gini_right = gini_impurity(df_right)\\n \\n\\n # Calculated weighted gini impurity\\n w_left = len(df_left.index) / n_rows\\n w_right = len(df_right.index) / n_rows\\n\\n w_gini = gini_left * w_left + gini_right * w_right\\n \\n\\n # Calculate gini gain (we want to minimize w_gini for the smallest impurity. Ideal split is perfect Left=c1, Right=c2)\\n # why not just find min w_gin instead of uding gini_gain and gini_base vaiables?\\n gini_gain = gini_base - w_gini\\n\\n # check if this is the best split so far, store values, update max_gini\\n if gini_gain > max_gain:\\n best_feature = columns[i]\\n best_value = x\\n max_gain = gini_gain\\n\\n df_left = data.loc[data[best_feature] < best_value]\\n df_right = data.loc[data[best_feature] >= best_value]\\n \\n\\n return best_feature, best_value, df_left, df_right\",\n \"def find_best_split(rows):\\n best_gain = 0 # keep track of the best information gain\\n best_question = None # keep train of the feature / value that produced it\\n current_uncertainty = gini(rows)\\n n_features = len(rows[0]) - 1 # number of columns\\n #print(\\\"n_features:\\\", n_features)\\n\\n for col in range(1,n_features): # for each feature\\n # for each iteration this is the set of all values of a specific column, eg, All pixels number 0\\n values = set([row[col] for row in rows]) # unique values in the column\\n for val in values: # for each value\\n\\n # Create a question object for each val under a column, holding the val and the col number\\n question = Question(col, val)\\n\\n # try splitting the dataset\\n true_rows, false_rows = partition(rows, question)\\n\\n # Skip this split if it doesn't divide the\\n # dataset.\\n if len(true_rows) == 0 or len(false_rows) == 0:\\n continue\\n\\n # Calculate the information gain from this split\\n gain = info_gain(true_rows, false_rows, current_uncertainty)\\n\\n # You actually can use '>' instead of '>=' here\\n # but I wanted the tree to look a certain way for our\\n # toy dataset.\\n if gain >= best_gain:\\n best_gain, best_question = gain, question\\n\\n return best_gain, best_question\",\n \"def get_best_split(rows):\\n best_gain = 0\\n best_question = None\\n current_impurity = get_gini(rows)\\n n_features = len(rows[0])\\n\\n for col in range(n_features):\\n\\n for row in rows:\\n question = Question(col, row[col])\\n true_rows, false_rows = partition(rows, question)\\n\\n if len(true_rows) == 0 or len(false_rows) == 0:\\n break\\n\\n question_gain = get_info_gain(true_rows, false_rows, current_impurity)\\n\\n if question_gain >= best_gain:\\n best_gain = question_gain\\n best_question = question\\n\\n print(best_gain)\\n print(best_question)\\n return best_gain, best_question\",\n \"def findBestColumnSplitByGainRatio(self, data, structure):\\n maxGainRatio, bestSplit = 0, None\\n for colName in list(structure.keys())[:-1]:\\n GainRatio = self.calcGainRatioSplitByColumn(data, structure, colName)\\n if GainRatio >= maxGainRatio:\\n maxGainRatio = GainRatio\\n bestSplit = colName\\n return bestSplit\",\n \"def get_split(self,X,y):\\n \\n BEST_COL = 0\\n BEST_SPLIT =0\\n BEST_IMPUR = 99\\n for i,feature in enumerate(X.T):\\n arg_sort=np.argsort(feature) #Sort the feature for optimizing the find of splitting points\\n feature= feature[arg_sort]\\n y_sort = y[arg_sort]\\n splits = self.possible_splits(feature,y_sort) #Get \\n\\n impur,splits = self.test_split(feature,y_sort,splits) #Get impurity for splitting points\\n best_idx = np.argmin(impur)\\n best_impur = impur[best_idx]\\n \\n if best_impur==0.0: #Found perfect split, terminate\\n return(i,splits[best_idx])\\n elif best_impur<BEST_IMPUR:\\n BEST_IMPUR=best_impur\\n BEST_SPLIT=splits[best_idx]\\n BEST_COL=i\\n return (BEST_COL,BEST_SPLIT)\",\n \"def getSplitFunc(self, splitType):\\n if splitType.upper() == \\\"INFO GAIN\\\":\\n return self.findBestColumnSplitByInfoGain\\n elif splitType.upper() == \\\"GAIN RATIO\\\":\\n return self.findBestColumnSplitByGainRatio\\n elif splitType.upper() == \\\"GINI INDEX\\\":\\n return self.findBestColumnSplitByGini\\n return None\",\n \"def findBestColumnSplitByGini(self, data, structure):\\n minGini, bestSplit = 1, None\\n for colName in list(structure.keys())[:-1]:\\n giniSplit = self.calcGiniSplitByColumn(data, structure, colName)\\n if giniSplit <= minGini:\\n minGini = giniSplit\\n bestSplit = colName\\n return bestSplit\",\n \"def findBestColumnSplitByInfoGain(self, data, structure):\\n maxInfoGain, bestSplit = 0, None\\n for colName in list(structure.keys())[:-1]:\\n infoGain = self.calcInfoGainByColumnSplit(data, structure, colName)\\n if infoGain >= maxInfoGain:\\n maxInfoGain = infoGain\\n bestSplit = colName\\n return bestSplit\",\n \"def pick_best_split(self,db,labels,ids,features=None):\\n idlabels = [labels[id] for id in ids]\\n if misclassification_error(idlabels) == 0:\\n #base case: no misclassifications\\n self.type = 'v'\\n self.value = idlabels[0]\\n return 0\\n best = None\\n bestCost = 0\\n splitval = None\\n discrete = True\\n if features == None:\\n if len(ids) < db.numFeatures():\\n #look at all present features in the training set\\n features = db.getPresentFeatures(ids)\\n #print len(features),\\\"of\\\",db.numFeatures(),\\\"features selected\\\"\\n else:\\n features = range(db.numFeatures())\\n elif callable(features):\\n features = features()\\n for i in features:\\n if len(db.entryLists[i]) == 0: continue\\n idiscrete = db.discreteFeature[i]\\n if idiscrete:\\n #count number of labels of a certain value\\n splitter = defaultdict(lambda:defaultdict(int))\\n #count of labels for missing values\\n nmissing = defaultdict(int)\\n for id in ids:\\n val = db[i,id]\\n if val is None:\\n #missing values go down to all splits\\n nmissing[labels[id]] += 1\\n continue\\n splitter[val][labels[id]] += 1\\n if len(splitter) > continuous_variable_threshold:\\n #print \\\"Determined to be a continuous variable\\\"\\n idiscrete = False\\n break\\n if idiscrete:\\n if len(splitter) <= 1:\\n #only a single value\\n continue\\n #count number of missing values in all splits\\n cmax = 0\\n for k in splitter:\\n for l,v in nmissing.iteritems():\\n splitter[k][l] += v\\n cmax = max(cmax,sum(splitter[k].values()))\\n #shrink by fraction of (# of ids - largest child)/(# of ids)\\n scale = (1.0-float(cmax)/float(len(ids)))*len(splitter)\\n #evaluate cost\\n cost = split_cost(splitter.values())*scale\\n #print \\\"Split on\\\",i,\\\"information gain\\\",-cost,splitter.values()\\n else:\\n #continuous, need to learn the best split\\n vals = []\\n presentlabels = []\\n nonelabels = []\\n for id in ids:\\n val = db[i,id]\\n if val is None:\\n nonelabels.append(labels[id])\\n continue\\n vals.append(val)\\n presentlabels.append(labels[id])\\n if len(vals) <= 1:\\n print \\\"No values for feature\\\",i,\\\"?\\\"\\n print vals\\n continue\\n #print \\\"Considering continuous split on\\\",i\\n s,cost = best_split(vals,presentlabels,nonelabels)\\n scale = (1.0-float(len(presentlabels)/2+len(nonelabels))/float(len(ids)))*2\\n cost *= scale\\n #print \\\"Result\\\",s,\\\"Information gain\\\",-cost\\n \\n if cost < bestCost:\\n best = i\\n bestCost = cost\\n discrete = idiscrete\\n if not idiscrete:\\n splitval = s\\n \\n if best is None:\\n self.type = 'v'\\n if len(ids) > 0:\\n self.value = vote(idlabels)\\n return misclassification_error(idlabels)\\n else:\\n self.value = None\\n return 0\\n else:\\n self.feature = best\\n #discrete or inequality split\\n if discrete:\\n self.type = 's'\\n else:\\n self.type = 'i'\\n self.value = splitval\\n return bestCost\",\n \"def findBestValueSplitByGini(self, data, structure, colIndex):\\n minGini, bestSplit = 1, []\\n for i in range(0, len(data)-1):\\n split = (float(data[i][colIndex]) + float(data[i+1][colIndex])) / 2\\n giniSplit = self.calcGiniSplitBySplitValue(data, structure, colIndex, split)\\n if giniSplit <= minGini:\\n minGini = giniSplit\\n bestSplit = [split, giniSplit]\\n return bestSplit\",\n \"def get_optimal_continuous_feature_split(\\n self, X: np.ndarray, y: np.ndarray, feature_col: int\\n ):\\n midpoints = BaseTree.get_valid_midpoints(arr=X[:, feature_col], y=y)\\n # If midpoints, get the best one\\n if len(midpoints) > 0:\\n return BaseTree.get_min_across_splits_continuous(\\n arr=X[:, feature_col], y=y, splits=midpoints, eval_func=self.eval_func\\n )\\n\\n # If no split points, return inf (can't split here)\\n return (0, np.inf, 1)\",\n \"def get_best_split(rows: list) -> (float, Question):\\n best_info_gain = 0\\n best_question = None\\n current_uncertainty = get_gini_impurity(rows)\\n\\n # minus 1 because we're ignoring the last column which is the label.\\n n_attributes = len(rows[0]) - 1\\n\\n for col in range(n_attributes):\\n\\n # get all unique values for an attribute/column\\n unique_values = set([row[col] for row in rows])\\n\\n for value in unique_values:\\n question = Question(col, value)\\n\\n # Split rows depending on the question\\n true_rows, false_rows = partition(rows, question)\\n\\n # We don't want to partition such rows\\n if len(true_rows) == 0 or len(false_rows) == 0:\\n continue\\n\\n # Get info gain from this split\\n info_gain = get_info_gain(false_rows, true_rows, current_uncertainty)\\n\\n if info_gain > best_info_gain:\\n best_info_gain, best_question = info_gain, question\\n\\n return best_info_gain, best_question\",\n \"def __find_best_split(self, x, y):\\n data = np.transpose(np.vstack((np.transpose(x), y)))\\n num_features = data.shape[1] - 1\\n\\n # initialise splitting rule components\\n integer_splitting_rule = None\\n feature_index_to_split = None\\n max_info_gain = 0\\n\\n # iterate over all the features and find best splits within these\\n for feature in range(num_features):\\n info_gain, split_int = self.__find_best_split_in_feature(\\n data[:, [feature, -1]])\\n if info_gain is None:\\n continue\\n # update max info gain so far as it iterates over features\\n if info_gain > max_info_gain:\\n max_info_gain = info_gain\\n feature_index_to_split = feature\\n integer_splitting_rule = int(split_int)\\n\\n return feature_index_to_split, integer_splitting_rule\",\n \"def best_split(self):\\r\\n best_splits = [[0, None, None]]\\r\\n impurity, best_S, best_xj = 0, None, None\\r\\n \\r\\n for xj in self.x_names:\\r\\n for S in self.potential_splits(xj):\\r\\n ir = float(self.impurity_reduction(xj, S))\\r\\n if ir > impurity:\\r\\n impurity, best_S, best_xj = ir, S, xj\\r\\n best_splits.append([S, xj])\\r\\n else: \\r\\n pass\\r\\n \\r\\n return best_S, best_xj\",\n \"def get_optimal_discrete_feature_split(\\n self, X: np.ndarray, y: np.ndarray, feature_col: int\\n ):\\n return BaseTree.get_discrete_split_value(\\n X[:, feature_col], y, eval_func=self.eval_func\\n )\",\n \"def best_split(values,labels,nonelabels=None):\\n assert len(values) >= 2\\n assert len(values) == len(labels)\\n N = len(values)\\n ilist = sorted((v,l) for (v,l) in zip(values,labels))\\n leftcount = defaultdict(int)\\n rightcount = defaultdict(int)\\n for v,l in ilist:\\n rightcount[l] += 1\\n bestindex = -1\\n bestcost = split_cost([leftcount,rightcount])\\n\\n cost = bestcost\\n #costs = [cost]\\n #print \\\"Split costs:\\\"\\n for i in xrange(len(ilist)):\\n v,l = ilist[i]\\n rightcount[l] -= 1\\n leftcount[l] += 1\\n if i+1 >= len(ilist) or v == ilist[i+1][0]:\\n #no splits when v is equal to the next value\\n continue\\n cost = split_cost([leftcount,rightcount])\\n #print \\\" \\\",v,leftcount.values(),rightcount.values(),cost\\n #costs.append(cost)\\n if cost < bestcost:\\n bestcost = cost\\n bestindex = i\\n #raw_input()\\n if bestindex < 0:\\n #no split found... try splitting in half\\n splitval = (ilist[0][0]+ilist[-1][0])*0.5\\n else:\\n splitval = (ilist[bestindex][0] + ilist[bestindex+1][0])*0.5\\n if nonelabels is None:\\n return (splitval,bestcost)\\n #reevaluate counts\\n leftcount = defaultdict(int)\\n rightcount = defaultdict(int)\\n for l in nonelabels:\\n leftcount[l] += 1\\n rightcount[l] += 1\\n for v,l in ilist:\\n if v <= splitval:\\n leftcount[l] += 1\\n else:\\n rightcount[l] += 1\\n return splitval,split_cost([leftcount,rightcount])\",\n \"def findBestSplitInDataByInfoGain(self, data, structure, colName):\\n colIndex, maxInfoGain, bestSplit = structure[colName]['index'], 0, []\\n for i in range(0, len(data)-1):\\n split = (float(data[i][colIndex]) + float(data[i+1][colIndex])) / 2\\n infoGain = self.calcInfoGainBySplitValue(data, structure, colName, split)\\n if infoGain >= maxInfoGain:\\n bestSplit = [split, infoGain]\\n maxInfoGain = infoGain\\n return bestSplit\",\n \"def split_data(data,split_column,split_value):\\n split_column_value = data[:,split_column]\\n type_of_feature = FEATURE_TYPE[split_column]\\n\\n if type_of_feature == 'continuous':\\n data_below = data[split_column_value <= split_value]\\n data_above = data[split_column_value > split_value]\\n else:\\n data_below = data[split_column_value == split_value]\\n data_above = data[split_column_value != split_value]\\n return data_below,data_above\",\n \"def random_splittable_value(self, variable: int) -> Any:\\n #print(\\\"enter bartpy/bartpy/data.py CovariateMatrix random_splittable_value\\\")\\n \\n if variable not in self.splittable_variables():\\n raise NoSplittableVariableException()\\n max_value = self.max_value_of_column(variable)\\n candidate = np.random.choice(self.get_column(variable))\\n while candidate == max_value:\\n candidate = np.random.choice(self.get_column(variable))\\n #print(\\\"-exit bartpy/bartpy/data.py CovariateMatrix random_splittable_value\\\")\\n return candidate\",\n \"def getSplit(self):\\n b_index, b_value, b_score, b_groups = 999, 999, 999, None\\n for j in range(len(self[0]) - 1):\\n for i in range(len(self)):\\n groups = self.splitAttribute(j, self[i][j]) # lit, big\\n gini = self.giniIndex(groups)\\n if gini < b_score and (j, \\\"%.1f\\\" % self[i][j]) not in self.atr:\\n b_index, b_value, b_score, b_groups = j, self[i][\\n j], gini, groups\\n return b_index, b_value, b_groups, b_score\",\n \"def _optimal_splits (self, split_axis):\\n n = len(self.displays)\\n size = self.screen.get_size()\\n # sizes in directions of first/second split\\n s1 = size[split_axis]\\n s2 = size[not split_axis]\\n ratio = self.ratio\\n # use screen aspect ratio if no preferred one given\\n if ratio is None:\\n ratio = float(size[0]) / size[1]\\n error = []\\n for splits in xrange(1, n + 1):\\n # maximal number of displays per row/column\\n per_split = ceil(float(n) / splits)\\n # minimise unused space (as a fraction of the screen)\\n space_e = abs(1 - float(n) / (splits * per_split))\\n # and ratio (we care about proportionality, so use log)\\n disp_ratio = float(s1 * splits) / (s2 * per_split)\\n if split_axis == 1:\\n # inverted if splitting into columns\\n disp_ratio = 1 / disp_ratio\\n ratio_e = abs(log(disp_ratio / ratio))\\n # adjust using some constants\\n e = space_e + ratio_e\\n error.append((e, splits))\\n return min(error)\",\n \"def find_splits(col):\\n unique = np.unique(sorted(col))\\n splits = np.array([np.mean([unique[i], unique[i+1]]) for i in range(len(unique)-1)])\\n return splits\",\n \"def _bestFeat2split(dataSet, impurity_crit, min_impurity_decrease, min_samples_split):\\n\\t\\tm, n = dataSet.shape\\n\\t\\tbestFeatInd, bestVal = None, DecisionTree._make_leaf(dataSet, impurity_crit)\\n\\n\\t\\tif m < min_samples_split or len(set(dataSet[:,-1])) == 1:\\n\\t\\t\\treturn bestFeatInd, bestVal\\n\\n\\t\\timpurity = m * impurity_crit(dataSet)\\n\\t\\tmin_impurity = np.inf\\n\\t\\t\\n\\n\\t\\tfor feat_ind in range(n-1):\\n\\t\\t\\tif type(dataSet[:, feat_ind][0]) != str:\\n\\t\\t\\t\\tuniqVal = set(dataSet[:, feat_ind])\\n\\t\\t\\telse:\\n\\t\\t\\t\\tuniqVal = map(set, subsets(list(dataSet[:, feat_ind])))\\n\\t\\t\\tfor val in uniqVal:\\n\\t\\t\\t\\tD1, D2 = DecisionTree._binarySplit(dataSet, feat_ind, val)\\n\\t\\t\\t\\tif len(D1) < min_samples_split or len(D2) < min_samples_split:\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\tnew_impurity = len(D1)*impurity_crit(D1) + len(D2)*impurity_crit(D2)\\n\\t\\t\\t\\tif impurity - new_impurity < min_impurity_decrease:\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\tif new_impurity < min_impurity:\\n\\t\\t\\t\\t\\tmin_impurity = new_impurity\\n\\t\\t\\t\\t\\tbestFeatInd = feat_ind; bestVal = val\\n\\t\\treturn bestFeatInd, bestVal\",\n \"def split(self,best):\\n\\t\\treturn self.cu_for_split(best,False)\",\n \"def get_next_split ( self, feature_matrix: np.ndarray, target_array: np.ndarray, tree_split: TreeSplits):\\n # If only 1 y value, make a leaf node\\n if len ( set ( target_array ) ) == 1:\\n tree_split.updateTreeValues (\\n feature_column = None,\\n feature_value = None,\\n node_type = None,\\n nodes = {},\\n children = target_array,\\n )\\n return tree_split\\n\\n # Get the presplit entropy\\n presplit_entropy = self.evaluate_function ( target_array )\\n\\n column_values = {}\\n for k, v in self.map_column_node_type.items():\\n # If there's only one value in feature matrix \\\"X\\\", set the split value to infinity\\n if len ( set ( feature_matrix [ :, k ] ) ) == 1:\\n value = np.inf\\n split = None\\n class_ratios = 1\\n elif v == \\\"continuous\\\":\\n # Get the best possible continuous split for the column\\n split, value, class_ratios = self.get_optimal_continuous_feature_split (\\n feature_matrix = feature_matrix, target_array = target_array, feature_column = k\\n )\\n else:\\n # Get the split value for the discrete column\\n value, class_ratios = self.get_optimal_discrete_feature_split (\\n feature_matrix = feature_matrix, target_array = target_array, feature_column = k\\n )\\n split = None\\n\\n column_values [ k ] = ( split, value, class_ratios )\\n\\n # Get the column with the largest gain ratio\\n col_idx_with_min_value = max (\\n column_values,\\n key = lambda x: ( presplit_entropy - column_values.get ( x ) [ 1 ] )\\n / column_values.get ( x ) [ 2 ],\\n )\\n\\n # If stopping criteria are met or all splits are infinite, terminate the process\\n if (\\n self.early_stopping_comparison (\\n column_values.get ( col_idx_with_min_value ) [ 1 ], self.early_stopping_value\\n )\\n ) or not np.isfinite ( column_values.get ( col_idx_with_min_value ) [ 1 ] ):\\n self.get_terminal_node (\\n feature_column = col_idx_with_min_value,\\n feature_value = column_values [ col_idx_with_min_value ] [ 0 ],\\n node = tree_split,\\n feature_matrix = feature_matrix ,\\n target_array = target_array,\\n )\\n return tree_split\\n\\n # If the best split is continuous, add a continuous node\\n if self.map_column_node_type.get ( col_idx_with_min_value ) == \\\"continuous\\\":\\n return self.get_continuous_node (\\n feature_column = col_idx_with_min_value,\\n feature_value = column_values [col_idx_with_min_value ] [ 0 ],\\n feature_matrix = feature_matrix,\\n target_array = target_array,\\n node = tree_split,\\n )\\n\\n # Otherwise, add a discrete node.\\n else:\\n return self.get_discrete_node (\\n feature_matrix = feature_matrix,\\n target_array = target_array,\\n feature_value = column_values [ col_idx_with_min_value ] [ 0 ],\\n feature_column = col_idx_with_min_value,\\n node = tree_split,\\n )\\n # End get_next_split\",\n \"def find_best_split(self, x, y):\\n\\n # check cornor case: all same x\\n n = y.size\\n\\n if all(x == x[0]):\\n return (0, amin(x) - self.eps)\\n\\n sort_index = argsort(x)\\n x_sorted = x[sort_index]\\n y_sorted = y[sort_index]\\n\\n # build potential split index array\\n split_index_array = array([i for i in range(1, n)\\n if x_sorted[i] != x_sorted[i - 1]\\n and y_sorted[i] != y_sorted[i - 1]])\\n\\n # split_index_array = linspace(\\n # 0, y.size, num=min(5, ceil(n / 5)), endpoint=False, dtype='int')\\n # split_index_array = split_index_array[1:]\\n\\n best_split_index = 0\\n best_gain = 0\\n h_x = self.cur_entropy\\n\\n for split_index in split_index_array:\\n left_entropy = self.entropy(y_sorted[:split_index])\\n right_entropy = self.entropy(y_sorted[split_index:])\\n h_xy = (split_index * left_entropy +\\n (n - split_index) * right_entropy) / n\\n cur_gain = h_x - h_xy\\n\\n if cur_gain > best_gain:\\n best_gain = cur_gain\\n best_split_index = split_index\\n\\n if best_split_index != 0:\\n best_split_point = (x_sorted[best_split_index] +\\n x_sorted[best_split_index - 1]) / 2\\n else:\\n best_split_point = x_sorted[best_split_index] - self.eps\\n\\n return (best_gain, best_split_point)\",\n \"def get_optimal_continuous_feature_split (\\n self, feature_matrix: np.ndarray, target_array: np.ndarray, feature_column: int\\n ):\\n midpoints = BaseTree.get_valid_midpoints ( feature_array = feature_matrix [ :, feature_column ], target_array = target_array )\\n # If midpoints, get the best one\\n if len ( midpoints ) > 0:\\n return BaseTree.get_min_across_splits_continuous (\\n feature_array = feature_matrix [ :, feature_column ], target_array = target_array, splits = midpoints, evaluate_function = self.evaluate_function\\n )\\n\\n # If no split points, return inf (can't split here)\\n return ( 0, np.inf, 1 )\\n # End get_optimal_continuous_feature_split()\",\n \"def pred_from_split(X, y, col_idx, split_value): \\n col = X[:,col_idx]\\n idx_n1, idx_n2 = col <= split_value, col > split_value\\n node1_y, node2_y = y[idx_n1], y[idx_n2]\\n \\n node1_c1, node1_c2 = sum(node1_y == 0), sum(node1_y == 1)\\n node2_c1, node2_c2 = sum(node2_y == 0), sum(node2_y == 1)\\n \\n if node1_c1 == node1_c2:\\n right_pred = 0 if node2_c1 > node2_c2 else 1\\n left_pred = 1 - right_pred\\n \\n elif node2_c1 == node2_c2:\\n left_pred = 0 if node1_c1 > node2_c2 else 1\\n right_pred = 1 - left_pred\\n \\n else:\\n left_pred = 0 if node1_c1 > node2_c2 else 1\\n right_pred = 0 if node2_c1 > node2_c2 else 1\\n \\n return (left_pred, right_pred)\",\n \"def __get_split_feature(self, data_set, target_feature, tree_features):\\n\\n if self.__criterion == 'entropy':\\n feature_gains = {feature: self.__gain(data_set, feature, target_feature) for (feature) in tree_features}\\n split_feature = max(feature_gains, key=feature_gains.get)\\n return split_feature\\n elif self.__criterion == 'gini':\\n feature_ginis = {feature: self.__gini(data_set, feature, target_feature) for (feature) in tree_features}\\n split_feature = min(feature_ginis, key=feature_ginis.get)\\n return split_feature\\n # TODO: I should check this (gini index).\",\n \"def best_cutoff(self,\\n split_label):\\n split_args = self.sub_split_args[split_label]\\n split_data = self.sub_split_data[split_label]\\n # This criterion for the use_scipy flag is arbitrary and needs\\n # further testing\\n n_unique = len(np.unique(split_data[~np.isnan(split_data)]))\\n use_scipy = True\\n if n_unique > len(split_data)/1000:\\n use_scipy = False\\n idxcut_below, effects_below, rstats_below, ndata_below =\\\\\\n self.u_data(split_label, use_scipy=use_scipy)\\n idxcut_above, effects_above, rstats_above, ndata_above =\\\\\\n self.u_data(split_label, above=True, use_scipy=use_scipy)\\n\\n # Default cutoff is min(split_data) - 1\\n cutoff = split_data[split_args[0]] - 1\\n value = 0\\n # If no cutoff was possible\\n if len(idxcut_below) == 0 or len(idxcut_above) == 0:\\n return cutoff, value\\n\\n # All idx_cutoffs and values for cutoffs, for debugging\\n for idx in range(len(idxcut_above)):\\n idxcut = idxcut_above[idx]\\n if idxcut != idxcut_below[idx]:\\n raise NameError('Code error, invalid split')\\n value_temp = (abs(effects_above[idx] -\\n effects_below[idx]) *\\n rstats_above[idx] *\\n rstats_below[idx] *\\n min(ndata_above[idx]) *\\n min(ndata_below[idx]))\\n if value_temp > value:\\n cutoff = (split_data[split_args[int(idxcut)]] +\\n split_data[split_args[int(idxcut)+1]])/2\\n value = value_temp\\n return cutoff, value\",\n \"def get_possible_splits( df , attribute ):\\n ds = df.loc[:,attribute]\\n \\n # First sort the values \\n ds = ds.sort_values().drop_duplicates()\\n \\n # Compute averages of consecutive values \\n ds = ds.rolling(2).sum().divide(2)\\n splits = ds[1:].tolist()\\n \\n # return the possible splits \\n return splits\",\n \"def compute_splits(feature_df, target_col, max_num_splits):\\n tree_estimator = DecisionTreeClassifier(max_leaf_nodes=max_num_splits+1,\\n class_weight='balanced',\\n random_state=1407)\\n\\n tree_estimator.fit(feature_df, target_col)\\n thresholds = tree_estimator.tree_.threshold[tree_estimator.tree_.children_left != _tree.TREE_LEAF]\\n return sorted(thresholds)\",\n \"def find_split(data):\\n ret = {\\\"router\\\": None, \\\"split_point\\\": None, \\\"entropy\\\": get_entropy(data[:, 7])}\\n\\n # Create array of unique datapoints\\n split_points_list = list()\\n\\n for i in range(data.shape[1] - 1):\\n unique_signal = np.unique(data[:, i])\\n split_points = list()\\n for j in range(len(unique_signal) - 1):\\n split_points.append((unique_signal[j]+unique_signal[j+1])/2)\\n split_points_list.append(split_points)\\n\\n # Split data by split points and calculate entropy\\n for feature in range(len(split_points_list)):\\n for i in range(len(split_points_list[feature])):\\n data_l, data_r = split_data(data, feature + 1, split_points_list[feature][i])\\n entropy = get_entropy(data_l[:, 7], data_r[:, 7])\\n if entropy < ret[\\\"entropy\\\"]:\\n ret[\\\"entropy\\\"] = entropy\\n ret[\\\"router\\\"] = feature + 1\\n ret[\\\"split_point\\\"] = split_points_list[feature][i]\\n\\n return ret[\\\"router\\\"], ret[\\\"split_point\\\"], split_data(data, ret[\\\"router\\\"], ret[\\\"split_point\\\"])\",\n \"def choose_split(data,treshold):\\n n_features = len(data[0]) - 1 # number of columns\\n quest_gain = [] # keep track of the gains and questions\\n\\n for col in range(1,n_features): # for each feature\\n values = set([row[col] for row in data]) # unique values in the column\\n for val in values: # for each value\\n question = Question(col, val)\\n \\n # try splitting the dataset\\n true_rows, false_rows = partition(data, question)\\n\\n # Skip this split if it doesn't divide the dataset.\\n if len(true_rows) == 0 or len(false_rows) == 0:\\n continue\\n\\n # Calculate the information gain from this split\\n gain = info_gain(data, true_rows, false_rows)\\n quest_gain.append(Question_gain(gain,question))\\n\\n possible_question = [] # possible questions to ask\\n n_quest_gain = len(quest_gain)\\n\\n if n_quest_gain == 0:\\n return float('Inf'), float('NaN') #\\n\\n for x in range(n_quest_gain):\\n if (quest_gain[x].gain >= treshold):\\n possible_question.append(Question_gain(quest_gain[x].gain,quest_gain[x].question))\\n \\n n_possible_question = len(possible_question)\\n if n_possible_question == 0:\\n return float('Inf'), float('NaN')\\n\\n if n_possible_question>=2:\\n [i, j] = random.sample(range(0, n_possible_question), 2)\\n else:\\n i = j = random.randint(0,n_possible_question-1)\\n\\n if possible_question[i].gain>=possible_question[j].gain:\\n return possible_question[i].gain, possible_question[i].question\\n else:\\n return possible_question[j].gain, possible_question[j].question\",\n \"def find_split(x, y):\\n\\n # Need the starting entropy so we can measure improvement...\\n start_entropy = calculate_entropy(y)\\n\\n # Best thus far, initialised to a dud that will be replaced immediately...\\n best = {'infogain': -np.inf}\\n\\n # Randomly allocate the splits to be traversed (without replacement)\\n feature_total = x.shape[1]\\n feature_subset_count = int(np.sqrt(feature_total))\\n feature_subset = np.random.permutation(feature_total)[:feature_subset_count]\\n\\n # Loop every possible split of every feature...\\n for feature_index in feature_subset:\\n for split in np.unique(x[:, feature_index]):\\n\\n left_indices = []\\n right_indices = []\\n\\n # Get index of rows where x[row_index,feature_index] <= split\\n for row_index,row in enumerate(x):\\n left_indices.append(row_index) if x[row_index,feature_index] <= split else right_indices.append(row_index)\\n\\n left_ys = y[left_indices]\\n right_ys = y[right_indices]\\n\\n nleft = len(left_ys)\\n nright = len(right_ys)\\n ntotal = nleft + nright\\n infogain = start_entropy - (nleft / ntotal) * calculate_entropy(left_ys) - (\\n nright / ntotal) * calculate_entropy(right_ys)\\n\\n if infogain > best['infogain']:\\n best = {'feature': feature_index,\\n 'split': split,\\n 'infogain': infogain,\\n 'left_indices': left_indices,\\n 'right_indices': right_indices}\\n return best\",\n \"def find_split(self, X, Y):\\n split_col = np.random.randint(X.shape[1])\\n return split_col, np.median(X[:,split_col])\",\n \"def best_cat_brute_force_split(self, ind, dep):\\n split = Split(None, None, None, None, 0)\\n all_dep = np.unique(dep.arr)\\n for i, ind_var in enumerate(ind):\\n ind_var = ind_var.deep_copy()\\n unique = np.unique(ind_var.arr)\\n\\n freq = {}\\n if dep.weights is None:\\n for col in unique:\\n counts = np.unique(np.compress(ind_var.arr == col, dep.arr), return_counts=True)\\n freq[col] = cl.defaultdict(int)\\n freq[col].update(np.transpose(counts))\\n else:\\n for col in unique:\\n counts = np.unique(np.compress(ind_var.arr == col, dep.arr), return_counts=True)\\n freq[col] = cl.defaultdict(int)\\n for dep_v in all_dep:\\n freq[col][dep_v] = dep.weights[(ind_var.arr == col) * (dep.arr == dep_v)].sum()\\n\\n if len(list(ind_var.possible_groupings())) == 0:\\n split.invalid_reason = InvalidSplitReason.PURE_NODE\\n\\n choice, highest_p_join, split_chi, dof = None, None, None, None\\n for comb in ind_var.all_combinations():\\n freqs = [ sum( [ cl.Counter(freq[key]) for key in c ], cl.Counter()) for c in comb ]\\n\\n if sum([ (sum(x.values()) < self.min_child_node_size) for x in freqs ] ) > 0:\\n continue\\n keys = set(sum([ list(f.keys()) for f in freqs ], []))\\n\\n n_ij = np.array(\\n [ [ col.get(k, 0) for k in keys ] for col in freqs ]\\n )\\n\\n chi, p_split, dof = chisquare(n_ij, dep.weights is not None)\\n\\n if (choice is None or p_split < highest_p_join or (p_split == highest_p_join and chi > split_chi)) and p_split < self.alpha_merge:\\n choice, highest_p_join, split_chi = comb, p_split, chi\\n\\n temp_split = Split(i, choice, split_chi, highest_p_join, dof, split_name=ind_var.name)\\n better_split = (not split.valid() or p_split < split.p or (p_split == split.p and chi > split.score)) and choice is not None\\n if better_split: split, temp_split = temp_split, split\\n\\n if split.valid() and choice is not None:\\n chi_threshold = self.split_threshold * split.score\\n\\n if temp_split.valid() and temp_split.score >= chi_threshold:\\n for sur in temp_split.surrogates:\\n if sur.column_id != i and sur.score >= chi_threshold:\\n split.surrogates.append(sur)\\n\\n temp_split.surrogates = []\\n split.surrogates.append(temp_split)\\n\\n split.sub_split_values(ind[split.column_id].metadata)\\n\\n return split\",\n \"def choose_best_split(self, X_subset, y_subset):\\n # YOUR CODE HERE\\n feature_index = None\\n threshold = None\\n best_G = np.inf\\n N = len(X_subset)\\n \\n for current_feature in range(X_subset.shape[1]):\\n thresholds = np.unique(X_subset[:, current_feature])\\n \\n for t in thresholds:\\n y_left, y_right = self.make_split_only_y(current_feature, t, X_subset, y_subset)\\n H_L = self.H(y_left)\\n H_R = self.H(y_right)\\n \\n G = (len(y_left) / N) * H_L + (len(y_right) / N) * H_R\\n \\n if G < best_G:\\n best_G = G\\n feature_index = current_feature\\n threshold = t\\n \\n return feature_index, threshold\",\n \"def find_split(self, X, y):\\n choices = y.size\\n if choices <= 1:\\n return None, None\\n\\n # find the number of each option in the current node.\\n options_parent = [np.sum(y == c) for c in range(self.num_outcomes)]\\n\\n # find the gini of current node.\\n best_gini = 1.0 - sum((n / choices) ** 2 for n in options_parent)\\n best_idx, best_split = None, None\\n\\n # loop through the features to get splits and options.\\n for idx in range(self.num_features):\\n splits, options = zip(*sorted(zip(X[:, idx], y)))\\n\\n num_left = [0] * self.num_outcomes\\n num_right = options_parent.copy()\\n for i in range(1, choices):\\n c = options[i - 1]\\n num_left[c] += 1\\n num_right[c] -= 1\\n gini_left = 1.0 - sum(\\n (num_left[x] / i) ** 2 for x in range(self.num_outcomes)\\n )\\n gini_right = 1.0 - sum(\\n (num_right[x] / i) ** 2 for x in range(self.num_outcomes)\\n )\\n\\n gini = (i * gini_left + (choices - i) * gini_right) / choices\\n\\n if splits[i] == splits[i - 1]:\\n continue\\n\\n if gini < best_gini:\\n best_gini = gini\\n best_idx = idx\\n best_split = (splits[i] + splits[i - 1]) / 2\\n\\n return best_idx, best_split\",\n \"def choose_split_value(attrs, classes):\\n indices = np.argsort(attrs)\\n classes = classes[indices]\\n attrs = attrs[indices]\\n max_gain = 0.0\\n max_gain_value = None\\n for i in range(len(attrs) - 1):\\n if classes[i] != classes[i+1]:\\n mean = (attrs[i] + attrs[i+1]) / 2.0\\n gain = inform_gain(attrs, classes, mean)\\n if gain > max_gain:\\n max_gain = gain\\n max_gain_value = mean\\n return max_gain_value, max_gain\",\n \"def select_randomly(self, val_split: float, test_split: float) -> {str: int}:\\n\\n def _select(start, n, label) -> int:\\n \\\"\\\"\\\"\\n Label all columns in [start, start+n) with label.\\n \\\"\\\"\\\"\\n n_selected = 0\\n for i in range(start, int(start + n)):\\n x = self._x_positions[i]\\n n_selected += self._cols[x].mark_as(label)\\n return n_selected\\n\\n def _remove_overlaps(start, end) -> int:\\n \\\"\\\"\\\"\\n Remove unlabelled columns in [start-col_width, end+col_width].\\n \\\"\\\"\\\"\\n start = self._x_positions[start % self.n_cols]\\n end = self._x_positions[int(end) % self.n_cols]\\n n_removed = 0\\n for x, col in self._cols.items():\\n if start - self.col_width <= x <= start or end <= x <= end + self.col_width:\\n if col.label is None:\\n n_removed += col.mark_as('ignore')\\n return n_removed\\n\\n def _next_unlabelled_col(x):\\n \\\"\\\"\\\"\\n Return index of first unlabelled column after x.\\n \\\"\\\"\\\"\\n for i in range(self.n_cols):\\n idx = (x + i) % self.n_cols\\n x_current = self._x_positions[idx]\\n if self._cols[x_current].label is None:\\n return idx\\n\\n # When computing number of columns per split we must take into account\\n # that some columns will be removed, i.e. we want to compute the split\\n # sizes as fraction of the number of actual selected columns, not of\\n # the total number of columns.\\n delta_x = self._x_positions[1] - self._x_positions[0]\\n n_to_remove_per_split = self.col_width / delta_x\\n # * 2 because 2 gaps between 3 splits\\n n_to_keep = self.n_cols - n_to_remove_per_split * 2\\n n_val = round(n_to_keep * val_split)\\n n_test = round(n_to_keep * test_split)\\n n_train = n_to_keep - n_val - n_test\\n\\n n_selected_crops_per_split = dict.fromkeys(['training', 'validation', 'test', 'ignore'], 0)\\n\\n # Place patches in arbitrary order\\n start = 0\\n for n, label in random.sample(list(zip([n_train, n_val, n_test], ['training', 'validation', 'test'])), k=3):\\n # Mark patch\\n n_selected_crops_per_split[label] += _select(start, n, label)\\n # Remove columns overlapping this patch\\n n_selected_crops_per_split['ignore'] += _remove_overlaps(start, start + n - 1)\\n # Next patch starts at next unlabelled column\\n start = _next_unlabelled_col(start)\\n\\n return n_selected_crops_per_split\",\n \"def best_split(self, X, y, attributes):\\n if (self.criterion==\\\"information_gain\\\"):\\n global_if = float('-inf') # the highest value of information gain/gini gain seen so far\\n attr = None\\n for attribute in attributes:\\n attr_val = X[attribute].copy()\\n cur_if = information_gain(y,attr_val,self.type)\\n if (cur_if>global_if):\\n # Update when a better split is receieved\\n global_if = cur_if\\n attr = attribute\\n return attr\\n else:\\n global_if = float('inf')\\n attr = None\\n for attribute in attributes:\\n attr_val = X[attribute].copy()\\n cur_if = gini_gain(y,attr_val)\\n if (global_if>cur_if):\\n # Update when a better split is receieved\\n global_if = cur_if\\n attr = attribute\\n return attr\",\n \"def find_shape(items: int):\\n for columns in range(1, MAX_COLUMNS + 1):\\n if columns / math.ceil(items / columns) >= MIN_RATIO:\\n return math.ceil(items / columns), columns\\n return math.ceil(items / MAX_COLUMNS), MAX_COLUMNS\",\n \"def get_cluster_to_split(clusters):\\n\\treturn max(clusters.items(), key=lambda x: x[1].get_distortion())[1]\",\n \"def getSplits(df, train_size, val_size, test_size, seed=None):\\n size = len(df)\\n\\n # size is considered a percentage if less than 1:\\n train_size = int(train_size * size) if train_size < 1 else train_size\\n val_size = int(val_size * size) if val_size < 1 else val_size\\n test_size = int(test_size * size) if test_size < 1 else test_size\\n\\n if not seed is None:\\n np.random.seed(seed)\\n\\n train_val_idx = np.random.choice(\\n a=range(size),\\n size=train_size + val_size,\\n replace=False\\n )\\n train_idx = train_val_idx[:train_size]\\n val_idx = train_val_idx[train_size:]\\n\\n train = df.iloc[train_idx]\\n val = df.iloc[val_idx]\\n test = df.drop(train.index).drop(val.index) # test is equal to the leftover\\n\\n assert len(train) + len(val) + len(test) == len(df)\\n\\n return train, val, test\",\n \"def best_split1(self,X,attributes):\\n if (self.criterion==\\\"information_gain\\\"):\\n global_if = float('-inf') # the highest value of varience seen so far\\n attr , val = None, None\\n for attribute in attributes[::-1]:\\n attr_val = pd.Series(X[attribute].unique()).sort_values(ignore_index=True)\\n last_val = attr_val[0]\\n for i in range(1,attr_val.size):\\n cur_val = attr_val[i]\\n valc = round((last_val+cur_val)/2,4)\\n last_val = cur_val\\n cur_if = information_gain1(valc,X[attribute],X[\\\"Output\\\"],self.type)\\n if (cur_if>global_if):\\n global_if,attr,val = cur_if,attribute,valc\\n return attr,val\\n else:\\n global_if = float('inf') # the lowest value of varience seen so far\\n attr , val = None, None\\n for attribute in attributes[::-1]:\\n attr_val = pd.Series(X[attribute].unique()).sort_values(ignore_index=True)\\n last_val = attr_val[0]\\n for i in range(1,attr_val.size):\\n cur_val = attr_val[i]\\n valc = round((last_val+cur_val)/2,4)\\n last_val = cur_val\\n cur_if = gini_gain1(X[\\\"Output\\\"],X[attribute], valc)\\n if (global_if>cur_if):\\n global_if,attr,val = cur_if,attribute,valc\\n return attr,val\",\n \"def calcGiniSplitByColumn(self, data, structure, colIName):\\n colIndex, giniSplit = structure[colIName]['index'], 0\\n for value in structure[colIName][\\\"values\\\"]:\\n newData = list(filter(lambda x: x[colIndex] == value, data))\\n p = len(newData) / len(data)\\n giniSplit += self.calcDataGini(newData, structure) * p\\n return round(giniSplit, 3)\",\n \"def entropyWithBestSplit(attr, X, y):\\n df = X[attr]\\n maxVal = df.max()\\n minVal = df.min()\\n\\n # Square root decomposition\\n r = math.ceil(math.sqrt(maxVal - minVal))\\n entropyVal = float('inf')\\n splitAt = -1\\n\\n iterNum = 0\\n while r > MIN_BIN_SIZE and iterNum < MAX_ITER:\\n iterNum += 1\\n i = minVal\\n while i < maxVal:\\n leftSplit = df[df < i].index.tolist()\\n rightSplit = df[df >= i].index.tolist()\\n buff_entropy = entropy(df, leftSplit) *\\\\\\n (len(leftSplit) / (len(leftSplit) + len(rightSplit)))\\n buff_entropy += entropy(df, rightSplit) *\\\\\\n (len(rightSplit) / (len(leftSplit) + len(rightSplit)))\\n if entropyVal >= buff_entropy:\\n entropyVal = buff_entropy\\n splitAt = i\\n i += r\\n minVal = min([splitAt - r, minVal])\\n maxVal = max([splitAt + r, maxVal])\\n r_buff = math.ceil(math.sqrt(maxVal - minVal))\\n if r_buff >= r:\\n break\\n else:\\n r = r_buff\\n finalIdxLists = [\\n df[df < splitAt].index.tolist(),\\n df[df >= splitAt].index.tolist()\\n ]\\n return [splitAt], finalIdxLists, entropyVal\",\n \"def get_min_across_splits_continuous(\\n arr: np.ndarray, y: np.ndarray, splits: np.ndarray, eval_func: Callable\\n ):\\n n = len(splits)\\n if n > 500:\\n # If many split points, use some threading\\n with multiprocessing.Pool(processes=8) as p:\\n # Get evaluation scores across all the splits\\n post_split_evals = dict(\\n zip(\\n range(len(splits)),\\n p.starmap(\\n BaseTree.get_split_goodness_fit_continuous,\\n zip([arr] * n, [y] * n, splits, [eval_func] * n),\\n ),\\n )\\n )\\n p.close()\\n else:\\n # If not too many split points, get scores across all splits\\n post_split_evals = dict(\\n zip(\\n range(len(splits)),\\n map(\\n lambda x: BaseTree.get_split_goodness_fit_continuous(*x),\\n zip([arr] * n, [y] * n, splits, [eval_func] * n),\\n ),\\n )\\n )\\n # Get the minimum split based on gain ratio\\n min_eval = min(\\n post_split_evals,\\n key=lambda x: pipe(\\n post_split_evals.get(x),\\n lambda results: results[0] / results[1], # entropy / intrinsic value\\n ),\\n )\\n\\n # Return the best split and the splits scores\\n return (splits[min_eval], *post_split_evals.get(min_eval))\",\n \"def splitData(df, split):\\n train = df.iloc[:int(len(df)*split)]\\n test = df.iloc[int(len(df)*split):]\\n \\n return train, test\",\n \"def __find_best_split_in_feature(self, feature_and_class):\\n\\n # sort the feature and class and use changes in the class to reduce\\n # number of potential split info gain calculations\\n sorted_data = feature_and_class[\\n feature_and_class[:, 0].astype(np.int).argsort()]\\n potential_splits = self.__find_integers_with_class_change(sorted_data)\\n info_gains = self.__info_gain_from_splits(potential_splits,\\n sorted_data)\\n\\n # returning nothing in no information gains are found\\n if len(info_gains) == 0:\\n return None, None\\n\\n index = info_gains.index(max(info_gains))\\n return info_gains[index], potential_splits[index]\",\n \"def _calc_optimal_subset(fracs: pd.DataFrame,\\r\\n match_col: str) -> Tuple[pd.DataFrame, float, float]:\\r\\n\\r\\n fracs = fracs.copy(deep=True)\\r\\n fracs['control_sample_fraction_naive'] = fracs['treatment']/fracs['control']\\r\\n scale_factor = fracs.control_sample_fraction_naive.max()**-1\\r\\n logging.getLogger(__name__).info(\\\"scale factor is {scale_factor:.2f} (coeffs for treatment w/ no drops\\\".format(scale_factor=scale_factor))\\r\\n\\r\\n # if no subscaling is necessary return fracs as is\\r\\n if scale_factor >= 1:\\r\\n logging.getLogger(__name__).info(\\\"can use all treatments safely, returning early\\\")\\r\\n fracs['control_scaled_sample_fraction'] = fracs['control_sample_fraction_naive']\\r\\n fracs['treatment_scaled_sample_fraction'] = 1\\r\\n fracs = fracs[[match_col, 'treatment_scaled_sample_fraction', 'control_scaled_sample_fraction']]\\r\\n return fracs, float(1), float(0)\\r\\n\\r\\n options = _create_options_grid(fracs, scale_factor)\\r\\n options['utility'] = options.apply(_calc_util_wrapper, axis=1)\\r\\n\\r\\n # pick best\\r\\n max_util = options.utility.max()\\r\\n best_row = options[options.utility == max_util].iloc[0]\\r\\n winning_scale = float(best_row['scale'])\\r\\n winning_drop = float(best_row['percent_dropped'])\\r\\n\\r\\n logging.getLogger(__name__).info(\\\"max_util:{mu:.2f}\\\\twinning_scale:{ws:.2f}\\\\twinning_drop:{wd:.2f}\\\".format(mu=max_util, ws=winning_scale, wd=winning_drop))\\r\\n\\r\\n fracs['control_scaled_sample_fraction'] = np.min([(fracs['treatment'] * winning_scale/fracs['control']).values, [1]*len(fracs)], axis=0)\\r\\n fracs['treatment_scaled_sample_fraction'] = fracs['control_scaled_sample_fraction'] * fracs['control']/fracs['treatment']\\r\\n fracs = fracs[[match_col, 'treatment_scaled_sample_fraction', 'control_scaled_sample_fraction']]\\r\\n\\r\\n return fracs, winning_scale, winning_drop\",\n \"def branching(self, df, layer, side):\\n min_err = 1\\n # Search for the best cut\\n for i in range(self.dim):\\n ddf = df.sort_values(i)\\n Y = ddf.y.values\\n\\n for j in range(1, len(ddf)):\\n err = self.impurity(Y, j)\\n if err < min_err:\\n best_d, best_val, min_err = i, ddf.iloc[j][i], err\\n\\n # Record the best branching parameters at this node\\n self.Branch[(layer, side)] = best_d, best_val\\n return best_d, best_val\",\n \"def best_B(Ag):\\n top = 0\\n for i in range(len(Ag)):\\n etop = np.min(cf.TD20[int(Ag[i]) - 1])\\n top += etop\\n return top\",\n \"def best_split(self):\\n sub_group = []\\n\\n current_entropy = self.entropy(self._Passengers)\\n best_gain = 0 # holds the best entropy difference so far\\n best_split = self._Attr[0].get_name()\\n relative_entropy = 0 # entropy while taking account for the size of the population\\n\\n for Attribute in self._Attr:\\n relative_entropy = 0\\n print(\\\"Attr considered: \\\" + Attribute.get_name())\\n for Attr_option in Attribute.get_options():\\n sub_group = []\\n for Passenger in self._Passengers:\\n if self.passenger_attr_option_check(Passenger,\\n Attribute.get_name(),\\n Attr_option): # if P.A = V\\n sub_group.append(Passenger)\\n if len(sub_group) > 0 and len(self._Passengers) > 0:\\n relative_entropy += self.entropy(sub_group) * (len(sub_group)/len(self._Passengers))\\n\\n if current_entropy - relative_entropy > best_gain:\\n best_gain = current_entropy - relative_entropy\\n best_split = Attribute.get_name()\\n\\n print(f\\\"best split:{best_split} \\\\n with entropy gain of:\\\\n {best_gain}\\\")\\n\\n return best_split\",\n \"def calcGainRatioSplitByColumn(self, data, structure, colIName):\\n splitInfo, colIndex = 0, structure[colIName]['index']\\n for value in structure[colIName]['values']:\\n newData = list(filter(lambda x: x[colIndex] == value, data))\\n p = len(newData) / len(data) if len(newData) != 0 else 1\\n splitInfo += (-1) * p * log2(p)\\n splitInfo = 1 if splitInfo == 0 else splitInfo\\n return round(self.calcInfoGainByColumnSplit(data, structure, colIName) / splitInfo, 3)\",\n \"def getBestSplitsInDataByInfoGain(self, data, structure, colName, numOfSplits):\\n splitsList, newSplitsList = {}, []\\n self.fillBestSplitsInDataByInfoGainIntoDict(data, structure, colName, numOfSplits, splitsList, 0)\\n for lists in list(splitsList.values())[1:]:\\n while len(lists) > 0:\\n splitOne, splitTwo = [], []\\n if len(lists) > 0:\\n splitOne = lists.pop()\\n if len(lists) > 0:\\n splitTwo = lists.pop()\\n if splitOne and splitTwo:\\n if splitOne[1] >= splitTwo[1]:\\n newSplitsList.append(splitOne[0])\\n newSplitsList.append(splitTwo[0])\\n else:\\n newSplitsList.append(splitTwo[0])\\n newSplitsList.append(splitOne[0])\\n elif splitOne:\\n newSplitsList.append(splitOne[0])\\n elif splitTwo:\\n newSplitsList.append(splitTwo[0])\\n\\n newSplitsList.insert(0, splitsList['0'][0][0])\\n self.removeDuplicatesInList(newSplitsList)\\n return newSplitsList[0:numOfSplits]\",\n \"def _best_split(cls, X, y):\\n n = X.shape[0]\\n num_feature = X.shape[1]\\n y_types = np.unique(y)\\n\\n # initialize\\n min_score = float(n)\\n feature_idx = None\\n best_theta = None\\n best_idx = None\\n\\n for feature_idx in xrange(num_feature):\\n # counter for y\\n cumulate_y = Counter()\\n rest_y = Counter()\\n for y_type in y_types:\\n cnt = np.where(y == y_type)[0].shape[0]\\n rest_y[y_type] = cnt\\n\\n # sorted data\\n sorted_idx = np.argsort(X[:, feature_idx])\\n sorted_X = np.copy(X)\\n sorted_y = np.copy(y)\\n sorted_X = sorted_X[sorted_idx]\\n sorted_y = sorted_y[sorted_idx]\\n #print \\\"_best_split:\\\", sorted_X.shape, sorted_y.shape\\n\\n for idx in xrange(n-1):\\n theta = (sorted_X[idx, feature_idx] + sorted_X[idx + 1, feature_idx]) / 2\\n y_label = sorted_y[idx]\\n cumulate_y[y_label] += 1\\n rest_y[y_label] -= 1\\n left_cnt = sum(cumulate_y.values())\\n right_cnt = sum(rest_y.values())\\n w_1 = left_cnt * cls._gini_index(cumulate_y.values())\\n w_2 = right_cnt * cls._gini_index(rest_y.values())\\n score = w_1 + w_2\\n if score < min_score:\\n min_score = score\\n best_theta = theta\\n best_idx = feature_idx\\n #print('new min score: %.3f' % score)\\n #print('feature: %d, theta: %.3f' % (best_idx, best_theta))\\n #print('left: %d, right: %d' % (left_cnt, right_cnt))\\n print('feature: %d, theta: %.3f' % (best_idx, best_theta))\\n return (best_idx, best_theta)\",\n \"def _best_split(cls, X, y):\\n n = X.shape[0]\\n num_feature = X.shape[1]\\n y_types = np.unique(y)\\n\\n # initialize\\n min_score = float(n)\\n feature_idx = None\\n best_theta = None\\n best_idx = None\\n\\n for feature_idx in xrange(num_feature):\\n # counter for y\\n cumulate_y = Counter()\\n rest_y = Counter()\\n for y_type in y_types:\\n cnt = np.where(y == y_type)[0].shape[0]\\n rest_y[y_type] = cnt\\n\\n # sorted data\\n sorted_idx = np.argsort(X[:, feature_idx])\\n sorted_X = np.copy(X)\\n sorted_y = np.copy(y)\\n sorted_X = sorted_X[sorted_idx]\\n sorted_y = sorted_y[sorted_idx]\\n #print \\\"_best_split:\\\", sorted_X.shape, sorted_y.shape\\n\\n for idx in xrange(n-1):\\n theta = (sorted_X[idx, feature_idx] + sorted_X[idx + 1, feature_idx]) / 2\\n y_label = sorted_y[idx]\\n cumulate_y[y_label] += 1\\n rest_y[y_label] -= 1\\n left_cnt = sum(cumulate_y.values())\\n right_cnt = sum(rest_y.values())\\n w_1 = left_cnt * cls._gini_index(cumulate_y.values())\\n w_2 = right_cnt * cls._gini_index(rest_y.values())\\n score = w_1 + w_2\\n if score < min_score:\\n min_score = score\\n best_theta = theta\\n best_idx = feature_idx\\n #print('new min score: %.3f' % score)\\n #print('feature: %d, theta: %.3f' % (best_idx, best_theta))\\n #print('left: %d, right: %d' % (left_cnt, right_cnt))\\n print('feature: %d, theta: %.3f' % (best_idx, best_theta))\\n return (best_idx, best_theta)\",\n \"def fit(self, col):\\n self.find_max_min(col)\",\n \"def _find_split(self, X, y, n_features):\\r\\n splits_info = []\\r\\n\\r\\n # Select features to consider\\r\\n features = self._feature_selection.get_features(n_features, self._feature_prob)\\r\\n\\r\\n # Get candidate splits\\r\\n for feature_id in features:\\r\\n for split_value in compute_split_values(X[:, feature_id]):\\r\\n splits_info.append(\\r\\n compute_split_info(self._split_criterion, X, y, feature_id, split_value, self._min_samples_leaf))\\r\\n\\r\\n splits = []\\r\\n for split_info in splits_info:\\r\\n if split_info is not None:\\r\\n gain, feature_id, split_value = split_info\\r\\n split = Split(feature_id, value=split_value, gain=gain)\\r\\n splits.append(split)\\r\\n else:\\r\\n continue\\r\\n\\r\\n selected_split = self._split_chooser.get_split(splits)\\r\\n return selected_split\",\n \"def calcGiniSplitBySplitValue(self, data, structure, colIndex, splitValue):\\n dataBellow = list(filter(lambda x: float(x[colIndex]) <= splitValue, data))\\n dataAbove = list(filter(lambda x: float(x[colIndex]) > splitValue, data))\\n giniSplit = (len(dataBellow) / len(data)) * self.calcDataGini(dataBellow, structure) +\\\\\\n (len(dataAbove) / len(data)) * self.calcDataGini(dataAbove, structure)\\n return round(giniSplit, 3)\",\n \"def get_bestparameter(self):\\n if self._df_test is None:\\n raise RuntimeError('get_bestparameter: please the '\\n 'train model first')\\n mean = self._df_test.mean(axis=1)\\n if len(mean) == 1:\\n result = mean.idxmax()\\n elif len(mean) == 2:\\n result = mean.loc[mean.index > 1].idxmax()\\n else:\\n result = mean.loc[mean.index > 2].idxmax()\\n return result\",\n \"def get_bestparameter(self):\\n if self._df_test is None:\\n raise RuntimeError('get_bestparameter: please the '\\n 'train model first')\\n mean = self._df_test.mean(axis=1)\\n if len(mean) == 1:\\n result = mean.idxmax()\\n elif len(mean) == 2:\\n result = mean.loc[mean.index > 1].idxmax()\\n else:\\n result = mean.loc[mean.index > 2].idxmax()\\n return result\",\n \"def possible_splits(self,feature,y):\\n\\n yi = y[:-1]\\n yi1= y[1:]\\n idx=np.argwhere((yi1-yi)!=0)\\n return idx.flatten()\",\n \"def get_splits(self):\\n\\t\\treturn self.k\",\n \"def getListWithBestValueSplitsOfDataByGini(self, data, structure, colIndex, numOfSplits):\\n splitsList, newSplitsList = {}, []\\n self.fillDictWithBestValueSplitsOfDataByGini(data, structure, colIndex, numOfSplits, splitsList, 0)\\n for lists in list(splitsList.values())[1:]:\\n while len(lists) > 0:\\n splitOne, splitTwo = [], []\\n if len(lists) > 0:\\n splitOne = lists.pop()\\n if len(lists) > 0:\\n splitTwo = lists.pop()\\n if splitOne and splitTwo:\\n if splitOne[1] <= splitTwo[1]:\\n newSplitsList.append(splitOne[0])\\n newSplitsList.append(splitTwo[0])\\n else:\\n newSplitsList.append(splitTwo[0])\\n newSplitsList.append(splitOne[0])\\n elif splitOne:\\n newSplitsList.append(splitOne[0])\\n elif splitTwo:\\n newSplitsList.append(splitTwo[0])\\n\\n newSplitsList.insert(0, splitsList['0'][0][0])\\n self.removeDuplicatesInList(newSplitsList)\\n return newSplitsList[0:numOfSplits]\",\n \"def MaxColumn(I, E, d, ro):\\n # http://en.wikipedia.org/wiki/Buckling\\n B = 1.86635\\n g = 9.81\\n h = (9 * B**2 * E*I / (4*ro*g*np.pi * (d/2)**2))**(1/3)\\n return h\",\n \"def choose_best_feature(data_set):\\n feature_size = len(data_set[0]) - 1\\n base_entropy = calc_entropy(data_set)\\n best_info_gain = 0.0; best_feature = -1\\n for i in xrange(feature_size):\\n feat_list = [eg[i] for eg in data_set]\\n unique_values = set(feat_list)\\n new_entropy = 0.0\\n for value in unique_values:\\n sub_ds = splite_dataset(data_set, i, value)\\n prob = len(sub_ds) / float(len(data_set))\\n new_entropy += prob * calc_entropy(sub_ds)\\n info_gain = base_entropy - new_entropy\\n if info_gain > best_info_gain:\\n best_info_gain = info_gain\\n best_feature = i\\n\\n return best_feature\",\n \"def optimal_2split(data, dicrete=True, equidistant=True, verbose=False):\\n if dicrete and equidistant:\\n uniqs = np.unique(data)\\n uniqs = np.sort(uniqs)\\n delta_ = (uniqs[1:] - uniqs[:-1]).min()\\n rho_crit = 10\\n n0 = data.shape[0]\\n l = uniqs.max() - uniqs.min()\\n rho_cur = n0 / (l / delta_)\\n delta = np.ceil(rho_crit / rho_cur) * delta_\\n bbs = np.arange(\\n uniqs.min() - 0.5 * delta, uniqs.max() + 0.5 * delta + 1e-6 * delta, delta\\n )\\n # n_actual = (bbs[-1] - bbs[0])/delta\\n if verbose:\\n print(bbs)\\n else:\\n bbs = 10\\n cnts, bbs = histogram(data, bbs)\\n diff = cnts[1:] - cnts[:-1]\\n ddif = diff[1:] - diff[:-1]\\n if verbose:\\n print(cnts, bbs)\\n print(list(zip(range(len(cnts)), cnts)), bbs)\\n print(\\\"f prime:\\\", diff)\\n print(\\\"f double prime:\\\", ddif)\\n # either diff == 0, or\\n derivative_change = diff[1:] * diff[:-1]\\n # sign change indices\\n ii = flatnonzero((derivative_change < 0) & (ddif > 0))\\n jj = flatnonzero(diff == 0)\\n concats = np.concatenate([ii, jj])\\n if verbose:\\n print(\\\"candidate indices\\\")\\n print(1 + ii, 1 + jj)\\n print(concats)\\n print(\\\"candidate cnts\\\")\\n print(cnts[1 + concats])\\n if concats.size > 0:\\n arg_glo_min = argmin(cnts[1 + concats])\\n if arg_glo_min < len(ii):\\n lbbs, rbbs = bbs[1 + concats[arg_glo_min]], bbs[2 + concats[arg_glo_min]]\\n optimal_split = 0.5 * (lbbs + rbbs)\\n else:\\n # two conseq. equal values, optinal split is between them\\n optimal_split = bbs[2 + concats[arg_glo_min]]\\n if verbose:\\n print(\\n arg_glo_min,\\n 1 + concats[arg_glo_min],\\n cnts[1 + concats[arg_glo_min]],\\n optimal_split,\\n )\\n else:\\n return np.nan\\n return optimal_split\",\n \"def data_splitting_tool(feature_cols = None, label_col = None ,val_size = 0.2, test_size = 0.2, random_state = 13):\\n if (val_size != ''):\\n total_test_size = val_size + test_size\\n test_ratio = test_size/total_test_size\\n X_train, X_test, y_train, y_test = train_test_split(feature_cols, label_col, test_size = total_test_size, random_state=random_state)\\n X_val, X_test, y_val, y_test = train_test_split(X_test, y_test, test_size=test_ratio, random_state=random_state)\\n return(X_train, y_train, X_val,y_val, X_test, y_test)\\n else:\\n X_train, X_test, y_train, y_test = train_test_split(feature_cols, label_col, test_size = test_size, random_state=random_state)\\n return(X_train, y_train, X_test, y_test)\",\n \"def _compute_best_split_and_push(self, node):\\n\\n node.split_info = self.splitter.find_node_split(\\n node.sample_indices, node.histograms, node.sum_gradients,\\n node.sum_hessians)\\n\\n if node.split_info.gain <= 0: # no valid split\\n self._finalize_leaf(node)\\n else:\\n heappush(self.splittable_nodes, node)\",\n \"def _find_largest_candidate(self, reduced):\\n nbr_counts = np.count_nonzero(reduced == 0, axis=0) # = [1, 1, 4, 2,...] where each value is the number of neighbours for the variant at that index.\\n count_max = nbr_counts.max()\\n if count_max == 0: # Indicates there are no available variants close enough\\n return None, [] # to the remaining unassigned. Usually raises an error.\\n max_inds = np.nonzero(nbr_counts == count_max)[0] # Array containing the indices of all variants with the max number of neighbours.\\n if len(max_inds) == 1: # A single largest cluster\\n best_center = max_inds[0]\\n best_clstr = np.nonzero(reduced[:,best_center] == 0)[0]\\n else: # A tie for largest cluster. Broken by smallest sum of full scores\\n # This was tested with the below more accurate and true scoring function. Unfortunately it became hideously slow (clustered_inds and centre_inds were given as args):\\n # clstr_inds = np.nonzero(reduced[:,max_ind] == 0)[0]\\n # covered_inds = list(clustered_inds | set(clstr_inds))\\n # centre_inds.append(max_ind)\\n # score = np.sum(np.min(self.orig_dists[np.ix_(covered_inds,centre_inds)], axis=1))\\n # centre_inds.pop()\\n best_center, best_clstr, best_score = None, [], np.inf\\n for max_ind in max_inds:\\n clstr_inds = np.nonzero(reduced[:,max_ind] == 0)[0]\\n score = np.sum(self.orig_dists[clstr_inds,max_ind])\\n if score < best_score:\\n best_center, best_clstr, best_score = max_ind, clstr_inds, score\\n return best_center, best_clstr\",\n \"def potential_splits(self, potential_xj):\\r\\n \\r\\n self.cur.execute(\\\"SELECT DISTINCT \\\" + potential_xj + \\\" FROM \\\" + self.table_name + \\\";\\\")\\r\\n potential_splits = [ii[0] for ii in self.cur.fetchall()]\\r\\n return potential_splits\",\n \"def get_discrete_split_value(arr: np.ndarray, y: np.ndarray, eval_func: Callable):\\n\\n # First element is the weighted average eval_func of the split\\n # Second term is the intrinsic value to penalize many splits.\\n return (\\n sum(\\n [\\n eval_func(y[arr == value]) * np.sum(arr == value) / len(y)\\n for value in set(arr)\\n ]\\n ),\\n -1\\n * sum(\\n [\\n pipe(\\n np.sum(arr == value) / len(y),\\n lambda ratio: ratio * np.log(ratio),\\n )\\n for value in set(arr)\\n ]\\n ),\\n )\",\n \"def bsp(splits, min_val, max_val):\\n if not splits and min_val == max_val:\\n return min_val\\n if splits[0] in ['F', 'L']:\\n return bsp(splits[1:], min_val, math.floor((min_val + max_val)/2))\\n elif splits[0] in ['B', 'R']:\\n return bsp(splits[1:], math.ceil((min_val + max_val)/2), max_val)\",\n \"def bisect_anyaxis(counts, ndomains, split_fac):\\n # split along any axis \\n splits = {}\\n pvals = []\\n for axis in range(len(counts.shape)):\\n # Sum over other axes\\n sum_axes = list(np.arange(len(counts.shape)))\\n sum_axes.pop(axis)\\n sum_axes = tuple(sum_axes)\\n\\n # split into left and right \\n counts1d = np.sum(counts, axis=sum_axes, dtype=np.int64)\\n \\n split_idx, n_L, pval = load_partition_1d(counts1d, ndomains, split_fac)\\n\\n splits[axis] = (split_idx, n_L)\\n\\n pvals.append(pval)\\n\\n axis = int(np.argmin(pvals))\\n split_idx, n_L = splits[axis]\\n return axis, split_idx, n_L\",\n \"def _split_threshold(self, node):\\n\\n # define the score to improve upon\\n if self.n_clusters >= self.min_leaves and node.size <= self.max_leaf_size:\\n # split only if min(children scores) > node.score\\n force_split = False\\n best_score = node.score\\n else:\\n # force split: just take the best (even if children are worse)\\n force_split = True\\n best_score = None\\n\\n left, right = None, None\\n\\n # iterate over embedding dimensions (first ones are more reliable)\\n # up to max_n_vec (included), until we found an improving split\\n for _vec in range(self.n_vec):\\n\\n # get the candidate thresholds along this dimension\\n threshs = self._get_candidate_thresholds(node, _vec)\\n\\n # look for an improving best split along this eigenvector\\n for _t in threshs:\\n # compute the split\\n below_thresh = self.E[node.ids, _vec] < _t\\n _lids = node.ids[below_thresh]\\n _rids = node.ids[np.logical_not(below_thresh)]\\n # check if the tubes are not too small\\n _nl, _nr = len(_lids), len(_rids)\\n is_valid = _nl >= self.min_leaf_size and _nr >= self.min_leaf_size\\n if is_valid:\\n # compute the score of the new tubes only\\n _sl = self.get_tube_score(_lids)\\n _sr = self.get_tube_score(_rids)\\n # get the score of this split\\n split_score = min(_sl, _sr)\\n if best_score is None or split_score > best_score:\\n # better split\\n best_score = split_score\\n node.has_children = True\\n node.thresh = _t\\n left = SpectralNode(\\n _lids, _vec, score=_sl, name=node.name + \\\"0\\\")\\n right = SpectralNode(\\n _rids, _vec, score=_sr, name=node.name + \\\"1\\\")\\n\\n # check stopping criterion\\n if node.has_children:\\n # we found an improving split\\n if _vec > 0 or not force_split:\\n # found an improving non-forced split: stop here\\n break\\n\\n return left, right\",\n \"def splittable_variables(self) -> List[int]:\\n #print(\\\"enter bartpy/bartpy/data.py CovariateMatrix splittable_variables\\\")\\n \\n for i in range(0, self._n_features):\\n if self._splittable_variables[i] is None:\\n self._splittable_variables[i] = is_not_constant(self.get_column(i))\\n \\n output = [i for (i, x) in enumerate(self._splittable_variables) if x is True] \\n #print(\\\"-exit bartpy/bartpy/data.py CovariateMatrix splittable_variables\\\")\\n return output\",\n \"def get_split_col_names():\\n return ['dna_%d' % (idx+1) for idx in range(60)]\",\n \"def ent_from_split(col, split_value, labels):\\n idx_n1, idx_n2 = col <= split_value, col > split_value\\n node1_x, node2_x = col[idx_n1], col[idx_n2]\\n node1_y, node2_y = labels[idx_n1], labels[idx_n2]\\n \\n p_node1 = len(node1_x) / len(col)\\n p_node2 = len(node2_x) / len(col)\\n assert p_node1 + p_node2 == 1\\n \\n ent_node1 = entropy(sum(node1_y == 0), sum(node1_y == 1))\\n ent_node2 = entropy(sum(node2_y == 0), sum(node2_y == 1))\\n return float(p_node1*ent_node1 + p_node2*ent_node2)\",\n \"def optimal_split(self, ratio = 0.5):\\n\\n if (sum(self.game_state) == 1):\\n if (randint(1,100)<=50):\\n return self.game_state, [0]*(self.K+1)\\n else:\\n return [0]*(self.K+1), self.game_state\\n \\n else:\\n prob = LpProblem(\\\"Optimal split\\\",LpMinimize)\\n A = []\\n for i in range(self.K + 1):\\n A += LpVariable(str(i), 0, self.game_state[i], LpInteger)\\n prob += sum([2**(-(self.K - i)) * c for c, i in zip(A, range(self.K + 1))]) - ratio * self.potential(self.game_state), \\\"Objective function\\\"\\n prob += sum([2**(-(self.K - i)) * c for c, i in zip(A, range(self.K + 1))]) >= ratio * self.potential(self.game_state), \\\"Constraint\\\"\\n #prob.writeLP(\\\"test.lp\\\")\\n prob.solve()\\n Abis = [0]*(self.K+1)\\n for v in prob.variables():\\n Abis[int(v.name)] = round(v.varValue)\\n B = [z - a for z, a in zip(self.game_state, Abis)]\\n return Abis, B\",\n \"def dataset_splits(self):\\n # 10% evaluation data\\n return [{\\n \\\"split\\\": problem.DatasetSplit.TRAIN,\\n \\\"shards\\\": 799,\\n }, {\\n \\\"split\\\": problem.DatasetSplit.EVAL,\\n \\\"shards\\\": 1,\\n }]\",\n \"def train_val_test_split(df):\\n from sklearn.model_selction import train_test_split\\n train, test = train_test_split(df, train_size = 0.80, test_size=0.20,\\n random_state = 42)\\n train, val = train_test_split(train, train_size = 0.70, val_size=0.30)\\n print(train.shape, val.shape, test.shape)\\n\\n return train, val, test\",\n \"def split(self, X, y, feature_array):\\n n, p = X.shape\\n\\n best_gain = 0\\n best_split_point = 0\\n best_feature_id = -1\\n for feature_id in feature_array:\\n cur_gain, cur_split_point = self.find_best_split(\\n X[:, feature_id], y)\\n if cur_gain > best_gain - self.eps:\\n best_gain = cur_gain\\n best_split_point = cur_split_point\\n best_feature_id = feature_id\\n\\n assert(best_feature_id != -1)\\n\\n x = X[:, best_feature_id]\\n left_index = x < best_split_point\\n right_index = x >= best_split_point\\n\\n self.split_id = best_feature_id\\n self.split_val = best_split_point\\n\\n return (left_index, right_index)\",\n \"def title_based_split(df, split_val):\\n # retrieve split title and get the minimum id with that title\\n split_title = df['title'].iloc[int(split_val * len(df)) - 1]\\n split_index = df[df['title'] == split_title].index.min()\\n return df.iloc[:split_index], df.iloc[split_index:]\",\n \"def fold_column(self):\\n return self._parms.get(\\\"fold_column\\\")\",\n \"def getColMinMax(table, col):\\n\\tvmin = None\\n\\tvmax = None\\n\\tfor rec in table:\\n\\t\\tvalue = rec[col]\\n\\t\\tif vmin is None:\\n\\t\\t\\tvmin = value\\n\\t\\t\\tvmax = value\\n\\t\\telse:\\n\\t\\t\\tif value < vmin:\\n\\t\\t\\t\\tvmin = value\\n\\t\\t\\telif value > vmax:\\n\\t\\t\\t\\tvmax = value\\n\\treturn (vmin, vmax, vmax - vmin)\",\n \"def __divideset(rows, column, value):\\n split_function = None #Initialize a variable split function.\\n if isinstance(value, int) or isinstance(value, float): #Check if value is a number\\n #True = the observation's value >= to the splitting criteria. False otherwise\\n split_function = lambda row: row[column] >= value\\n else:\\n #If value is a string, True is where the observation's value == the criteria\\n split_function = lambda row:row[column] == value\\n \\n #Divide the rows into two sets and return them\\n set1 = [row for row in rows if split_function(row)]\\n set2 = [row for row in rows if not split_function(row)]\\n return (set1, set2)\",\n \"def _compute_best_value(self):\\n asgt = self._neighbors_values.copy()\\n best_cost, best_val = None, []\\n\\n for v in self._variable.domain:\\n asgt[self.variable.name] = v\\n c = self._compute_cost(**asgt)\\n if (\\n best_cost is None\\n or (best_cost > c and self._mode == \\\"min\\\")\\n or (best_cost < c and self._mode == \\\"max\\\")\\n ):\\n best_cost = c\\n best_val = [v]\\n elif best_cost == c:\\n best_val.append(v)\\n\\n return best_val, best_cost\",\n \"def split(df, stratify_by=None):\\n \\n if stratify_by == None:\\n train, test = train_test_split(df, test_size=.3, random_state=123)\\n train, validate = train_test_split(df, test_size=.3, random_state=123)\\n else:\\n train, test = train_test_split(df, test_size=.2, random_state=123, stratify=df[stratify_by])\\n train, validate = train_test_split(df, test_size=.3, random_state=123, stratify=train[stratify_by])\\n \\n return train, validate, test\",\n \"def single_cv(df, n_splits=3, val_size=2, seed=0xBadCafe):\\n folds = sorted(df.fold.unique())\\n split = []\\n for f in folds:\\n idx_b = df[df.fold == f].index.tolist()\\n cv_b = train_val_test_split(idx_b, val_size=val_size, n_splits=n_splits, random_state=seed)\\n for cv in cv_b:\\n split.append(cv)\\n return split\",\n \"def _mode(x, def_fill=ImputerMixin._def_fill):\\n idx = x.as_data_frame(use_pandas=True)[x.columns[0]].value_counts().index\\n\\n # if the most common is null, then return the next most common.\\n # if there is no next common (i.e., 100% null) then we return the def_fill\\n return idx[0] if not pd.isnull(idx[0]) else idx[1] if idx.shape[0] > 1 else def_fill\",\n \"def max_score_column(self, scores):\\r\\n m = max(scores)\\r\\n lc = []\\r\\n for i in range(len(scores)):\\r\\n if scores[i] == m:\\r\\n lc += [i]\\r\\n if len(lc) > 1:\\r\\n if self.tiebreak == \\\"LEFT\\\":\\r\\n column = lc[0]\\r\\n elif self.tiebreak == \\\"RIGHT\\\":\\r\\n column = lc[-1]\\r\\n else:\\r\\n column = random.choice(lc)\\r\\n return column\\r\\n else:\\r\\n return lc[0]\",\n \"def dataset_splits(self):\\n return [{\\n \\\"split\\\": problem.DatasetSplit.TRAIN,\\n \\\"shards\\\": 80,\\n }, {\\n \\\"split\\\": problem.DatasetSplit.EVAL,\\n \\\"shards\\\": 2,\\n }]\",\n \"def calcEntropyBySplitValue(self, data, structure, colName, splitVal):\\n colIndex, entropy = structure[colName]['index'], 0\\n newDataBellowSplit = list(filter(lambda y: float(y[colIndex]) <= splitVal, data))\\n newDataAboveSplit = list(filter(lambda y: float(y[colIndex]) > splitVal, data))\\n entropyOfNewDataBellowSplit = self.calcDataEntropy(newDataBellowSplit, structure)\\n entropyOfNewAboveSplit = self.calcDataEntropy(newDataAboveSplit, structure)\\n entropy += (len(newDataBellowSplit) / len(data)) * entropyOfNewDataBellowSplit\\n entropy += (len(newDataAboveSplit) / len(data)) * entropyOfNewAboveSplit\\n return round(entropy, 3)\",\n \"def optimal_perturbed_splitting(self,acc=1.e-12,rmax=50.01,tol=1.e-13,algorithm='split'):\\n from nodepy.utils import bisect\\n try:\\n import cvxpy as cvx\\n except:\\n algorithm = 'split'\\n\\n if algorithm == 'LP':\\n r=bisect(0,rmax,acc,tol,self.lp_perturb)\\n elif algorithm == 'split':\\n r=bisect(0,rmax,acc,tol,self.is_splittable)\\n\\n d,alpha,alphatilde=self.resplit(r,tol=tol)\\n return r,d,alpha,alphatilde\",\n \"def get_cols_dummy():\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.74880135","0.7095881","0.69653386","0.6910484","0.68618083","0.67778367","0.6647111","0.65734416","0.6570264","0.6497623","0.6492311","0.644486","0.63778055","0.6318494","0.63056034","0.630296","0.6181761","0.6156663","0.6149908","0.61427826","0.613402","0.61079985","0.6082613","0.6075094","0.6074986","0.60443884","0.60115963","0.6010737","0.5895862","0.5854242","0.58462715","0.58326435","0.5820271","0.57924056","0.57392365","0.5735031","0.570967","0.5684243","0.5682185","0.56753653","0.56315154","0.5631047","0.5620987","0.5610466","0.560528","0.55758566","0.5552783","0.5537562","0.5523517","0.55048704","0.548483","0.5461136","0.5460054","0.54413086","0.5396503","0.53896797","0.53804547","0.5359705","0.535523","0.53518623","0.53518623","0.5327314","0.5300674","0.52967095","0.52916455","0.52916455","0.52893203","0.5285997","0.52682525","0.5268159","0.5266259","0.52651286","0.5259592","0.5237908","0.5235636","0.5219001","0.5216942","0.5214187","0.52138716","0.5194228","0.51864403","0.5178635","0.51736796","0.51561034","0.5155007","0.5153059","0.51466715","0.514563","0.5143962","0.5142925","0.5137903","0.51266587","0.5125495","0.51165897","0.5105725","0.508324","0.5083136","0.5077704","0.50746614","0.5066769"],"string":"[\n \"0.74880135\",\n \"0.7095881\",\n \"0.69653386\",\n \"0.6910484\",\n \"0.68618083\",\n \"0.67778367\",\n \"0.6647111\",\n \"0.65734416\",\n \"0.6570264\",\n \"0.6497623\",\n \"0.6492311\",\n \"0.644486\",\n \"0.63778055\",\n \"0.6318494\",\n \"0.63056034\",\n \"0.630296\",\n \"0.6181761\",\n \"0.6156663\",\n \"0.6149908\",\n \"0.61427826\",\n \"0.613402\",\n \"0.61079985\",\n \"0.6082613\",\n \"0.6075094\",\n \"0.6074986\",\n \"0.60443884\",\n \"0.60115963\",\n \"0.6010737\",\n \"0.5895862\",\n \"0.5854242\",\n \"0.58462715\",\n \"0.58326435\",\n \"0.5820271\",\n \"0.57924056\",\n \"0.57392365\",\n \"0.5735031\",\n \"0.570967\",\n \"0.5684243\",\n \"0.5682185\",\n \"0.56753653\",\n \"0.56315154\",\n \"0.5631047\",\n \"0.5620987\",\n \"0.5610466\",\n \"0.560528\",\n \"0.55758566\",\n \"0.5552783\",\n \"0.5537562\",\n \"0.5523517\",\n \"0.55048704\",\n \"0.548483\",\n \"0.5461136\",\n \"0.5460054\",\n \"0.54413086\",\n \"0.5396503\",\n \"0.53896797\",\n \"0.53804547\",\n \"0.5359705\",\n \"0.535523\",\n \"0.53518623\",\n \"0.53518623\",\n \"0.5327314\",\n \"0.5300674\",\n \"0.52967095\",\n \"0.52916455\",\n \"0.52916455\",\n \"0.52893203\",\n \"0.5285997\",\n \"0.52682525\",\n \"0.5268159\",\n \"0.5266259\",\n \"0.52651286\",\n \"0.5259592\",\n \"0.5237908\",\n \"0.5235636\",\n \"0.5219001\",\n \"0.5216942\",\n \"0.5214187\",\n \"0.52138716\",\n \"0.5194228\",\n \"0.51864403\",\n \"0.5178635\",\n \"0.51736796\",\n \"0.51561034\",\n \"0.5155007\",\n \"0.5153059\",\n \"0.51466715\",\n \"0.514563\",\n \"0.5143962\",\n \"0.5142925\",\n \"0.5137903\",\n \"0.51266587\",\n \"0.5125495\",\n \"0.51165897\",\n \"0.5105725\",\n \"0.508324\",\n \"0.5083136\",\n \"0.5077704\",\n \"0.50746614\",\n \"0.5066769\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.58607"},"document_rank":{"kind":"string","value":"29"}}},{"rowIdx":78598,"cells":{"query":{"kind":"string","value":"Function to create a terminal node."},"document":{"kind":"string","value":"def get_terminal_node (\n self,\n feature_column: int,\n node: TreeSplits,\n feature_value: float,\n feature_matrix: np.ndarray,\n target_array: np.ndarray,\n ):\n # Get the node type\n node_type = self.map_column_node_type [ feature_column ]\n\n if node_type == \"continuous\":\n # If no feature value is passed, this node is the leaf\n if feature_value is None:\n node.children = target_array\n self.n_nodes += 1\n # If a feature value is passed, create leaves as children\n else:\n # Get the above node\n above = feature_matrix [ :, feature_column ] > feature_value\n\n # Add two children\n node.updateTreeValues (\n feature_column = feature_column,\n feature_value = feature_value,\n node_type = node_type,\n nodes = {\n # Children are above points\n \"above\": TreeSplits (\n children = target_array [ above ]\n ), \n # Children are below points\n \"below\": TreeSplits (\n children = target_array [ np.bitwise_not ( above ) ]\n ), \n },\n )\n # Add two nodes to count\n self.n_nodes += 2\n else:\n # Get the valid values of the discrete column\n unique_x_vals = self.discrete_value_maps [ feature_column ]\n # Create the node\n node.updateTreeValues (\n feature_column = feature_column,\n feature_value = None,\n nodes = {\n # Add in the matching rows\n xval: TreeSplits (\n children = target_array [ feature_matrix [ :, feature_column ] == xval ]\n ) \n # If discrete values match\n if np.any ( feature_matrix [ :, feature_column ] == xval ) \n # Add in all the rows if there are no matching values\n else TreeSplits (\n children = target_array\n ) \n for xval in unique_x_vals\n },\n node_type = \"discrete\" ,\n )\n # Increment node counter\n self.n_nodes += len ( unique_x_vals )\n # End get_terminal_node()"},"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 create_terminal() -> str:\n ...","def terminal_node(\n self,\n expr: Any = None,\n ) -> None:\n self.data.append(\n {\n \"type\": \"TERMINAL\",\n \"expr\": expr,\n \"id\": len(\n self.data,\n ),\n }\n )","def __repr__(self):\n return \"Terminal('{}')\".format(self.name)","def create_node(self, **kwargs):\n if not self.nodes:\n self.get_nodes()\n\n _node = Node(project_id=self.project_id, connector=self.connector, **kwargs)\n\n _node.create()\n self.nodes.append(_node)\n print(\n f\"Created: {_node.name} -- Type: {_node.node_type} -- \"\n f\"Console: {_node.console}\"\n )","def create_terminal(self):\n\n indicator = self.__get_indicator()\n class_func = self.__get_classifier_function(indicator)\n classifier_detail = self.__get_classifier_detail(class_func)\n\n # class function\n self.node_data['class_func'] = class_func\n\n # map_type\n map_type_box = set(indicator.map_type) & set(classifier_detail['map_type']) # 取交集\n if not map_type_box:\n print('IndexError: Cannot choose from an empty sequence!!!! %s, %s' % (indicator, classifier_detail))\n self.create_terminal() # 如匹配错误，重新生成。\n self.node_data['map_type'] = random.choice(list(map_type_box))\n\n # node_type (output value type)\n if self.node_data['map_type'] == 'condition':\n self.node_data['node_type'] = 'abs_value'\n else:\n self.node_data['node_type'] = 'pos_value'\n\n # function group\n func_group = None\n for name, group in self.classifier_group.items():\n if class_func in group:\n func_group = name\n self.node_data['class_func_group'] = func_group\n\n # others\n if func_group == 'cut' or func_group == 'compare':\n self.__create_terminal_dict(indicator, classifier_detail)\n\n elif func_group == 'permutation' or func_group == 'trend':\n self.__create_terminal_list(indicator, classifier_detail)\n\n else:\n raise ValueError('Uncategorized class_function: %s. 9484' % class_func)\n\n self.lv_mut_tag = Classifier.lv_mut_tag.copy()\n self.node_result = self.cal()\n\n return self.node_result","def _create_node(\n self,\n name,\n ):\n pass","def createNode(self, pkg, exe, args, name, nspace):\r\n node = Node(self)\r\n self.callRemote('createNode', pkg, exe, args, name,\r\n nspace).chainDeferred(node)\r\n return node","def createNode(self, name):\n return Node(name)","def parse_terminal(node, ty=None):\n if ty == \"METHOD_CALL\":\n return Terminal(\"var\", None)\n elif ty:\n return Terminal(\"var\", ty)\n else:\n return Terminal(\"var\", get_type(node))","def createNode(*args, name: AnyStr=\"\", parent: AnyStr=\"\", shared: bool=True, skipSelect:\n bool=True, **kwargs)->AnyStr:\n pass","def create_node(\n self,\n node: Node,\n parameters: Any\n ) -> str:\n raise NotImplementedError","def addTerminal(self, name, **opts):\n opts.update(renamable=True, removable=True)\n name = self.nextTerminalName(name)\n term = NetTerminal(self, name, **opts)\n self.terminals[name] = term\n if term.isInput():\n self._inputs[name] = term\n elif term.isOutput():\n self._outputs[name] = term\n self.graphicsItem().updateTerminals()\n self.sigTerminalAdded.emit(self, term)\n return term","def createNode(_session, _segment, _const, _type):\n node = _session.create_el(_segment, sc.SC_NODE | _const)\n #_session.appendObj2Sets(_segment, node, [node_sets[_type]])\n createPairPosPerm(_session, _segment, node_sets[_type], node, sc.SC_CONST)\n return node","def create_node(self, *labels, **props):\n component = Node(*labels, **props)\n self.graph.create(component)\n return component","def create_node(identifier, *args, **kwargs):\r\n\r\n d = node_dictionary()\r\n node_class = d[identifier]\r\n node = node_class(*args, **kwargs)\r\n return node","def terminal_init(self):\n pass","def create_test_node():\n node = cmds.createNode(\"unknown\")\n _add_test_attrs_to_node(node)\n return node","def _read_terminal_node(cls, elements):\n \n # TODO: add option to read lemma, pos if the input come from ccg\n label = elements[0]\n word = elements[1]\n return SyntacticNode(label, word=word, pos=label)","def _create_node(self, index: int, name: str, external_id: Optional[str] = None) -> Node:\r\n return Node(graph=self._graph, index=index, name=name, external_id=external_id)","def create_node(self, hx, data):\n return Node(hx, data)","def remote_createNode(self, pkg, exe, args, name, namespace):\r\n return Node(self, pkg, exe, args, name, namespace)","def new_node(self, offset):\n # First we get the name of the node\n nameidx = self.string[offset:].find(b'\\0')\n name = self.string[offset: offset + nameidx]\n string_offset = offset + calc_length_word_align(nameidx + 1)\n node = FDTNode(name)\n return string_offset, node","def create_node(self, node_class, *args, **kwds):\n assert isinstance(node_class, str)\n cls = nodelist.all_nodes[node_class]\n node = cls(*args, **kwds)\n self.add_node(node)\n return node","def to_tree(json):\n value = json[\"value\"]\n ty = json[\"type\"]\n is_function_call = json[\"is_function_call\"]\n return Terminal(value, ty, is_function_call)","def node_create(self, **kwargs):\n node = self.ironic_client.node.create(**kwargs)\n self.addCleanup(self.node_delete, node)\n return node","def _new_node(self):\n self._size += 1\n return self._node_factory()","def draw_node(j, x, y):\n return \"\\\\node(T\" + str(j) + \") at (\" + str(x) + \",\" + str(y) + \") {\" + str(j) + \"};\\n\"","def makeTree(size):\n # Probability that a character will be green.\n prob_gr = 0.6\n # Colour codes.\n colours = [31, 33, 34, 35, 36, 37]\n # Characters to use for decorations. Experiment with these.\n # The chr(169) and chr(174) characters may not work in all terminals\n # (extended ASCII, c and r in a circle).\n decs = ['@', '&', '*', chr(169), chr(174)]\n\n # Format string for printing blinking characters.\n blink_col = \"\\033[5;{0}m{1}\\033[0m\"\n # String to print a green octothorpe ('#').\n leaf = \"\\033[32m#\\033[0m\"\n\n # Width of the tree, will grow by 2 each time.\n width = 1\n # Initialise the tree string, with a star at the top.\n tree = \"\\n{}*\\n\".format(' ' * (size))\n\n \"\"\" Main Loop starts now.\"\"\"\n\n \"\"\" We can't use the normal \"format\" centering approach:\n (\"{:^nn}\".format(string) where \"nn\" is the width of the line), \n with these ansi codes. This is because Python sees the strings as being\n more than one character long (15 & 10 for baubles and leaves).\"\"\"\n\n # Loop from (size - 1) down to 0, using the counter as the padding size.\n for pad in range(size - 1, -1, -1):\n # Increase the width of the tree by 2.\n width += 2\n\n # Put the characters for the line in \"temp\".\n temp = \"\"\n for j in range(width):\n # Make some leaves.\n if random() < prob_gr:\n temp += leaf\n # And also some baubles.\n else:\n temp += blink_col.format(choice(colours), choice(decs))\n\n # Add that string to the line, with padding.\n tree += \"{0}{1}\\n\".format(' ' * pad, temp)\n\n # Add a \"trunk\" of 2 lines and return.\n return tree + \"{0}{1}\\n\".format(' ' * (size - 1), \"000\") * 2","def new_node(name):\n\n return name, []","def createNode(self):\n\n for i in range(self.nobjects):\n # Create a new array\n self.fileh.create_array('/', 'array' + str(i), self.a1)\n # Put a mark\n self.fileh.mark()\n # Unwind all marks sequentially\n for i in range(self.niter):\n t1 = clock()\n for i in range(self.nobjects):\n self.fileh.undo()\n if verbose:\n print(\"u\", end=' ')\n if verbose:\n print()\n undo = clock() - t1\n # Rewind all marks sequentially\n t1 = clock()\n for i in range(self.nobjects):\n self.fileh.redo()\n if verbose:\n print(\"r\", end=' ')\n if verbose:\n print()\n redo = clock() - t1\n\n print(\"Time for Undo, Redo (createNode):\", undo, \"s, \", redo, \"s\")","def openTerminal():\n\n nodes = nuke.selectedNodes()\n if nodes:\n for node in nodes:\n if node.Class() in ['Read', 'Write']:\n if 'views' in node.knobs().keys():\n path = os.path.dirname(node['file'].evaluate())\n if os.path.exists(path):\n view = node['views'].value().split(' ')[0]\n command = ['gnome-terminal', '--working-directory=%s/' % path]\n print runCommand(command)\n #subprocess.Popen(['gnome-terminal', '--working-directory=%s/' % path])\n else:\n raise UserWarning(\"No such file or directory\")\n else:\n path = os.path.dirname(node['file'].evaluate())\n if os.path.exists(path):\n command = ['gnome-terminal', '--working-directory=%s/' % path]\n print runCommand(command)\n #subprocess.Popen(['gnome-terminal', '--working-directory=%s/' % path])\n else:\n raise UserWarning(\"No such file or directory\")\n else:\n raise UserWarning(\"No node to explore\")\n else:\n raise UserWarning(\"No node to explore\")","def create_empty_node():\n from linked_list import Node\n return Node()","def create_node(\n self, x: float, y: float, node_type: NodeType, model: str\n ) -> Optional[Node]:\n node_id = self.next_node_id()\n position = Position(x=x, y=y)\n image = None\n if nutils.has_image(node_type):\n image = \"ubuntu:latest\"\n emane = None\n if node_type == NodeType.EMANE:\n if not self.emane_models:\n dialog = EmaneInstallDialog(self.app)\n dialog.show()\n return\n emane = self.emane_models[0]\n name = f\"emane{node_id}\"\n elif node_type == NodeType.WIRELESS_LAN:\n name = f\"wlan{node_id}\"\n elif node_type in [NodeType.RJ45, NodeType.TUNNEL]:\n name = \"unassigned\"\n else:\n name = f\"n{node_id}\"\n node = Node(\n id=node_id,\n type=node_type,\n name=name,\n model=model,\n position=position,\n image=image,\n emane=emane,\n )\n if nutils.is_custom(node):\n services = nutils.get_custom_services(self.app.guiconfig, model)\n node.config_services = set(services)\n # assign default services to CORE node\n else:\n services = self.session.default_services.get(model)\n if services:\n node.config_services = set(services)\n logger.info(\n \"add node(%s) to session(%s), coordinates(%s, %s)\",\n node.name,\n self.session.id,\n x,\n y,\n )\n self.session.nodes[node.id] = node\n return node","def create_node(self, address, service):\n node = create_node(address, service)\n node.id = address + \"_\" + service\n return node","def newnode(self, name=None, num_states=0):\n # (const char* name, int num_states, net_bn* net)\n if num_states == 0:\n print(\"Warning: Set the number of states when using newnode() \" +\n \"or adding discrete levels won't work.\")\n\n cnetica.NewNode_bn.argtypes = [c_char_p, c_int, c_void_p]\n cnetica.NewNode_bn.restype = c_void_p\n return cnetica.NewNode_bn(ccharp(name), num_states, self.net)","def create_node(self, data):\n node = RealNode(data, layer=self)\n self.append_node(node)\n return node","def to_node(value: str) -> Node:\n if not value:\n res = Empty()\n elif value in CONCATENATION_SYMBOLS:\n res = Concatenation()\n elif value in UNION_SYMBOLS:\n res = Union()\n elif value in KLEENE_STAR_SYMBOLS:\n res = KleeneStar()\n elif value in EPSILON_SYMBOLS:\n res = Epsilon()\n elif value[0] == \"\\\\\":\n res = Symbol(value[1:])\n else:\n res = Symbol(value)\n return res","def __init__(self):\n self.head = PrefixNode('', False)","def new_remotenode(address) -> str:\n return address","def use_terminal_visitor(cls, ctx) -> str:\n v = TelTerminalVisitor()\n v.visitChildren(ctx)\n\n return v.output_string","def create_new_node(subgraph, prev_node, label, bb):\n return add_node(subgraph, update_node_name(prev_node.get_name(), bb-1), label=update_bb_string(label, bb-1))","def node(self, pos, shape=None, draw=None, fill=\"black\", text=\"\", lw=0.2,\n sep=0, minsize=3, options=None, kwoptions=None):\n\n draw = norm_colour(draw)\n self.use_colour(draw)\n fill = norm_colour(fill)\n self.use_colour(fill)\n\n self._commands.append(rf\"\\node[{shape+',' if shape else ''}\"\n rf\"line width={lw},inner sep={sep},minimum size={minsize},\"\n rf\"{fmt_options(options,kwoptions,draw=draw,fill=fill)}] \"\n rf\"at {fmt_point(pos)} {{{text}}};\")","def __init__(self):\n self.root = Node(\"\")","def __init__(self):\n self.root = Node(\"\")","def make_node_text(self):\n fmtstr = ub.codeblock(\n '''\n process {name}\n :: {type}\n ''')\n parts = [fmtstr.format(name=self.name, type=self.type)]\n if self.config:\n if isinstance(self.config, six.string_types):\n parts.extend(self.config.splitlines())\n else:\n for key, val in self.config.items():\n parts.append(' :{key} {val}'.format(key=key, val=val))\n text = '\\n'.join(parts)\n return text","def make_knode(self,i,path_len=0):\n return Knode(path_len=path_len,\\\n ident=self.nodes[i].ident,\\\n lindex=i)","def __init__(self, numero_telefono, tarifa):\n self.tarifa = tarifa\n \"\"\"\n Llamamos al constructor de la clase Terminal\n \"\"\"\n Terminal.__init__(self, numero_telefono)","def __init__(self):\n self.root = Node('')","def __init__(self):\n self.start = Node('-1')","def create_node(name, node_type):\n if node_type in NODE_REGISTRY:\n return Node(name, NODE_REGISTRY[node_type])\n raise TypeError('The specified node type \\'%s\\' could not be found within imagegen.' % node_type)","def createMachine():\n cd('/')\n machine = create(machineName, 'UnixMachine')\n cd('Machines/'+machineName+'/NodeManager/'+machineName)\n cmo.setName(machineName)\n cmo.setListenAddress(hostname)","def createRotoPaintNodeMI():\n return gr()","def parse_terminal_annotated(node, annotation=None):\n if not annotation:\n return parse_terminal(node)\n else:\n return Terminal(\"var\", annotation.name)","def __init__(self, node_text=\"\", node_type=0, node_parent=None):\n self.node_text = node_text\n self.node_type = node_type\n self.node_parent = node_parent\n self.node_left = None\n self.node_right = None","def create(self,\n name=None,\n image=None,\n size=None,\n timeout=360,\n group=None,\n **kwargs):\n \"\"\"\n create one node\n \"\"\"\n raise NotImplementedError","def add_node(graph, node_name, label, shape='record', style='filled', fillcolor='lightgrey'):\n node = Node(name=node_name, shape=shape, style=style, fillcolor=fillcolor, label=label)\n graph.add_node(node)\n return node","def draw_tree(self) -> None:\n import turtle\n\n def height(head):\n return 1 + max(height(head.left), height(head.right)) if head else -1\n\n def jump_to(x, y):\n t.penup()\n t.goto(x, y)\n t.pendown()\n\n def draw(node, x, y, dx):\n if node:\n t.goto(x, y)\n jump_to(x, y - 20)\n t.write(node.val, align=\"center\", font=(\"Arial\", 15, \"normal\"))\n t.circle(10)\n draw(node.left, x - dx, y - 50, dx / 2)\n jump_to(x, y - 20)\n draw(node.right, x + dx, y - 50, dx / 2)\n\n t = turtle.Turtle()\n t.speed(0)\n turtle.delay(0)\n h = height(self)\n jump_to(0, 100 + 10 * h)\n draw(self, 0, 100 + 10 * h, 20 * h)\n t.hideturtle()\n turtle.mainloop()","def cmd_NODE(self, line):\r\n config = NodeOptions(self.terminal)\r\n\r\n try:\r\n config.parseOptions(line)\r\n cmd = config.subCommand\r\n opts = config.subOptions if hasattr(config, 'subOptions') else {}\r\n except usage.UsageError as errortext:\r\n self.terminal.write(\"BUG in usage: {0}\".format(errortext))\r\n else:\r\n if cmd == 'start':\r\n if (opts['args'] and opts['ctag'] and opts['ntag']\r\n and opts['pkg'] and opts['exe']):\r\n self.callToUser('addNode', 'robot', opts['ctag'],\r\n opts['ntag'], opts['pkg'], opts['exe'],\r\n opts['args'])\r\n elif (opts['ctag'] and opts['ntag'] and opts['pkg']\r\n and opts['exe']):\r\n self.callToUser('addNode', 'robot', opts['ctag'],\r\n opts['ntag'], opts['pkg'], opts['exe'])\r\n elif cmd == 'stop':\r\n if opts['ctag'] and opts['ntag']:\r\n self.callToUser('removeNode', 'robot', opts['ctag'],\r\n opts['ntag'])","def node(self, viz_node: VizNode) -> None:\n\n self._node_id_rpo.appendleft(viz_node.identity)\n\n if viz_node.identity not in self._graph:\n # Add the node into the graph.\n self._graph[viz_node.identity] = []\n\n # Create TermNode from VizNode\n node = TermNode(viz_node)\n self._id_to_term_node[viz_node.identity] = node","def _spawn_turtle(self, trt_x, trt_y, name=None):\n\n\t\tif name is None or name == \"\":\n\t\t\tname = self._create_unique_turtle_name()\n\t\telif self._has_turtle(name):\n\t\t\treturn \"\"\n\n\t\tturtle = Turtle(name, Point(trt_x, trt_y))\n\t\tself._turtles[name] = turtle\n\n\t\trospy.loginfo(\"New turtle [%s] at x=[%d], y=[%d]\", name, trt_x, trt_y)\n\n\t\treturn name","def draw_node(self, canvas):\r\n canvas.create_oval( \\\r\n self.location[0] - Node.radius, \\\r\n self.location[1] - Node.radius, \\\r\n self.location[0] + Node.radius, \\\r\n self.location[1] + Node.radius, \\\r\n fill=self.bg_color, outline=self.fg_color)\r\n canvas.create_text(self.location[0], self.location[1], \\\r\n text=self.name, fill=self.fg_color)","def __init__(self):\n self.root = TreeNode('#')","def createNodeMenu(dash_instance):\n\tnodeLabel = html.Label(id='NodeLabel', \n\t style=dict(fontWeight='bold', width=50, marginLeft='100', marginRight='20', marginTop='0px', display='block'), \n\t\t\t\t\t\t children='Nodes: ')\n\tnodeOptions = [{'label': 'Select a group first or search for specific node', 'value': 'None'}]\n\tnodeDropDown = dcc.Dropdown(id=\"NodeDropDown\", \n\t options=nodeOptions,\n\t\t\t\t\t\t\t\tstyle=dict(width=350, marginRight='20', marginBottom='50', display='block'), \n\t\t\t\t\t\t\t\tplaceholder='Select a node...', clearable=True, value='')\n\n\treturn nodeLabel, nodeDropDown","def create_nodes(self):","def console_create(self):\n return self.call('console.create')","def pf_one_node(self, depth):\n if self.op == NodeOperation.CHAR:\n line = 'char: {}'.format(self.char)\n else:\n line = 'op: {}'.format(self.op)\n out = '-' * depth + line\n return out","def terminal(self):\n return self._term","def n(label):\n global id\n node = pydot.Node(name=id, obj_dict=None, label=label)\n id += 1\n graph.add_node(node)\n return node","def tree(self) -> Node:\n return Node(self.to_string())","def new_node(self, **kwargs):\n params = self._node_param_resolve(**kwargs)\n return GuidedNode(**params)","def setup_node(config, args):\n if args.templates:\n config['templates'].insert(0, args.templates)\n config.templates = config._templates()\n stdin, stderr = args.node.ssh(config.template(\"scripts/node_setup.sh\"))\n if stderr:\n print stderr\n else:\n print u\"Node ready at %s\" % (args.node.hostname)","def create_node(self, node_cfg):\n with self.__connect_node(node_cfg) as conn:\n self._provision_node(conn, node_cfg)\n self._bootup_node(conn)","def get_new_node(self):\n return TrieNode()","def _is_terminal(self):\n raise NotImplementedError","def send_node(self) -> str:\n node = self.current_node\n MDI_Send(node, MDI_COMMAND_LENGTH, MDI_CHAR, self.comm)\n return node","def nodeOutliner(*args, addCommand: Union[Script, bool]=None, addObject: name=None, annotation:\n Union[AnyStr, bool]=\"\", attrAlphaOrder: Union[AnyStr, bool]=\"\",\n backgroundColor: Union[List[float, float, float], bool]=None, connectivity:\n Union[name, bool]=None, currentSelection: bool=True, defineTemplate: AnyStr=\"\",\n docTag: Union[AnyStr, bool]=\"\", dragCallback: Script=None, dropCallback:\n Script=None, enable: bool=True, enableBackground: bool=True,\n enableKeyboardFocus: bool=True, exists: bool=True, fullPathName: bool=True,\n height: Union[int, bool]=0, highlightColor: Union[List[float, float, float],\n bool]=None, isObscured: bool=True, lastClickedNode: bool=True, lastMenuChoice:\n Union[AnyStr, bool]=\"\", longNames: bool=True, manage: bool=True, menuCommand:\n Script=None, menuMultiOption: bool=True, multiSelect: bool=True, niceNames:\n bool=True, noBackground: bool=True, noConnectivity: bool=True, nodesDisplayed:\n bool=True, numberOfPopupMenus: bool=True, parent: Union[AnyStr, bool]=\"\",\n popupMenuArray: bool=True, pressHighlightsUnconnected: bool=True,\n preventOverride: bool=True, redraw: bool=True, redrawRow: bool=True, remove:\n Union[AnyStr, List[AnyStr]]=\"\", removeAll: bool=True, replace: Union[name,\n bool]=None, selectCommand: Union[Script, bool]=None, showConnectedOnly:\n bool=True, showHidden: bool=True, showInputs: bool=True, showNonConnectable:\n bool=True, showNonKeyable: bool=True, showOutputs: bool=True, showPublished:\n bool=True, showReadOnly: bool=True, statusBarMessage: AnyStr=\"\", useTemplate:\n AnyStr=\"\", visible: bool=True, visibleChangeCommand: Union[Script, bool]=None,\n width: Union[int, bool]=0, q=True, query=True, e=True, edit=True,\n **kwargs)->Union[None, Any]:\n pass","def create_session(\n path: str,\n type: str,\n name: Optional[str] = None,\n kernel_name: Optional[str] = None,\n kernel_id: Optional[str] = None,\n) -> str:\n ...","def __init__(self):\n self.root = TridNode()","def newVarnode(self, sz: int, addr: ghidra.program.model.address.Address) -> ghidra.program.model.pcode.Varnode:\n ...","def cypher_create():\n graph.cypher.execute(\"CREATE (a:Person {name:{N}})\", {\"N\": \"yangyy\"})","def node(self):\n return Node(self)","def node():\n return render_template('nodes.html')","def terminal(self):\n\t\treturn self._terminal","def make_node(self, node_property):\n # Try except because Ubigraph is old as hell!\n try: n = self.G.new_vertex()\n except: pass\n for prop, val in node_property.items():\n try: self.G.set_vertex_attribute(n, prop, val)\n except: return make_node(node_property)\n return n","def nodes(input):\n \n f = open(os.path.join(os.getcwd(), 'INPUT-Periods'))\n per_tty = f.readlines()\n \n for i in range(0, len(per_tty)):\n per_tty[i] = per_tty[i].split('_')\n \n if os.path.exists(os.path.join(input['datapath'], 'tty-info')) != True:\n \n if os.path.exists(input['datapath']) != True:\n os.makedirs(input['datapath'])\n \n print '--------------------------------------------------------'\n n = int(raw_input('Please enter a node number: (from 0 to ... ' + \\\n 'depends on INPUT-Periods.)' + '\\n'))\n print '--------------------------------------------------------'\n \n tty = open(os.path.join(input['datapath'], 'tty-info'), 'a+')\n \n tty.writelines(commands.getoutput('hostname') + ' , ' + \\\n commands.getoutput('tty') + ' , ' + per_tty[n][0] + \\\n '_' + per_tty[n][1] + '_' + per_tty[n][2] + '_' + \\\n per_tty[n][3][:-1] + ' , ' + '\\n')\n \n tty.close() \n \n else:\n \n print '--------------------------------------------------------'\n n = int(raw_input('Please enter a node number: (from 0 to ... ' + \\\n 'depends on INPUT-Periods.)' + '\\n' + '(If you enter \"-1\", ' + \\\n 'it means that the node number already exists in the ' + \\\n '\"tty-info\" file.)' + '\\n'))\n print '--------------------------------------------------------'\n \n if n == -1:\n print 'You entered \"-1\" -- the node number exists in the tty-info!'\n print '--------------------------------------------------------'\n else: \n tty = open(os.path.join(input['datapath'], 'tty-info'), 'a')\n tty.writelines(commands.getoutput('hostname') + ' , ' + \\\n commands.getoutput('tty') + ' , ' + per_tty[n][0] + \\\n '_' + per_tty[n][1] + '_' + per_tty[n][2] + '_' + \\\n per_tty[n][3][:-1] + ' , ' + '\\n')\n\n tty.close() \n \n tty = open(os.path.join(input['datapath'], 'tty-info'), 'r')\n tty_str = tty.readlines()\n \n for i in range(0, len(tty_str)):\n tty_str[i] = tty_str[i].split(' , ')\n \n for i in range(0, len(tty_str)):\n if commands.getoutput('hostname') == tty_str[i][0]:\n if commands.getoutput('tty') == tty_str[i][1]:\n \n input['min_date'] = tty_str[i][2].split('_')[0]\n input['max_date'] = tty_str[i][2].split('_')[1]\n input['min_mag'] = tty_str[i][2].split('_')[2]\n input['max_mag'] = tty_str[i][2].split('_')[3]\n \n print input['min_date']\n print input['max_date']\n print input['min_mag'] \n print input['max_mag']\n \n return input","def get_custom_terminal_cmd():\n return lnp.userconfig.get_string('terminal')","def _add_node(self, node_name, node_type):\n q = 'MATCH (r:' + node_type + ') WHERE r.name=\"' \\\n + node_name + '\" RETURN r'\n results = self.db.query(q, returns=(client.Node, str, client.Node))\n res = self.db.labels.create(node_type)\n\n if (len(results) == 0):\n r = self.db.nodes.create(name=node_name)\n res.add(r)\n else:\n r = results[0][0]\n return r","def make_tree(fname: str):\n\n tree = PDDL_Tree.create(fname)\n tree.print_tree()","def make_turtle(colr, sz):\n t = turtle.Turtle()\n t.color(colr)\n t.pensize(sz)\n return t","def newNode(name):\n ret = libxml2mod.xmlNewNode(name)\n if ret is None:raise treeError('xmlNewNode() failed')\n return xmlNode(_obj=ret)","def node(self, viz_node: VizNode) -> None:\n self._digraph.node(\n viz_node.identity,\n f\"{viz_node.type_name}\\n{viz_node.detail}\",\n **self._get_node_attr(viz_node),\n )","def __init__(self):\n self.root = Node()","def __init__(self):\n self.root = Node()","def __init__(self):\n self.root = Node()","def create_namespace(self):\n print(\"\\nCreating namespace...\")\n\n name = input(\" - name (default = commands): \") or \"commands\"\n path = \"./{}\".format(name.replace(\".\", \"/\")).lower()\n\n os.makedirs(path, exist_ok=True)\n\n init_path = os.path.join(path, \"__init__.py\")\n if not os.path.isfile(init_path):\n open(init_path, 'w+').close()\n\n return name, path","def PEGNode(cls):\n return cls","def create_node(self, name, img, size):\n if self._create_needed(name):\n node = self._driver.create_node(\n name=name,\n image=self.get_ami_by_id(img),\n size=self.get_size_by_id(size))\n self._driver.wait_until_running([node])\n return node\n else:\n logger.debug(\"node %s already created, no action\" % name)\n return None","def __init__(self, character=None):\n # Character that this node represents\n self.character = character\n # Data structure to associate character keys to children node values\n self.children = PrefixTreeNode.CHILDREN_TYPE()\n # TODO: changes this later to be more modular\n # we need this, if we dont initialize the children when we create a node\n # we are losing the actual ask which way is better/right\n self.children = [None] * 26\n # Marks if this node terminates a string in the prefix tree\n self.terminal = False\n # storing full word at the terminal node","def __init__(self):\n self.root = TreeNode(\"\")","def __init__(self):\n self.root = TreeNode(\"\")","def test_create_trienode():\n node = TrieNode(\"h\")\n assert node.value == \"h\"\n assert node.children == {}"],"string":"[\n \"def create_terminal() -> str:\\n ...\",\n \"def terminal_node(\\n self,\\n expr: Any = None,\\n ) -> None:\\n self.data.append(\\n {\\n \\\"type\\\": \\\"TERMINAL\\\",\\n \\\"expr\\\": expr,\\n \\\"id\\\": len(\\n self.data,\\n ),\\n }\\n )\",\n \"def __repr__(self):\\n return \\\"Terminal('{}')\\\".format(self.name)\",\n \"def create_node(self, **kwargs):\\n if not self.nodes:\\n self.get_nodes()\\n\\n _node = Node(project_id=self.project_id, connector=self.connector, **kwargs)\\n\\n _node.create()\\n self.nodes.append(_node)\\n print(\\n f\\\"Created: {_node.name} -- Type: {_node.node_type} -- \\\"\\n f\\\"Console: {_node.console}\\\"\\n )\",\n \"def create_terminal(self):\\n\\n indicator = self.__get_indicator()\\n class_func = self.__get_classifier_function(indicator)\\n classifier_detail = self.__get_classifier_detail(class_func)\\n\\n # class function\\n self.node_data['class_func'] = class_func\\n\\n # map_type\\n map_type_box = set(indicator.map_type) & set(classifier_detail['map_type']) # 取交集\\n if not map_type_box:\\n print('IndexError: Cannot choose from an empty sequence!!!! %s, %s' % (indicator, classifier_detail))\\n self.create_terminal() # 如匹配错误，重新生成。\\n self.node_data['map_type'] = random.choice(list(map_type_box))\\n\\n # node_type (output value type)\\n if self.node_data['map_type'] == 'condition':\\n self.node_data['node_type'] = 'abs_value'\\n else:\\n self.node_data['node_type'] = 'pos_value'\\n\\n # function group\\n func_group = None\\n for name, group in self.classifier_group.items():\\n if class_func in group:\\n func_group = name\\n self.node_data['class_func_group'] = func_group\\n\\n # others\\n if func_group == 'cut' or func_group == 'compare':\\n self.__create_terminal_dict(indicator, classifier_detail)\\n\\n elif func_group == 'permutation' or func_group == 'trend':\\n self.__create_terminal_list(indicator, classifier_detail)\\n\\n else:\\n raise ValueError('Uncategorized class_function: %s. 9484' % class_func)\\n\\n self.lv_mut_tag = Classifier.lv_mut_tag.copy()\\n self.node_result = self.cal()\\n\\n return self.node_result\",\n \"def _create_node(\\n self,\\n name,\\n ):\\n pass\",\n \"def createNode(self, pkg, exe, args, name, nspace):\\r\\n node = Node(self)\\r\\n self.callRemote('createNode', pkg, exe, args, name,\\r\\n nspace).chainDeferred(node)\\r\\n return node\",\n \"def createNode(self, name):\\n return Node(name)\",\n \"def parse_terminal(node, ty=None):\\n if ty == \\\"METHOD_CALL\\\":\\n return Terminal(\\\"var\\\", None)\\n elif ty:\\n return Terminal(\\\"var\\\", ty)\\n else:\\n return Terminal(\\\"var\\\", get_type(node))\",\n \"def createNode(*args, name: AnyStr=\\\"\\\", parent: AnyStr=\\\"\\\", shared: bool=True, skipSelect:\\n bool=True, **kwargs)->AnyStr:\\n pass\",\n \"def create_node(\\n self,\\n node: Node,\\n parameters: Any\\n ) -> str:\\n raise NotImplementedError\",\n \"def addTerminal(self, name, **opts):\\n opts.update(renamable=True, removable=True)\\n name = self.nextTerminalName(name)\\n term = NetTerminal(self, name, **opts)\\n self.terminals[name] = term\\n if term.isInput():\\n self._inputs[name] = term\\n elif term.isOutput():\\n self._outputs[name] = term\\n self.graphicsItem().updateTerminals()\\n self.sigTerminalAdded.emit(self, term)\\n return term\",\n \"def createNode(_session, _segment, _const, _type):\\n node = _session.create_el(_segment, sc.SC_NODE | _const)\\n #_session.appendObj2Sets(_segment, node, [node_sets[_type]])\\n createPairPosPerm(_session, _segment, node_sets[_type], node, sc.SC_CONST)\\n return node\",\n \"def create_node(self, *labels, **props):\\n component = Node(*labels, **props)\\n self.graph.create(component)\\n return component\",\n \"def create_node(identifier, *args, **kwargs):\\r\\n\\r\\n d = node_dictionary()\\r\\n node_class = d[identifier]\\r\\n node = node_class(*args, **kwargs)\\r\\n return node\",\n \"def terminal_init(self):\\n pass\",\n \"def create_test_node():\\n node = cmds.createNode(\\\"unknown\\\")\\n _add_test_attrs_to_node(node)\\n return node\",\n \"def _read_terminal_node(cls, elements):\\n \\n # TODO: add option to read lemma, pos if the input come from ccg\\n label = elements[0]\\n word = elements[1]\\n return SyntacticNode(label, word=word, pos=label)\",\n \"def _create_node(self, index: int, name: str, external_id: Optional[str] = None) -> Node:\\r\\n return Node(graph=self._graph, index=index, name=name, external_id=external_id)\",\n \"def create_node(self, hx, data):\\n return Node(hx, data)\",\n \"def remote_createNode(self, pkg, exe, args, name, namespace):\\r\\n return Node(self, pkg, exe, args, name, namespace)\",\n \"def new_node(self, offset):\\n # First we get the name of the node\\n nameidx = self.string[offset:].find(b'\\\\0')\\n name = self.string[offset: offset + nameidx]\\n string_offset = offset + calc_length_word_align(nameidx + 1)\\n node = FDTNode(name)\\n return string_offset, node\",\n \"def create_node(self, node_class, *args, **kwds):\\n assert isinstance(node_class, str)\\n cls = nodelist.all_nodes[node_class]\\n node = cls(*args, **kwds)\\n self.add_node(node)\\n return node\",\n \"def to_tree(json):\\n value = json[\\\"value\\\"]\\n ty = json[\\\"type\\\"]\\n is_function_call = json[\\\"is_function_call\\\"]\\n return Terminal(value, ty, is_function_call)\",\n \"def node_create(self, **kwargs):\\n node = self.ironic_client.node.create(**kwargs)\\n self.addCleanup(self.node_delete, node)\\n return node\",\n \"def _new_node(self):\\n self._size += 1\\n return self._node_factory()\",\n \"def draw_node(j, x, y):\\n return \\\"\\\\\\\\node(T\\\" + str(j) + \\\") at (\\\" + str(x) + \\\",\\\" + str(y) + \\\") {\\\" + str(j) + \\\"};\\\\n\\\"\",\n \"def makeTree(size):\\n # Probability that a character will be green.\\n prob_gr = 0.6\\n # Colour codes.\\n colours = [31, 33, 34, 35, 36, 37]\\n # Characters to use for decorations. Experiment with these.\\n # The chr(169) and chr(174) characters may not work in all terminals\\n # (extended ASCII, c and r in a circle).\\n decs = ['@', '&', '*', chr(169), chr(174)]\\n\\n # Format string for printing blinking characters.\\n blink_col = \\\"\\\\033[5;{0}m{1}\\\\033[0m\\\"\\n # String to print a green octothorpe ('#').\\n leaf = \\\"\\\\033[32m#\\\\033[0m\\\"\\n\\n # Width of the tree, will grow by 2 each time.\\n width = 1\\n # Initialise the tree string, with a star at the top.\\n tree = \\\"\\\\n{}*\\\\n\\\".format(' ' * (size))\\n\\n \\\"\\\"\\\" Main Loop starts now.\\\"\\\"\\\"\\n\\n \\\"\\\"\\\" We can't use the normal \\\"format\\\" centering approach:\\n (\\\"{:^nn}\\\".format(string) where \\\"nn\\\" is the width of the line), \\n with these ansi codes. This is because Python sees the strings as being\\n more than one character long (15 & 10 for baubles and leaves).\\\"\\\"\\\"\\n\\n # Loop from (size - 1) down to 0, using the counter as the padding size.\\n for pad in range(size - 1, -1, -1):\\n # Increase the width of the tree by 2.\\n width += 2\\n\\n # Put the characters for the line in \\\"temp\\\".\\n temp = \\\"\\\"\\n for j in range(width):\\n # Make some leaves.\\n if random() < prob_gr:\\n temp += leaf\\n # And also some baubles.\\n else:\\n temp += blink_col.format(choice(colours), choice(decs))\\n\\n # Add that string to the line, with padding.\\n tree += \\\"{0}{1}\\\\n\\\".format(' ' * pad, temp)\\n\\n # Add a \\\"trunk\\\" of 2 lines and return.\\n return tree + \\\"{0}{1}\\\\n\\\".format(' ' * (size - 1), \\\"000\\\") * 2\",\n \"def new_node(name):\\n\\n return name, []\",\n \"def createNode(self):\\n\\n for i in range(self.nobjects):\\n # Create a new array\\n self.fileh.create_array('/', 'array' + str(i), self.a1)\\n # Put a mark\\n self.fileh.mark()\\n # Unwind all marks sequentially\\n for i in range(self.niter):\\n t1 = clock()\\n for i in range(self.nobjects):\\n self.fileh.undo()\\n if verbose:\\n print(\\\"u\\\", end=' ')\\n if verbose:\\n print()\\n undo = clock() - t1\\n # Rewind all marks sequentially\\n t1 = clock()\\n for i in range(self.nobjects):\\n self.fileh.redo()\\n if verbose:\\n print(\\\"r\\\", end=' ')\\n if verbose:\\n print()\\n redo = clock() - t1\\n\\n print(\\\"Time for Undo, Redo (createNode):\\\", undo, \\\"s, \\\", redo, \\\"s\\\")\",\n \"def openTerminal():\\n\\n nodes = nuke.selectedNodes()\\n if nodes:\\n for node in nodes:\\n if node.Class() in ['Read', 'Write']:\\n if 'views' in node.knobs().keys():\\n path = os.path.dirname(node['file'].evaluate())\\n if os.path.exists(path):\\n view = node['views'].value().split(' ')[0]\\n command = ['gnome-terminal', '--working-directory=%s/' % path]\\n print runCommand(command)\\n #subprocess.Popen(['gnome-terminal', '--working-directory=%s/' % path])\\n else:\\n raise UserWarning(\\\"No such file or directory\\\")\\n else:\\n path = os.path.dirname(node['file'].evaluate())\\n if os.path.exists(path):\\n command = ['gnome-terminal', '--working-directory=%s/' % path]\\n print runCommand(command)\\n #subprocess.Popen(['gnome-terminal', '--working-directory=%s/' % path])\\n else:\\n raise UserWarning(\\\"No such file or directory\\\")\\n else:\\n raise UserWarning(\\\"No node to explore\\\")\\n else:\\n raise UserWarning(\\\"No node to explore\\\")\",\n \"def create_empty_node():\\n from linked_list import Node\\n return Node()\",\n \"def create_node(\\n self, x: float, y: float, node_type: NodeType, model: str\\n ) -> Optional[Node]:\\n node_id = self.next_node_id()\\n position = Position(x=x, y=y)\\n image = None\\n if nutils.has_image(node_type):\\n image = \\\"ubuntu:latest\\\"\\n emane = None\\n if node_type == NodeType.EMANE:\\n if not self.emane_models:\\n dialog = EmaneInstallDialog(self.app)\\n dialog.show()\\n return\\n emane = self.emane_models[0]\\n name = f\\\"emane{node_id}\\\"\\n elif node_type == NodeType.WIRELESS_LAN:\\n name = f\\\"wlan{node_id}\\\"\\n elif node_type in [NodeType.RJ45, NodeType.TUNNEL]:\\n name = \\\"unassigned\\\"\\n else:\\n name = f\\\"n{node_id}\\\"\\n node = Node(\\n id=node_id,\\n type=node_type,\\n name=name,\\n model=model,\\n position=position,\\n image=image,\\n emane=emane,\\n )\\n if nutils.is_custom(node):\\n services = nutils.get_custom_services(self.app.guiconfig, model)\\n node.config_services = set(services)\\n # assign default services to CORE node\\n else:\\n services = self.session.default_services.get(model)\\n if services:\\n node.config_services = set(services)\\n logger.info(\\n \\\"add node(%s) to session(%s), coordinates(%s, %s)\\\",\\n node.name,\\n self.session.id,\\n x,\\n y,\\n )\\n self.session.nodes[node.id] = node\\n return node\",\n \"def create_node(self, address, service):\\n node = create_node(address, service)\\n node.id = address + \\\"_\\\" + service\\n return node\",\n \"def newnode(self, name=None, num_states=0):\\n # (const char* name, int num_states, net_bn* net)\\n if num_states == 0:\\n print(\\\"Warning: Set the number of states when using newnode() \\\" +\\n \\\"or adding discrete levels won't work.\\\")\\n\\n cnetica.NewNode_bn.argtypes = [c_char_p, c_int, c_void_p]\\n cnetica.NewNode_bn.restype = c_void_p\\n return cnetica.NewNode_bn(ccharp(name), num_states, self.net)\",\n \"def create_node(self, data):\\n node = RealNode(data, layer=self)\\n self.append_node(node)\\n return node\",\n \"def to_node(value: str) -> Node:\\n if not value:\\n res = Empty()\\n elif value in CONCATENATION_SYMBOLS:\\n res = Concatenation()\\n elif value in UNION_SYMBOLS:\\n res = Union()\\n elif value in KLEENE_STAR_SYMBOLS:\\n res = KleeneStar()\\n elif value in EPSILON_SYMBOLS:\\n res = Epsilon()\\n elif value[0] == \\\"\\\\\\\\\\\":\\n res = Symbol(value[1:])\\n else:\\n res = Symbol(value)\\n return res\",\n \"def __init__(self):\\n self.head = PrefixNode('', False)\",\n \"def new_remotenode(address) -> str:\\n return address\",\n \"def use_terminal_visitor(cls, ctx) -> str:\\n v = TelTerminalVisitor()\\n v.visitChildren(ctx)\\n\\n return v.output_string\",\n \"def create_new_node(subgraph, prev_node, label, bb):\\n return add_node(subgraph, update_node_name(prev_node.get_name(), bb-1), label=update_bb_string(label, bb-1))\",\n \"def node(self, pos, shape=None, draw=None, fill=\\\"black\\\", text=\\\"\\\", lw=0.2,\\n sep=0, minsize=3, options=None, kwoptions=None):\\n\\n draw = norm_colour(draw)\\n self.use_colour(draw)\\n fill = norm_colour(fill)\\n self.use_colour(fill)\\n\\n self._commands.append(rf\\\"\\\\node[{shape+',' if shape else ''}\\\"\\n rf\\\"line width={lw},inner sep={sep},minimum size={minsize},\\\"\\n rf\\\"{fmt_options(options,kwoptions,draw=draw,fill=fill)}] \\\"\\n rf\\\"at {fmt_point(pos)} {{{text}}};\\\")\",\n \"def __init__(self):\\n self.root = Node(\\\"\\\")\",\n \"def __init__(self):\\n self.root = Node(\\\"\\\")\",\n \"def make_node_text(self):\\n fmtstr = ub.codeblock(\\n '''\\n process {name}\\n :: {type}\\n ''')\\n parts = [fmtstr.format(name=self.name, type=self.type)]\\n if self.config:\\n if isinstance(self.config, six.string_types):\\n parts.extend(self.config.splitlines())\\n else:\\n for key, val in self.config.items():\\n parts.append(' :{key} {val}'.format(key=key, val=val))\\n text = '\\\\n'.join(parts)\\n return text\",\n \"def make_knode(self,i,path_len=0):\\n return Knode(path_len=path_len,\\\\\\n ident=self.nodes[i].ident,\\\\\\n lindex=i)\",\n \"def __init__(self, numero_telefono, tarifa):\\n self.tarifa = tarifa\\n \\\"\\\"\\\"\\n Llamamos al constructor de la clase Terminal\\n \\\"\\\"\\\"\\n Terminal.__init__(self, numero_telefono)\",\n \"def __init__(self):\\n self.root = Node('')\",\n \"def __init__(self):\\n self.start = Node('-1')\",\n \"def create_node(name, node_type):\\n if node_type in NODE_REGISTRY:\\n return Node(name, NODE_REGISTRY[node_type])\\n raise TypeError('The specified node type \\\\'%s\\\\' could not be found within imagegen.' % node_type)\",\n \"def createMachine():\\n cd('/')\\n machine = create(machineName, 'UnixMachine')\\n cd('Machines/'+machineName+'/NodeManager/'+machineName)\\n cmo.setName(machineName)\\n cmo.setListenAddress(hostname)\",\n \"def createRotoPaintNodeMI():\\n return gr()\",\n \"def parse_terminal_annotated(node, annotation=None):\\n if not annotation:\\n return parse_terminal(node)\\n else:\\n return Terminal(\\\"var\\\", annotation.name)\",\n \"def __init__(self, node_text=\\\"\\\", node_type=0, node_parent=None):\\n self.node_text = node_text\\n self.node_type = node_type\\n self.node_parent = node_parent\\n self.node_left = None\\n self.node_right = None\",\n \"def create(self,\\n name=None,\\n image=None,\\n size=None,\\n timeout=360,\\n group=None,\\n **kwargs):\\n \\\"\\\"\\\"\\n create one node\\n \\\"\\\"\\\"\\n raise NotImplementedError\",\n \"def add_node(graph, node_name, label, shape='record', style='filled', fillcolor='lightgrey'):\\n node = Node(name=node_name, shape=shape, style=style, fillcolor=fillcolor, label=label)\\n graph.add_node(node)\\n return node\",\n \"def draw_tree(self) -> None:\\n import turtle\\n\\n def height(head):\\n return 1 + max(height(head.left), height(head.right)) if head else -1\\n\\n def jump_to(x, y):\\n t.penup()\\n t.goto(x, y)\\n t.pendown()\\n\\n def draw(node, x, y, dx):\\n if node:\\n t.goto(x, y)\\n jump_to(x, y - 20)\\n t.write(node.val, align=\\\"center\\\", font=(\\\"Arial\\\", 15, \\\"normal\\\"))\\n t.circle(10)\\n draw(node.left, x - dx, y - 50, dx / 2)\\n jump_to(x, y - 20)\\n draw(node.right, x + dx, y - 50, dx / 2)\\n\\n t = turtle.Turtle()\\n t.speed(0)\\n turtle.delay(0)\\n h = height(self)\\n jump_to(0, 100 + 10 * h)\\n draw(self, 0, 100 + 10 * h, 20 * h)\\n t.hideturtle()\\n turtle.mainloop()\",\n \"def cmd_NODE(self, line):\\r\\n config = NodeOptions(self.terminal)\\r\\n\\r\\n try:\\r\\n config.parseOptions(line)\\r\\n cmd = config.subCommand\\r\\n opts = config.subOptions if hasattr(config, 'subOptions') else {}\\r\\n except usage.UsageError as errortext:\\r\\n self.terminal.write(\\\"BUG in usage: {0}\\\".format(errortext))\\r\\n else:\\r\\n if cmd == 'start':\\r\\n if (opts['args'] and opts['ctag'] and opts['ntag']\\r\\n and opts['pkg'] and opts['exe']):\\r\\n self.callToUser('addNode', 'robot', opts['ctag'],\\r\\n opts['ntag'], opts['pkg'], opts['exe'],\\r\\n opts['args'])\\r\\n elif (opts['ctag'] and opts['ntag'] and opts['pkg']\\r\\n and opts['exe']):\\r\\n self.callToUser('addNode', 'robot', opts['ctag'],\\r\\n opts['ntag'], opts['pkg'], opts['exe'])\\r\\n elif cmd == 'stop':\\r\\n if opts['ctag'] and opts['ntag']:\\r\\n self.callToUser('removeNode', 'robot', opts['ctag'],\\r\\n opts['ntag'])\",\n \"def node(self, viz_node: VizNode) -> None:\\n\\n self._node_id_rpo.appendleft(viz_node.identity)\\n\\n if viz_node.identity not in self._graph:\\n # Add the node into the graph.\\n self._graph[viz_node.identity] = []\\n\\n # Create TermNode from VizNode\\n node = TermNode(viz_node)\\n self._id_to_term_node[viz_node.identity] = node\",\n \"def _spawn_turtle(self, trt_x, trt_y, name=None):\\n\\n\\t\\tif name is None or name == \\\"\\\":\\n\\t\\t\\tname = self._create_unique_turtle_name()\\n\\t\\telif self._has_turtle(name):\\n\\t\\t\\treturn \\\"\\\"\\n\\n\\t\\tturtle = Turtle(name, Point(trt_x, trt_y))\\n\\t\\tself._turtles[name] = turtle\\n\\n\\t\\trospy.loginfo(\\\"New turtle [%s] at x=[%d], y=[%d]\\\", name, trt_x, trt_y)\\n\\n\\t\\treturn name\",\n \"def draw_node(self, canvas):\\r\\n canvas.create_oval( \\\\\\r\\n self.location[0] - Node.radius, \\\\\\r\\n self.location[1] - Node.radius, \\\\\\r\\n self.location[0] + Node.radius, \\\\\\r\\n self.location[1] + Node.radius, \\\\\\r\\n fill=self.bg_color, outline=self.fg_color)\\r\\n canvas.create_text(self.location[0], self.location[1], \\\\\\r\\n text=self.name, fill=self.fg_color)\",\n \"def __init__(self):\\n self.root = TreeNode('#')\",\n \"def createNodeMenu(dash_instance):\\n\\tnodeLabel = html.Label(id='NodeLabel', \\n\\t style=dict(fontWeight='bold', width=50, marginLeft='100', marginRight='20', marginTop='0px', display='block'), \\n\\t\\t\\t\\t\\t\\t children='Nodes: ')\\n\\tnodeOptions = [{'label': 'Select a group first or search for specific node', 'value': 'None'}]\\n\\tnodeDropDown = dcc.Dropdown(id=\\\"NodeDropDown\\\", \\n\\t options=nodeOptions,\\n\\t\\t\\t\\t\\t\\t\\t\\tstyle=dict(width=350, marginRight='20', marginBottom='50', display='block'), \\n\\t\\t\\t\\t\\t\\t\\t\\tplaceholder='Select a node...', clearable=True, value='')\\n\\n\\treturn nodeLabel, nodeDropDown\",\n \"def create_nodes(self):\",\n \"def console_create(self):\\n return self.call('console.create')\",\n \"def pf_one_node(self, depth):\\n if self.op == NodeOperation.CHAR:\\n line = 'char: {}'.format(self.char)\\n else:\\n line = 'op: {}'.format(self.op)\\n out = '-' * depth + line\\n return out\",\n \"def terminal(self):\\n return self._term\",\n \"def n(label):\\n global id\\n node = pydot.Node(name=id, obj_dict=None, label=label)\\n id += 1\\n graph.add_node(node)\\n return node\",\n \"def tree(self) -> Node:\\n return Node(self.to_string())\",\n \"def new_node(self, **kwargs):\\n params = self._node_param_resolve(**kwargs)\\n return GuidedNode(**params)\",\n \"def setup_node(config, args):\\n if args.templates:\\n config['templates'].insert(0, args.templates)\\n config.templates = config._templates()\\n stdin, stderr = args.node.ssh(config.template(\\\"scripts/node_setup.sh\\\"))\\n if stderr:\\n print stderr\\n else:\\n print u\\\"Node ready at %s\\\" % (args.node.hostname)\",\n \"def create_node(self, node_cfg):\\n with self.__connect_node(node_cfg) as conn:\\n self._provision_node(conn, node_cfg)\\n self._bootup_node(conn)\",\n \"def get_new_node(self):\\n return TrieNode()\",\n \"def _is_terminal(self):\\n raise NotImplementedError\",\n \"def send_node(self) -> str:\\n node = self.current_node\\n MDI_Send(node, MDI_COMMAND_LENGTH, MDI_CHAR, self.comm)\\n return node\",\n \"def nodeOutliner(*args, addCommand: Union[Script, bool]=None, addObject: name=None, annotation:\\n Union[AnyStr, bool]=\\\"\\\", attrAlphaOrder: Union[AnyStr, bool]=\\\"\\\",\\n backgroundColor: Union[List[float, float, float], bool]=None, connectivity:\\n Union[name, bool]=None, currentSelection: bool=True, defineTemplate: AnyStr=\\\"\\\",\\n docTag: Union[AnyStr, bool]=\\\"\\\", dragCallback: Script=None, dropCallback:\\n Script=None, enable: bool=True, enableBackground: bool=True,\\n enableKeyboardFocus: bool=True, exists: bool=True, fullPathName: bool=True,\\n height: Union[int, bool]=0, highlightColor: Union[List[float, float, float],\\n bool]=None, isObscured: bool=True, lastClickedNode: bool=True, lastMenuChoice:\\n Union[AnyStr, bool]=\\\"\\\", longNames: bool=True, manage: bool=True, menuCommand:\\n Script=None, menuMultiOption: bool=True, multiSelect: bool=True, niceNames:\\n bool=True, noBackground: bool=True, noConnectivity: bool=True, nodesDisplayed:\\n bool=True, numberOfPopupMenus: bool=True, parent: Union[AnyStr, bool]=\\\"\\\",\\n popupMenuArray: bool=True, pressHighlightsUnconnected: bool=True,\\n preventOverride: bool=True, redraw: bool=True, redrawRow: bool=True, remove:\\n Union[AnyStr, List[AnyStr]]=\\\"\\\", removeAll: bool=True, replace: Union[name,\\n bool]=None, selectCommand: Union[Script, bool]=None, showConnectedOnly:\\n bool=True, showHidden: bool=True, showInputs: bool=True, showNonConnectable:\\n bool=True, showNonKeyable: bool=True, showOutputs: bool=True, showPublished:\\n bool=True, showReadOnly: bool=True, statusBarMessage: AnyStr=\\\"\\\", useTemplate:\\n AnyStr=\\\"\\\", visible: bool=True, visibleChangeCommand: Union[Script, bool]=None,\\n width: Union[int, bool]=0, q=True, query=True, e=True, edit=True,\\n **kwargs)->Union[None, Any]:\\n pass\",\n \"def create_session(\\n path: str,\\n type: str,\\n name: Optional[str] = None,\\n kernel_name: Optional[str] = None,\\n kernel_id: Optional[str] = None,\\n) -> str:\\n ...\",\n \"def __init__(self):\\n self.root = TridNode()\",\n \"def newVarnode(self, sz: int, addr: ghidra.program.model.address.Address) -> ghidra.program.model.pcode.Varnode:\\n ...\",\n \"def cypher_create():\\n graph.cypher.execute(\\\"CREATE (a:Person {name:{N}})\\\", {\\\"N\\\": \\\"yangyy\\\"})\",\n \"def node(self):\\n return Node(self)\",\n \"def node():\\n return render_template('nodes.html')\",\n \"def terminal(self):\\n\\t\\treturn self._terminal\",\n \"def make_node(self, node_property):\\n # Try except because Ubigraph is old as hell!\\n try: n = self.G.new_vertex()\\n except: pass\\n for prop, val in node_property.items():\\n try: self.G.set_vertex_attribute(n, prop, val)\\n except: return make_node(node_property)\\n return n\",\n \"def nodes(input):\\n \\n f = open(os.path.join(os.getcwd(), 'INPUT-Periods'))\\n per_tty = f.readlines()\\n \\n for i in range(0, len(per_tty)):\\n per_tty[i] = per_tty[i].split('_')\\n \\n if os.path.exists(os.path.join(input['datapath'], 'tty-info')) != True:\\n \\n if os.path.exists(input['datapath']) != True:\\n os.makedirs(input['datapath'])\\n \\n print '--------------------------------------------------------'\\n n = int(raw_input('Please enter a node number: (from 0 to ... ' + \\\\\\n 'depends on INPUT-Periods.)' + '\\\\n'))\\n print '--------------------------------------------------------'\\n \\n tty = open(os.path.join(input['datapath'], 'tty-info'), 'a+')\\n \\n tty.writelines(commands.getoutput('hostname') + ' , ' + \\\\\\n commands.getoutput('tty') + ' , ' + per_tty[n][0] + \\\\\\n '_' + per_tty[n][1] + '_' + per_tty[n][2] + '_' + \\\\\\n per_tty[n][3][:-1] + ' , ' + '\\\\n')\\n \\n tty.close() \\n \\n else:\\n \\n print '--------------------------------------------------------'\\n n = int(raw_input('Please enter a node number: (from 0 to ... ' + \\\\\\n 'depends on INPUT-Periods.)' + '\\\\n' + '(If you enter \\\"-1\\\", ' + \\\\\\n 'it means that the node number already exists in the ' + \\\\\\n '\\\"tty-info\\\" file.)' + '\\\\n'))\\n print '--------------------------------------------------------'\\n \\n if n == -1:\\n print 'You entered \\\"-1\\\" -- the node number exists in the tty-info!'\\n print '--------------------------------------------------------'\\n else: \\n tty = open(os.path.join(input['datapath'], 'tty-info'), 'a')\\n tty.writelines(commands.getoutput('hostname') + ' , ' + \\\\\\n commands.getoutput('tty') + ' , ' + per_tty[n][0] + \\\\\\n '_' + per_tty[n][1] + '_' + per_tty[n][2] + '_' + \\\\\\n per_tty[n][3][:-1] + ' , ' + '\\\\n')\\n\\n tty.close() \\n \\n tty = open(os.path.join(input['datapath'], 'tty-info'), 'r')\\n tty_str = tty.readlines()\\n \\n for i in range(0, len(tty_str)):\\n tty_str[i] = tty_str[i].split(' , ')\\n \\n for i in range(0, len(tty_str)):\\n if commands.getoutput('hostname') == tty_str[i][0]:\\n if commands.getoutput('tty') == tty_str[i][1]:\\n \\n input['min_date'] = tty_str[i][2].split('_')[0]\\n input['max_date'] = tty_str[i][2].split('_')[1]\\n input['min_mag'] = tty_str[i][2].split('_')[2]\\n input['max_mag'] = tty_str[i][2].split('_')[3]\\n \\n print input['min_date']\\n print input['max_date']\\n print input['min_mag'] \\n print input['max_mag']\\n \\n return input\",\n \"def get_custom_terminal_cmd():\\n return lnp.userconfig.get_string('terminal')\",\n \"def _add_node(self, node_name, node_type):\\n q = 'MATCH (r:' + node_type + ') WHERE r.name=\\\"' \\\\\\n + node_name + '\\\" RETURN r'\\n results = self.db.query(q, returns=(client.Node, str, client.Node))\\n res = self.db.labels.create(node_type)\\n\\n if (len(results) == 0):\\n r = self.db.nodes.create(name=node_name)\\n res.add(r)\\n else:\\n r = results[0][0]\\n return r\",\n \"def make_tree(fname: str):\\n\\n tree = PDDL_Tree.create(fname)\\n tree.print_tree()\",\n \"def make_turtle(colr, sz):\\n t = turtle.Turtle()\\n t.color(colr)\\n t.pensize(sz)\\n return t\",\n \"def newNode(name):\\n ret = libxml2mod.xmlNewNode(name)\\n if ret is None:raise treeError('xmlNewNode() failed')\\n return xmlNode(_obj=ret)\",\n \"def node(self, viz_node: VizNode) -> None:\\n self._digraph.node(\\n viz_node.identity,\\n f\\\"{viz_node.type_name}\\\\n{viz_node.detail}\\\",\\n **self._get_node_attr(viz_node),\\n )\",\n \"def __init__(self):\\n self.root = Node()\",\n \"def __init__(self):\\n self.root = Node()\",\n \"def __init__(self):\\n self.root = Node()\",\n \"def create_namespace(self):\\n print(\\\"\\\\nCreating namespace...\\\")\\n\\n name = input(\\\" - name (default = commands): \\\") or \\\"commands\\\"\\n path = \\\"./{}\\\".format(name.replace(\\\".\\\", \\\"/\\\")).lower()\\n\\n os.makedirs(path, exist_ok=True)\\n\\n init_path = os.path.join(path, \\\"__init__.py\\\")\\n if not os.path.isfile(init_path):\\n open(init_path, 'w+').close()\\n\\n return name, path\",\n \"def PEGNode(cls):\\n return cls\",\n \"def create_node(self, name, img, size):\\n if self._create_needed(name):\\n node = self._driver.create_node(\\n name=name,\\n image=self.get_ami_by_id(img),\\n size=self.get_size_by_id(size))\\n self._driver.wait_until_running([node])\\n return node\\n else:\\n logger.debug(\\\"node %s already created, no action\\\" % name)\\n return None\",\n \"def __init__(self, character=None):\\n # Character that this node represents\\n self.character = character\\n # Data structure to associate character keys to children node values\\n self.children = PrefixTreeNode.CHILDREN_TYPE()\\n # TODO: changes this later to be more modular\\n # we need this, if we dont initialize the children when we create a node\\n # we are losing the actual ask which way is better/right\\n self.children = [None] * 26\\n # Marks if this node terminates a string in the prefix tree\\n self.terminal = False\\n # storing full word at the terminal node\",\n \"def __init__(self):\\n self.root = TreeNode(\\\"\\\")\",\n \"def __init__(self):\\n self.root = TreeNode(\\\"\\\")\",\n \"def test_create_trienode():\\n node = TrieNode(\\\"h\\\")\\n assert node.value == \\\"h\\\"\\n assert node.children == {}\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.77555245","0.7163272","0.6366092","0.62840253","0.6274114","0.6256749","0.6191868","0.61676985","0.6153323","0.6140978","0.6128334","0.61176777","0.6109941","0.6029727","0.6004716","0.5998977","0.5952726","0.58835274","0.5871811","0.5863557","0.5851825","0.57681185","0.5710722","0.56967777","0.5693146","0.5678091","0.56270885","0.56249905","0.5618187","0.5557717","0.5545671","0.55359817","0.5528238","0.551771","0.5491797","0.54512084","0.5433509","0.5407299","0.5404759","0.53783154","0.53749514","0.5359448","0.5337468","0.5337468","0.53372616","0.53284997","0.5324896","0.5319363","0.53057593","0.5297227","0.5292278","0.52881765","0.52841985","0.5272045","0.5261124","0.52602583","0.5258227","0.52519035","0.5251732","0.5251426","0.52271473","0.52133167","0.52068573","0.51966184","0.5179402","0.5178801","0.51619565","0.51509404","0.5143786","0.5143436","0.51313597","0.5126915","0.5114424","0.5107922","0.510592","0.5100308","0.51000625","0.5096294","0.5083146","0.5080267","0.5070037","0.50624794","0.5058673","0.5057194","0.5038567","0.50383854","0.5031747","0.5030887","0.5020221","0.5019589","0.50179917","0.5016675","0.5016675","0.5016675","0.5009033","0.50086474","0.50066596","0.5004395","0.50028956","0.50028956","0.4994332"],"string":"[\n \"0.77555245\",\n \"0.7163272\",\n \"0.6366092\",\n \"0.62840253\",\n \"0.6274114\",\n \"0.6256749\",\n \"0.6191868\",\n \"0.61676985\",\n \"0.6153323\",\n \"0.6140978\",\n \"0.6128334\",\n \"0.61176777\",\n \"0.6109941\",\n \"0.6029727\",\n \"0.6004716\",\n \"0.5998977\",\n \"0.5952726\",\n \"0.58835274\",\n \"0.5871811\",\n \"0.5863557\",\n \"0.5851825\",\n \"0.57681185\",\n \"0.5710722\",\n \"0.56967777\",\n \"0.5693146\",\n \"0.5678091\",\n \"0.56270885\",\n \"0.56249905\",\n \"0.5618187\",\n \"0.5557717\",\n \"0.5545671\",\n \"0.55359817\",\n \"0.5528238\",\n \"0.551771\",\n \"0.5491797\",\n \"0.54512084\",\n \"0.5433509\",\n \"0.5407299\",\n \"0.5404759\",\n \"0.53783154\",\n \"0.53749514\",\n \"0.5359448\",\n \"0.5337468\",\n \"0.5337468\",\n \"0.53372616\",\n \"0.53284997\",\n \"0.5324896\",\n \"0.5319363\",\n \"0.53057593\",\n \"0.5297227\",\n \"0.5292278\",\n \"0.52881765\",\n \"0.52841985\",\n \"0.5272045\",\n \"0.5261124\",\n \"0.52602583\",\n \"0.5258227\",\n \"0.52519035\",\n \"0.5251732\",\n \"0.5251426\",\n \"0.52271473\",\n \"0.52133167\",\n \"0.52068573\",\n \"0.51966184\",\n \"0.5179402\",\n \"0.5178801\",\n \"0.51619565\",\n \"0.51509404\",\n \"0.5143786\",\n \"0.5143436\",\n \"0.51313597\",\n \"0.5126915\",\n \"0.5114424\",\n \"0.5107922\",\n \"0.510592\",\n \"0.5100308\",\n \"0.51000625\",\n \"0.5096294\",\n \"0.5083146\",\n \"0.5080267\",\n \"0.5070037\",\n \"0.50624794\",\n \"0.5058673\",\n \"0.5057194\",\n \"0.5038567\",\n \"0.50383854\",\n \"0.5031747\",\n \"0.5030887\",\n \"0.5020221\",\n \"0.5019589\",\n \"0.50179917\",\n \"0.5016675\",\n \"0.5016675\",\n \"0.5016675\",\n \"0.5009033\",\n \"0.50086474\",\n \"0.50066596\",\n \"0.5004395\",\n \"0.50028956\",\n \"0.50028956\",\n \"0.4994332\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":78599,"cells":{"query":{"kind":"string","value":"Function to create a continuous node split."},"document":{"kind":"string","value":"def get_continuous_node (\n self,\n feature_column: int,\n feature_value: float,\n feature_matrix: np.ndarray,\n target_array: np.ndarray,\n node: TreeSplits,\n ):\n node.updateTreeValues (\n feature_column = feature_column,\n feature_value = feature_value,\n nodes = { \"below\": TreeSplits(), \"above\": TreeSplits() },\n node_type = \"continuous\",\n )\n # Get the above\n above = feature_matrix [ :, feature_column ] >= feature_value\n # Get the next split for the above node\n self.get_next_split ( feature_matrix = feature_matrix [ above ], target_array = target_array [ above ], tree_split = node.nodes [ \"above\" ] )\n # Add one node to counter\n self.n_nodes += 1\n # Get the next split for the below node\n self.get_next_split (\n feature_matrix = feature_matrix [ np.bitwise_not ( above ) ],\n target_array = target_array [ np.bitwise_not ( above ) ],\n tree_split = node.nodes [ \"below\" ],\n )\n # Add one node to counter\n self.n_nodes += 1\n\n return node # Continuous node\n # End get_continuous_node"},"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 create_split(self) -> NoReturn:\n raise NotImplementedError","def _create_split(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\n\n node.attribute.extend([\n helper.make_attribute('axis', op.axis),\n helper.make_attribute('split', op.parts),\n ])\n return node","def _create_split(cls, onnx_node, inputs, opset_version):\n axis = onnx_node.getattr(\"axis\", 0)\n split = onnx_node.getattr(\"split\", None)\n num_output = len(onnx_node.outputs)\n _, forward = cls._common_onnx_node_to_singa_op(onnx_node, inputs,\n opset_version)\n return _, forward(axis, split, num_output)","def __split_node(self, cur_node):\n temp = self.Node(cur_node.data_list[len(cur_node.data_list) / 2:], cur_node.next_node)\n cur_node.data_list = cur_node.data_list[:len(cur_node.data_list) / 2]\n cur_node.next_node = temp\n\n if cur_node == self.tail:\n self.tail = cur_node.next_node","def split(self, node, width, height):\r\n node.used = True\r\n node.down = SquareAlgorithmNode(x=node.x,\r\n y=node.y + height,\r\n width=node.width,\r\n height=node.height - height)\r\n node.right = SquareAlgorithmNode(x=node.x + width,\r\n y=node.y,\r\n width=node.width - width,\r\n height=height)\r\n return node","def convert_split(g, op, block):\n\n x = g.get_node(op.input(\"X\")[0])\n axis = op.input(\"AxisTensor\")\n if axis:\n axis = g.get_node(axis[0])\n axis, infered = try_infer_value(axis, g.get_params())\n if infered:\n axis = axis.tolist()[0]\n else:\n axis = op.attr(\"axis\")\n\n sections = op.input(\"SectionsTensorList\")\n if sections:\n tmp_section = []\n for i in sections:\n i = g.get_node(i)\n i, infered = try_infer_value(i, g.get_params())\n if infered:\n i = i.tolist()\n else:\n raise ValueError(\"Dynamic Split not yet supported.\")\n tmp_section.extend(i)\n sections = tmp_section\n else:\n sections = op.attr(\"sections\")\n if sections:\n indices = []\n split_index = 0\n for i in sections[:-1]:\n if i == -1:\n input_shape = infer_shape(x)[axis]\n i = input_shape - np.sum(sections) - 1\n split_index += i\n indices.append(split_index)\n else:\n indices = op.attr(\"num\")\n\n out = _op.split(x, indices, axis)\n for i, out_i in enumerate(out):\n g.add_node(op.output(\"Out\")[i], out_i)","def split_network(self):\n disconnect_nodes(self.nodes[1], 2)\n disconnect_nodes(self.nodes[2], 1)\n self.sync_all([self.nodes[:2], self.nodes[2:]])","def split(x, y, t):\n return (Shape(t, x.memory - y.memory, x.cores - y.cores, x.disk - y.disk),\n NodeReservation(Shape(x.wallTime - t, x.memory, x.cores, x.disk)))","def _split_forced(self, node):\n # compute the split\n _vec = 0\n sorted_idxs = np.argsort(self.E[node.ids, _vec]).squeeze()\n n = len(sorted_idxs) // 2\n _lids = node.ids[sorted_idxs[:n]]\n _rids = node.ids[sorted_idxs[n:]]\n # compute the score of the new tubes only\n _sl = self.get_tube_score(_lids)\n _sr = self.get_tube_score(_rids)\n # register the split\n node.has_children = True\n node.thresh = np.median(self.E[node.ids, _vec]) # arbitrary\n # Note: median would not ensure equal size (because of duplicate values)\n left = SpectralNode(_lids, _vec, score=_sl, name=node.name + \"0\")\n right = SpectralNode(_rids, _vec, score=_sr, name=node.name + \"1\")\n\n return left, right","def get_continuous_node(\n self,\n feature_col: int,\n feature_value: float,\n X: np.ndarray,\n y: np.ndarray,\n node: TreeSplits,\n ):\n node.update(\n feature_col=feature_col,\n feature_value=feature_value,\n nodes={\"below\": TreeSplits(), \"above\": TreeSplits()},\n node_type=\"continuous\",\n )\n # Get the above\n above = X[:, feature_col] >= feature_value\n # Get the next split for the above node\n self.get_next_split(X=X[above], y=y[above], tree_split=node.nodes[\"above\"])\n # Add one node to counter\n self.n_nodes += 1\n # Get the next split for the below node\n self.get_next_split(\n X=X[np.bitwise_not(above)],\n y=y[np.bitwise_not(above)],\n tree_split=node.nodes[\"below\"],\n )\n # Add one node to counter\n self.n_nodes += 1\n\n return node","def split_node(node, delimiter):\n if(delimiter == ''):\n sub_labels = [x for x in node.label]\n else:\n sub_labels = node.label.rsplit(delimiter)\n sub_nodes = list()\n for label in sub_labels:\n sub_nodes.append(Node(label, 0))\n if len(sub_nodes) > 0:\n for child in node.children:\n sub_nodes[0].children.extend(split_node(child, delimiter))\n return sub_nodes","def split(self):\n left = BPlusNode(self.order)\n right = BPlusNode(self.order)\n mid = self.order // 2\n\n left.keys = self.keys[:mid]\n left.values = self.values[:mid]\n\n right.keys = self.keys[mid:]\n right.values = self.values[mid:]\n\n # When the node is split, set the parent key to the left-most key of the right child node.\n self.keys = [right.keys[0]]\n self.values = [left, right]\n self.leaf = False","def gen_split(shape,left=True):\n # Create the splitting tensor\n if left:\n split_shape = (np.prod(shape),)+shape\n else:\n split_shape = shape+(np.prod(shape),)\n split_ten = np.zeros(split_shape)\n # Turn into correct identity\n allinds = [range(i) for i in shape]\n cnt = 0\n for ind in itertools.product(*allinds):\n if left:\n tenind = (cnt,)+tuple(ind)\n else:\n tenind = tuple(ind)+(cnt,)\n split_ten[tenind] = 1.\n cnt += 1\n # Return result\n return split_ten","def split(bn, node, Z=None):\n # no estoy seguro si hace falta crear nuevas variables, pero mas\n # vale prevenir que lamentar\n for v in bn.V:\n if v.name == node:\n node = v\n break\n if Z is None:\n Z = bn.G[node]\n\n V = [RandomVariable(var.name, var.Domain) for var in bn.V]\n\n # mapeo de variables viejas a las nuevas. Sirve mas adelante para\n # crear la lista de arcos\n old2new = dict(zip(bn.V, V))\n\n # crear el nuevo nodo y agregarlo a la lista de variables\n newnode = RandomVariable(node.name + \"*\", node.Domain)\n V.append(newnode)\n\n # crear la lista de arcos\n E = []\n for parent, children in bn.G.iteritems():\n for child in children:\n if parent == node and child in Z:\n E.append((newnode, old2new[child]))\n else:\n E.append((old2new[parent], old2new[child]))\n\n # calcular los CPTs\n\n # para cada variable no afectada por el split + variable papa: copiar cpts\n for v in bn.V:\n if not (v in Z):\n old2new[v].cpt = Factor([old2new[e] for e in v.cpt.domain()], v.cpt.getfunction())\n\n # para la variable creada por el split: cpt uniforme\n newnode.cpt = Factor([newnode], [1.0/len(newnode.domain()) for e in newnode.domain()])\n\n # para cada variable hijo afectada por el split: cpt igual a anterior, pero\n # con lista de papas cambiada\n def cp(e):\n if e == node:\n return newnode\n\n return old2new[e]\n\n for v in Z:\n old2new[v].cpt = Factor([cp(e) for e in v.cpt.domain()], v.cpt.getfunction())\n \n name = bn.name + \" splitted\"\n beta = 1\n return DBN(V,E,name,\"\"), newnode","def split_node(node: saldag.OpNode):\n\n # Only dealing with single child case for now\n assert (len(node.children) <= 1)\n clone = copy.deepcopy(node)\n clone.out_rel.rename(node.out_rel.name + \"_obl\")\n clone.parents = set()\n clone.children = set()\n clone.is_mpc = True\n child = next(iter(node.children), None)\n saldag.insert_between(node, child, clone)","def split(axis: int) -> SplitDistribute:\n assert type(axis) is int\n assert str(axis) in _axis_str2split_axis_obj, \"not a valid split. expected: [0, 11)\"\n return _axis_str2split_axis_obj[str(axis)]","def split_range(r, n):\n \n step = int(r / n)\n segments = []\n for i in range(n):\n new_segment = [step * i, step * (i + 1)]\n segments.append(new_segment)\n # correct the gap in the missing index due to the truncated step\n segments[-1][-1] = r\n return segments","def split(self):\n if self.split_level <= 0:\n self.doSplit = False\n return []\n else:\n vel_polar = cart_to_polar(self.pos[1])\n\n ang1 = vel_polar[1] + math.pi / 4\n ang2 = vel_polar[1] - math.pi / 4\n\n vel1 = polar_to_cart( [vel_polar[0] * 1.5, ang1] )\n vel2 = polar_to_cart( [vel_polar[0] * 1.5, ang2] )\n\n offset1 = polar_to_cart( [self.radius, ang1] )\n offset2 = polar_to_cart( [self.radius, ang2] )\n\n pos1 = self.pos[0] + offset1\n pos2 = self.pos[0] + offset2\n\n return [ Asteroid([pos1, vel1], [self.ang[0] + 0.01, self.ang[1] * 1.5],\n scale = self.scale / 1.4,\n color_idx = self.color_idx,\n doSplit = True,\n split_level = self.split_level - 1\n ),\n Asteroid([pos2, vel2], [self.ang[0] - 0.01, -self.ang[1] * 1.5],\n scale = self.scale / 1.4,\n color_idx = self.color_idx,\n doSplit = True,\n split_level = self.split_level - 1\n )\n ]","def split(self, user, number=2, piece='a', comment=None, force_refresh=True):\n if comment is None:\n comment = 'Split sample into {0} pieces'.format(number)\n\n process = Process.objects.create(title='Split Sample',\n comment=comment,\n user=user,\n type_id='split-process')\n nodes = []\n\n branch = self.get_piece(piece)\n for i in range(number):\n if i == 0:\n new_piece = piece\n else:\n new_piece = self._get_next_piece()\n # Note: Issue #248 in django-mptt causes the tree to not be properly\n # updated when inserting objects if parent is set. Workaround\n # is to set parent_id instead. This fixes methods such as\n # MPTTModel.get_descendants(). Since you are referencing an\n # object that has changed in the database (process_tree),\n # the lft and rght items are not updated properly. Workarounds\n # include manually updating the root node or requerying for\n # the sample object which will force a refresh.\n nodes.append(self._insert_node(process, new_piece, i + 1, branch))\n if force_refresh: # workaround to force the root node to update\n self.refresh_tree()\n return nodes","def split(self, X):","def class_split(x):\r\n return np.split(x, [19,43])","def split(self, x):\r\n if x >= self.n2.x or x <= self.n1.x: return [self]\r\n n_intermediate = Node.MiddleNode(x=x)\r\n bar1 = BeamElement(nodes=[self.n1, n_intermediate], section=self.section, material=self.material)\r\n bar2 = BeamElement(nodes=[n_intermediate, self.n2], section=self.section, material=self.material)\r\n return [bar1, bar2]","def grow(self):\n while self.splittable_nodes:\n self.split_next()","def split(self, node):\n # check node was not already split\n if node.has_children:\n raise SplitError(\"BUG: node was already split\")\n\n # early stopping (only if enough nodes already)\n if self.n_clusters >= self.min_leaves:\n # make a leaf if too small to split\n if node.size <= 2 * self.min_leaf_size:\n return None, None\n # special case: make a leaf if too deep already\n if len(node.name) > self.max_depth:\n # int(node.name, 2) is too big to be represented as a long (int64)\n # if len(node.name > 62)\n sys.stderr.write('# WARNING: early stopping too deep branch'\n ' {}\\n'.format(node.name))\n sys.stderr.flush()\n return None, None\n\n # bi-partition the node's samples\n if self.split_type == \"kmeans\":\n left, right = self._split_kmeans(node)\n else:\n left, right = self._split_threshold(node)\n\n # check if we have two leaves or none\n if (left is None and right is not None) or (left is not None and right is None):\n raise SplitError(\n \"BUG: both children should be simultaneously\"\n \"either None or not\")\n\n # check the post-conditions\n if left is None or right is None:\n # node is a leaf\n if node.has_children:\n raise SplitError(\"BUG: leaf node marked with (empty) children\")\n # check if it must have been split instead of being a leaf\n if node.size > self.max_leaf_size:\n # force the split\n left, right = self._split_forced(node)\n msg = 'WARNING: forced to split a must-split node that was'\n msg += ' too big to be a leaf ({0} > max_leaf_size={1})\\n'\n sys.stderr.write(msg.format(node.size, self.max_leaf_size))\n if self.n_clusters < self.min_leaves:\n # force the split\n left, right = self._split_forced(node)\n msg = 'WARNING: forced to split a must-split node that had'\n msg += ' not enough clusters ({0} < min_leaves={1})\\n'\n sys.stderr.write(msg.format(self.n_clusters, self.min_leaves))\n\n # finalize the split\n if node.has_children:\n # update the labels of right child only (left keeps the same)\n self.labels[right.ids] = self.n_clusters\n self.n_clusters += 1\n\n return left, right","def create_nodes(self):","def split_line(self, start, end, increment):\n\n # Determine the number of splits of the line\n num_splits = int(np.linalg.norm(end - start)/increment)\n return (\n np.linspace(start[0], end[0], num_splits),\n np.linspace(start[1], end[1], num_splits)\n )","def BCT_operators(self):\n leaves_original = [node for node, degree in self.tree.out_degree().items() if degree == 0]\n\n def split(node):\n # ##\n # Return bin-tuple of the orphaned tree\n #\n # Parameter:\n # node: string\n #\n # Return:\n # (split_node_parent, node)\n # ##\n\n # Trivialize the orphaned subtree and re-allocate the position to\n # the child of the split_node_parent does not be cut.\n split_node_parent = M.tree.predecessors(node)[0]\n\n if M.tree.predecessors(split_node_parent) != []:\n split_node_parent_parent = M.tree.predecessors(split_node_parent)[0]\n else:\n split_node_parent_parent = None\n M.tree.node[node]['position'] = 'trivial'\n the_other_child = [n for n in M.tree.successors(split_node_parent) if n != node][0]\n\n # Shift the child to the position of its parent\n M.tree.node[the_other_child]['position'] = M.tree.node[split_node_parent]['position']\n M.tree.node[split_node_parent]['position'] = 'trivial'\n\n # Cutting the edge which is related to the parent of the split node\n try:\n cutting_edges_list = [(n1, n2) for n1, n2 in M.tree.edges() if\n (n1 == split_node_parent or n2 == split_node_parent) and (n2 != node)]\n\n # Remove edeges\n for i, j in cutting_edges_list:\n M.tree.remove_edge(i, j)\n\n # Establish the edge on the new movement\n if split_node_parent_parent:\n i, j = [n1 for n1, n2 in cutting_edges_list if n1 == split_node_parent_parent][0], \\\n [n2 for n1, n2 in cutting_edges_list if n2 == the_other_child][0]\n\n M.tree.add_edge(i, j)\n\n except Exception:\n raise Exception(\"in the part of split() suc-function of BCT_operator() function\")\n\n return split_node_parent, node\n\n\n def insertion(M, insert_node, split_node_parent, split_node, operator, split_node_position):\n # ##\n # Return a new binary construction tree\n #\n # Parameter:\n # split_node_parent: string, the old operator\n # split_node: string, the cut node, is used to reinsert to the binary construction tree\n # operator: string, the new operator, typically two options (\"series\" and \"parallel\")\n # split_node_position: string, the new position allocated to the cut node.\n #\n # Return:\n # M: BinaryConstructionTree\n # ##\n\n try:\n # Relabel the arributes of relevant nodes.\n mapping = {split_node_parent: operator}\n M.tree = nx.relabel_nodes(M.tree, mapping)\n M.tree.node[operator]['position'] = M.tree.node[insert_node]['position']\n insert_node_parent = M.tree.predecessors(insert_node)[0]\n\n # Re-allocate the position to the relevant nodes.\n if split_node_position == 'right' and split_node_position == M.tree.node[insert_node]['position']:\n M.tree.node[insert_node]['position'] = 'left'\n\n elif split_node_position == 'left' and split_node_position == M.tree.node[insert_node]['position']:\n M.tree.node[insert_node]['position'] = 'right'\n M.tree.node[split_node]['position'] = split_node_position\n\n # print M.tree.edges()\n # Remove the related edges of the current binary tree\n M.tree.remove_edge(insert_node_parent, insert_node)\n\n # Add the new edges to binary tree\n M.tree.add_edge(insert_node_parent, operator)\n M.tree.add_edge(operator, insert_node)\n\n # Eliminate the redundant edge.\n # for i, j in M.tree.edges():\n\n except Exception:\n raise Exception('in tha part of insertion() sub-function of BCT_operator() function')\n\n return M\n\n # To preserve meta structure.\n M_self = copy.deepcopy(self)\n\n # To traverse all possible isomorphic binary tree\n for node in leaves_original:\n\n M = copy.deepcopy(M_self)\n\n # Do split operation\n split_node_parent, split_node = split(node)\n\n # The children that are used to be inserted\n leaves_insertion = leaves_original[:]\n leaves_insertion.remove(split_node)\n\n # print leaves_insertion\n # Do insertion operation\n for insertnode in leaves_insertion:\n\n # Choose the operator (\"series\" and \"parallel\")\n for operator in ['series', 'parallel']:\n operator_id = len([n for n in M.tree.nodes() if n.__contains__(operator)])\n operator_entity = operator + str(operator_id)\n for position in ['left', 'right']:\n M_split = copy.deepcopy(M)\n M_split = insertion(M_split, insertnode, split_node_parent, split_node, operator_entity,\n position)\n\n is_heteromorphism = 0\n\n identity_series_order = M_split.identity_isomorphic_order()\n\n for m in self.heteromorphism:\n m_identity_series_order = m.identity_isomorphic_order()\n # print \"m_identity:{}\".format(m_identity_series_order)\n # print \"M_split:{}\".format(identity_series_order)\n if identity_series_order != m_identity_series_order:\n is_heteromorphism += 1\n\n if is_heteromorphism == len(self.heteromorphism):\n self.heteromorphism.append(M_split)\n # print M_split.series_partial_order_position_representation()\n # print M_split.tree.nodes(data = True)\n # print\n\n return","def split_at_nodes(shp):\n nodes = find_nodes(shp)\n nodeIds = list(nodes)\n nodeIds.sort()\n nodeIds = dict([(node,i) for i,node in enumerate(nodeIds)])\n \n for road in shp:\n vrts = road.vertices\n midVrts = set(road.vertices[1:-1]) #we know end points are nodes\n midNodes = midVrts.intersection(nodes) # find any nodes in the middle of the feature.\n midIdx = [vrts.index(node) for node in midNodes] # Get their indices\n midIdx.sort()\n if midIdx:\n #print vrts\n starts = [0]+midIdx\n stops = [x+1 for x in midIdx]+[None]\n for start,stop in zip(starts,stops):\n feat = pysal.cg.Chain(vrts[start:stop])\n rec = (nodeIds[feat.vertices[0]],nodeIds[feat.vertices[-1]],False)\n yield feat,rec\n else:\n rec = (nodeIds[road.vertices[0]],nodeIds[road.vertices[-1]],False)\n yield road,rec","def split_joint(pynode, split = 2, replace = True):\n output = []\n # make sure this is joint\n if not isinstance(pynode, pm.nt.Joint):\n return output\n if len(pynode.getChildren(type = 'joint')) > 0 and split > 1:\n # get first child\n children = pynode.getChildren(type = 'joint')\n if children:\n children = children[0]\n # get vector\n vec_a = pynode.getTranslation(space = 'world')\n vec_b = children.getTranslation(space = 'world')\n\n parent = pynode\n if not replace:\n parent = pm.createNode('joint')\n transformation.align(parent, pynode)\n output.append(parent)\n\n factor = (vec_b - vec_a) / split\n for i in range(1, split):\n jnt = pm.createNode('joint')\n pos = factor * i + vec_a\n\n # set split joint translate\n jnt.setTranslation(pos, space = 'world')\n # set split joint rotation\n transformation.align(jnt, pynode, mode = 'rotate')\n\n # set parent split joint\n jnt.setParent(parent)\n # clean transformation on joint\n transformation.freeze_transform(jnt)\n\n # append newly created split joint to output\n output.append(jnt)\n # set new variable parent\n parent = jnt\n\n if replace:\n children.setParent(parent)\n else:\n jnt = pm.createNode('joint')\n transformation.align(jnt, children)\n jnt.setParent(parent)\n output.append(jnt)\n\n return output","def detect_splits(self):\n logg.info(' abstracted graph will have {} nodes'.format(self.n_splits+1))\n indices_all = np.arange(self.X.shape[0], dtype=int)\n segs = [indices_all]\n if False: # this is safe, but not compatible with on-the-fly computation\n tips_all = np.array(np.unravel_index(np.argmax(self.Dchosen), self.Dchosen.shape))\n else:\n if self.iroot is not None:\n tip_0 = np.argmax(self.Dchosen[self.iroot])\n else:\n tip_0 = np.argmax(self.Dchosen[0]) # just a random index, here fixed to \"0\"\n tips_all = np.array([tip_0, np.argmax(self.Dchosen[tip_0])])\n # we keep a list of the tips of each segment\n segs_tips = [tips_all]\n if self.clusters_precomputed_names:\n self.segs_names_original = [', '.join(self.clusters_precomputed_names)]\n segs_undecided = [True]\n segs_adjacency = [[]]\n segs_distances = np.zeros((1, 1))\n segs_adjacency_nodes = [{}]\n # logg.info(' do not consider groups with less than {} points for splitting'\n # .format(self.min_group_size))\n for ibranch in range(self.n_splits):\n if self.clusters == 'unconstrained_segments':\n iseg, new_tips = self.select_segment(segs, segs_tips, segs_undecided)\n if iseg == -1:\n logg.info('... partitioning converged')\n break\n logg.info('... branching {}:'.format(ibranch + 1),\n 'split group', iseg)\n segs_distances = self.do_split(segs, segs_tips,\n segs_undecided,\n segs_adjacency,\n segs_distances,\n iseg, new_tips)\n else:\n logg.msg(' split', ibranch + 1, v=4)\n stop, segs_distances = self.do_split_constrained(segs, segs_tips,\n segs_adjacency,\n segs_adjacency_nodes,\n segs_distances)\n if stop: break\n\n # segments\n self.segs = segs\n self.segs_tips = segs_tips\n self.segs_sizes = []\n for iseg, seg in enumerate(self.segs): self.segs_sizes.append(len(seg))\n\n # the full, unscaled adjacency matrix\n self.segs_adjacency_full_attachedness = 1/segs_distances\n # if self.attachedness_measure == 'connectedness':\n # norm = np.sqrt(np.multiply.outer(self.segs_sizes, self.segs_sizes))\n # self.segs_adjacency_full_attachedness /= norm\n self.segs_adjacency_full_confidence, self.segs_adjacency_tree_confidence \\\n = self.compute_adjacency_confidence(\n self.segs_adjacency_full_attachedness,\n segs_adjacency,\n self.tree_based_confidence)\n np.fill_diagonal(self.segs_adjacency_full_attachedness, 0)","def _split_heads(self, x: torch.Tensor) -> torch.Tensor:\n depth = x.size(-1)\n split_x = torch.reshape(x, (\n x.size(0), x.size(1),\n self._hparams.num_heads, depth // self._hparams.num_heads))\n return split_x.permute((0, 2, 1, 3))","def test_split_activities(self):\n labels = np.ones(3000)\n labels[range(150)] = 2\n X = np.ones((3000,9))\n splittedX, splitted_y = tutorial_pamap2.split_activities(labels,X,[0], borders=50)\n assert splittedX[0].shape == (50, 9)\n assert splittedX[1].shape == (2750, 9)","def create_child_nodes(current_node: Node, goal: list, generated: set) -> list:\n\n children = []\n locations = state_to_locations(current_node.state)\n blank = locations[0]\n\n # Moving blank to the left\n if blank[1] != 0:\n new_locations = copy.deepcopy(locations)\n new_locations[0] = (new_locations[0][0], new_locations[0][1] - 1)\n # Modifies the location of the blank in the new list\n \"\"\" Note that the index 0 represents the first column. So long as \n the blank is not in the first column, it can be moved to the left.\"\"\"\n neighbor = current_node.state[blank[0]][blank[1] - 1]\n # Finds the number on the tile to the left of the blank\n new_locations[neighbor] = (new_locations[neighbor][0], new_locations[neighbor][1] + 1)\n # Modifies the location of the neighbor in the new list\n new_path_history = copy.deepcopy(current_node.path_history)\n new_path_history.append('L')\n new_state = locations_to_state(new_locations)\n # Constructs the new state by calling locations_to_state\n new_node = Node(new_state, current_node, current_node.path_cost + 1,\n heuristic_cal(new_state, goal), new_path_history)\n if new_node not in generated:\n children.append(new_node)\n \"\"\" Append the child node to the list only if it's not a \n repeated state.\"\"\"\n\n # Moving blank to the right\n if blank[1] != 3:\n new_locations = copy.deepcopy(locations)\n new_locations[0] = (new_locations[0][0], new_locations[0][1] + 1)\n \"\"\" Similar to the case above: so long as the blank is not in the fourth \n column, it can be moved to the right.\"\"\"\n neighbor = current_node.state[blank[0]][blank[1] + 1]\n # Finds the number on the tile to the right of the blank\n new_locations[neighbor] = (new_locations[neighbor][0], new_locations[neighbor][1] - 1)\n new_path_history = copy.deepcopy(current_node.path_history)\n new_path_history.append('R')\n new_state = locations_to_state(new_locations)\n new_node = Node(new_state, current_node, current_node.path_cost + 1,\n heuristic_cal(new_state, goal), new_path_history)\n if new_node not in generated:\n children.append(new_node)\n\n # Moving blank up\n if blank[0] != 0:\n new_locations = copy.deepcopy(locations)\n new_locations[0] = (new_locations[0][0] - 1, new_locations[0][1])\n \"\"\" So long as the blank is not in the first row, it can be moved up.\"\"\"\n neighbor = current_node.state[blank[0] - 1][blank[1]]\n # Finds the number on the tile above the blank\n new_locations[neighbor] = (new_locations[neighbor][0] + 1, new_locations[neighbor][1])\n new_path_history = copy.deepcopy(current_node.path_history)\n new_path_history.append('U')\n new_state = locations_to_state(new_locations)\n new_node = Node(new_state, current_node, current_node.path_cost + 1,\n heuristic_cal(new_state, goal), new_path_history)\n if new_node not in generated:\n children.append(new_node)\n\n # Moving the blank down\n if blank[0] != 3:\n new_locations = copy.deepcopy(locations)\n new_locations[0] = (new_locations[0][0] + 1, new_locations[0][1])\n \"\"\" So long as the blank is not in the fourth row, it can be moved down.\"\"\"\n neighbor = current_node.state[blank[0] + 1][blank[1]]\n # Finds the number on the tile below the blank\n new_locations[neighbor] = (new_locations[neighbor][0] - 1, new_locations[neighbor][1])\n new_path_history = copy.deepcopy(current_node.path_history)\n new_path_history.append('D')\n new_state = locations_to_state(new_locations)\n new_node = Node(new_state, current_node, current_node.path_cost + 1,\n heuristic_cal(new_state, goal), new_path_history)\n if new_node not in generated:\n children.append(new_node)\n\n return children","def split_window(num_x, num_y):\n\n viewPorts = np.zeros((num_x*num_y, 4))\n counter = 0\n for i in range(num_x):\n for j in range(num_y):\n viewPorts[num_x*j + i, :] = [i*(1.0/float(num_x)),\n 1.0 - (j+1.0)*(1.0/float(num_y)),\n (i+1.0)*1.0/float(num_x),\n 1.0 - j*(1.0/float(num_y))\n ] # [num_y*i + j,:] for vertical fill first\n\n return viewPorts","def subpartition_bsp(self, min_width, min_height):\n \n def split_horizontal(p):\n ul_x, ul_y = p.ul_pos\n \n split_pos = (random.choice(\n list(range(ul_x + min_width, ul_x + p.width - min_width + 1))), ul_y)\n \n split_x, split_y = split_pos\n \n return([Partition(p.ul_pos, split_x-ul_x, p.height), \n Partition(split_pos, ul_x + p.width - split_x, p.height)])\n \n def split_vertical(p):\n ul_x, ul_y = p.ul_pos\n \n split_pos = (ul_x, random.choice(\n list(range(ul_y + min_height, ul_y + p.height - min_height + 1))))\n \n split_x, split_y = split_pos\n \n return([Partition(p.ul_pos, p.width, split_y-ul_y), \n Partition(split_pos, p.width, ul_y + p.height - split_y)])\n \n\n \n if self.width < min_width or self.height < min_height:\n raise PartitionException(\"Partition too small!\")\n \n splith = (self.width > 2*min_width)\n splitv = (self.height > 2*min_height)\n \n new_partitions = None\n \n if splith and splitv:\n new_partitions = random.choice([\n split_horizontal, split_vertical])(self)\n \n elif splith:\n new_partitions = split_horizontal(self)\n \n elif splitv:\n new_partitions = split_vertical(self)\n \n else:\n return [self]\n \n return list(flatten([p.subpartition_bsp(min_width, min_height) \n for p in new_partitions]))","def insert_nodes(self):\n neighbour_max_distance = 5\n new_nodes = []\n for node in self.nodes:\n left_distance = node.get_distance(node.neighbour1)\n right_distance = node.get_distance(node.neighbour2)\n if left_distance > neighbour_max_distance:\n # halfway\n half_point = (\n node.x + (node.neighbour1.x - node.x) / 2,\n node.y + (node.neighbour1.y - node.y) / 2\n )\n new_node = Node(half_point)\n node.neighbour1.connect(node.neighbour1.neighbour1, new_node)\n new_node.connect(node.neighbour1, node)\n node.connect(new_node, node.neighbour2)\n new_nodes.append(new_node)\n new_nodes.append(node)\n\n if right_distance > neighbour_max_distance:\n # halfway\n half_point = (\n node.x + (node.neighbour2.x - node.x) / 2,\n node.y + (node.neighbour2.y - node.y) / 2\n )\n new_node = Node(half_point)\n node.neighbour2.connect(new_node, node.neighbour2.neighbour2)\n new_node.connect(node, node.neighbour2)\n node.connect(node.neighbour1, new_node)\n new_nodes.append(new_node)\n\n return new_nodes","def split(nvim, vertical=False, new_file=True):\n cmds = Cmds([\"vsplit\" if vertical else \"split\"])\n if new_file:\n cmds.append(\"enew\")\n cmds.run(nvim)\n\n return nvim.current.window","def splitEdge(self, edge, index, link):\n #print 'Splitting edge', edge\n node = Node(len(self.nodes))\n if link:\n suffix_link = SuffixLink(node)\n self.latest_node.addSuffixLink(suffix_link)\n # copy out existing destination and bounds\n old_dest = edge.getDestination()\n old_bounds = edge.getSuffix()\n old_start = old_bounds[0]\n # Adjust edge finish point to n + index, connect new node\n edge.setBound(stop = old_start + index)\n edge.setDestination(node) \n # Create new edge representing the remains of the old edge\n offcut = Edge(self.target[old_start + index], old_start + index, \n old_bounds[1], old_dest)\n # Add the offcut edge as a child of the new node\n node.addChild(offcut) \n # Create new edge for the current pos\n n = self.pos.getVal()\n new_edge = Edge(self.target[n], n, self.pos)\n node.addChild(new_edge)\n self.nodes.append(node)\n self.latest_node = node\n # rule 1 - a split from the root node\n if self.active_node == self.root:\n # active length decrements\n self.active_length -= 1\n pos = self.pos.getVal()\n # active edge changes\n self.active_edge = self.target[pos - self.active_length]\n # active node remains root\n else:\n if self.active_node.hasSuffixLink():\n # Set the active node to the link destination\n link = self.active_node.getSuffixLink()\n self.active_node = link.getDestination()\n else:\n self.active_node = self.root # set active node to root","def split(self, place_leaf_splitted):\n raise NotImplementedError","def bdev_split_create(client, base_bdev, split_count, split_size_mb=None):\n params = {\n 'base_bdev': base_bdev,\n 'split_count': split_count,\n }\n if split_size_mb:\n params['split_size_mb'] = split_size_mb\n\n return client.call('bdev_split_create', params)","def splitPlace(self):\r\n \r\n \r\n \r\n nodeSortedIter = sorted(self.G.degree_iter(),key=itemgetter(1),reverse=True)\r\n \r\n placeCnt = 0\r\n \r\n for node in nodeSortedIter:\r\n if placeCnt<self.cells/2:\r\n self.sitesA.append(node[0])\r\n self.G.node[node[0]][\"part\"] = 'A'\r\n else:\r\n self.sitesB.append(node[0])\r\n self.G.node[node[0]][\"part\"] = 'B'\r\n placeCnt+=1","def nextSplit(self):\n pass","def _create_slice(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\n for attr in ['starts', 'ends', 'axes', 'steps']:\n node.input.append(op.name + \":\" + attr)\n return node","def split_data(basedir, data_split=0.80):\n manip = data_manipulator(basedir)\n manip.train_test_split(data_split=data_split)","def create_nodes(coords):\n nodes = []\n for coord in coords:\n nodes.append(Node(coord))\n\n for i, node1 in enumerate(nodes):\n node0 = nodes[i - 1]\n if i == len(nodes) - 1:\n node2 = nodes[0]\n else:\n node2 = nodes[i + 1]\n node1.connect(node0, node2)\n return nodes","def split_segments(old_seg_ends, B):\n new_segment_ends = []\n for q in range(0, B.size):\n new_ends = list(np.linspace(old_seg_ends[q], old_seg_ends[q + 1], B[q] + 1))\n new_segment_ends.extend(new_ends[:-1])\n new_segment_ends.extend([1])\n new_segment_ends = np.asarray(new_segment_ends)\n return new_segment_ends","def perform_node_split(self, node: RTreeNode[T], group1: List[RTreeEntry[T]], group2: List[RTreeEntry[T]])\\\n -> RTreeNode[T]:\n node.entries = group1\n split_node = RTreeNode(self, node.is_leaf, parent=node.parent, entries=group2)\n self._fix_children(node)\n self._fix_children(split_node)\n return split_node","def prepare_initial_nodes(x_start, x_end, nodes_y):\n nodes_x = [float(x_start + ((x_end - x_start) / (len(nodes_y) - 1)) * i) for i in range(0, len(nodes_y))]\n nodes_y = [float(y) for y in nodes_y]\n print(nodes_x)\n print(nodes_y)\n nodes = list(zip(nodes_x, nodes_y))\n return nodes","def train_test_data_split(node_features, labels, train_ratio=0.8):\n num_graph = node_features.shape[0]\n train_test_split = int(train_ratio*num_graph)\n x_train = node_features[:train_test_split,:,:] \n y_train = labels[:train_test_split,:,:] \n x_test = node_features[train_test_split:,:,:] \n y_test = labels[train_test_split:,:,:]\n np.save(\"data/node_features_train.npy\", x_train)\n np.save(\"data/node_features_test.npy\", x_test)\n np.save(\"data/labels_train.npy\", y_train)\n np.save(\"data/labels_test.npy\", y_test)\n return x_train, x_test, y_train, y_test","def split_edge(self,j,**node_args):\n nA,nC=self.edges['nodes'][j]\n assert np.all( self.edge_to_cells(j) < 0 )\n\n edge_data=rec_to_dict(self.edges[j].copy())\n \n self.delete_edge(j)\n\n # choose midpoint as default\n loc_args=dict(x= 0.5*(self.nodes['x'][nA] + self.nodes['x'][nC]))\n loc_args.update(node_args) # but args will overwrite\n\n nB=self.add_node(**loc_args)\n edge_data['nodes'][1]=nB\n self.add_edge(_index=j,**edge_data)\n # this way we get the same cell marks, too.\n # this helps in tracking marks like UNDEFINED vs. UNPAVED\n edge_data['nodes']=[nB,nC]\n jnew=self.add_edge(**edge_data)\n return jnew,nB","def createNodes(self, size):\n\t\tnodeList = []\n\t\tfor i in range(size) :\n\t\t\tnodeList.append(Node(str(i)))\n\t\treturn nodeList","def add_nodes(\n self,\n nodes,\n subsections=None,\n spacing=None,\n is_first_new=True,\n close=True,\n is_polygon=False,\n boundary_id=-1,\n boundary_ids=None,\n ):\n nodes = np.asarray(nodes)\n\n # Get index of the first new connectivity info.\n # Only used if `is_polygon` is true.\n if self.connectivity_ is None:\n new_connectivity_begin = 0\n else:\n new_connectivity_begin = self.connectivity_.shape[0]\n\n # In case of polygon, don't add any points on the edge\n if is_polygon:\n subsections = 1\n spacing = None\n if self.nodes is None:\n ind_offset = 0\n else:\n ind_offset = self.nodes.shape[0]\n\n # Prepare boundary_ids\n first_new = 0 if is_first_new else 1\n closing = 0 if close else -1\n num_new_connectivity = int(len(nodes) + first_new + closing)\n\n # Set boundary_ids\n if boundary_ids is not None:\n assert num_new_connectivity == len(boundary_ids),\\\n \"Length of boundary_ids is inappropriate.\"\n\n boundary_ids = np.asarray(boundary_ids).astype(np.int32).flatten()\n logging.debug(\"Segment - Applying specified boundary id to each \" +\\\n \"new connectivity.\")\n\n else:\n # Form boundary_ids using boundary_id\n boundary_ids = np.repeat(\n boundary_id, num_new_connectivity\n ).astype(np.int32).flatten()\n logging.debug(\"Segment - Applying same boundary id {bid} to all \" +\\\n \"new connectivities.\".format(bid=boundary_id))\n\n # Carefully assgin the first boundary_id\n # -1 here is just a dummy, since it won't be applied in that case\n if is_first_new:\n fbid = -1\n\n else:\n fbid = boundary_ids[0]\n boundary_ids = boundary_ids[1:]\n\n # Add first node\n self.add_node(\n node=nodes[0],\n subsections=subsections,\n spacing=spacing,\n new_sequence=is_first_new,\n boundary_id=fbid,\n )\n\n # Add mid-nodes\n # If `close=True`, len(boundary_ids) == len(nodes[1:-1]) + 2 (or +1)\n # but `zip` will stop at whatever is shorter.\n if len(nodes[1:-1]) != 0:\n for n, b in zip(nodes[1:-1], boundary_ids):\n self.add_node(\n node=n,\n subsections=subsections,\n spacing=spacing,\n boundary_id=b,\n )\n\n # Carefully assgin the last two `boundary_id`s\n if close:\n lbid = boundary_ids[-2] \n cbid = boundary_ids[-1]\n\n else:\n lbid = boundary_ids[-1]\n cbid = None\n\n # Add last node\n self.add_node(\n node=nodes[-1],\n subsections=subsections,\n spacing=spacing,\n close_sequence=close,\n boundary_id=lbid,\n closing_boundary_id=cbid,\n )\n\n logging.debug(\"Segment - Added {nn} nodes.\".format(nn=nodes.shape[0]))\n logging.debug(\"Segment - First was new: {n}.\".format(n=is_first_new))\n logging.debug(\"Segment - Closed the sequence: {c}.\".format(c=close))\n\n # In case of polygon, append freshly added nodes.\n if is_polygon:\n self.polygons_.append(\n # self.connectivity_[new_connectivity_begin:,0].tolist()\n (np.arange(nodes.shape[0]) + ind_offset).tolist()\n )\n logging.debug(\n \"Segment - Polygon with {nv} vertices are added.\".format(\n nv=len(self.polygons_[-1])\n )\n )\n\n # Set facet BC\n self.add_boundary_id(\n boundary_id=boundary_id,\n num_boundary_id=1, # One polygon at a time\n facet=True,\n )","def get_split(X: List, y: List) -> tp.Split:\n\n def my_train_test_split(my_X, my_y, split_size: float):\n return train_test_split(my_X, my_y, test_size=split_size, random_state=0, stratify=my_y)\n\n X_train, X_dev, y_train, y_dev = my_train_test_split(X, y, split_size=0.20)\n X_train, X_test, y_train, y_test = my_train_test_split(X_train, y_train, split_size=0.25)\n\n train = tp.Xy(X_train, y_train)\n dev = tp.Xy(X_dev, y_dev)\n test = tp.Xy(X_test, y_test)\n return tp.Split(train, dev, test)","def __init__(self, from_node, to_node, span=None):\n self.from_node = from_node\n self.to_node = to_node\n self.span = span\n self.dummyedges = []","def draw_divider(self, context: DrawContext, node: Node) -> None:\n target = str(id(node))\n for _ in range(context.height(node)):\n parent, target = target, f\":{target}\"\n context.graph.add_node(DotNode(target, **self.hidden_node))\n context.graph.add_edge(Edge(parent, target, style=\"invis\", weight=5))","def _split_heads(x, num_heads):\n\tshape_lst = bert_utils.get_shape_list(x)\n\tdepth = shape_lst[-1]\n\tbatch = shape_lst[0]\n\tseq = shape_lst[1]\n\t# print(x.get_shape(), \"===splitheads===\")\n\tsplitted_x = tf.reshape(x, [tf.shape(x)[0], tf.shape(x)[1], \\\n\t\tnum_heads, depth // num_heads])\n\treturn tf.transpose(splitted_x, [0, 2, 1, 3])","def get_discrete_node(self, X, y, feature_col, feature_value, node):\n # Get the unique values for the X poitns\n unique_x_vals = self.discrete_value_maps[feature_col]\n\n # Create the node with an empty child for each x value\n node.update(\n feature_col=feature_col,\n feature_value=feature_value,\n nodes={xval: TreeSplits() for xval in unique_x_vals},\n node_type=\"discrete\",\n )\n\n # For each unique value in the feature column...\n for x_col_value in unique_x_vals:\n # Get the matching rows\n matches = X[:, feature_col] == x_col_value\n\n # If no matches, put all points in a leaf node\n if np.sum(matches) == 0:\n node.nodes[x_col_value] = TreeSplits(\n node_type=\"discrete\",\n feature_col=feature_col,\n feature_value=x_col_value,\n children=y,\n )\n else:\n # If there are matches, get the next split\n self.get_next_split(\n X=X[matches], y=y[matches], tree_split=node.nodes[x_col_value],\n )\n # Increment by one.\n self.n_nodes += 1\n\n return node","def chunk(self, shape, split) -> NotImplementedError:\n raise NotImplementedError()","def vsplit(nvim, new_file=True):\n return split(nvim, True, new_file)","def test_add_empty_nodes_with_label_when_splitting(self):\n print \"----- test_add_empty_nodes_with_label_when_splitting -----\"\n sel_axis = (lambda axis: axis)\n \n #create tree, first node splits in x direction\n tree = kdtree.createNewTree([[0.5, 0.5]],axis = 0, sel_axis= sel_axis)\n kdtree.visualize(tree)\n \n point_left = [0.4, 0.5]\n tree.split2(point_left, axis = 0)\n kdtree.visualize(tree)\n \n point1 = [0.3, 0.5]\n found_node = tree.get_path_to_leaf(point1)[-1]\n correct_node1 = 3\n self.assertEqual(found_node.label, correct_node1, \"Not correct node found\")\n \n point_right = [0.6, 0.5]\n tree.split2(point_right, axis = 1)\n kdtree.visualize(tree)\n \n point2 = [0.6, 0.7]\n found_node = tree.get_path_to_leaf(point2)[-1]\n correct_node2 = 6\n self.assertEqual(found_node.label, correct_node2, \"Not correct node found\")\n \n print \"----- end: test_add_empty_nodes_with_label_when_splitting -----\"","def push_nodes_with_binary(self, b, step_ratio=0.1, niter=0):\n lid = list(self._data[:, 0])\n lpid = list(self._data[:, -2])\n t_data = self._data.copy()\n\n children_idx = {\n pid: [i for i, p in enumerate(lpid) if p == t_data[i, 0]] for pid in lpid\n }\n\n for _ in range(niter):\n for i in range(t_data.shape[0]):\n pid, radius, (x, y, z) = (\n int(t_data[i, -2]),\n t_data[i, -3],\n t_data[i, 2:5],\n )\n cidx = children_idx[pid]\n if pid != i and pid in lid and len(cidx) <= 1:\n px, py, pz = t_data[t_data[:, 0] == pid, 2:5][0]\n vnorm = norm_vec(np.asarray([x - px, y - py, z - pz]))\n\n if len(cidx) == 1:\n cx, cy, cz = t_data[cidx[0], 2:5]\n vnorm = (\n vnorm + norm_vec(np.asarray([cx - x, cy - y, cz - z]))\n ) / 2\n if all([v == 0 for v in vnorm]):\n continue\n\n pt = np.asarray([x, y, z])\n p_vectors = get_perpendicular_vectors(pt, vnorm)\n p_distances = [\n get_distance_to_boundary(pt, pvec, b) for pvec in p_vectors\n ]\n dx, dy, dz = np.sum(\n [pv * pd for pv, pd in zip(p_vectors, p_distances)], 0\n )\n\n # Constrain the displacement by the nodo radii\n tx = x + dx * step_ratio\n ty = y + dy * step_ratio\n tz = z + dz * step_ratio\n dist = (\n (tx - self._data[i, 2]) ** 2\n + (ty - self._data[i, 3]) ** 2\n + (tz - self._data[i, 4]) ** 2\n ) ** 0.5\n if dist <= radius / 2:\n t_data[i, 2] = tx\n t_data[i, 3] = ty\n t_data[i, 4] = tz\n else:\n pass\n self._data = t_data","def split_kbucket(self):\n cur_range_size = self.range_max - self.range_min\n half_point = self.range_min + cur_range_size // 2\n\n # Ensure no empty range is created.\n assert self.range_min < half_point < self.range_max\n\n # Make the instantiation dependent on the actual class,\n # for easy inheritance.\n new_kbucket = self.__class__(half_point, self.range_max)\n\n # Halve the ID space of the split KBucket.\n self.range_max = half_point\n\n # Split the contact list into two, according to the new ranges.\n self._contacts, new_kbucket._contacts = util.partition(\n self._contacts,\n self.contact_in_range\n )\n\n return new_kbucket","def convert_slice_channel(node, **kwargs):\n name, input_nodes, input_shapes, attrs = get_inputs(node, kwargs, with_shapes=True)\n\n num_outputs = int(attrs.get(\"num_outputs\"))\n axis = int(attrs.get(\"axis\", 1))\n squeeze_axis = int(attrs.get(\"squeeze_axis\", 0))\n\n if squeeze_axis == 1 and num_outputs == 1:\n node = onnx.helper.make_node(\n \"Squeeze\",\n input_nodes,\n [name],\n axes=[axis],\n name=name,\n )\n return [node]\n elif squeeze_axis == 0 and num_outputs > 1:\n in_shape = input_shapes[0]\n split = in_shape[axis] // num_outputs\n node = onnx.helper.make_node(\n \"Split\",\n input_nodes,\n [name+'_output'+str(i) for i in range(num_outputs)],\n axis=axis,\n split=[split for _ in range(num_outputs)],\n name=name,\n )\n return [node]\n else:\n raise NotImplementedError(\"SliceChannel operator with num_outputs>1 and\"\n \"squeeze_axis true is not implemented.\")","def discretizespace(self):\n \n # Grid\n self.xgriddim = ( self.x0_n , self.x1_n )\n \n self.xd = [ None , None ]\n self.xd[0] = np.linspace( self.DS.x_lb[0] , self.DS.x_ub[0] , self.x0_n )\n self.xd[1] = np.linspace( self.DS.x_lb[1] , self.DS.x_ub[1] , self.x1_n )\n \n self.x_grid2node = np.zeros( ( self.x0_n , self.x1_n ) , dtype = int ) # grid of corresponding index\n \n # 1-D List of nodes\n self.nodes_n = self.x0_n * self.x1_n\n self.nodes_state = np.zeros(( self.nodes_n , self.DS.n ), dtype = float ) # Number of nodes x state dimensions\n self.nodes_index = np.zeros(( self.nodes_n , self.DS.n ), dtype = int ) # Number of nodes x state dimensions","def rect_splitter(split_depth, rect, start_dimension='vertical'):\n\n splitters = (rect_vertical_split, rect_horizontal_split)\n if start_dimension == 'vertical':\n pass\n elif start_dimension == 'horizontal':\n splitters = splitters[1], splitters[0]\n else:\n raise ValueError(\"Invalid `start_dimension`\")\n\n split_results = [rect.copy()]\n\n for i in range(split_depth):\n new_split_results = []\n for x in split_results:\n new_split_results.extend(splitters[i % 2](x))\n split_results = new_split_results\n\n return split_results","def get_splits(ntot, nper):\n beglist = numpy.arange(0,ntot,nper)\n endlist = numpy.arange(0,ntot,nper) + nper - 1\n\n if (ntot % nper) != 0:\n endlist[-1] = ntot-1\n return beglist, endlist","def pyramid_factory(motor, start, stop, step_size):\n if stop < start:\n start, stop = stop, start\n last_group = None\n last_pos = start\n\n def x_motion_per_step(dets, stream_name):\n nonlocal last_group\n nonlocal last_pos\n nonlocal step_size\n\n if last_group is not None:\n yield from bps.wait(last_group)\n\n yield from bps.trigger_and_read(dets, stream_name)\n\n last_group = short_uid()\n\n if not start < last_pos + step_size < stop:\n step_size *= -1\n last_pos += step_size\n\n yield from bps.abs_set(motor, last_pos, group=last_group)\n\n return x_motion_per_step","def addSplit(self):\n pass","def greedy_split(arr, n, axis=0):\n length = arr.shape[axis]\n # compute the size of each of the first n-1 blocks\n block_size = int(np.ceil(length / float(n)))\n # the indices at which the splits will occur\n ix = np.arange(block_size, length, block_size)\n return np.array(np.split(arr, ix, axis))","def train_test_split(self):\n random.seed(self.args.seed)\n nodes = [node for node in range(self.ncount)]\n random.shuffle(nodes)\n self.train_nodes = torch.LongTensor(nodes[0:self.args.training_size])\n self.validation_nodes = torch.LongTensor(nodes[self.args.training_size:self.args.training_size+self.args.validation_size])\n self.test_nodes = torch.LongTensor(nodes[self.args.training_size+self.args.validation_size:])","def split(self,X,y=None):\n all_idx = pd.Series(np.arange(X.shape[0])) \n mbrg = int(X.shape[0]*self.embargo_pct)\n test_starts=[(i[0],i[-1]+1) for i in np.array_split(all_idx.values,self.n_splits)]\n for i, j in test_starts:\n t0 = all_idx.index[i] # start of test set\n test_indices = all_idx.values[i:j]\n maxT1Idx = all_idx.index.searchsorted(all_idx[test_indices].max())\n train_indices = all_idx.index.searchsorted(all_idx[all_idx<=t0].index)\n if maxT1Idx < X.shape[0]: \n train_indices=np.concatenate((train_indices,all_idx[maxT1Idx+mbrg:]))\n yield train_indices,test_indices","def set_split(self, split, force=True):\n if(force or self.split != split):\n c = (0, 1)[split]\n self.debug_print('set split mode: %d' % c)\n r = self.send_com(0x0f, [c])\n if(r):\n self.split = split\n return r","def geomspace(start, stop, num=50, include_endpoint=True, dtype=None, constant=False):\n return Tensor(np.geomspace(start, stop, num, include_endpoint, dtype), constant=constant)","def make_splits(self):\n # produce fold/portion splits of the training indexes: these output indexes to the tr. indexes themselves\n if self.folds is not None:\n meta_trainval_idx = kfold_split(self.train_idx, self.folds, self.seed, self.labels, self.label_info)\n elif self.portion is not None:\n meta_trainval_idx = portion_split(self.train_idx, self.portion, self.seed, self.labels, self.label_info)\n else:\n meta_trainval_idx = [(np.arange(len(self.train_idx)), np.arange(0, dtype=np.int32))]\n # \"dereference\" the metaindexes to point to the data themselves\n self.trainval_idx = []\n for (tidx, vidx) in meta_trainval_idx:\n self.trainval_idx.append((self.train_idx[tidx], self.train_idx[vidx]))","def partid2nids(self, partid):\n # TODO do we need to cache it?\n start = self._node_map[partid - 1] if partid > 0 else 0\n end = self._node_map[partid]\n return F.arange(start, end)","def _setup_splits(self):\n #ntot = self.reredux_conf['nperfile']\n ntot = self.reredux_conf['Ngals']\n npersplit = self.runconf['nper']\n\n self.beglist, self.endlist = get_splits(ntot, npersplit)","def _create_train_val_split(\n self, data_size, shuffle = False, seed = None\n ):\n val_size = int(np.round(data_size * self._val_fraction))\n val_size = max(1, val_size) if self._val_fraction > 0 else 0\n train_size = data_size - val_size\n train_split = np.concatenate(\n [np.ones([train_size], dtype=np.int32),\n np.zeros([val_size], dtype=np.int32)])\n if shuffle:\n np.random.RandomState(seed).shuffle(train_split)\n return train_split","def discretizespace(self):\n \n # Grid\n self.xgriddim = ( self.x0_n , self.x1_n , self.x2_n )\n \n self.xd = [ None , None , None ]\n self.xd[0] = np.linspace( self.DS.x_lb[0] , self.DS.x_ub[0] , self.x0_n )\n self.xd[1] = np.linspace( self.DS.x_lb[1] , self.DS.x_ub[1] , self.x1_n )\n self.xd[2] = np.linspace( self.DS.x_lb[2] , self.DS.x_ub[2] , self.x2_n )\n \n self.x_grid2node = np.zeros( ( self.x0_n , self.x1_n , self.x2_n ) , dtype = int ) # grid of corresponding index\n \n # 1-D List of nodes\n self.nodes_n = self.x0_n * self.x1_n * self.x2_n\n self.nodes_state = np.zeros(( self.nodes_n , self.DS.n ), dtype = float ) # Number of nodes x state dimensions\n self.nodes_index = np.zeros(( self.nodes_n , self.DS.n ), dtype = int ) # Number of nodes x state dimensions","def make_splits(input_pkl, test_split=0.1, val_split=0.1):\n if (test_split > 1) or (val_split > 1) or (test_split + val_split > 1) or (test_split <= 0) or (val_split <= 0):\n logging.warning('Check the input for make splits, quitting')\n exit()\n\n main_dict = load_pickle(input_pkl)\n data, labels = main_dict['data'], main_dict['labels']\n idx_arr = np.random.choice(len(data), len(data))\n data, labels = data[idx_arr], labels[idx_arr]\n print(len(data[0][-1]))\n # Find the split sizes\n val_split = int(len(data) * val_split)\n test_split = val_split + int(len(data) * test_split)\n\n # Make and save the splits\n save_pickle({'data': data[:val_split], 'labels': labels[:val_split]}, 'data/val.pkl')\n save_pickle({'data': data[val_split:test_split], 'labels': labels[val_split:test_split]}, 'data/test.pkl')\n save_pickle({'data': data[test_split:], 'labels': labels[test_split:]}, 'data/train.pkl')","def test_split_cell_splits_neighbours(mock_amg):\n\n # split the centre cell in the mock grid\n # this will create 4 more cells at tier 1\n mock_amg.cells[4].split()\n\n # now split the bottom right of these cells\n # this should force the east and south cells to also be split\n mock_amg.cells[4].children['br'].split()\n\n assert mock_amg.cells[5].has_children\n assert mock_amg.cells[1].has_children","def train(self, x, y, feature_search=None,\n max_depth=8, min_samples_split=2, min_samples_leaf=1):\n if self._depth < max_depth and x.shape[0] > min_samples_split:\n\n # Retrieve best split coordinates based on gini impurity\n # and two groups\n self._feature_idx, self._split_value, group_1, group_2 = \\\n split_search(x, y, min_samples_leaf, feature_search)\n\n if self._feature_idx is not np.NaN:\n # Recursively split and train child nodes\n self._left_child = Node(self._depth + 1)\n self._right_child = Node(self._depth + 1)\n self._left_child.train(*group_1, feature_search, max_depth,\n min_samples_split,\n min_samples_leaf)\n self._right_child.train(*group_2, feature_search, max_depth,\n min_samples_split,\n min_samples_leaf)\n else:\n # Impossible to split. Convert to leaf node\n # This will occur when observations are\n # identical in a given node\n self._sprout(y)\n else:\n # End condition met. Convert to leaf node\n self._sprout(y)","def split(self):\n\n ratio_c = 1 - self.ratio\n self.train, self.test = self.df.randomSplit([self.ratio, ratio_c], seed=12345)","def _splitBucket(self, bucket):\n idx = self.buckets.index(bucket)\n self.buckets.pop(idx)\n middle = int(bucket.low + (bucket.high - bucket.low)/2)\n \n bucketLow = Bucket(bucket.low, middle, bucket.refreshed)\n bucketHigh = Bucket(middle+1, bucket.high, refreshed.refreshed)\n \n self.buckets.append(bucketLow)\n self.buckets.append(bucketHigh)\n \n for bucket in bucket.nodes:\n if bucketLow.inRange(bucket):\n bucketLow.addNode(bucket)\n else:\n bucketHigh.addNode(bucket)\n \n return (bucketLow, bucketHigh)","def split(root, Dk, maxDepth, minRows, currDepth):\n \n left, right = root['branches']\n del(root['branches'])\n \n# if not left and not right:\n# return\n \n # Check if the node is a leaf\n if not len(left): \n root['left'] = root['right'] = getLeafClass(right)\n return\n elif not len(right):\n root['left'] = root['right'] = getLeafClass(left)\n return\n \n # Check for max depth\n if(currDepth >= maxDepth):\n root['left'], root['right'] = getLeafClass(left), getLeafClass(right)\n return\n \n # Process left branch\n if(len(left) <= minRows):\n root['left'] = getLeafClass(left)\n else:\n root['left'] = findNextSplit(left, Dk)\n split(root['left'], Dk, maxDepth, minRows, currDepth + 1)\n \n # Process right branch\n if(len(right) <= minRows):\n root['right'] = getLeafClass(right)\n else:\n root['right'] = findNextSplit(right, Dk)\n split(root['right'], Dk, maxDepth, minRows, currDepth + 1)","def test_split_adds_parents(mock_amg):\n\n mock_amg.cells[0].split()\n assert mock_amg.cells[-4].parent is mock_amg.cells[0]\n assert mock_amg.cells[-3].parent is mock_amg.cells[0]\n assert mock_amg.cells[-2].parent is mock_amg.cells[0]\n assert mock_amg.cells[-1].parent is mock_amg.cells[0]","def partition(self, data, labels):\n\t\tfor i in range(self.splits):\n\t\t\tyield self.makePartition(len(labels))","def make_sidewalk_nodes(street, prev_node, curr_node, next_node):\n if prev_node is None:\n v = - curr_node.vector_to(next_node, normalize=False)\n vec_prev = curr_node.vector() + v\n prev_node = Node(None, vec_prev[0], vec_prev[1])\n elif next_node is None:\n v = - curr_node.vector_to(prev_node, normalize=False)\n vec_next = curr_node.vector() + v\n next_node = Node(None, vec_next[0], vec_next[1])\n\n curr_latlng = np.array(curr_node.location())\n\n v_cp_n = curr_node.vector_to(prev_node, normalize=True)\n v_cn_n = curr_node.vector_to(next_node, normalize=True)\n v_sidewalk = v_cp_n + v_cn_n\n\n if np.linalg.norm(v_sidewalk) < 1e-10:\n v_sidewalk_n = np.array([v_cn_n[1], - v_cn_n[0]])\n else:\n v_sidewalk_n = v_sidewalk / np.linalg.norm(v_sidewalk)\n\n p1 = curr_latlng + street.distance_to_sidewalk * v_sidewalk_n\n p2 = curr_latlng - street.distance_to_sidewalk * v_sidewalk_n\n\n p_sidewalk_1 = Node(None, p1[0], p1[1])\n p_sidewalk_2 = Node(None, p2[0], p2[1])\n\n curr_node.append_sidewalk_node(street.id, p_sidewalk_1)\n curr_node.append_sidewalk_node(street.id, p_sidewalk_2)\n\n # Figure out on which side you want to put each sidewalk node\n v_c1 = curr_node.vector_to(p_sidewalk_1)\n if np.cross(v_cn_n, v_c1) > 0:\n return p_sidewalk_1, p_sidewalk_2\n else:\n return p_sidewalk_2, p_sidewalk_1","def split(self, X):\n # Make sure it's a sparse array...\n X = check_sparse_array(X)\n\n # Use np.linspace to evenly partition the space between 0 and 1 into\n # k + 1 pieces so we can use them as \"training_sizes\"\n train_sizes = np.linspace(0, 1, self.n_splits + 1)\n\n # We use a series of \"permuted values\" to mask out the training/testing\n # folds.\n random_state = check_random_state(self.random_state)\n values = _get_train_mask_linspace(X.nnz, random_state,\n shuffle=self.shuffle)\n\n # Iterate the fold space bounds in a generator, returning train/test\n for lower, upper in zip(train_sizes[:-1], train_sizes[1:]):\n test, train = _split_between_values(X, values, lower, upper)\n yield train, test","def split():\n tmux_call(['split-window'])","def batch_split(self) -> np.array:\n pass","def split(self):\n new_level = self.level - 1\n if new_level < 0:\n return []\n new_radius = Asteroid.radii[new_level]\n num_to_create = self.radius // new_radius\n spawn_angle = random.randrange(\n Asteroid.split_angle_min, Asteroid.split_angle_max)\n base_vec = None\n if self.vel.xy != (0, 0):\n base_vec = vec2(self.vel).rotate(spawn_angle / 2)\n to_ret = []\n new_vel_mag = (len(Asteroid.radii) - new_level)*(self.radius * self.vel.magnitude()) / \\\n (num_to_create * new_radius)\n for i in range(num_to_create):\n spawn_vel = vec2(base_vec).rotate(-i*(spawn_angle //\n num_to_create)) if base_vec != None else vec2(0, 0)\n if spawn_vel.xy != (0, 0):\n spawn_vel.scale_to_length(new_vel_mag)\n new_rot_vel = (spawn_vel.magnitude_squared() /\n self.vel.magnitude_squared()) * self.rot_vel\n to_ret.append(\n Asteroid(self.surface, self.pos, spawn_vel, new_rot_vel, new_level))\n return to_ret","def split_next(self):\n # Consider the node with the highest loss reduction (a.k.a. gain)\n node = heappop(self.splittable_nodes)\n\n tic = time()\n (sample_indices_left,\n sample_indices_right,\n right_child_pos) = self.splitter.split_indices(node.split_info,\n node.sample_indices)\n self.total_apply_split_time += time() - tic\n\n depth = node.depth + 1\n n_leaf_nodes = len(self.finalized_leaves) + len(self.splittable_nodes)\n n_leaf_nodes += 2\n\n left_child_node = TreeNode(depth,\n sample_indices_left,\n node.split_info.sum_gradient_left,\n node.split_info.sum_hessian_left,\n parent=node)\n right_child_node = TreeNode(depth,\n sample_indices_right,\n node.split_info.sum_gradient_right,\n node.split_info.sum_hessian_right,\n parent=node)\n left_child_node.sibling = right_child_node\n right_child_node.sibling = left_child_node\n node.right_child = right_child_node\n node.left_child = left_child_node\n\n # set start and stop indices\n left_child_node.partition_start = node.partition_start\n left_child_node.partition_stop = node.partition_start + right_child_pos\n right_child_node.partition_start = left_child_node.partition_stop\n right_child_node.partition_stop = node.partition_stop\n\n self.n_nodes += 2\n\n if self.max_depth is not None and depth == self.max_depth:\n self._finalize_leaf(left_child_node)\n self._finalize_leaf(right_child_node)\n return left_child_node, right_child_node\n\n if (self.max_leaf_nodes is not None\n and n_leaf_nodes == self.max_leaf_nodes):\n self._finalize_leaf(left_child_node)\n self._finalize_leaf(right_child_node)\n self._finalize_splittable_nodes()\n return left_child_node, right_child_node\n\n if left_child_node.n_samples < self.min_samples_leaf * 2:\n self._finalize_leaf(left_child_node)\n if right_child_node.n_samples < self.min_samples_leaf * 2:\n self._finalize_leaf(right_child_node)\n\n # Compute histograms of childs, and compute their best possible split\n # (if needed)\n should_split_left = left_child_node.value is None # node isn't a leaf\n should_split_right = right_child_node.value is None\n if should_split_left or should_split_right:\n\n # We will compute the histograms of both nodes even if one of them\n # is a leaf, since computing the second histogram is very cheap\n # (using histogram subtraction).\n n_samples_left = left_child_node.sample_indices.shape[0]\n n_samples_right = right_child_node.sample_indices.shape[0]\n if n_samples_left < n_samples_right:\n smallest_child = left_child_node\n largest_child = right_child_node\n else:\n smallest_child = right_child_node\n largest_child = left_child_node\n\n # We use the brute O(n_samples) method on the child that has the\n # smallest number of samples, and the subtraction trick O(n_bins)\n # on the other one.\n tic = time()\n smallest_child.histograms = \\\n self.histogram_builder.compute_histograms_brute(\n smallest_child.sample_indices)\n largest_child.histograms = \\\n self.histogram_builder.compute_histograms_subtraction(\n node.histograms, smallest_child.histograms)\n self.total_compute_hist_time += time() - tic\n\n tic = time()\n if should_split_left:\n self._compute_best_split_and_push(left_child_node)\n if should_split_right:\n self._compute_best_split_and_push(right_child_node)\n self.total_find_split_time += time() - tic\n\n return left_child_node, right_child_node","def draw_split(self):\n\n gelem = Element(\"g\") # create a group\n level = self.sval\n if level == 'H':\n y = self.y-self.height\n elif level == 'Z':\n y = self.y - self.height/2.0\n else:\n y = self.y\n\n l0elem = Element(\"line\")\n l0elem.attrib['x1'] = str(self.x)\n l0elem.attrib['y1'] = str(y);\n l0elem.attrib['x2'] = str(self.x + 3.5 * self.period/8.0)\n l0elem.attrib['y2'] = str(y);\n l0elem.attrib['stroke'] = \"black\"\n\n gelem.append(l0elem)\n\n\n l1elem = Element(\"line\")\n l1elem.attrib['x1'] = str(self.x + 3.0* self.period/8.0)\n l1elem.attrib['y1'] = str(y + self.height/4.0);\n l1elem.attrib['x2'] = str(self.x + 4*self.period/8.0)\n l1elem.attrib['y2'] = str(y - self.height/4.0);\n l1elem.attrib['stroke'] = \"black\"\n\n gelem.append(l1elem)\n\n l2elem = Element(\"line\")\n l2elem.attrib['x1'] = str(self.x + 4.0* self.period/8.0)\n l2elem.attrib['y1'] = str(y + self.height/4.0);\n l2elem.attrib['x2'] = str(self.x + 5.0*self.period/8.0)\n l2elem.attrib['y2'] = str(y - self.height/4.0);\n l2elem.attrib['stroke'] = \"black\"\n\n gelem.append(l2elem)\n\n l3elem = Element(\"line\")\n l3elem.attrib['x1'] = str(self.x + 4.5*self.period/8.0)\n l3elem.attrib['y1'] = str(y);\n l3elem.attrib['x2'] = str(self.x + self.period)\n l3elem.attrib['y2'] = str(y);\n l3elem.attrib['stroke'] = \"black\"\n\n gelem.append(l3elem)\n\n\n self.x += self.period\n\n return gelem","def _split(self, c, n):\n\tsubsets = []\n\tstart = 0\n\tfor i in range(n):\n\t subset = c[start:start + (len(c) - start) / (n - i)]\n\t subsets.append(subset)\n\t start = start + len(subset)\n\treturn subsets","def split_heads(x, num_heads):\n sz = x.size()\n # x -> [batch_size, length, heads, depth / num_heads]\n x = x.view(sz[0], sz[1], num_heads, sz[2] // num_heads)\n # [batch_size, length, 1, depth // num_heads] * \n heads = torch.chunk(x, num_heads, 2)\n x = []\n for i in range(num_heads):\n x.append(torch.squeeze(heads[i], 2))\n return x","def split(self, count: int) -> 'List':\n split = List()\n\n for idx in reversed(range(1, count + 1)):\n split_idx = len(self) // idx\n split.append(List(self[:split_idx]))\n self = self[split_idx:]\n\n return split","def split_at(self, i):\n\n if i in self.forced:\n inconsistent_generation()\n\n assert not self.is_exhausted\n\n key = self.values[i]\n\n child = TreeNode(\n bit_lengths=self.bit_lengths[i + 1 :],\n values=self.values[i + 1 :],\n transition=self.transition,\n )\n self.transition = Branch(bit_length=self.bit_lengths[i], children={key: child})\n if self.__forced is not None:\n child.__forced = {j - i - 1 for j in self.__forced if j > i}\n self.__forced = {j for j in self.__forced if j < i}\n child.check_exhausted()\n del self.values[i:]\n del self.bit_lengths[i:]\n assert len(self.values) == len(self.bit_lengths) == i","def _create_slice(cls, onnx_node, inputs, opset_version):\n # we move several inputs to singa's attribuates\n # and mark them so we don't use them when we run this operator\n starts = tensor.to_numpy(inputs.pop(1)).astype(np.int32).tolist()\n ends = tensor.to_numpy(inputs.pop(1)).astype(np.int32).tolist()\n # sometime onnx may ignore these two inputs, axes and step\n if len(inputs) >= 2 and onnx_node.inputs[3] != '':\n axes = tensor.to_numpy(inputs.pop(1)).astype(np.int32).tolist()\n else:\n axes = None\n steps = tensor.to_numpy(inputs.pop(1)).astype(\n np.int32).tolist() if len(inputs) >= 2 else None\n onnx_node.consumed_inputs.extend(onnx_node.inputs[1:])\n _, forward = cls._common_onnx_node_to_singa_op(onnx_node, inputs,\n opset_version)\n return _, forward(starts, ends, axes, steps)","def split(linked_list):\n\n if linked_list is None or linked_list.head is None:\n left_half = linked_list\n right_half = None\n\n return left_half, right_half\n\n else:\n size = linked_list.size()\n midpoint = size // 2\n\n mid_node = linked_list.node_at_index(midpoint - 1)\n\n left_half = linked_list\n right_half = LinkedList()\n right_half.head = mid_node.next_node\n mid_node.next_node = None\n\n return left_half, right_half","def build_partition_tree(self):\n \n xmin = 0\n xmax = self.shape[0]\n ymin = 0\n ymax = self.shape[1]\n zmin = 0\n zmax = self.shape[2]\n total_xwidth = xmax - xmin\n total_ywidth = ymax - ymin\n total_zwidth = zmax - zmin\n q = queue.PriorityQueue()\n M = (xmax - xmin) * (ymax - ymin) * (zmax - zmin)\n self.partition_tree = np.zeros((M - 1, 2))\n q.put((0, xmin, xmax, ymin, ymax, zmin, zmax, -1, False))\n ind = len(self.partition_tree) - 1\n while not q.empty():\n _, xmin, xmax, ymin, ymax, zmin, zmax, parent_ind, is_left = q.get()\n \n if parent_ind >= 0:\n self.partition_tree[parent_ind, 0 if is_left else 1] = ind\n\n # make sure we line up with a flattened indexing scheme\n if ind < 0:\n assert -ind - 1 == xmin * total_ywidth * total_zwidth + ymin * total_zwidth + zmin\n\n xwidth = xmax - xmin\n ywidth = ymax - ymin\n zwidth = zmax - zmin\n if xwidth == 1 and ywidth == 1 and zwidth == 1:\n pass\n else:\n\n # by default our ranges remain unchanged\n lxmin = rxmin = xmin\n lxmax = rxmax = xmax\n lymin = rymin = ymin\n lymax = rymax = ymax\n lzmin = rzmin = zmin\n lzmax = rzmax = zmax\n\n # split the xaxis if it is the largest dimension\n if xwidth >= ywidth and xwidth > 1:\n xmid = xmin + xwidth // 2\n lxmax = xmid\n rxmin = xmid\n\n # split the yaxis\n elif ywidth > 1:\n ymid = ymin + ywidth // 2\n lymax = ymid\n rymin = ymid\n\n # split the zaxis only when the other ranges are already width 1\n else:\n zmid = zmin + zwidth // 2\n lzmax = zmid\n rzmin = zmid\n\n lsize = (lxmax - lxmin) * (lymax - lymin) * (lzmax - lzmin)\n rsize = (rxmax - rxmin) * (rymax - rymin) * (rzmax - rzmin)\n\n q.put((-lsize, lxmin, lxmax, lymin, lymax, lzmin, lzmax, ind, True))\n q.put((-rsize, rxmin, rxmax, rymin, rymax, rzmin, rzmax, ind, False))\n\n ind -= 1\n self.partition_tree += int(M)"],"string":"[\n \"def create_split(self) -> NoReturn:\\n raise NotImplementedError\",\n \"def _create_split(cls, op, op_t):\\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\\n\\n node.attribute.extend([\\n helper.make_attribute('axis', op.axis),\\n helper.make_attribute('split', op.parts),\\n ])\\n return node\",\n \"def _create_split(cls, onnx_node, inputs, opset_version):\\n axis = onnx_node.getattr(\\\"axis\\\", 0)\\n split = onnx_node.getattr(\\\"split\\\", None)\\n num_output = len(onnx_node.outputs)\\n _, forward = cls._common_onnx_node_to_singa_op(onnx_node, inputs,\\n opset_version)\\n return _, forward(axis, split, num_output)\",\n \"def __split_node(self, cur_node):\\n temp = self.Node(cur_node.data_list[len(cur_node.data_list) / 2:], cur_node.next_node)\\n cur_node.data_list = cur_node.data_list[:len(cur_node.data_list) / 2]\\n cur_node.next_node = temp\\n\\n if cur_node == self.tail:\\n self.tail = cur_node.next_node\",\n \"def split(self, node, width, height):\\r\\n node.used = True\\r\\n node.down = SquareAlgorithmNode(x=node.x,\\r\\n y=node.y + height,\\r\\n width=node.width,\\r\\n height=node.height - height)\\r\\n node.right = SquareAlgorithmNode(x=node.x + width,\\r\\n y=node.y,\\r\\n width=node.width - width,\\r\\n height=height)\\r\\n return node\",\n \"def convert_split(g, op, block):\\n\\n x = g.get_node(op.input(\\\"X\\\")[0])\\n axis = op.input(\\\"AxisTensor\\\")\\n if axis:\\n axis = g.get_node(axis[0])\\n axis, infered = try_infer_value(axis, g.get_params())\\n if infered:\\n axis = axis.tolist()[0]\\n else:\\n axis = op.attr(\\\"axis\\\")\\n\\n sections = op.input(\\\"SectionsTensorList\\\")\\n if sections:\\n tmp_section = []\\n for i in sections:\\n i = g.get_node(i)\\n i, infered = try_infer_value(i, g.get_params())\\n if infered:\\n i = i.tolist()\\n else:\\n raise ValueError(\\\"Dynamic Split not yet supported.\\\")\\n tmp_section.extend(i)\\n sections = tmp_section\\n else:\\n sections = op.attr(\\\"sections\\\")\\n if sections:\\n indices = []\\n split_index = 0\\n for i in sections[:-1]:\\n if i == -1:\\n input_shape = infer_shape(x)[axis]\\n i = input_shape - np.sum(sections) - 1\\n split_index += i\\n indices.append(split_index)\\n else:\\n indices = op.attr(\\\"num\\\")\\n\\n out = _op.split(x, indices, axis)\\n for i, out_i in enumerate(out):\\n g.add_node(op.output(\\\"Out\\\")[i], out_i)\",\n \"def split_network(self):\\n disconnect_nodes(self.nodes[1], 2)\\n disconnect_nodes(self.nodes[2], 1)\\n self.sync_all([self.nodes[:2], self.nodes[2:]])\",\n \"def split(x, y, t):\\n return (Shape(t, x.memory - y.memory, x.cores - y.cores, x.disk - y.disk),\\n NodeReservation(Shape(x.wallTime - t, x.memory, x.cores, x.disk)))\",\n \"def _split_forced(self, node):\\n # compute the split\\n _vec = 0\\n sorted_idxs = np.argsort(self.E[node.ids, _vec]).squeeze()\\n n = len(sorted_idxs) // 2\\n _lids = node.ids[sorted_idxs[:n]]\\n _rids = node.ids[sorted_idxs[n:]]\\n # compute the score of the new tubes only\\n _sl = self.get_tube_score(_lids)\\n _sr = self.get_tube_score(_rids)\\n # register the split\\n node.has_children = True\\n node.thresh = np.median(self.E[node.ids, _vec]) # arbitrary\\n # Note: median would not ensure equal size (because of duplicate values)\\n left = SpectralNode(_lids, _vec, score=_sl, name=node.name + \\\"0\\\")\\n right = SpectralNode(_rids, _vec, score=_sr, name=node.name + \\\"1\\\")\\n\\n return left, right\",\n \"def get_continuous_node(\\n self,\\n feature_col: int,\\n feature_value: float,\\n X: np.ndarray,\\n y: np.ndarray,\\n node: TreeSplits,\\n ):\\n node.update(\\n feature_col=feature_col,\\n feature_value=feature_value,\\n nodes={\\\"below\\\": TreeSplits(), \\\"above\\\": TreeSplits()},\\n node_type=\\\"continuous\\\",\\n )\\n # Get the above\\n above = X[:, feature_col] >= feature_value\\n # Get the next split for the above node\\n self.get_next_split(X=X[above], y=y[above], tree_split=node.nodes[\\\"above\\\"])\\n # Add one node to counter\\n self.n_nodes += 1\\n # Get the next split for the below node\\n self.get_next_split(\\n X=X[np.bitwise_not(above)],\\n y=y[np.bitwise_not(above)],\\n tree_split=node.nodes[\\\"below\\\"],\\n )\\n # Add one node to counter\\n self.n_nodes += 1\\n\\n return node\",\n \"def split_node(node, delimiter):\\n if(delimiter == ''):\\n sub_labels = [x for x in node.label]\\n else:\\n sub_labels = node.label.rsplit(delimiter)\\n sub_nodes = list()\\n for label in sub_labels:\\n sub_nodes.append(Node(label, 0))\\n if len(sub_nodes) > 0:\\n for child in node.children:\\n sub_nodes[0].children.extend(split_node(child, delimiter))\\n return sub_nodes\",\n \"def split(self):\\n left = BPlusNode(self.order)\\n right = BPlusNode(self.order)\\n mid = self.order // 2\\n\\n left.keys = self.keys[:mid]\\n left.values = self.values[:mid]\\n\\n right.keys = self.keys[mid:]\\n right.values = self.values[mid:]\\n\\n # When the node is split, set the parent key to the left-most key of the right child node.\\n self.keys = [right.keys[0]]\\n self.values = [left, right]\\n self.leaf = False\",\n \"def gen_split(shape,left=True):\\n # Create the splitting tensor\\n if left:\\n split_shape = (np.prod(shape),)+shape\\n else:\\n split_shape = shape+(np.prod(shape),)\\n split_ten = np.zeros(split_shape)\\n # Turn into correct identity\\n allinds = [range(i) for i in shape]\\n cnt = 0\\n for ind in itertools.product(*allinds):\\n if left:\\n tenind = (cnt,)+tuple(ind)\\n else:\\n tenind = tuple(ind)+(cnt,)\\n split_ten[tenind] = 1.\\n cnt += 1\\n # Return result\\n return split_ten\",\n \"def split(bn, node, Z=None):\\n # no estoy seguro si hace falta crear nuevas variables, pero mas\\n # vale prevenir que lamentar\\n for v in bn.V:\\n if v.name == node:\\n node = v\\n break\\n if Z is None:\\n Z = bn.G[node]\\n\\n V = [RandomVariable(var.name, var.Domain) for var in bn.V]\\n\\n # mapeo de variables viejas a las nuevas. Sirve mas adelante para\\n # crear la lista de arcos\\n old2new = dict(zip(bn.V, V))\\n\\n # crear el nuevo nodo y agregarlo a la lista de variables\\n newnode = RandomVariable(node.name + \\\"*\\\", node.Domain)\\n V.append(newnode)\\n\\n # crear la lista de arcos\\n E = []\\n for parent, children in bn.G.iteritems():\\n for child in children:\\n if parent == node and child in Z:\\n E.append((newnode, old2new[child]))\\n else:\\n E.append((old2new[parent], old2new[child]))\\n\\n # calcular los CPTs\\n\\n # para cada variable no afectada por el split + variable papa: copiar cpts\\n for v in bn.V:\\n if not (v in Z):\\n old2new[v].cpt = Factor([old2new[e] for e in v.cpt.domain()], v.cpt.getfunction())\\n\\n # para la variable creada por el split: cpt uniforme\\n newnode.cpt = Factor([newnode], [1.0/len(newnode.domain()) for e in newnode.domain()])\\n\\n # para cada variable hijo afectada por el split: cpt igual a anterior, pero\\n # con lista de papas cambiada\\n def cp(e):\\n if e == node:\\n return newnode\\n\\n return old2new[e]\\n\\n for v in Z:\\n old2new[v].cpt = Factor([cp(e) for e in v.cpt.domain()], v.cpt.getfunction())\\n \\n name = bn.name + \\\" splitted\\\"\\n beta = 1\\n return DBN(V,E,name,\\\"\\\"), newnode\",\n \"def split_node(node: saldag.OpNode):\\n\\n # Only dealing with single child case for now\\n assert (len(node.children) <= 1)\\n clone = copy.deepcopy(node)\\n clone.out_rel.rename(node.out_rel.name + \\\"_obl\\\")\\n clone.parents = set()\\n clone.children = set()\\n clone.is_mpc = True\\n child = next(iter(node.children), None)\\n saldag.insert_between(node, child, clone)\",\n \"def split(axis: int) -> SplitDistribute:\\n assert type(axis) is int\\n assert str(axis) in _axis_str2split_axis_obj, \\\"not a valid split. expected: [0, 11)\\\"\\n return _axis_str2split_axis_obj[str(axis)]\",\n \"def split_range(r, n):\\n \\n step = int(r / n)\\n segments = []\\n for i in range(n):\\n new_segment = [step * i, step * (i + 1)]\\n segments.append(new_segment)\\n # correct the gap in the missing index due to the truncated step\\n segments[-1][-1] = r\\n return segments\",\n \"def split(self):\\n if self.split_level <= 0:\\n self.doSplit = False\\n return []\\n else:\\n vel_polar = cart_to_polar(self.pos[1])\\n\\n ang1 = vel_polar[1] + math.pi / 4\\n ang2 = vel_polar[1] - math.pi / 4\\n\\n vel1 = polar_to_cart( [vel_polar[0] * 1.5, ang1] )\\n vel2 = polar_to_cart( [vel_polar[0] * 1.5, ang2] )\\n\\n offset1 = polar_to_cart( [self.radius, ang1] )\\n offset2 = polar_to_cart( [self.radius, ang2] )\\n\\n pos1 = self.pos[0] + offset1\\n pos2 = self.pos[0] + offset2\\n\\n return [ Asteroid([pos1, vel1], [self.ang[0] + 0.01, self.ang[1] * 1.5],\\n scale = self.scale / 1.4,\\n color_idx = self.color_idx,\\n doSplit = True,\\n split_level = self.split_level - 1\\n ),\\n Asteroid([pos2, vel2], [self.ang[0] - 0.01, -self.ang[1] * 1.5],\\n scale = self.scale / 1.4,\\n color_idx = self.color_idx,\\n doSplit = True,\\n split_level = self.split_level - 1\\n )\\n ]\",\n \"def split(self, user, number=2, piece='a', comment=None, force_refresh=True):\\n if comment is None:\\n comment = 'Split sample into {0} pieces'.format(number)\\n\\n process = Process.objects.create(title='Split Sample',\\n comment=comment,\\n user=user,\\n type_id='split-process')\\n nodes = []\\n\\n branch = self.get_piece(piece)\\n for i in range(number):\\n if i == 0:\\n new_piece = piece\\n else:\\n new_piece = self._get_next_piece()\\n # Note: Issue #248 in django-mptt causes the tree to not be properly\\n # updated when inserting objects if parent is set. Workaround\\n # is to set parent_id instead. This fixes methods such as\\n # MPTTModel.get_descendants(). Since you are referencing an\\n # object that has changed in the database (process_tree),\\n # the lft and rght items are not updated properly. Workarounds\\n # include manually updating the root node or requerying for\\n # the sample object which will force a refresh.\\n nodes.append(self._insert_node(process, new_piece, i + 1, branch))\\n if force_refresh: # workaround to force the root node to update\\n self.refresh_tree()\\n return nodes\",\n \"def split(self, X):\",\n \"def class_split(x):\\r\\n return np.split(x, [19,43])\",\n \"def split(self, x):\\r\\n if x >= self.n2.x or x <= self.n1.x: return [self]\\r\\n n_intermediate = Node.MiddleNode(x=x)\\r\\n bar1 = BeamElement(nodes=[self.n1, n_intermediate], section=self.section, material=self.material)\\r\\n bar2 = BeamElement(nodes=[n_intermediate, self.n2], section=self.section, material=self.material)\\r\\n return [bar1, bar2]\",\n \"def grow(self):\\n while self.splittable_nodes:\\n self.split_next()\",\n \"def split(self, node):\\n # check node was not already split\\n if node.has_children:\\n raise SplitError(\\\"BUG: node was already split\\\")\\n\\n # early stopping (only if enough nodes already)\\n if self.n_clusters >= self.min_leaves:\\n # make a leaf if too small to split\\n if node.size <= 2 * self.min_leaf_size:\\n return None, None\\n # special case: make a leaf if too deep already\\n if len(node.name) > self.max_depth:\\n # int(node.name, 2) is too big to be represented as a long (int64)\\n # if len(node.name > 62)\\n sys.stderr.write('# WARNING: early stopping too deep branch'\\n ' {}\\\\n'.format(node.name))\\n sys.stderr.flush()\\n return None, None\\n\\n # bi-partition the node's samples\\n if self.split_type == \\\"kmeans\\\":\\n left, right = self._split_kmeans(node)\\n else:\\n left, right = self._split_threshold(node)\\n\\n # check if we have two leaves or none\\n if (left is None and right is not None) or (left is not None and right is None):\\n raise SplitError(\\n \\\"BUG: both children should be simultaneously\\\"\\n \\\"either None or not\\\")\\n\\n # check the post-conditions\\n if left is None or right is None:\\n # node is a leaf\\n if node.has_children:\\n raise SplitError(\\\"BUG: leaf node marked with (empty) children\\\")\\n # check if it must have been split instead of being a leaf\\n if node.size > self.max_leaf_size:\\n # force the split\\n left, right = self._split_forced(node)\\n msg = 'WARNING: forced to split a must-split node that was'\\n msg += ' too big to be a leaf ({0} > max_leaf_size={1})\\\\n'\\n sys.stderr.write(msg.format(node.size, self.max_leaf_size))\\n if self.n_clusters < self.min_leaves:\\n # force the split\\n left, right = self._split_forced(node)\\n msg = 'WARNING: forced to split a must-split node that had'\\n msg += ' not enough clusters ({0} < min_leaves={1})\\\\n'\\n sys.stderr.write(msg.format(self.n_clusters, self.min_leaves))\\n\\n # finalize the split\\n if node.has_children:\\n # update the labels of right child only (left keeps the same)\\n self.labels[right.ids] = self.n_clusters\\n self.n_clusters += 1\\n\\n return left, right\",\n \"def create_nodes(self):\",\n \"def split_line(self, start, end, increment):\\n\\n # Determine the number of splits of the line\\n num_splits = int(np.linalg.norm(end - start)/increment)\\n return (\\n np.linspace(start[0], end[0], num_splits),\\n np.linspace(start[1], end[1], num_splits)\\n )\",\n \"def BCT_operators(self):\\n leaves_original = [node for node, degree in self.tree.out_degree().items() if degree == 0]\\n\\n def split(node):\\n # ##\\n # Return bin-tuple of the orphaned tree\\n #\\n # Parameter:\\n # node: string\\n #\\n # Return:\\n # (split_node_parent, node)\\n # ##\\n\\n # Trivialize the orphaned subtree and re-allocate the position to\\n # the child of the split_node_parent does not be cut.\\n split_node_parent = M.tree.predecessors(node)[0]\\n\\n if M.tree.predecessors(split_node_parent) != []:\\n split_node_parent_parent = M.tree.predecessors(split_node_parent)[0]\\n else:\\n split_node_parent_parent = None\\n M.tree.node[node]['position'] = 'trivial'\\n the_other_child = [n for n in M.tree.successors(split_node_parent) if n != node][0]\\n\\n # Shift the child to the position of its parent\\n M.tree.node[the_other_child]['position'] = M.tree.node[split_node_parent]['position']\\n M.tree.node[split_node_parent]['position'] = 'trivial'\\n\\n # Cutting the edge which is related to the parent of the split node\\n try:\\n cutting_edges_list = [(n1, n2) for n1, n2 in M.tree.edges() if\\n (n1 == split_node_parent or n2 == split_node_parent) and (n2 != node)]\\n\\n # Remove edeges\\n for i, j in cutting_edges_list:\\n M.tree.remove_edge(i, j)\\n\\n # Establish the edge on the new movement\\n if split_node_parent_parent:\\n i, j = [n1 for n1, n2 in cutting_edges_list if n1 == split_node_parent_parent][0], \\\\\\n [n2 for n1, n2 in cutting_edges_list if n2 == the_other_child][0]\\n\\n M.tree.add_edge(i, j)\\n\\n except Exception:\\n raise Exception(\\\"in the part of split() suc-function of BCT_operator() function\\\")\\n\\n return split_node_parent, node\\n\\n\\n def insertion(M, insert_node, split_node_parent, split_node, operator, split_node_position):\\n # ##\\n # Return a new binary construction tree\\n #\\n # Parameter:\\n # split_node_parent: string, the old operator\\n # split_node: string, the cut node, is used to reinsert to the binary construction tree\\n # operator: string, the new operator, typically two options (\\\"series\\\" and \\\"parallel\\\")\\n # split_node_position: string, the new position allocated to the cut node.\\n #\\n # Return:\\n # M: BinaryConstructionTree\\n # ##\\n\\n try:\\n # Relabel the arributes of relevant nodes.\\n mapping = {split_node_parent: operator}\\n M.tree = nx.relabel_nodes(M.tree, mapping)\\n M.tree.node[operator]['position'] = M.tree.node[insert_node]['position']\\n insert_node_parent = M.tree.predecessors(insert_node)[0]\\n\\n # Re-allocate the position to the relevant nodes.\\n if split_node_position == 'right' and split_node_position == M.tree.node[insert_node]['position']:\\n M.tree.node[insert_node]['position'] = 'left'\\n\\n elif split_node_position == 'left' and split_node_position == M.tree.node[insert_node]['position']:\\n M.tree.node[insert_node]['position'] = 'right'\\n M.tree.node[split_node]['position'] = split_node_position\\n\\n # print M.tree.edges()\\n # Remove the related edges of the current binary tree\\n M.tree.remove_edge(insert_node_parent, insert_node)\\n\\n # Add the new edges to binary tree\\n M.tree.add_edge(insert_node_parent, operator)\\n M.tree.add_edge(operator, insert_node)\\n\\n # Eliminate the redundant edge.\\n # for i, j in M.tree.edges():\\n\\n except Exception:\\n raise Exception('in tha part of insertion() sub-function of BCT_operator() function')\\n\\n return M\\n\\n # To preserve meta structure.\\n M_self = copy.deepcopy(self)\\n\\n # To traverse all possible isomorphic binary tree\\n for node in leaves_original:\\n\\n M = copy.deepcopy(M_self)\\n\\n # Do split operation\\n split_node_parent, split_node = split(node)\\n\\n # The children that are used to be inserted\\n leaves_insertion = leaves_original[:]\\n leaves_insertion.remove(split_node)\\n\\n # print leaves_insertion\\n # Do insertion operation\\n for insertnode in leaves_insertion:\\n\\n # Choose the operator (\\\"series\\\" and \\\"parallel\\\")\\n for operator in ['series', 'parallel']:\\n operator_id = len([n for n in M.tree.nodes() if n.__contains__(operator)])\\n operator_entity = operator + str(operator_id)\\n for position in ['left', 'right']:\\n M_split = copy.deepcopy(M)\\n M_split = insertion(M_split, insertnode, split_node_parent, split_node, operator_entity,\\n position)\\n\\n is_heteromorphism = 0\\n\\n identity_series_order = M_split.identity_isomorphic_order()\\n\\n for m in self.heteromorphism:\\n m_identity_series_order = m.identity_isomorphic_order()\\n # print \\\"m_identity:{}\\\".format(m_identity_series_order)\\n # print \\\"M_split:{}\\\".format(identity_series_order)\\n if identity_series_order != m_identity_series_order:\\n is_heteromorphism += 1\\n\\n if is_heteromorphism == len(self.heteromorphism):\\n self.heteromorphism.append(M_split)\\n # print M_split.series_partial_order_position_representation()\\n # print M_split.tree.nodes(data = True)\\n # print\\n\\n return\",\n \"def split_at_nodes(shp):\\n nodes = find_nodes(shp)\\n nodeIds = list(nodes)\\n nodeIds.sort()\\n nodeIds = dict([(node,i) for i,node in enumerate(nodeIds)])\\n \\n for road in shp:\\n vrts = road.vertices\\n midVrts = set(road.vertices[1:-1]) #we know end points are nodes\\n midNodes = midVrts.intersection(nodes) # find any nodes in the middle of the feature.\\n midIdx = [vrts.index(node) for node in midNodes] # Get their indices\\n midIdx.sort()\\n if midIdx:\\n #print vrts\\n starts = [0]+midIdx\\n stops = [x+1 for x in midIdx]+[None]\\n for start,stop in zip(starts,stops):\\n feat = pysal.cg.Chain(vrts[start:stop])\\n rec = (nodeIds[feat.vertices[0]],nodeIds[feat.vertices[-1]],False)\\n yield feat,rec\\n else:\\n rec = (nodeIds[road.vertices[0]],nodeIds[road.vertices[-1]],False)\\n yield road,rec\",\n \"def split_joint(pynode, split = 2, replace = True):\\n output = []\\n # make sure this is joint\\n if not isinstance(pynode, pm.nt.Joint):\\n return output\\n if len(pynode.getChildren(type = 'joint')) > 0 and split > 1:\\n # get first child\\n children = pynode.getChildren(type = 'joint')\\n if children:\\n children = children[0]\\n # get vector\\n vec_a = pynode.getTranslation(space = 'world')\\n vec_b = children.getTranslation(space = 'world')\\n\\n parent = pynode\\n if not replace:\\n parent = pm.createNode('joint')\\n transformation.align(parent, pynode)\\n output.append(parent)\\n\\n factor = (vec_b - vec_a) / split\\n for i in range(1, split):\\n jnt = pm.createNode('joint')\\n pos = factor * i + vec_a\\n\\n # set split joint translate\\n jnt.setTranslation(pos, space = 'world')\\n # set split joint rotation\\n transformation.align(jnt, pynode, mode = 'rotate')\\n\\n # set parent split joint\\n jnt.setParent(parent)\\n # clean transformation on joint\\n transformation.freeze_transform(jnt)\\n\\n # append newly created split joint to output\\n output.append(jnt)\\n # set new variable parent\\n parent = jnt\\n\\n if replace:\\n children.setParent(parent)\\n else:\\n jnt = pm.createNode('joint')\\n transformation.align(jnt, children)\\n jnt.setParent(parent)\\n output.append(jnt)\\n\\n return output\",\n \"def detect_splits(self):\\n logg.info(' abstracted graph will have {} nodes'.format(self.n_splits+1))\\n indices_all = np.arange(self.X.shape[0], dtype=int)\\n segs = [indices_all]\\n if False: # this is safe, but not compatible with on-the-fly computation\\n tips_all = np.array(np.unravel_index(np.argmax(self.Dchosen), self.Dchosen.shape))\\n else:\\n if self.iroot is not None:\\n tip_0 = np.argmax(self.Dchosen[self.iroot])\\n else:\\n tip_0 = np.argmax(self.Dchosen[0]) # just a random index, here fixed to \\\"0\\\"\\n tips_all = np.array([tip_0, np.argmax(self.Dchosen[tip_0])])\\n # we keep a list of the tips of each segment\\n segs_tips = [tips_all]\\n if self.clusters_precomputed_names:\\n self.segs_names_original = [', '.join(self.clusters_precomputed_names)]\\n segs_undecided = [True]\\n segs_adjacency = [[]]\\n segs_distances = np.zeros((1, 1))\\n segs_adjacency_nodes = [{}]\\n # logg.info(' do not consider groups with less than {} points for splitting'\\n # .format(self.min_group_size))\\n for ibranch in range(self.n_splits):\\n if self.clusters == 'unconstrained_segments':\\n iseg, new_tips = self.select_segment(segs, segs_tips, segs_undecided)\\n if iseg == -1:\\n logg.info('... partitioning converged')\\n break\\n logg.info('... branching {}:'.format(ibranch + 1),\\n 'split group', iseg)\\n segs_distances = self.do_split(segs, segs_tips,\\n segs_undecided,\\n segs_adjacency,\\n segs_distances,\\n iseg, new_tips)\\n else:\\n logg.msg(' split', ibranch + 1, v=4)\\n stop, segs_distances = self.do_split_constrained(segs, segs_tips,\\n segs_adjacency,\\n segs_adjacency_nodes,\\n segs_distances)\\n if stop: break\\n\\n # segments\\n self.segs = segs\\n self.segs_tips = segs_tips\\n self.segs_sizes = []\\n for iseg, seg in enumerate(self.segs): self.segs_sizes.append(len(seg))\\n\\n # the full, unscaled adjacency matrix\\n self.segs_adjacency_full_attachedness = 1/segs_distances\\n # if self.attachedness_measure == 'connectedness':\\n # norm = np.sqrt(np.multiply.outer(self.segs_sizes, self.segs_sizes))\\n # self.segs_adjacency_full_attachedness /= norm\\n self.segs_adjacency_full_confidence, self.segs_adjacency_tree_confidence \\\\\\n = self.compute_adjacency_confidence(\\n self.segs_adjacency_full_attachedness,\\n segs_adjacency,\\n self.tree_based_confidence)\\n np.fill_diagonal(self.segs_adjacency_full_attachedness, 0)\",\n \"def _split_heads(self, x: torch.Tensor) -> torch.Tensor:\\n depth = x.size(-1)\\n split_x = torch.reshape(x, (\\n x.size(0), x.size(1),\\n self._hparams.num_heads, depth // self._hparams.num_heads))\\n return split_x.permute((0, 2, 1, 3))\",\n \"def test_split_activities(self):\\n labels = np.ones(3000)\\n labels[range(150)] = 2\\n X = np.ones((3000,9))\\n splittedX, splitted_y = tutorial_pamap2.split_activities(labels,X,[0], borders=50)\\n assert splittedX[0].shape == (50, 9)\\n assert splittedX[1].shape == (2750, 9)\",\n \"def create_child_nodes(current_node: Node, goal: list, generated: set) -> list:\\n\\n children = []\\n locations = state_to_locations(current_node.state)\\n blank = locations[0]\\n\\n # Moving blank to the left\\n if blank[1] != 0:\\n new_locations = copy.deepcopy(locations)\\n new_locations[0] = (new_locations[0][0], new_locations[0][1] - 1)\\n # Modifies the location of the blank in the new list\\n \\\"\\\"\\\" Note that the index 0 represents the first column. So long as \\n the blank is not in the first column, it can be moved to the left.\\\"\\\"\\\"\\n neighbor = current_node.state[blank[0]][blank[1] - 1]\\n # Finds the number on the tile to the left of the blank\\n new_locations[neighbor] = (new_locations[neighbor][0], new_locations[neighbor][1] + 1)\\n # Modifies the location of the neighbor in the new list\\n new_path_history = copy.deepcopy(current_node.path_history)\\n new_path_history.append('L')\\n new_state = locations_to_state(new_locations)\\n # Constructs the new state by calling locations_to_state\\n new_node = Node(new_state, current_node, current_node.path_cost + 1,\\n heuristic_cal(new_state, goal), new_path_history)\\n if new_node not in generated:\\n children.append(new_node)\\n \\\"\\\"\\\" Append the child node to the list only if it's not a \\n repeated state.\\\"\\\"\\\"\\n\\n # Moving blank to the right\\n if blank[1] != 3:\\n new_locations = copy.deepcopy(locations)\\n new_locations[0] = (new_locations[0][0], new_locations[0][1] + 1)\\n \\\"\\\"\\\" Similar to the case above: so long as the blank is not in the fourth \\n column, it can be moved to the right.\\\"\\\"\\\"\\n neighbor = current_node.state[blank[0]][blank[1] + 1]\\n # Finds the number on the tile to the right of the blank\\n new_locations[neighbor] = (new_locations[neighbor][0], new_locations[neighbor][1] - 1)\\n new_path_history = copy.deepcopy(current_node.path_history)\\n new_path_history.append('R')\\n new_state = locations_to_state(new_locations)\\n new_node = Node(new_state, current_node, current_node.path_cost + 1,\\n heuristic_cal(new_state, goal), new_path_history)\\n if new_node not in generated:\\n children.append(new_node)\\n\\n # Moving blank up\\n if blank[0] != 0:\\n new_locations = copy.deepcopy(locations)\\n new_locations[0] = (new_locations[0][0] - 1, new_locations[0][1])\\n \\\"\\\"\\\" So long as the blank is not in the first row, it can be moved up.\\\"\\\"\\\"\\n neighbor = current_node.state[blank[0] - 1][blank[1]]\\n # Finds the number on the tile above the blank\\n new_locations[neighbor] = (new_locations[neighbor][0] + 1, new_locations[neighbor][1])\\n new_path_history = copy.deepcopy(current_node.path_history)\\n new_path_history.append('U')\\n new_state = locations_to_state(new_locations)\\n new_node = Node(new_state, current_node, current_node.path_cost + 1,\\n heuristic_cal(new_state, goal), new_path_history)\\n if new_node not in generated:\\n children.append(new_node)\\n\\n # Moving the blank down\\n if blank[0] != 3:\\n new_locations = copy.deepcopy(locations)\\n new_locations[0] = (new_locations[0][0] + 1, new_locations[0][1])\\n \\\"\\\"\\\" So long as the blank is not in the fourth row, it can be moved down.\\\"\\\"\\\"\\n neighbor = current_node.state[blank[0] + 1][blank[1]]\\n # Finds the number on the tile below the blank\\n new_locations[neighbor] = (new_locations[neighbor][0] - 1, new_locations[neighbor][1])\\n new_path_history = copy.deepcopy(current_node.path_history)\\n new_path_history.append('D')\\n new_state = locations_to_state(new_locations)\\n new_node = Node(new_state, current_node, current_node.path_cost + 1,\\n heuristic_cal(new_state, goal), new_path_history)\\n if new_node not in generated:\\n children.append(new_node)\\n\\n return children\",\n \"def split_window(num_x, num_y):\\n\\n viewPorts = np.zeros((num_x*num_y, 4))\\n counter = 0\\n for i in range(num_x):\\n for j in range(num_y):\\n viewPorts[num_x*j + i, :] = [i*(1.0/float(num_x)),\\n 1.0 - (j+1.0)*(1.0/float(num_y)),\\n (i+1.0)*1.0/float(num_x),\\n 1.0 - j*(1.0/float(num_y))\\n ] # [num_y*i + j,:] for vertical fill first\\n\\n return viewPorts\",\n \"def subpartition_bsp(self, min_width, min_height):\\n \\n def split_horizontal(p):\\n ul_x, ul_y = p.ul_pos\\n \\n split_pos = (random.choice(\\n list(range(ul_x + min_width, ul_x + p.width - min_width + 1))), ul_y)\\n \\n split_x, split_y = split_pos\\n \\n return([Partition(p.ul_pos, split_x-ul_x, p.height), \\n Partition(split_pos, ul_x + p.width - split_x, p.height)])\\n \\n def split_vertical(p):\\n ul_x, ul_y = p.ul_pos\\n \\n split_pos = (ul_x, random.choice(\\n list(range(ul_y + min_height, ul_y + p.height - min_height + 1))))\\n \\n split_x, split_y = split_pos\\n \\n return([Partition(p.ul_pos, p.width, split_y-ul_y), \\n Partition(split_pos, p.width, ul_y + p.height - split_y)])\\n \\n\\n \\n if self.width < min_width or self.height < min_height:\\n raise PartitionException(\\\"Partition too small!\\\")\\n \\n splith = (self.width > 2*min_width)\\n splitv = (self.height > 2*min_height)\\n \\n new_partitions = None\\n \\n if splith and splitv:\\n new_partitions = random.choice([\\n split_horizontal, split_vertical])(self)\\n \\n elif splith:\\n new_partitions = split_horizontal(self)\\n \\n elif splitv:\\n new_partitions = split_vertical(self)\\n \\n else:\\n return [self]\\n \\n return list(flatten([p.subpartition_bsp(min_width, min_height) \\n for p in new_partitions]))\",\n \"def insert_nodes(self):\\n neighbour_max_distance = 5\\n new_nodes = []\\n for node in self.nodes:\\n left_distance = node.get_distance(node.neighbour1)\\n right_distance = node.get_distance(node.neighbour2)\\n if left_distance > neighbour_max_distance:\\n # halfway\\n half_point = (\\n node.x + (node.neighbour1.x - node.x) / 2,\\n node.y + (node.neighbour1.y - node.y) / 2\\n )\\n new_node = Node(half_point)\\n node.neighbour1.connect(node.neighbour1.neighbour1, new_node)\\n new_node.connect(node.neighbour1, node)\\n node.connect(new_node, node.neighbour2)\\n new_nodes.append(new_node)\\n new_nodes.append(node)\\n\\n if right_distance > neighbour_max_distance:\\n # halfway\\n half_point = (\\n node.x + (node.neighbour2.x - node.x) / 2,\\n node.y + (node.neighbour2.y - node.y) / 2\\n )\\n new_node = Node(half_point)\\n node.neighbour2.connect(new_node, node.neighbour2.neighbour2)\\n new_node.connect(node, node.neighbour2)\\n node.connect(node.neighbour1, new_node)\\n new_nodes.append(new_node)\\n\\n return new_nodes\",\n \"def split(nvim, vertical=False, new_file=True):\\n cmds = Cmds([\\\"vsplit\\\" if vertical else \\\"split\\\"])\\n if new_file:\\n cmds.append(\\\"enew\\\")\\n cmds.run(nvim)\\n\\n return nvim.current.window\",\n \"def splitEdge(self, edge, index, link):\\n #print 'Splitting edge', edge\\n node = Node(len(self.nodes))\\n if link:\\n suffix_link = SuffixLink(node)\\n self.latest_node.addSuffixLink(suffix_link)\\n # copy out existing destination and bounds\\n old_dest = edge.getDestination()\\n old_bounds = edge.getSuffix()\\n old_start = old_bounds[0]\\n # Adjust edge finish point to n + index, connect new node\\n edge.setBound(stop = old_start + index)\\n edge.setDestination(node) \\n # Create new edge representing the remains of the old edge\\n offcut = Edge(self.target[old_start + index], old_start + index, \\n old_bounds[1], old_dest)\\n # Add the offcut edge as a child of the new node\\n node.addChild(offcut) \\n # Create new edge for the current pos\\n n = self.pos.getVal()\\n new_edge = Edge(self.target[n], n, self.pos)\\n node.addChild(new_edge)\\n self.nodes.append(node)\\n self.latest_node = node\\n # rule 1 - a split from the root node\\n if self.active_node == self.root:\\n # active length decrements\\n self.active_length -= 1\\n pos = self.pos.getVal()\\n # active edge changes\\n self.active_edge = self.target[pos - self.active_length]\\n # active node remains root\\n else:\\n if self.active_node.hasSuffixLink():\\n # Set the active node to the link destination\\n link = self.active_node.getSuffixLink()\\n self.active_node = link.getDestination()\\n else:\\n self.active_node = self.root # set active node to root\",\n \"def split(self, place_leaf_splitted):\\n raise NotImplementedError\",\n \"def bdev_split_create(client, base_bdev, split_count, split_size_mb=None):\\n params = {\\n 'base_bdev': base_bdev,\\n 'split_count': split_count,\\n }\\n if split_size_mb:\\n params['split_size_mb'] = split_size_mb\\n\\n return client.call('bdev_split_create', params)\",\n \"def splitPlace(self):\\r\\n \\r\\n \\r\\n \\r\\n nodeSortedIter = sorted(self.G.degree_iter(),key=itemgetter(1),reverse=True)\\r\\n \\r\\n placeCnt = 0\\r\\n \\r\\n for node in nodeSortedIter:\\r\\n if placeCnt<self.cells/2:\\r\\n self.sitesA.append(node[0])\\r\\n self.G.node[node[0]][\\\"part\\\"] = 'A'\\r\\n else:\\r\\n self.sitesB.append(node[0])\\r\\n self.G.node[node[0]][\\\"part\\\"] = 'B'\\r\\n placeCnt+=1\",\n \"def nextSplit(self):\\n pass\",\n \"def _create_slice(cls, op, op_t):\\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\\n for attr in ['starts', 'ends', 'axes', 'steps']:\\n node.input.append(op.name + \\\":\\\" + attr)\\n return node\",\n \"def split_data(basedir, data_split=0.80):\\n manip = data_manipulator(basedir)\\n manip.train_test_split(data_split=data_split)\",\n \"def create_nodes(coords):\\n nodes = []\\n for coord in coords:\\n nodes.append(Node(coord))\\n\\n for i, node1 in enumerate(nodes):\\n node0 = nodes[i - 1]\\n if i == len(nodes) - 1:\\n node2 = nodes[0]\\n else:\\n node2 = nodes[i + 1]\\n node1.connect(node0, node2)\\n return nodes\",\n \"def split_segments(old_seg_ends, B):\\n new_segment_ends = []\\n for q in range(0, B.size):\\n new_ends = list(np.linspace(old_seg_ends[q], old_seg_ends[q + 1], B[q] + 1))\\n new_segment_ends.extend(new_ends[:-1])\\n new_segment_ends.extend([1])\\n new_segment_ends = np.asarray(new_segment_ends)\\n return new_segment_ends\",\n \"def perform_node_split(self, node: RTreeNode[T], group1: List[RTreeEntry[T]], group2: List[RTreeEntry[T]])\\\\\\n -> RTreeNode[T]:\\n node.entries = group1\\n split_node = RTreeNode(self, node.is_leaf, parent=node.parent, entries=group2)\\n self._fix_children(node)\\n self._fix_children(split_node)\\n return split_node\",\n \"def prepare_initial_nodes(x_start, x_end, nodes_y):\\n nodes_x = [float(x_start + ((x_end - x_start) / (len(nodes_y) - 1)) * i) for i in range(0, len(nodes_y))]\\n nodes_y = [float(y) for y in nodes_y]\\n print(nodes_x)\\n print(nodes_y)\\n nodes = list(zip(nodes_x, nodes_y))\\n return nodes\",\n \"def train_test_data_split(node_features, labels, train_ratio=0.8):\\n num_graph = node_features.shape[0]\\n train_test_split = int(train_ratio*num_graph)\\n x_train = node_features[:train_test_split,:,:] \\n y_train = labels[:train_test_split,:,:] \\n x_test = node_features[train_test_split:,:,:] \\n y_test = labels[train_test_split:,:,:]\\n np.save(\\\"data/node_features_train.npy\\\", x_train)\\n np.save(\\\"data/node_features_test.npy\\\", x_test)\\n np.save(\\\"data/labels_train.npy\\\", y_train)\\n np.save(\\\"data/labels_test.npy\\\", y_test)\\n return x_train, x_test, y_train, y_test\",\n \"def split_edge(self,j,**node_args):\\n nA,nC=self.edges['nodes'][j]\\n assert np.all( self.edge_to_cells(j) < 0 )\\n\\n edge_data=rec_to_dict(self.edges[j].copy())\\n \\n self.delete_edge(j)\\n\\n # choose midpoint as default\\n loc_args=dict(x= 0.5*(self.nodes['x'][nA] + self.nodes['x'][nC]))\\n loc_args.update(node_args) # but args will overwrite\\n\\n nB=self.add_node(**loc_args)\\n edge_data['nodes'][1]=nB\\n self.add_edge(_index=j,**edge_data)\\n # this way we get the same cell marks, too.\\n # this helps in tracking marks like UNDEFINED vs. UNPAVED\\n edge_data['nodes']=[nB,nC]\\n jnew=self.add_edge(**edge_data)\\n return jnew,nB\",\n \"def createNodes(self, size):\\n\\t\\tnodeList = []\\n\\t\\tfor i in range(size) :\\n\\t\\t\\tnodeList.append(Node(str(i)))\\n\\t\\treturn nodeList\",\n \"def add_nodes(\\n self,\\n nodes,\\n subsections=None,\\n spacing=None,\\n is_first_new=True,\\n close=True,\\n is_polygon=False,\\n boundary_id=-1,\\n boundary_ids=None,\\n ):\\n nodes = np.asarray(nodes)\\n\\n # Get index of the first new connectivity info.\\n # Only used if `is_polygon` is true.\\n if self.connectivity_ is None:\\n new_connectivity_begin = 0\\n else:\\n new_connectivity_begin = self.connectivity_.shape[0]\\n\\n # In case of polygon, don't add any points on the edge\\n if is_polygon:\\n subsections = 1\\n spacing = None\\n if self.nodes is None:\\n ind_offset = 0\\n else:\\n ind_offset = self.nodes.shape[0]\\n\\n # Prepare boundary_ids\\n first_new = 0 if is_first_new else 1\\n closing = 0 if close else -1\\n num_new_connectivity = int(len(nodes) + first_new + closing)\\n\\n # Set boundary_ids\\n if boundary_ids is not None:\\n assert num_new_connectivity == len(boundary_ids),\\\\\\n \\\"Length of boundary_ids is inappropriate.\\\"\\n\\n boundary_ids = np.asarray(boundary_ids).astype(np.int32).flatten()\\n logging.debug(\\\"Segment - Applying specified boundary id to each \\\" +\\\\\\n \\\"new connectivity.\\\")\\n\\n else:\\n # Form boundary_ids using boundary_id\\n boundary_ids = np.repeat(\\n boundary_id, num_new_connectivity\\n ).astype(np.int32).flatten()\\n logging.debug(\\\"Segment - Applying same boundary id {bid} to all \\\" +\\\\\\n \\\"new connectivities.\\\".format(bid=boundary_id))\\n\\n # Carefully assgin the first boundary_id\\n # -1 here is just a dummy, since it won't be applied in that case\\n if is_first_new:\\n fbid = -1\\n\\n else:\\n fbid = boundary_ids[0]\\n boundary_ids = boundary_ids[1:]\\n\\n # Add first node\\n self.add_node(\\n node=nodes[0],\\n subsections=subsections,\\n spacing=spacing,\\n new_sequence=is_first_new,\\n boundary_id=fbid,\\n )\\n\\n # Add mid-nodes\\n # If `close=True`, len(boundary_ids) == len(nodes[1:-1]) + 2 (or +1)\\n # but `zip` will stop at whatever is shorter.\\n if len(nodes[1:-1]) != 0:\\n for n, b in zip(nodes[1:-1], boundary_ids):\\n self.add_node(\\n node=n,\\n subsections=subsections,\\n spacing=spacing,\\n boundary_id=b,\\n )\\n\\n # Carefully assgin the last two `boundary_id`s\\n if close:\\n lbid = boundary_ids[-2] \\n cbid = boundary_ids[-1]\\n\\n else:\\n lbid = boundary_ids[-1]\\n cbid = None\\n\\n # Add last node\\n self.add_node(\\n node=nodes[-1],\\n subsections=subsections,\\n spacing=spacing,\\n close_sequence=close,\\n boundary_id=lbid,\\n closing_boundary_id=cbid,\\n )\\n\\n logging.debug(\\\"Segment - Added {nn} nodes.\\\".format(nn=nodes.shape[0]))\\n logging.debug(\\\"Segment - First was new: {n}.\\\".format(n=is_first_new))\\n logging.debug(\\\"Segment - Closed the sequence: {c}.\\\".format(c=close))\\n\\n # In case of polygon, append freshly added nodes.\\n if is_polygon:\\n self.polygons_.append(\\n # self.connectivity_[new_connectivity_begin:,0].tolist()\\n (np.arange(nodes.shape[0]) + ind_offset).tolist()\\n )\\n logging.debug(\\n \\\"Segment - Polygon with {nv} vertices are added.\\\".format(\\n nv=len(self.polygons_[-1])\\n )\\n )\\n\\n # Set facet BC\\n self.add_boundary_id(\\n boundary_id=boundary_id,\\n num_boundary_id=1, # One polygon at a time\\n facet=True,\\n )\",\n \"def get_split(X: List, y: List) -> tp.Split:\\n\\n def my_train_test_split(my_X, my_y, split_size: float):\\n return train_test_split(my_X, my_y, test_size=split_size, random_state=0, stratify=my_y)\\n\\n X_train, X_dev, y_train, y_dev = my_train_test_split(X, y, split_size=0.20)\\n X_train, X_test, y_train, y_test = my_train_test_split(X_train, y_train, split_size=0.25)\\n\\n train = tp.Xy(X_train, y_train)\\n dev = tp.Xy(X_dev, y_dev)\\n test = tp.Xy(X_test, y_test)\\n return tp.Split(train, dev, test)\",\n \"def __init__(self, from_node, to_node, span=None):\\n self.from_node = from_node\\n self.to_node = to_node\\n self.span = span\\n self.dummyedges = []\",\n \"def draw_divider(self, context: DrawContext, node: Node) -> None:\\n target = str(id(node))\\n for _ in range(context.height(node)):\\n parent, target = target, f\\\":{target}\\\"\\n context.graph.add_node(DotNode(target, **self.hidden_node))\\n context.graph.add_edge(Edge(parent, target, style=\\\"invis\\\", weight=5))\",\n \"def _split_heads(x, num_heads):\\n\\tshape_lst = bert_utils.get_shape_list(x)\\n\\tdepth = shape_lst[-1]\\n\\tbatch = shape_lst[0]\\n\\tseq = shape_lst[1]\\n\\t# print(x.get_shape(), \\\"===splitheads===\\\")\\n\\tsplitted_x = tf.reshape(x, [tf.shape(x)[0], tf.shape(x)[1], \\\\\\n\\t\\tnum_heads, depth // num_heads])\\n\\treturn tf.transpose(splitted_x, [0, 2, 1, 3])\",\n \"def get_discrete_node(self, X, y, feature_col, feature_value, node):\\n # Get the unique values for the X poitns\\n unique_x_vals = self.discrete_value_maps[feature_col]\\n\\n # Create the node with an empty child for each x value\\n node.update(\\n feature_col=feature_col,\\n feature_value=feature_value,\\n nodes={xval: TreeSplits() for xval in unique_x_vals},\\n node_type=\\\"discrete\\\",\\n )\\n\\n # For each unique value in the feature column...\\n for x_col_value in unique_x_vals:\\n # Get the matching rows\\n matches = X[:, feature_col] == x_col_value\\n\\n # If no matches, put all points in a leaf node\\n if np.sum(matches) == 0:\\n node.nodes[x_col_value] = TreeSplits(\\n node_type=\\\"discrete\\\",\\n feature_col=feature_col,\\n feature_value=x_col_value,\\n children=y,\\n )\\n else:\\n # If there are matches, get the next split\\n self.get_next_split(\\n X=X[matches], y=y[matches], tree_split=node.nodes[x_col_value],\\n )\\n # Increment by one.\\n self.n_nodes += 1\\n\\n return node\",\n \"def chunk(self, shape, split) -> NotImplementedError:\\n raise NotImplementedError()\",\n \"def vsplit(nvim, new_file=True):\\n return split(nvim, True, new_file)\",\n \"def test_add_empty_nodes_with_label_when_splitting(self):\\n print \\\"----- test_add_empty_nodes_with_label_when_splitting -----\\\"\\n sel_axis = (lambda axis: axis)\\n \\n #create tree, first node splits in x direction\\n tree = kdtree.createNewTree([[0.5, 0.5]],axis = 0, sel_axis= sel_axis)\\n kdtree.visualize(tree)\\n \\n point_left = [0.4, 0.5]\\n tree.split2(point_left, axis = 0)\\n kdtree.visualize(tree)\\n \\n point1 = [0.3, 0.5]\\n found_node = tree.get_path_to_leaf(point1)[-1]\\n correct_node1 = 3\\n self.assertEqual(found_node.label, correct_node1, \\\"Not correct node found\\\")\\n \\n point_right = [0.6, 0.5]\\n tree.split2(point_right, axis = 1)\\n kdtree.visualize(tree)\\n \\n point2 = [0.6, 0.7]\\n found_node = tree.get_path_to_leaf(point2)[-1]\\n correct_node2 = 6\\n self.assertEqual(found_node.label, correct_node2, \\\"Not correct node found\\\")\\n \\n print \\\"----- end: test_add_empty_nodes_with_label_when_splitting -----\\\"\",\n \"def push_nodes_with_binary(self, b, step_ratio=0.1, niter=0):\\n lid = list(self._data[:, 0])\\n lpid = list(self._data[:, -2])\\n t_data = self._data.copy()\\n\\n children_idx = {\\n pid: [i for i, p in enumerate(lpid) if p == t_data[i, 0]] for pid in lpid\\n }\\n\\n for _ in range(niter):\\n for i in range(t_data.shape[0]):\\n pid, radius, (x, y, z) = (\\n int(t_data[i, -2]),\\n t_data[i, -3],\\n t_data[i, 2:5],\\n )\\n cidx = children_idx[pid]\\n if pid != i and pid in lid and len(cidx) <= 1:\\n px, py, pz = t_data[t_data[:, 0] == pid, 2:5][0]\\n vnorm = norm_vec(np.asarray([x - px, y - py, z - pz]))\\n\\n if len(cidx) == 1:\\n cx, cy, cz = t_data[cidx[0], 2:5]\\n vnorm = (\\n vnorm + norm_vec(np.asarray([cx - x, cy - y, cz - z]))\\n ) / 2\\n if all([v == 0 for v in vnorm]):\\n continue\\n\\n pt = np.asarray([x, y, z])\\n p_vectors = get_perpendicular_vectors(pt, vnorm)\\n p_distances = [\\n get_distance_to_boundary(pt, pvec, b) for pvec in p_vectors\\n ]\\n dx, dy, dz = np.sum(\\n [pv * pd for pv, pd in zip(p_vectors, p_distances)], 0\\n )\\n\\n # Constrain the displacement by the nodo radii\\n tx = x + dx * step_ratio\\n ty = y + dy * step_ratio\\n tz = z + dz * step_ratio\\n dist = (\\n (tx - self._data[i, 2]) ** 2\\n + (ty - self._data[i, 3]) ** 2\\n + (tz - self._data[i, 4]) ** 2\\n ) ** 0.5\\n if dist <= radius / 2:\\n t_data[i, 2] = tx\\n t_data[i, 3] = ty\\n t_data[i, 4] = tz\\n else:\\n pass\\n self._data = t_data\",\n \"def split_kbucket(self):\\n cur_range_size = self.range_max - self.range_min\\n half_point = self.range_min + cur_range_size // 2\\n\\n # Ensure no empty range is created.\\n assert self.range_min < half_point < self.range_max\\n\\n # Make the instantiation dependent on the actual class,\\n # for easy inheritance.\\n new_kbucket = self.__class__(half_point, self.range_max)\\n\\n # Halve the ID space of the split KBucket.\\n self.range_max = half_point\\n\\n # Split the contact list into two, according to the new ranges.\\n self._contacts, new_kbucket._contacts = util.partition(\\n self._contacts,\\n self.contact_in_range\\n )\\n\\n return new_kbucket\",\n \"def convert_slice_channel(node, **kwargs):\\n name, input_nodes, input_shapes, attrs = get_inputs(node, kwargs, with_shapes=True)\\n\\n num_outputs = int(attrs.get(\\\"num_outputs\\\"))\\n axis = int(attrs.get(\\\"axis\\\", 1))\\n squeeze_axis = int(attrs.get(\\\"squeeze_axis\\\", 0))\\n\\n if squeeze_axis == 1 and num_outputs == 1:\\n node = onnx.helper.make_node(\\n \\\"Squeeze\\\",\\n input_nodes,\\n [name],\\n axes=[axis],\\n name=name,\\n )\\n return [node]\\n elif squeeze_axis == 0 and num_outputs > 1:\\n in_shape = input_shapes[0]\\n split = in_shape[axis] // num_outputs\\n node = onnx.helper.make_node(\\n \\\"Split\\\",\\n input_nodes,\\n [name+'_output'+str(i) for i in range(num_outputs)],\\n axis=axis,\\n split=[split for _ in range(num_outputs)],\\n name=name,\\n )\\n return [node]\\n else:\\n raise NotImplementedError(\\\"SliceChannel operator with num_outputs>1 and\\\"\\n \\\"squeeze_axis true is not implemented.\\\")\",\n \"def discretizespace(self):\\n \\n # Grid\\n self.xgriddim = ( self.x0_n , self.x1_n )\\n \\n self.xd = [ None , None ]\\n self.xd[0] = np.linspace( self.DS.x_lb[0] , self.DS.x_ub[0] , self.x0_n )\\n self.xd[1] = np.linspace( self.DS.x_lb[1] , self.DS.x_ub[1] , self.x1_n )\\n \\n self.x_grid2node = np.zeros( ( self.x0_n , self.x1_n ) , dtype = int ) # grid of corresponding index\\n \\n # 1-D List of nodes\\n self.nodes_n = self.x0_n * self.x1_n\\n self.nodes_state = np.zeros(( self.nodes_n , self.DS.n ), dtype = float ) # Number of nodes x state dimensions\\n self.nodes_index = np.zeros(( self.nodes_n , self.DS.n ), dtype = int ) # Number of nodes x state dimensions\",\n \"def rect_splitter(split_depth, rect, start_dimension='vertical'):\\n\\n splitters = (rect_vertical_split, rect_horizontal_split)\\n if start_dimension == 'vertical':\\n pass\\n elif start_dimension == 'horizontal':\\n splitters = splitters[1], splitters[0]\\n else:\\n raise ValueError(\\\"Invalid `start_dimension`\\\")\\n\\n split_results = [rect.copy()]\\n\\n for i in range(split_depth):\\n new_split_results = []\\n for x in split_results:\\n new_split_results.extend(splitters[i % 2](x))\\n split_results = new_split_results\\n\\n return split_results\",\n \"def get_splits(ntot, nper):\\n beglist = numpy.arange(0,ntot,nper)\\n endlist = numpy.arange(0,ntot,nper) + nper - 1\\n\\n if (ntot % nper) != 0:\\n endlist[-1] = ntot-1\\n return beglist, endlist\",\n \"def pyramid_factory(motor, start, stop, step_size):\\n if stop < start:\\n start, stop = stop, start\\n last_group = None\\n last_pos = start\\n\\n def x_motion_per_step(dets, stream_name):\\n nonlocal last_group\\n nonlocal last_pos\\n nonlocal step_size\\n\\n if last_group is not None:\\n yield from bps.wait(last_group)\\n\\n yield from bps.trigger_and_read(dets, stream_name)\\n\\n last_group = short_uid()\\n\\n if not start < last_pos + step_size < stop:\\n step_size *= -1\\n last_pos += step_size\\n\\n yield from bps.abs_set(motor, last_pos, group=last_group)\\n\\n return x_motion_per_step\",\n \"def addSplit(self):\\n pass\",\n \"def greedy_split(arr, n, axis=0):\\n length = arr.shape[axis]\\n # compute the size of each of the first n-1 blocks\\n block_size = int(np.ceil(length / float(n)))\\n # the indices at which the splits will occur\\n ix = np.arange(block_size, length, block_size)\\n return np.array(np.split(arr, ix, axis))\",\n \"def train_test_split(self):\\n random.seed(self.args.seed)\\n nodes = [node for node in range(self.ncount)]\\n random.shuffle(nodes)\\n self.train_nodes = torch.LongTensor(nodes[0:self.args.training_size])\\n self.validation_nodes = torch.LongTensor(nodes[self.args.training_size:self.args.training_size+self.args.validation_size])\\n self.test_nodes = torch.LongTensor(nodes[self.args.training_size+self.args.validation_size:])\",\n \"def split(self,X,y=None):\\n all_idx = pd.Series(np.arange(X.shape[0])) \\n mbrg = int(X.shape[0]*self.embargo_pct)\\n test_starts=[(i[0],i[-1]+1) for i in np.array_split(all_idx.values,self.n_splits)]\\n for i, j in test_starts:\\n t0 = all_idx.index[i] # start of test set\\n test_indices = all_idx.values[i:j]\\n maxT1Idx = all_idx.index.searchsorted(all_idx[test_indices].max())\\n train_indices = all_idx.index.searchsorted(all_idx[all_idx<=t0].index)\\n if maxT1Idx < X.shape[0]: \\n train_indices=np.concatenate((train_indices,all_idx[maxT1Idx+mbrg:]))\\n yield train_indices,test_indices\",\n \"def set_split(self, split, force=True):\\n if(force or self.split != split):\\n c = (0, 1)[split]\\n self.debug_print('set split mode: %d' % c)\\n r = self.send_com(0x0f, [c])\\n if(r):\\n self.split = split\\n return r\",\n \"def geomspace(start, stop, num=50, include_endpoint=True, dtype=None, constant=False):\\n return Tensor(np.geomspace(start, stop, num, include_endpoint, dtype), constant=constant)\",\n \"def make_splits(self):\\n # produce fold/portion splits of the training indexes: these output indexes to the tr. indexes themselves\\n if self.folds is not None:\\n meta_trainval_idx = kfold_split(self.train_idx, self.folds, self.seed, self.labels, self.label_info)\\n elif self.portion is not None:\\n meta_trainval_idx = portion_split(self.train_idx, self.portion, self.seed, self.labels, self.label_info)\\n else:\\n meta_trainval_idx = [(np.arange(len(self.train_idx)), np.arange(0, dtype=np.int32))]\\n # \\\"dereference\\\" the metaindexes to point to the data themselves\\n self.trainval_idx = []\\n for (tidx, vidx) in meta_trainval_idx:\\n self.trainval_idx.append((self.train_idx[tidx], self.train_idx[vidx]))\",\n \"def partid2nids(self, partid):\\n # TODO do we need to cache it?\\n start = self._node_map[partid - 1] if partid > 0 else 0\\n end = self._node_map[partid]\\n return F.arange(start, end)\",\n \"def _setup_splits(self):\\n #ntot = self.reredux_conf['nperfile']\\n ntot = self.reredux_conf['Ngals']\\n npersplit = self.runconf['nper']\\n\\n self.beglist, self.endlist = get_splits(ntot, npersplit)\",\n \"def _create_train_val_split(\\n self, data_size, shuffle = False, seed = None\\n ):\\n val_size = int(np.round(data_size * self._val_fraction))\\n val_size = max(1, val_size) if self._val_fraction > 0 else 0\\n train_size = data_size - val_size\\n train_split = np.concatenate(\\n [np.ones([train_size], dtype=np.int32),\\n np.zeros([val_size], dtype=np.int32)])\\n if shuffle:\\n np.random.RandomState(seed).shuffle(train_split)\\n return train_split\",\n \"def discretizespace(self):\\n \\n # Grid\\n self.xgriddim = ( self.x0_n , self.x1_n , self.x2_n )\\n \\n self.xd = [ None , None , None ]\\n self.xd[0] = np.linspace( self.DS.x_lb[0] , self.DS.x_ub[0] , self.x0_n )\\n self.xd[1] = np.linspace( self.DS.x_lb[1] , self.DS.x_ub[1] , self.x1_n )\\n self.xd[2] = np.linspace( self.DS.x_lb[2] , self.DS.x_ub[2] , self.x2_n )\\n \\n self.x_grid2node = np.zeros( ( self.x0_n , self.x1_n , self.x2_n ) , dtype = int ) # grid of corresponding index\\n \\n # 1-D List of nodes\\n self.nodes_n = self.x0_n * self.x1_n * self.x2_n\\n self.nodes_state = np.zeros(( self.nodes_n , self.DS.n ), dtype = float ) # Number of nodes x state dimensions\\n self.nodes_index = np.zeros(( self.nodes_n , self.DS.n ), dtype = int ) # Number of nodes x state dimensions\",\n \"def make_splits(input_pkl, test_split=0.1, val_split=0.1):\\n if (test_split > 1) or (val_split > 1) or (test_split + val_split > 1) or (test_split <= 0) or (val_split <= 0):\\n logging.warning('Check the input for make splits, quitting')\\n exit()\\n\\n main_dict = load_pickle(input_pkl)\\n data, labels = main_dict['data'], main_dict['labels']\\n idx_arr = np.random.choice(len(data), len(data))\\n data, labels = data[idx_arr], labels[idx_arr]\\n print(len(data[0][-1]))\\n # Find the split sizes\\n val_split = int(len(data) * val_split)\\n test_split = val_split + int(len(data) * test_split)\\n\\n # Make and save the splits\\n save_pickle({'data': data[:val_split], 'labels': labels[:val_split]}, 'data/val.pkl')\\n save_pickle({'data': data[val_split:test_split], 'labels': labels[val_split:test_split]}, 'data/test.pkl')\\n save_pickle({'data': data[test_split:], 'labels': labels[test_split:]}, 'data/train.pkl')\",\n \"def test_split_cell_splits_neighbours(mock_amg):\\n\\n # split the centre cell in the mock grid\\n # this will create 4 more cells at tier 1\\n mock_amg.cells[4].split()\\n\\n # now split the bottom right of these cells\\n # this should force the east and south cells to also be split\\n mock_amg.cells[4].children['br'].split()\\n\\n assert mock_amg.cells[5].has_children\\n assert mock_amg.cells[1].has_children\",\n \"def train(self, x, y, feature_search=None,\\n max_depth=8, min_samples_split=2, min_samples_leaf=1):\\n if self._depth < max_depth and x.shape[0] > min_samples_split:\\n\\n # Retrieve best split coordinates based on gini impurity\\n # and two groups\\n self._feature_idx, self._split_value, group_1, group_2 = \\\\\\n split_search(x, y, min_samples_leaf, feature_search)\\n\\n if self._feature_idx is not np.NaN:\\n # Recursively split and train child nodes\\n self._left_child = Node(self._depth + 1)\\n self._right_child = Node(self._depth + 1)\\n self._left_child.train(*group_1, feature_search, max_depth,\\n min_samples_split,\\n min_samples_leaf)\\n self._right_child.train(*group_2, feature_search, max_depth,\\n min_samples_split,\\n min_samples_leaf)\\n else:\\n # Impossible to split. Convert to leaf node\\n # This will occur when observations are\\n # identical in a given node\\n self._sprout(y)\\n else:\\n # End condition met. Convert to leaf node\\n self._sprout(y)\",\n \"def split(self):\\n\\n ratio_c = 1 - self.ratio\\n self.train, self.test = self.df.randomSplit([self.ratio, ratio_c], seed=12345)\",\n \"def _splitBucket(self, bucket):\\n idx = self.buckets.index(bucket)\\n self.buckets.pop(idx)\\n middle = int(bucket.low + (bucket.high - bucket.low)/2)\\n \\n bucketLow = Bucket(bucket.low, middle, bucket.refreshed)\\n bucketHigh = Bucket(middle+1, bucket.high, refreshed.refreshed)\\n \\n self.buckets.append(bucketLow)\\n self.buckets.append(bucketHigh)\\n \\n for bucket in bucket.nodes:\\n if bucketLow.inRange(bucket):\\n bucketLow.addNode(bucket)\\n else:\\n bucketHigh.addNode(bucket)\\n \\n return (bucketLow, bucketHigh)\",\n \"def split(root, Dk, maxDepth, minRows, currDepth):\\n \\n left, right = root['branches']\\n del(root['branches'])\\n \\n# if not left and not right:\\n# return\\n \\n # Check if the node is a leaf\\n if not len(left): \\n root['left'] = root['right'] = getLeafClass(right)\\n return\\n elif not len(right):\\n root['left'] = root['right'] = getLeafClass(left)\\n return\\n \\n # Check for max depth\\n if(currDepth >= maxDepth):\\n root['left'], root['right'] = getLeafClass(left), getLeafClass(right)\\n return\\n \\n # Process left branch\\n if(len(left) <= minRows):\\n root['left'] = getLeafClass(left)\\n else:\\n root['left'] = findNextSplit(left, Dk)\\n split(root['left'], Dk, maxDepth, minRows, currDepth + 1)\\n \\n # Process right branch\\n if(len(right) <= minRows):\\n root['right'] = getLeafClass(right)\\n else:\\n root['right'] = findNextSplit(right, Dk)\\n split(root['right'], Dk, maxDepth, minRows, currDepth + 1)\",\n \"def test_split_adds_parents(mock_amg):\\n\\n mock_amg.cells[0].split()\\n assert mock_amg.cells[-4].parent is mock_amg.cells[0]\\n assert mock_amg.cells[-3].parent is mock_amg.cells[0]\\n assert mock_amg.cells[-2].parent is mock_amg.cells[0]\\n assert mock_amg.cells[-1].parent is mock_amg.cells[0]\",\n \"def partition(self, data, labels):\\n\\t\\tfor i in range(self.splits):\\n\\t\\t\\tyield self.makePartition(len(labels))\",\n \"def make_sidewalk_nodes(street, prev_node, curr_node, next_node):\\n if prev_node is None:\\n v = - curr_node.vector_to(next_node, normalize=False)\\n vec_prev = curr_node.vector() + v\\n prev_node = Node(None, vec_prev[0], vec_prev[1])\\n elif next_node is None:\\n v = - curr_node.vector_to(prev_node, normalize=False)\\n vec_next = curr_node.vector() + v\\n next_node = Node(None, vec_next[0], vec_next[1])\\n\\n curr_latlng = np.array(curr_node.location())\\n\\n v_cp_n = curr_node.vector_to(prev_node, normalize=True)\\n v_cn_n = curr_node.vector_to(next_node, normalize=True)\\n v_sidewalk = v_cp_n + v_cn_n\\n\\n if np.linalg.norm(v_sidewalk) < 1e-10:\\n v_sidewalk_n = np.array([v_cn_n[1], - v_cn_n[0]])\\n else:\\n v_sidewalk_n = v_sidewalk / np.linalg.norm(v_sidewalk)\\n\\n p1 = curr_latlng + street.distance_to_sidewalk * v_sidewalk_n\\n p2 = curr_latlng - street.distance_to_sidewalk * v_sidewalk_n\\n\\n p_sidewalk_1 = Node(None, p1[0], p1[1])\\n p_sidewalk_2 = Node(None, p2[0], p2[1])\\n\\n curr_node.append_sidewalk_node(street.id, p_sidewalk_1)\\n curr_node.append_sidewalk_node(street.id, p_sidewalk_2)\\n\\n # Figure out on which side you want to put each sidewalk node\\n v_c1 = curr_node.vector_to(p_sidewalk_1)\\n if np.cross(v_cn_n, v_c1) > 0:\\n return p_sidewalk_1, p_sidewalk_2\\n else:\\n return p_sidewalk_2, p_sidewalk_1\",\n \"def split(self, X):\\n # Make sure it's a sparse array...\\n X = check_sparse_array(X)\\n\\n # Use np.linspace to evenly partition the space between 0 and 1 into\\n # k + 1 pieces so we can use them as \\\"training_sizes\\\"\\n train_sizes = np.linspace(0, 1, self.n_splits + 1)\\n\\n # We use a series of \\\"permuted values\\\" to mask out the training/testing\\n # folds.\\n random_state = check_random_state(self.random_state)\\n values = _get_train_mask_linspace(X.nnz, random_state,\\n shuffle=self.shuffle)\\n\\n # Iterate the fold space bounds in a generator, returning train/test\\n for lower, upper in zip(train_sizes[:-1], train_sizes[1:]):\\n test, train = _split_between_values(X, values, lower, upper)\\n yield train, test\",\n \"def split():\\n tmux_call(['split-window'])\",\n \"def batch_split(self) -> np.array:\\n pass\",\n \"def split(self):\\n new_level = self.level - 1\\n if new_level < 0:\\n return []\\n new_radius = Asteroid.radii[new_level]\\n num_to_create = self.radius // new_radius\\n spawn_angle = random.randrange(\\n Asteroid.split_angle_min, Asteroid.split_angle_max)\\n base_vec = None\\n if self.vel.xy != (0, 0):\\n base_vec = vec2(self.vel).rotate(spawn_angle / 2)\\n to_ret = []\\n new_vel_mag = (len(Asteroid.radii) - new_level)*(self.radius * self.vel.magnitude()) / \\\\\\n (num_to_create * new_radius)\\n for i in range(num_to_create):\\n spawn_vel = vec2(base_vec).rotate(-i*(spawn_angle //\\n num_to_create)) if base_vec != None else vec2(0, 0)\\n if spawn_vel.xy != (0, 0):\\n spawn_vel.scale_to_length(new_vel_mag)\\n new_rot_vel = (spawn_vel.magnitude_squared() /\\n self.vel.magnitude_squared()) * self.rot_vel\\n to_ret.append(\\n Asteroid(self.surface, self.pos, spawn_vel, new_rot_vel, new_level))\\n return to_ret\",\n \"def split_next(self):\\n # Consider the node with the highest loss reduction (a.k.a. gain)\\n node = heappop(self.splittable_nodes)\\n\\n tic = time()\\n (sample_indices_left,\\n sample_indices_right,\\n right_child_pos) = self.splitter.split_indices(node.split_info,\\n node.sample_indices)\\n self.total_apply_split_time += time() - tic\\n\\n depth = node.depth + 1\\n n_leaf_nodes = len(self.finalized_leaves) + len(self.splittable_nodes)\\n n_leaf_nodes += 2\\n\\n left_child_node = TreeNode(depth,\\n sample_indices_left,\\n node.split_info.sum_gradient_left,\\n node.split_info.sum_hessian_left,\\n parent=node)\\n right_child_node = TreeNode(depth,\\n sample_indices_right,\\n node.split_info.sum_gradient_right,\\n node.split_info.sum_hessian_right,\\n parent=node)\\n left_child_node.sibling = right_child_node\\n right_child_node.sibling = left_child_node\\n node.right_child = right_child_node\\n node.left_child = left_child_node\\n\\n # set start and stop indices\\n left_child_node.partition_start = node.partition_start\\n left_child_node.partition_stop = node.partition_start + right_child_pos\\n right_child_node.partition_start = left_child_node.partition_stop\\n right_child_node.partition_stop = node.partition_stop\\n\\n self.n_nodes += 2\\n\\n if self.max_depth is not None and depth == self.max_depth:\\n self._finalize_leaf(left_child_node)\\n self._finalize_leaf(right_child_node)\\n return left_child_node, right_child_node\\n\\n if (self.max_leaf_nodes is not None\\n and n_leaf_nodes == self.max_leaf_nodes):\\n self._finalize_leaf(left_child_node)\\n self._finalize_leaf(right_child_node)\\n self._finalize_splittable_nodes()\\n return left_child_node, right_child_node\\n\\n if left_child_node.n_samples < self.min_samples_leaf * 2:\\n self._finalize_leaf(left_child_node)\\n if right_child_node.n_samples < self.min_samples_leaf * 2:\\n self._finalize_leaf(right_child_node)\\n\\n # Compute histograms of childs, and compute their best possible split\\n # (if needed)\\n should_split_left = left_child_node.value is None # node isn't a leaf\\n should_split_right = right_child_node.value is None\\n if should_split_left or should_split_right:\\n\\n # We will compute the histograms of both nodes even if one of them\\n # is a leaf, since computing the second histogram is very cheap\\n # (using histogram subtraction).\\n n_samples_left = left_child_node.sample_indices.shape[0]\\n n_samples_right = right_child_node.sample_indices.shape[0]\\n if n_samples_left < n_samples_right:\\n smallest_child = left_child_node\\n largest_child = right_child_node\\n else:\\n smallest_child = right_child_node\\n largest_child = left_child_node\\n\\n # We use the brute O(n_samples) method on the child that has the\\n # smallest number of samples, and the subtraction trick O(n_bins)\\n # on the other one.\\n tic = time()\\n smallest_child.histograms = \\\\\\n self.histogram_builder.compute_histograms_brute(\\n smallest_child.sample_indices)\\n largest_child.histograms = \\\\\\n self.histogram_builder.compute_histograms_subtraction(\\n node.histograms, smallest_child.histograms)\\n self.total_compute_hist_time += time() - tic\\n\\n tic = time()\\n if should_split_left:\\n self._compute_best_split_and_push(left_child_node)\\n if should_split_right:\\n self._compute_best_split_and_push(right_child_node)\\n self.total_find_split_time += time() - tic\\n\\n return left_child_node, right_child_node\",\n \"def draw_split(self):\\n\\n gelem = Element(\\\"g\\\") # create a group\\n level = self.sval\\n if level == 'H':\\n y = self.y-self.height\\n elif level == 'Z':\\n y = self.y - self.height/2.0\\n else:\\n y = self.y\\n\\n l0elem = Element(\\\"line\\\")\\n l0elem.attrib['x1'] = str(self.x)\\n l0elem.attrib['y1'] = str(y);\\n l0elem.attrib['x2'] = str(self.x + 3.5 * self.period/8.0)\\n l0elem.attrib['y2'] = str(y);\\n l0elem.attrib['stroke'] = \\\"black\\\"\\n\\n gelem.append(l0elem)\\n\\n\\n l1elem = Element(\\\"line\\\")\\n l1elem.attrib['x1'] = str(self.x + 3.0* self.period/8.0)\\n l1elem.attrib['y1'] = str(y + self.height/4.0);\\n l1elem.attrib['x2'] = str(self.x + 4*self.period/8.0)\\n l1elem.attrib['y2'] = str(y - self.height/4.0);\\n l1elem.attrib['stroke'] = \\\"black\\\"\\n\\n gelem.append(l1elem)\\n\\n l2elem = Element(\\\"line\\\")\\n l2elem.attrib['x1'] = str(self.x + 4.0* self.period/8.0)\\n l2elem.attrib['y1'] = str(y + self.height/4.0);\\n l2elem.attrib['x2'] = str(self.x + 5.0*self.period/8.0)\\n l2elem.attrib['y2'] = str(y - self.height/4.0);\\n l2elem.attrib['stroke'] = \\\"black\\\"\\n\\n gelem.append(l2elem)\\n\\n l3elem = Element(\\\"line\\\")\\n l3elem.attrib['x1'] = str(self.x + 4.5*self.period/8.0)\\n l3elem.attrib['y1'] = str(y);\\n l3elem.attrib['x2'] = str(self.x + self.period)\\n l3elem.attrib['y2'] = str(y);\\n l3elem.attrib['stroke'] = \\\"black\\\"\\n\\n gelem.append(l3elem)\\n\\n\\n self.x += self.period\\n\\n return gelem\",\n \"def _split(self, c, n):\\n\\tsubsets = []\\n\\tstart = 0\\n\\tfor i in range(n):\\n\\t subset = c[start:start + (len(c) - start) / (n - i)]\\n\\t subsets.append(subset)\\n\\t start = start + len(subset)\\n\\treturn subsets\",\n \"def split_heads(x, num_heads):\\n sz = x.size()\\n # x -> [batch_size, length, heads, depth / num_heads]\\n x = x.view(sz[0], sz[1], num_heads, sz[2] // num_heads)\\n # [batch_size, length, 1, depth // num_heads] * \\n heads = torch.chunk(x, num_heads, 2)\\n x = []\\n for i in range(num_heads):\\n x.append(torch.squeeze(heads[i], 2))\\n return x\",\n \"def split(self, count: int) -> 'List':\\n split = List()\\n\\n for idx in reversed(range(1, count + 1)):\\n split_idx = len(self) // idx\\n split.append(List(self[:split_idx]))\\n self = self[split_idx:]\\n\\n return split\",\n \"def split_at(self, i):\\n\\n if i in self.forced:\\n inconsistent_generation()\\n\\n assert not self.is_exhausted\\n\\n key = self.values[i]\\n\\n child = TreeNode(\\n bit_lengths=self.bit_lengths[i + 1 :],\\n values=self.values[i + 1 :],\\n transition=self.transition,\\n )\\n self.transition = Branch(bit_length=self.bit_lengths[i], children={key: child})\\n if self.__forced is not None:\\n child.__forced = {j - i - 1 for j in self.__forced if j > i}\\n self.__forced = {j for j in self.__forced if j < i}\\n child.check_exhausted()\\n del self.values[i:]\\n del self.bit_lengths[i:]\\n assert len(self.values) == len(self.bit_lengths) == i\",\n \"def _create_slice(cls, onnx_node, inputs, opset_version):\\n # we move several inputs to singa's attribuates\\n # and mark them so we don't use them when we run this operator\\n starts = tensor.to_numpy(inputs.pop(1)).astype(np.int32).tolist()\\n ends = tensor.to_numpy(inputs.pop(1)).astype(np.int32).tolist()\\n # sometime onnx may ignore these two inputs, axes and step\\n if len(inputs) >= 2 and onnx_node.inputs[3] != '':\\n axes = tensor.to_numpy(inputs.pop(1)).astype(np.int32).tolist()\\n else:\\n axes = None\\n steps = tensor.to_numpy(inputs.pop(1)).astype(\\n np.int32).tolist() if len(inputs) >= 2 else None\\n onnx_node.consumed_inputs.extend(onnx_node.inputs[1:])\\n _, forward = cls._common_onnx_node_to_singa_op(onnx_node, inputs,\\n opset_version)\\n return _, forward(starts, ends, axes, steps)\",\n \"def split(linked_list):\\n\\n if linked_list is None or linked_list.head is None:\\n left_half = linked_list\\n right_half = None\\n\\n return left_half, right_half\\n\\n else:\\n size = linked_list.size()\\n midpoint = size // 2\\n\\n mid_node = linked_list.node_at_index(midpoint - 1)\\n\\n left_half = linked_list\\n right_half = LinkedList()\\n right_half.head = mid_node.next_node\\n mid_node.next_node = None\\n\\n return left_half, right_half\",\n \"def build_partition_tree(self):\\n \\n xmin = 0\\n xmax = self.shape[0]\\n ymin = 0\\n ymax = self.shape[1]\\n zmin = 0\\n zmax = self.shape[2]\\n total_xwidth = xmax - xmin\\n total_ywidth = ymax - ymin\\n total_zwidth = zmax - zmin\\n q = queue.PriorityQueue()\\n M = (xmax - xmin) * (ymax - ymin) * (zmax - zmin)\\n self.partition_tree = np.zeros((M - 1, 2))\\n q.put((0, xmin, xmax, ymin, ymax, zmin, zmax, -1, False))\\n ind = len(self.partition_tree) - 1\\n while not q.empty():\\n _, xmin, xmax, ymin, ymax, zmin, zmax, parent_ind, is_left = q.get()\\n \\n if parent_ind >= 0:\\n self.partition_tree[parent_ind, 0 if is_left else 1] = ind\\n\\n # make sure we line up with a flattened indexing scheme\\n if ind < 0:\\n assert -ind - 1 == xmin * total_ywidth * total_zwidth + ymin * total_zwidth + zmin\\n\\n xwidth = xmax - xmin\\n ywidth = ymax - ymin\\n zwidth = zmax - zmin\\n if xwidth == 1 and ywidth == 1 and zwidth == 1:\\n pass\\n else:\\n\\n # by default our ranges remain unchanged\\n lxmin = rxmin = xmin\\n lxmax = rxmax = xmax\\n lymin = rymin = ymin\\n lymax = rymax = ymax\\n lzmin = rzmin = zmin\\n lzmax = rzmax = zmax\\n\\n # split the xaxis if it is the largest dimension\\n if xwidth >= ywidth and xwidth > 1:\\n xmid = xmin + xwidth // 2\\n lxmax = xmid\\n rxmin = xmid\\n\\n # split the yaxis\\n elif ywidth > 1:\\n ymid = ymin + ywidth // 2\\n lymax = ymid\\n rymin = ymid\\n\\n # split the zaxis only when the other ranges are already width 1\\n else:\\n zmid = zmin + zwidth // 2\\n lzmax = zmid\\n rzmin = zmid\\n\\n lsize = (lxmax - lxmin) * (lymax - lymin) * (lzmax - lzmin)\\n rsize = (rxmax - rxmin) * (rymax - rymin) * (rzmax - rzmin)\\n\\n q.put((-lsize, lxmin, lxmax, lymin, lymax, lzmin, lzmax, ind, True))\\n q.put((-rsize, rxmin, rxmax, rymin, rymax, rzmin, rzmax, ind, False))\\n\\n ind -= 1\\n self.partition_tree += int(M)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66962695","0.65341157","0.64728427","0.62156624","0.6158806","0.60809195","0.5970829","0.5816579","0.57917887","0.5685064","0.5624523","0.5579703","0.5562783","0.55390286","0.55183446","0.5501418","0.5480847","0.5439089","0.54173994","0.540672","0.5402454","0.53887504","0.5384382","0.53816533","0.5358954","0.5327074","0.52963096","0.529089","0.5283437","0.5259554","0.5252088","0.5229898","0.5226238","0.52087396","0.5206203","0.5185626","0.5168692","0.5161963","0.51533175","0.5151756","0.5150349","0.5149972","0.5130312","0.5104938","0.51029086","0.5094817","0.50667983","0.50583166","0.50535053","0.5025868","0.50245583","0.501039","0.5007687","0.50029796","0.49969667","0.49907604","0.4982211","0.49780893","0.49767798","0.4961279","0.49593133","0.4956398","0.49538282","0.49402422","0.49363136","0.49313137","0.49251527","0.49183494","0.49148405","0.49119642","0.49105096","0.49089152","0.49068886","0.4895915","0.4881436","0.48796102","0.4872864","0.4866173","0.48659143","0.4859084","0.48577666","0.4856995","0.48553416","0.48546955","0.48546338","0.48374462","0.48365855","0.48249426","0.4823804","0.4822033","0.4821012","0.48203385","0.48174366","0.4808648","0.48044255","0.47980365","0.47923723","0.4786618","0.4780019","0.47720686"],"string":"[\n \"0.66962695\",\n \"0.65341157\",\n \"0.64728427\",\n \"0.62156624\",\n \"0.6158806\",\n \"0.60809195\",\n \"0.5970829\",\n \"0.5816579\",\n \"0.57917887\",\n \"0.5685064\",\n \"0.5624523\",\n \"0.5579703\",\n \"0.5562783\",\n \"0.55390286\",\n \"0.55183446\",\n \"0.5501418\",\n \"0.5480847\",\n \"0.5439089\",\n \"0.54173994\",\n \"0.540672\",\n \"0.5402454\",\n \"0.53887504\",\n \"0.5384382\",\n \"0.53816533\",\n \"0.5358954\",\n \"0.5327074\",\n \"0.52963096\",\n \"0.529089\",\n \"0.5283437\",\n \"0.5259554\",\n \"0.5252088\",\n \"0.5229898\",\n \"0.5226238\",\n \"0.52087396\",\n \"0.5206203\",\n \"0.5185626\",\n \"0.5168692\",\n \"0.5161963\",\n \"0.51533175\",\n \"0.5151756\",\n \"0.5150349\",\n \"0.5149972\",\n \"0.5130312\",\n \"0.5104938\",\n \"0.51029086\",\n \"0.5094817\",\n \"0.50667983\",\n \"0.50583166\",\n \"0.50535053\",\n \"0.5025868\",\n \"0.50245583\",\n \"0.501039\",\n \"0.5007687\",\n \"0.50029796\",\n \"0.49969667\",\n \"0.49907604\",\n \"0.4982211\",\n \"0.49780893\",\n \"0.49767798\",\n \"0.4961279\",\n \"0.49593133\",\n \"0.4956398\",\n \"0.49538282\",\n \"0.49402422\",\n \"0.49363136\",\n \"0.49313137\",\n \"0.49251527\",\n \"0.49183494\",\n \"0.49148405\",\n \"0.49119642\",\n \"0.49105096\",\n \"0.49089152\",\n \"0.49068886\",\n \"0.4895915\",\n \"0.4881436\",\n \"0.48796102\",\n \"0.4872864\",\n \"0.4866173\",\n \"0.48659143\",\n \"0.4859084\",\n \"0.48577666\",\n \"0.4856995\",\n \"0.48553416\",\n \"0.48546955\",\n \"0.48546338\",\n \"0.48374462\",\n \"0.48365855\",\n \"0.48249426\",\n \"0.4823804\",\n \"0.4822033\",\n \"0.4821012\",\n \"0.48203385\",\n \"0.48174366\",\n \"0.4808648\",\n \"0.48044255\",\n \"0.47980365\",\n \"0.47923723\",\n \"0.4786618\",\n \"0.4780019\",\n \"0.47720686\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5380758"},"document_rank":{"kind":"string","value":"24"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":785,"numItemsPerPage":100,"numTotalItems":95772,"offset":78500,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjMzMzI2OSwianRpIjoiODRkYjBmNzgtZjkyMy00N2RiLTkxZTAtYmM4ZTgxNDZjNmUxIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYzMzY4NjksImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.Jk6Bgu1UYU4Rnn1sc5xAmZLAo18LwQKOk-SbfyfBmpPIYJGu86W27wJusuQkMbvUEyrhiY13eVjiJXMuwNC_Aw","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 |
|---|---|---|---|---|---|---|
Return a number of bins for this dataset using the FreedmanDiaconis rule. | def binning(data, low, high):
if len(data) == 0: return 1
mask1 = (data >= low)
mask2 = (data < high)
mask3 = numpy.logical_and(mask1, mask2)
data = data[mask3]
if len(data) == 0: return 10
data.sort()
q1 = data[int(math.floor(0.25*len(data)))]
q3 = data[int(math.floor(0.75*len(da... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def freedman_diaconis_bins(self, arr):\n # From https://stats.stackexchange.com/questions/798/\n if len(arr) < 2:\n return 1\n # Calculate the iqr ranges.\n self.iqr(arr)\n # Calculate the h\n h = 2 * (self.q3 - self.q1) / (len(arr) ** (1 / 3))\n # fall b... | [
"0.69271",
"0.6696379",
"0.6671535",
"0.6590386",
"0.6581825",
"0.65656954",
"0.6553514",
"0.6543408",
"0.6536041",
"0.6536041",
"0.65276605",
"0.6514374",
"0.6472568",
"0.6446772",
"0.64086914",
"0.6390756",
"0.6386423",
"0.6348384",
"0.6332559",
"0.6332559",
"0.6318721",
... | 0.0 | -1 |
Quickly obtain a number of seconds from the current time or a given time. | def timesec(year=None, month=None, day=None, hour=None, min=None, sec=None):
seconds, subsecs = divmod(time.time(), 1)
now = time.gmtime(int(seconds))
if year is None: year = now.tm_year
if month is None: month = now.tm_mon
if day is None: day = now.tm_mday
if hour is None: hour = now.tm_hour
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def SECOND(time):\n\n return _make_datetime(time).second",
"def currentTimeSecs():\n return time.time()",
"def _current_time_seconds(self):\n return int(round(time.time()))",
"def get_time_ms():\n return int(round(time.time() * 1000))",
"def current_time_seconds(self):\n return int(rou... | [
"0.737952",
"0.7302293",
"0.72305924",
"0.72084624",
"0.7106146",
"0.70204425",
"0.6925001",
"0.6913195",
"0.6887243",
"0.67612076",
"0.6753471",
"0.67462283",
"0.6736127",
"0.6720788",
"0.6720726",
"0.67097896",
"0.6701813",
"0.6694461",
"0.6694461",
"0.6694461",
"0.6694461"... | 0.5976235 | 85 |
Convert a time string or many time strings into a number(s) of seconds. | def fromtimestring(timestrings, format, subseconds=False, t0=0.):
if isinstance(t0, (numbers.Number, numpy.number)) or format is None:
t0 = float(t0)
else:
if subseconds:
pytimestring, subsecs = t0.split(".")
subsecs = float("0." + subsecs)
else:
pyti... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def str2seconds(strtime):\n\n result = 0\n\n for i in re.split(r\"([0-9]+[a-z]+)\", strtime):\n\n stri = i.strip().lower() # Case insensitive\n if not stri:\n continue\n\n digits = \"\".join([i for i in stri if i.isdigit()])\n\n if len(stri) == len(digits): # Without ... | [
"0.790042",
"0.77960193",
"0.7617983",
"0.75185776",
"0.7437581",
"0.7420613",
"0.735528",
"0.731489",
"0.72933215",
"0.72796965",
"0.72436625",
"0.7190395",
"0.71774894",
"0.7173548",
"0.7173548",
"0.71201843",
"0.7105515",
"0.7100587",
"0.70640224",
"0.70492315",
"0.7029429... | 0.0 | -1 |
Convert a number of seconds or a list of numbers into time string(s). | def totimestring(timenumbers, format, subseconds=False, t0=0.):
if isinstance(t0, (numbers.Number, numpy.number)):
t0 = float(t0)
else:
if subseconds:
pytimestring, subsecs = t0.split(".")
subsecs = float("0." + subsecs)
else:
pytimestring, subsecs = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def time_str(num):\n if num > 3600:\n return \"%0.2f hrs\" % (num / 3600)\n elif num > 60:\n return \"%0.2f mins\" % (num / 60)\n else:\n return \"%d seconds\" % num",
"def format_seconds(num_seconds: Union[int, float]) -> str:\n # todo: maybe negative numbers should be in bracke... | [
"0.7215992",
"0.6938643",
"0.6798597",
"0.6684981",
"0.65917695",
"0.6566157",
"0.65319616",
"0.6497229",
"0.64805907",
"0.6471903",
"0.6455611",
"0.6445046",
"0.6428167",
"0.63516116",
"0.6350956",
"0.6350658",
"0.63335466",
"0.6327067",
"0.6322626",
"0.63068676",
"0.6297793... | 0.65031767 | 7 |
Set x tickmarks to temporally meaningful values. | def timeticks(major, minor, format="%Y-%m-%d %H:%M:%S", subseconds=False, t0=0., start=None):
if start is None: start = t0
if isinstance(start, basestring): start = fromtimestring(start, format, subseconds, t0)
def timeticks(low, high):
newstart = math.ceil((low - start)/major) * major + start
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_integer_xticks(self, set_ticks = False):\n self._x_integer_ticks = True",
"def py_apply_ticks(self, plot):\n if self.x_ticks is not None:\n plot.set_xticks(self.x_ticks)\n if self.x_labels is not None:\n plot.set_xticklabels(self.x_labels)\n if self.y_tic... | [
"0.7056864",
"0.6957497",
"0.6462958",
"0.61831015",
"0.6142413",
"0.60997754",
"0.6065084",
"0.6055155",
"0.60530174",
"0.597969",
"0.5962037",
"0.59546316",
"0.5927258",
"0.5920369",
"0.5879339",
"0.58592063",
"0.5858137",
"0.5835507",
"0.5826103",
"0.58144534",
"0.5717638"... | 0.0 | -1 |
This function includes all of the measurements and variables for the bricks | def __init__(self, width, height, color, main_surface):
self.main_surface = main_surface
self.width = width
self.height = height
self.color = color | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getBarySamples(self):\n self.XC1Fields = np.zeros([self.nSample, self.nCell_cfd])\n self.XC2Fields = np.zeros([self.nSample, self.nCell_cfd])\n self.c1Fields = np.zeros([self.nSample, self.nCell_cfd])\n self.c2Fields = np.zeros([self.nSample, self.nCell_cfd])\n self.c3Fields ... | [
"0.59622735",
"0.5801456",
"0.5714045",
"0.56901675",
"0.567993",
"0.5640426",
"0.5636425",
"0.56289315",
"0.55658686",
"0.5565351",
"0.55215836",
"0.55199933",
"0.54793805",
"0.54666305",
"0.54627633",
"0.5459547",
"0.54510325",
"0.5426512",
"0.5420701",
"0.542021",
"0.54160... | 0.0 | -1 |
This function draws the bricks | def draw_brick(self, x, y):
pygame.draw.rect(self.main_surface, self.color, (x, y, self.width, self.height), 0)
pygame.display.update() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def drawBricks(self, view):\n for a in self._bricks:\n a.draw(view)",
"def newBricks(self, view):\n self.__init__()\n for i in range(BRICK_ROWS):\n self._bricks.extend(create_brick_row(i))\n for brick in self._bricks:\n brick.draw(view)\n self.d... | [
"0.7610794",
"0.70125526",
"0.6783159",
"0.6544072",
"0.6480906",
"0.6443306",
"0.63650465",
"0.6316012",
"0.6291486",
"0.62352437",
"0.62313396",
"0.62061805",
"0.6197166",
"0.61571187",
"0.6140718",
"0.61333686",
"0.6110781",
"0.60986227",
"0.6045685",
"0.5935241",
"0.59336... | 0.6807062 | 2 |
Load the ui file for the applet drawer, which we own. | def initAppletDrawerUic(self):
with Tracer(traceLogger):
# Load the ui file (find it in our own directory)
localDir = os.path.split(__file__)[0]+'/'
# (We don't pass self here because we keep the drawer ui in a separate object.)
self.drawer = uic.loadUi(localDir+"... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_gui():\r\n\r\n print(\"\\nLoading graphical user interface...\\n\")\r\n SongStorageGUI().mainloop()",
"def loadUI(self,factory={'GLOB':Glob,'BOOK':Book,'SCPT':Scpt,'CELL':Cell}):\n FileRep.loadUI(self,factory)",
"def loadForm(self):\n\n formUI = os.path.join(sys.path[0], 'views/acq... | [
"0.63236564",
"0.60985297",
"0.6043393",
"0.6038417",
"0.5976114",
"0.5816129",
"0.57881004",
"0.5724756",
"0.57222754",
"0.5704641",
"0.5683649",
"0.5668115",
"0.56456685",
"0.56370246",
"0.5625678",
"0.5599373",
"0.5575998",
"0.55754936",
"0.5525895",
"0.5523762",
"0.551148... | 0.7867472 | 0 |
Load the GUI from the ui file into this class and connect it with event handlers. | def initCentralUic(self):
self.initFileTableWidget()
self.initViewerStack()
self.splitter.setSizes([150, 850]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_gui():\r\n\r\n print(\"\\nLoading graphical user interface...\\n\")\r\n SongStorageGUI().mainloop()",
"def InitUI(self):\n\t\tself._initMenuBar()\n\t\tself._initLayout()\n\t\t\n\t\t# Bindings\n\t\tself.Bind(wx.EVT_BUTTON, self.OnButtonClicked)\n\t\t\n\t\t# We can't even start without an input file... | [
"0.74387133",
"0.73665154",
"0.7134974",
"0.7073232",
"0.70021194",
"0.6954133",
"0.6943297",
"0.6935844",
"0.69270736",
"0.691732",
"0.68945724",
"0.68652666",
"0.68619984",
"0.6795575",
"0.67894846",
"0.6788402",
"0.6769412",
"0.6755813",
"0.6755813",
"0.67467767",
"0.66974... | 0.0 | -1 |
The user clicked the "Add File" button. Ask him to choose a file (or several) and add them to both the GUI table and the toplevel operator inputs. | def handleAddFileButtonClicked(self):
# Find the directory of the most recently opened image file
mostRecentImageFile = PreferencesManager().get( 'DataSelection', 'recent image' )
if mostRecentImageFile is not None:
defaultDirectory = os.path.split(mostRecentImageFile)[0]
els... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_file_input(\n self,\n name: str,\n label: Optional[str] = None,\n source: Optional[str] = None,\n file_type: Optional[str] = None,\n multiple: bool = False,\n ) -> None:\n\n def on_pick_result(event: FilePickerResultEvent):\n if event.files:\n ... | [
"0.64918983",
"0.6431509",
"0.6418309",
"0.6305412",
"0.61918384",
"0.61420715",
"0.610769",
"0.60797346",
"0.6059743",
"0.6056999",
"0.60375744",
"0.59630734",
"0.5940347",
"0.5890774",
"0.5878446",
"0.5872943",
"0.5860542",
"0.58562905",
"0.5852387",
"0.5851146",
"0.5833489... | 0.69240236 | 0 |
The user clicked the "Import Stack Directory" button. | def handleAddStackButtonClicked(self):
# Find the directory of the most recently opened image file
mostRecentStackDirectory = PreferencesManager().get( 'DataSelection', 'recent stack directory' )
if mostRecentStackDirectory is not None:
defaultDirectory = os.path.split(mostRecentStac... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handleAddStackFilesButtonClicked(self):\n # Find the directory of the most recently opened image file\n mostRecentStackImageFile = PreferencesManager().get( 'DataSelection', 'recent stack image' )\n if mostRecentStackImageFile is not None:\n defaultDirectory = os.path.split(most... | [
"0.63807386",
"0.60662997",
"0.596505",
"0.59516096",
"0.59324336",
"0.5866149",
"0.5780327",
"0.5672773",
"0.5672773",
"0.5672773",
"0.5588122",
"0.55458176",
"0.5526395",
"0.5451664",
"0.53536344",
"0.5325478",
"0.53163785",
"0.52934563",
"0.5268285",
"0.52584463",
"0.51927... | 0.7046417 | 0 |
The user clicked the "Import Stack Files" button. | def handleAddStackFilesButtonClicked(self):
# Find the directory of the most recently opened image file
mostRecentStackImageFile = PreferencesManager().get( 'DataSelection', 'recent stack image' )
if mostRecentStackImageFile is not None:
defaultDirectory = os.path.split(mostRecentSta... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handleAddStackButtonClicked(self):\n # Find the directory of the most recently opened image file\n mostRecentStackDirectory = PreferencesManager().get( 'DataSelection', 'recent stack directory' )\n if mostRecentStackDirectory is not None:\n defaultDirectory = os.path.split(mostR... | [
"0.7401952",
"0.60361826",
"0.5968294",
"0.5963187",
"0.5903095",
"0.5903095",
"0.5903095",
"0.5888331",
"0.58152413",
"0.57804424",
"0.5680004",
"0.56641406",
"0.5612863",
"0.55243236",
"0.54665464",
"0.5428981",
"0.54050756",
"0.53769785",
"0.5372776",
"0.53452855",
"0.5321... | 0.7355732 | 1 |
Launch an "Open File" dialog to ask the user for one or more image files. | def getImageFileNamesToOpen(self, defaultDirectory):
extensions = OpDataSelection.SupportedExtensions
filt = "Image files (" + ' '.join('*.' + x for x in extensions) + ')'
options = QFileDialog.Options()
if ilastik_config.getboolean("ilastik", "debug"):
options |= QFileDialo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def selectFile(title=\"Select image\", initialdir=None, multiple=False):\r\n file = filedialog.askopenfilename(\r\n initialdir=initialdir,\r\n multiple=multiple,\r\n title=title\r\n )\r\n return file",
"def open_files():\n import Tkinter\n import tkFileDial... | [
"0.71490604",
"0.7085282",
"0.70119643",
"0.69890976",
"0.69593513",
"0.6935807",
"0.6925271",
"0.68205",
"0.6623227",
"0.6606702",
"0.65966076",
"0.65714514",
"0.65665215",
"0.6526502",
"0.6515496",
"0.6498538",
"0.6467295",
"0.6463145",
"0.64520234",
"0.6436567",
"0.6420097... | 0.6250779 | 28 |
The word 'glob' is used loosely here. See the OpStackLoader operator for details. | def importStackFromGlobString(self, globString):
globString = globString.replace("\\","/")
info = DatasetInfo()
info.filePath = globString
# Allow labels by default if this gui isn't being used for batch data.
info.allowLabels = ( self.guiMode == GuiMode.Normal )
def im... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def locGlob(): \n #glob = \"From Internal Local Name Space\" # Toggle Comment\n print(glob)\n\n return",
"def test_glob_pattern(self):\n glob_pattern = GlobPattern()\n det_name = 'R22_S11'\n self.assertEqual(glob_pattern('fe55', det_name),\n 'fe55_fe55_*/*_{}... | [
"0.6904358",
"0.62507033",
"0.6115817",
"0.6093213",
"0.5870921",
"0.585917",
"0.5644251",
"0.5596094",
"0.55333716",
"0.5516278",
"0.5372138",
"0.5367748",
"0.53069293",
"0.5204023",
"0.519716",
"0.5191702",
"0.50825864",
"0.50751287",
"0.5039543",
"0.5035867",
"0.5022817",
... | 0.52720916 | 13 |
Add the given filenames to both the GUI table and the toplevel operator inputs. | def addFileNames(self, fileNames):
with Tracer(traceLogger):
infos = []
oldNumFiles = len(self.topLevelOperator.Dataset)
# HACK: If the filePath isn't valid, replace it
# This is to work around the scenario where two independent data selection applets are coupled... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_files(self):\n file_paths = tkinter.filedialog.askopenfilenames(parent=self)\n\n if not file_paths:\n return\n for file_path in file_paths:\n self.files_treeview.insert(\"\", \"end\", values=(file_path,))\n self.files_treeview.selection_set(self.files_treev... | [
"0.6075016",
"0.6000558",
"0.596491",
"0.58751535",
"0.5829462",
"0.57028913",
"0.5648508",
"0.56384313",
"0.56383616",
"0.5623524",
"0.5554015",
"0.55150545",
"0.54891205",
"0.5437899",
"0.53998584",
"0.53493977",
"0.5336115",
"0.5292974",
"0.5270632",
"0.525856",
"0.524532"... | 0.6710461 | 0 |
Update the given rows using the toplevel operator parameters | def updateTableForSlot(self, slot, *args):
with Tracer(traceLogger):
# Don't update anything if the slot doesn't have data yet
if not slot.connected():
return
# Which index is this slot?
row = -1
for i in range( len(self.topLevelOpera... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, updates, predicate):\n for row in self.rows:\n if predicate(row):\n for column, new_value in updates.items():\n row[column] = new_value",
"def updateRow(self, index: int) -> None:\n ...",
"def setRow(self, row):\n # Row of the d... | [
"0.62828267",
"0.59299856",
"0.58693624",
"0.58242786",
"0.5797138",
"0.5753691",
"0.5725859",
"0.56664556",
"0.5620474",
"0.55361575",
"0.5500609",
"0.5478034",
"0.5427957",
"0.5427957",
"0.54237574",
"0.5380283",
"0.5317558",
"0.52668935",
"0.5243685",
"0.52374893",
"0.5236... | 0.48500547 | 55 |
The user (un)checked the "allow labels" checkbox in one of the table rows. Update the corresponding dataset info in the operator (which is given in the parameter 'slot') | def handleAllowLabelsCheckbox(self, slot, checked):
with Tracer(traceLogger):
# COPY the dataset so we trigger the slot to be dirty
newDatasetInfo = copy.copy(slot.value)
newDatasetInfo.allowLabels = ( checked == Qt.Checked )
# Only update if necessary
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def updateTableForSlot(self, slot, *args):\n with Tracer(traceLogger):\n\n # Don't update anything if the slot doesn't have data yet\n if not slot.connected():\n return\n\n # Which index is this slot?\n row = -1\n for i in range( len(self... | [
"0.6179488",
"0.5845522",
"0.58064353",
"0.5581023",
"0.55638903",
"0.5357033",
"0.52947384",
"0.5255203",
"0.5205964",
"0.518046",
"0.51680946",
"0.5164398",
"0.5143642",
"0.5132615",
"0.5130291",
"0.5119018",
"0.51143825",
"0.50607854",
"0.5041646",
"0.4999295",
"0.4979582"... | 0.6519952 | 0 |
Create and add the combobox for storage location options | def updateStorageOptionComboBox(self, row, filePath):
assert threading.current_thread().name == "MainThread"
with Tracer(traceLogger):
# Determine the relative path to this file
absPath, relPath = getPathVariants(filePath, self.topLevelOperator.WorkingDirectory.value)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_combo_box(self, name, value=None, options=None, label=None, add_indicator=None):\n widget=QtWidgets.QComboBox(self)\n widget.setObjectName(_fromUtf8(self.name+\"_\"+name))\n if options:\n widget.addItems(options)\n if value is not None:\n widget.set... | [
"0.63493586",
"0.57815427",
"0.5772928",
"0.57538795",
"0.5747907",
"0.5733699",
"0.5682541",
"0.56459165",
"0.5585773",
"0.5577615",
"0.5562045",
"0.55241734",
"0.548213",
"0.543225",
"0.54069054",
"0.5350624",
"0.53404826",
"0.5329477",
"0.53247994",
"0.5262176",
"0.5246481... | 0.6170078 | 1 |
The user manually edited a file name in the table. Update the operator and other GUI elements with the new file path. | def handleRowDataChange(self, changedItem ):
with Tracer(traceLogger):
# Figure out which row this widget is in
row = changedItem.row()
column = changedItem.column()
# Can't update until the row is fully initialized
needUpdate = True
needU... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def updateFilePath(self, index):\n with Tracer(traceLogger):\n oldLocationSetting = self.topLevelOperator.Dataset[index].value.location\n\n # Get the directory by inspecting the original operator path\n oldTotalPath = self.topLevelOperator.Dataset[index].value.filePath.repla... | [
"0.66101885",
"0.64000237",
"0.64000237",
"0.6362748",
"0.62647414",
"0.62446743",
"0.62028664",
"0.61208254",
"0.6117045",
"0.6081102",
"0.6037847",
"0.60202473",
"0.59801805",
"0.59678453",
"0.5946963",
"0.59453547",
"0.59417",
"0.58884573",
"0.5861818",
"0.5850862",
"0.583... | 0.0 | -1 |
Update the operator's filePath input to match the gui | def updateFilePath(self, index):
with Tracer(traceLogger):
oldLocationSetting = self.topLevelOperator.Dataset[index].value.location
# Get the directory by inspecting the original operator path
oldTotalPath = self.topLevelOperator.Dataset[index].value.filePath.replace('\\', '... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def input_file_chooser(self):\n filename = tk.filedialog.askopenfilename()\n self._input_path_var.set(filename)",
"def browse_files_out(self,*args):\n path_to_data = tkFileDialog.askopenfilename()\n #show chosen value in textframe\n self.docstring_offers.delete(0,tk.END)\n ... | [
"0.7001716",
"0.6854931",
"0.6504425",
"0.6456651",
"0.638439",
"0.6247839",
"0.6225895",
"0.6196959",
"0.6188512",
"0.6188512",
"0.617856",
"0.6092836",
"0.6067322",
"0.60563415",
"0.60496354",
"0.6038306",
"0.6024043",
"0.5992593",
"0.59883094",
"0.5973095",
"0.59682596",
... | 0.66875553 | 2 |
The user clicked the "Remove" button. Remove the currently selected row(s) from both the GUI and the toplevel operator. | def handleRemoveButtonClicked(self):
with Tracer(traceLogger):
# Figure out which dataset to remove
rowsToDelete = set()
selectedRanges = self.fileInfoTableWidget.selectedRanges()
for rng in selectedRanges:
for row in range(rng.topRow(), rng.bottom... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_row(self):\n if len(self.columns[\"rows\"].children) > 0:\n self.selects.pop()\n self.button_groups.pop()\n self.buttons[\"edit\"].pop()\n self.columns[\"rows\"].children.pop()",
"def removeObject(self):\n\t\tfor SelectedItem in self.objects_lw.select... | [
"0.75775635",
"0.73554677",
"0.69494325",
"0.68314517",
"0.6789492",
"0.6658385",
"0.6601661",
"0.6563126",
"0.65295523",
"0.6529164",
"0.6499993",
"0.6471326",
"0.64638305",
"0.6461784",
"0.6439678",
"0.64392084",
"0.63918245",
"0.638411",
"0.6379691",
"0.6368745",
"0.635695... | 0.7852163 | 0 |
Handles changes to any combo change in the table (either external path or internal path) | def handleComboSelectionChanged(self, combo, index):
with Tracer(traceLogger):
logger.debug("Combo selection changed: " + combo.itemText(1) + str(index))
# Figure out which row this combo is in
tableWidget = self.fileInfoTableWidget
changedRow = -1
fo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def comboBoxChanged(self):\n new_action = self.ui.comboBoxAction.currentText().lower()\n self.parameters['action'] = new_action\n\n self.changed.emit()",
"def _callback_combo_cell(self, cell, path, row, position, treemodel):\r\n\r\n _model = cell.get_property('model')\r\n _text... | [
"0.6172025",
"0.5913377",
"0.58997405",
"0.5888051",
"0.58503884",
"0.58247435",
"0.57801026",
"0.57432413",
"0.5640571",
"0.563494",
"0.5616561",
"0.56068355",
"0.5606437",
"0.5573447",
"0.5563066",
"0.55510837",
"0.54804873",
"0.54715496",
"0.5466768",
"0.5444184",
"0.54320... | 0.60713905 | 1 |
Any time the user selects a new item, select the whole row. | def handleTableSelectionChange(self):
self.selectEntireRow()
self.showSelectedDataset() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def people_item_select(self):\n # Whenever the people table subjects have been selected\n # grey out the checkin button\n self.row_i = self.people_table.currentRow()\n # TODO: okay to return DF of empty?\n # might want to clear other things when no results\n if self.row_i... | [
"0.7052263",
"0.70413625",
"0.6938748",
"0.6933411",
"0.6897258",
"0.6846295",
"0.66692257",
"0.66188014",
"0.6579844",
"0.65542483",
"0.65015703",
"0.649491",
"0.6468015",
"0.6384764",
"0.63539386",
"0.63495123",
"0.63334334",
"0.63334334",
"0.6275927",
"0.6255295",
"0.62136... | 0.72043216 | 0 |
Instantiates the Flask instance and associated parameters. | def create_app(config_filename):
app = Flask(__name__)
app.config.from_object(config_filename)
from app import api_bp
app.register_blueprint(api_bp, url_prefix='/api')
from Model import db
with app.app_context():
db.init_app(app)
db.create_all([None])
return ap... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize():\n app = Flask(__name__)\n # Load private config at instance/config.py\n config_path = 'instance/config.py'\n if os.path.exists(config_path):\n app.config.from_pyfile(os.path.abspath(config_path))\n\n # Initialize database\n init_db(\n app.config['DB_USERNAME'],\n ... | [
"0.7546474",
"0.7465154",
"0.7437626",
"0.729399",
"0.71954864",
"0.71917486",
"0.71597254",
"0.70166236",
"0.70074224",
"0.69816077",
"0.6921856",
"0.6921187",
"0.69106394",
"0.6906584",
"0.6897556",
"0.6897512",
"0.68827015",
"0.68768495",
"0.68698466",
"0.6868935",
"0.6865... | 0.0 | -1 |
Return a resource instance as an attribute. If the resource hasn't yet been loaded into cache, it will be imported, fetched from the module, and cached. Subsequent attribute fetches for this resource will be returned from the cache. | def __getattr__(self, name):
if name.startswith('__'):
# Don't attempt to look up any special function/operator names
# as modules. This was first noticed as a series of errors caused
# by Sphinx's autodoc introspection code.
return super(ResourcesRegistry, self).... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __cached(self):\n # already cached stuff\n if self._cached is None:\n self._cached = Cached(self.resource)\n return self._cached",
"def __getattr__(self, resource):\n return ResourceManager(self, resource)",
"def get(module: str, attribute: str):\n return _manageAt... | [
"0.65890276",
"0.6446413",
"0.6415658",
"0.62708116",
"0.6201392",
"0.6089802",
"0.60478544",
"0.6004497",
"0.5988703",
"0.5988703",
"0.5901449",
"0.58880585",
"0.5815014",
"0.58120877",
"0.57987595",
"0.57940334",
"0.5776671",
"0.5739819",
"0.5716186",
"0.5710766",
"0.571076... | 0.61004335 | 5 |
Register model to resource mappings. Subclasses must override this to do any registration they may need. | def register_resources(self):
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register_resource_for_model(model, resource):\n _model_to_resources[model] = resource",
"def register_model(self, model):\n\n self._model = model",
"def register(cls, model):\n cls.models[model] = True",
"def register(self, *model):\n for m in model:\n m.Register()\n self.mo... | [
"0.7501223",
"0.6653077",
"0.65550554",
"0.6108307",
"0.6104962",
"0.59786534",
"0.5913898",
"0.58804697",
"0.57783335",
"0.57450867",
"0.5733444",
"0.56834364",
"0.56577826",
"0.5607221",
"0.555102",
"0.55320704",
"0.5526848",
"0.5526848",
"0.5513127",
"0.54973423",
"0.54528... | 0.6685671 | 1 |
Register a resource as the official location for a model. | def register_resource_for_model(model, resource):
_model_to_resources[model] = resource | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _register_resource(self, name):\n GlobalClass.register(self)\n tag = self.module.name.lower()\n group = self.config.xpath(self.xpath + \"/\" + tag)[0]\n group_mysql4 = group.tag + \"_mysql4\"\n resource_model = find_or_create(group, \"resourceModel\")\n resource_model.... | [
"0.6097805",
"0.6078597",
"0.6000599",
"0.59710836",
"0.596382",
"0.5836003",
"0.58176094",
"0.58176094",
"0.5783218",
"0.5745019",
"0.5735456",
"0.5614592",
"0.5565347",
"0.55405563",
"0.5499648",
"0.5370664",
"0.5360497",
"0.53290606",
"0.52897364",
"0.5284575",
"0.5260971"... | 0.73618525 | 0 |
Remove the official location for a model. | def unregister_resource_for_model(model):
del _model_to_resources[model] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __location_del(self):\n self.db_location = None\n self.save(update_fields=[\"db_location\"])",
"def location(self):\n del self._location",
"def remove_location(self, **kwargs):\n \n self.options.update(kwargs)\n self.options['action'] = 'locator.location.remove'\n ... | [
"0.6723639",
"0.66767335",
"0.6262924",
"0.61227584",
"0.6120357",
"0.6023274",
"0.59902483",
"0.59236014",
"0.58762664",
"0.58372384",
"0.5804065",
"0.57834613",
"0.5683986",
"0.5682015",
"0.5653655",
"0.5647387",
"0.5603276",
"0.5592522",
"0.55893296",
"0.5589141",
"0.55840... | 0.56138283 | 16 |
Return the resource for an object. | def get_resource_for_object(obj):
from djblets.webapi.resources.base import WebAPIResource
cls = obj.__class__
# Deferred models are a subclass of the actual model that we want to look
# up.
if getattr(obj, '_deferred', False):
cls = cls.__bases__[0]
resource = _model_to_resources.get... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_object ( self, object ):\n return object",
"def resource(self):\n return self._resource",
"def resource(self):\n return self._resource",
"def resource(self):\n return self._resource",
"def resource(self):\n return self._resource",
"def resource(self):\n r... | [
"0.7132309",
"0.70808786",
"0.70808786",
"0.70808786",
"0.70808786",
"0.70808786",
"0.70808786",
"0.70808786",
"0.69478905",
"0.6892674",
"0.6882015",
"0.6850975",
"0.6826252",
"0.680579",
"0.6796926",
"0.67565787",
"0.6696587",
"0.66093224",
"0.6583387",
"0.6565771",
"0.6481... | 0.7670397 | 0 |
Return the resource of the specified name. | def get_resource_from_name(name):
return _name_to_resources.get(name, None) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_resource(self, name: str) -> Resource:\n return self.get_session.query(self.resource_model).filter_by(name=name).one_or_none()",
"def GetResource(self, name):\r\n matches = [x for x in self.resources if x.name == name]\r\n if len(matches) == 1:\r\n return matches[0]\r\n elif len(matc... | [
"0.82805157",
"0.80796313",
"0.796345",
"0.78018993",
"0.7711447",
"0.72921443",
"0.727059",
"0.7054507",
"0.7051002",
"0.7009372",
"0.6961014",
"0.69041646",
"0.68261045",
"0.6757441",
"0.67551",
"0.67448837",
"0.67232054",
"0.6704062",
"0.6703346",
"0.6686181",
"0.6673515",... | 0.88857186 | 0 |
Return the resource with the specified resource class. | def get_resource_from_class(klass):
return _class_to_resources.get(klass, None) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resource_class(self):\n resource_module = '.'.join(self.resource_class_path.split('.')[:-1])\n resource_class_name = self.resource_class_path.split('.')[-1]\n return getattr(import_module(resource_module), resource_class_name)",
"def resource_class(self):\n resource_module = '.'.j... | [
"0.7832141",
"0.7832141",
"0.7712705",
"0.6950276",
"0.68987846",
"0.66122043",
"0.6541201",
"0.6495036",
"0.6437813",
"0.6411328",
"0.6365627",
"0.63542414",
"0.6345779",
"0.63337135",
"0.6322805",
"0.63152754",
"0.62987596",
"0.62941813",
"0.62185717",
"0.6204819",
"0.62022... | 0.8665222 | 0 |
Unregister a resource from the caches. | def unregister_resource(resource):
del _name_to_resources[resource.name]
del _name_to_resources[resource.name_plural]
del _class_to_resources[resource.__class__] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unregister(self, resource):\n for item in self.resources:\n if resource == item[\"resource\"]:\n item[\"status\"] = UNREGISTER",
"def unregister(self):\r\n self._unregister()",
"def _cache_drop(self, metric_name):\n with self._lock:\n del self.__cac... | [
"0.695629",
"0.64772457",
"0.6466498",
"0.64457786",
"0.6288041",
"0.6288041",
"0.61837035",
"0.6126617",
"0.6099737",
"0.6067333",
"0.6057097",
"0.6050785",
"0.60381985",
"0.59959465",
"0.59620714",
"0.5961482",
"0.5955716",
"0.59399253",
"0.5935144",
"0.59329534",
"0.586909... | 0.7239517 | 0 |
Connect to market data server. | def connect_quote(self):
try:
self.quote_client = QuoteClient(self.client_config)
self.symbol_names = dict(
self.quote_client.get_symbol_names(lang=Language.zh_CN))
self.query_contract()
except ApiException:
self.write_log("查询合约失败")
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def connect(self):\n self.conn.connect()",
"async def _open_market_data_websocket(self):\n market_data_url = self._wss_url_base + \\\n '/v1/marketdata/BTCUSD?heartbeat=true'\n self._market_data_sock_info.ws = await websockets.client.connect(\n market_data_... | [
"0.6758905",
"0.6684229",
"0.6403466",
"0.6322858",
"0.62941265",
"0.6277353",
"0.6262684",
"0.615094",
"0.6145239",
"0.60558206",
"0.6024012",
"0.601306",
"0.6006173",
"0.59702605",
"0.59702605",
"0.59368443",
"0.5931306",
"0.5895381",
"0.5880848",
"0.5874744",
"0.58643043",... | 0.5645965 | 56 |
Connect to trade server. | def connect_trade(self):
self.trade_client = TradeClient(self.client_config)
try:
self.add_task(self.query_order)
self.add_task(self.query_position)
self.add_task(self.query_account)
except ApiException:
self.write_log("交易接口连接失败")
retur... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def connectToServer(self):\n self.client = Client(base_url = self.server)\n self.ping()",
"def connect(self):\n self.conn.connect()",
"def connect(self):\n\n symbol = self.order.symbol\n\n if self.test:\n host = 'wss://testnet.bitmex.com/realtime'\n else:\n ... | [
"0.67305315",
"0.66895556",
"0.6657646",
"0.6608166",
"0.6548882",
"0.6479017",
"0.6472146",
"0.64224577",
"0.63764036",
"0.63736725",
"0.62640786",
"0.6244553",
"0.62354064",
"0.6216869",
"0.6200346",
"0.61953896",
"0.6190848",
"0.61894286",
"0.6174592",
"0.6170257",
"0.6144... | 0.7262335 | 0 |
Connect to push server. | def connect_push(self):
protocol, host, port = self.client_config.socket_host_port
self.push_client = PushClient(host, port, (protocol == "ssl"))
self.push_client.quote_changed = self.on_quote_change
self.push_client.asset_changed = self.on_asset_change
self.push_client.position... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _connect(self):\r\n self.sock = socket.socket()\r\n host = \"pubsub.pubnub.com\"\r\n port = 80\r\n if self.use_ssl:\r\n self.sock = ssl.wrap_socket(self.sock)\r\n port = 443\r\n self.sock.connect((host, port))\r\n self.connected = True",
"def co... | [
"0.7291151",
"0.6847644",
"0.67866546",
"0.67768633",
"0.6661692",
"0.6655104",
"0.6596576",
"0.6536159",
"0.65285504",
"0.6524723",
"0.65192074",
"0.65151745",
"0.6496408",
"0.6478729",
"0.6464252",
"0.6449753",
"0.6418711",
"0.6414711",
"0.63653946",
"0.63524014",
"0.635009... | 0.79299897 | 0 |
Process trade data for both query and update. | def process_deal(self, data):
for i in data:
if i.status == OrderStatus.PARTIALLY_FILLED or i.status == OrderStatus.FILLED:
symbol, exchange = convert_symbol_tiger2vt(str(i.contract))
self.tradeid += 1
trade = TradeData(
symbol=sym... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def process_trade(self, data):\n for item in data:\n symbol = item[\"symbol\"]\n trade = {\n \"platform\": self._platform,\n \"symbol\": symbol,\n \"action\": ORDER_ACTION_BUY if item[\"side\"] == \"Buy\" else ORDER_ACTION_SELL,\n ... | [
"0.68010473",
"0.6513125",
"0.6495422",
"0.6462116",
"0.6318342",
"0.6311736",
"0.63095254",
"0.6301807",
"0.62855184",
"0.6077452",
"0.6056953",
"0.603197",
"0.60087824",
"0.59963775",
"0.59963775",
"0.59963775",
"0.59963775",
"0.59313375",
"0.591776",
"0.5892385",
"0.588439... | 0.6608865 | 1 |
Convert symbol from vt to tiger. | def convert_symbol_tiger2vt(symbol):
if symbol.encode("UTF-8").isalpha():
exchange = Exchange.SMART
else:
if len(symbol) < 6:
exchange = Exchange.SEHK
elif symbol.startswith("6"):
exchange = Exchange.SSE
elif symbol.endswith(".SH"):
exchange = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_symbol_vt2tiger(symbol, exchange):\n if exchange == Exchange.SSE and symbol.startswith(\"0\"):\n symbol = symbol + \".SH\"\n else:\n symbol = symbol\n return symbol",
"def to_symbol(text):\n text = text.upper()\n if text in (\"BGM\", \"BANGUMI\"):\n return \"bgm\"\... | [
"0.808804",
"0.60368603",
"0.5791044",
"0.56720763",
"0.5637549",
"0.55791175",
"0.55277675",
"0.5505299",
"0.5419636",
"0.54013735",
"0.53962946",
"0.5395829",
"0.53817433",
"0.5333906",
"0.5278394",
"0.52763736",
"0.5265407",
"0.5249531",
"0.52154344",
"0.52097255",
"0.5201... | 0.81928307 | 0 |
Convert symbol from vt to tiger. | def convert_symbol_vt2tiger(symbol, exchange):
if exchange == Exchange.SSE and symbol.startswith("0"):
symbol = symbol + ".SH"
else:
symbol = symbol
return symbol | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_symbol_tiger2vt(symbol):\n if symbol.encode(\"UTF-8\").isalpha():\n exchange = Exchange.SMART\n else:\n if len(symbol) < 6:\n exchange = Exchange.SEHK\n elif symbol.startswith(\"6\"):\n exchange = Exchange.SSE\n elif symbol.endswith(\".SH\"):\n ... | [
"0.81928307",
"0.60368603",
"0.5791044",
"0.56720763",
"0.5637549",
"0.55791175",
"0.55277675",
"0.5505299",
"0.5419636",
"0.54013735",
"0.53962946",
"0.5395829",
"0.53817433",
"0.5333906",
"0.5278394",
"0.52763736",
"0.5265407",
"0.5249531",
"0.52154344",
"0.52097255",
"0.52... | 0.808804 | 1 |
Config symbol to corresponding currency | def config_symbol_currency(symbol):
if symbol.encode("UTF-8").isalpha():
currency = Currency.USD
else:
if len(symbol) < 6:
currency = Currency.HKD
else:
currency = Currency.CNH
return currency | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getCurrencySymbol():",
"def currency_symbol(self, init):\r\n\r\n c2 = CurrencyCodes()\r\n c_symbol = c2.get_symbol(init)\r\n return c_symbol",
"def getCurrencySymbol(id=None):",
"def getDefaultCurrency():",
"def quote_currencies(self):\n pass",
"def currency(self, currency... | [
"0.79462665",
"0.74198484",
"0.66513836",
"0.6561869",
"0.64658445",
"0.6448337",
"0.6419649",
"0.6266505",
"0.61048144",
"0.6058995",
"0.60494053",
"0.6024492",
"0.5996669",
"0.5974246",
"0.58935475",
"0.5873423",
"0.5847701",
"0.5830133",
"0.5808687",
"0.58026433",
"0.57539... | 0.79219276 | 1 |
Strip the leading and trailing whitespace of a given text | def strip_whitespace(self, text):
return text.strip() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_whitespaces(text: str) -> str:\n return text.lstrip().rstrip()",
"def remove_leading_whitespace_and_empty_lines(text: str) -> str:\n # We call lstrip() twice on the same line. This is inefficient but ok for small unit tests.\n # Please change it if you want to.\n return '\\n'.join([lin... | [
"0.80575657",
"0.78265435",
"0.77780694",
"0.7634085",
"0.7620508",
"0.7521066",
"0.7518481",
"0.74882275",
"0.74422944",
"0.73665917",
"0.7358045",
"0.73027694",
"0.7300915",
"0.7294546",
"0.7215683",
"0.71842605",
"0.71270746",
"0.71270746",
"0.709766",
"0.7091407",
"0.7085... | 0.8302335 | 0 |
Delete any whitespace in a given string | def del_whitespace(selfs, text):
return text.replace(' ', '') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def strip_space(string):\n return string.replace(' ', '')",
"def _clean(self, string):\n return re.sub('\\s+', ' ', string).strip()",
"def remove_white_spaces(input_string):\n return re.sub(r'\\s+', ' ', input_string).strip()",
"def _clean(s):\n return re.sub(r'\\s+', ' ', s.strip())",
"def... | [
"0.8386853",
"0.8282755",
"0.8259965",
"0.8231743",
"0.82165647",
"0.81852895",
"0.8062439",
"0.7945549",
"0.79050696",
"0.7848309",
"0.7831649",
"0.7806161",
"0.7806161",
"0.77685887",
"0.77685887",
"0.7742288",
"0.76699007",
"0.7577561",
"0.7572943",
"0.7553713",
"0.7528789... | 0.81443447 | 6 |
Uppercase all characer in a given string | def to_upper(self, text):
return text.upper() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def upper(string):\n new_string = '' # Empty string to append to\n for char in string: # Itterate over each character in user's string\n if char.isalpha() and not char.isupper(): # If the character is an alphabet and not already uppercase\n char = (chr(ord(char) - 32)) # Subtract 32 from it... | [
"0.790776",
"0.7735673",
"0.77356625",
"0.7521186",
"0.74673855",
"0.74584377",
"0.7438182",
"0.7413072",
"0.7411056",
"0.73737097",
"0.7281533",
"0.7273776",
"0.7201532",
"0.7180221",
"0.7129265",
"0.70013803",
"0.6978227",
"0.6964081",
"0.69567746",
"0.6934419",
"0.68477446... | 0.7509662 | 4 |
Format the output of a course | def format_course_output(self, course, schedule):
# handle schedule
str_list = schedule.schedule.strip().split(' ')
sch_res = ''
if (len(str_list) >= 6):
val_list = str_list[:6]
val_list[5] = val_list[5][:3]
# time
time = val_list[0] + ' ' + val_list[1] + ' ' + val_list[2] + ' ' + val_list[3]... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_output(filtered_courses_list):\n\n if not filtered_courses_list:\n print(\"No courses matched the query.\")\n return\n\n max_name_length = max([len(course.name) for course in filtered_courses_list])\n\n print(\" Sem | Course ID | Pts | \" +\n \" \" * ((max_name_length - 1... | [
"0.6944422",
"0.6730091",
"0.6578019",
"0.6519152",
"0.6504523",
"0.6474363",
"0.642245",
"0.6395715",
"0.6341537",
"0.61744756",
"0.6163076",
"0.6133065",
"0.6130324",
"0.6114346",
"0.60810196",
"0.60802037",
"0.59981614",
"0.5904079",
"0.5876718",
"0.5844278",
"0.5802319",
... | 0.7844055 | 0 |
Given the input string (course code), return the course | def get_course_by_code(input):
res = None
user_input = input
input = str(input)
# clean input
input = util.strip_whitespace(input)
input = util.del_whitespace(input)
input = util.to_upper(input)
print input
course = query_cat.filter(Course.course_code == input).first()
schedule = query_sch.filter(Schedule... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def course_name(input):\n for course in config.current_courses:\n if strip_string(course) == strip_string(input):\n return course\n\n return input",
"def _parse_course_id_from_string(input_str):\r\n m_obj = re.match(r'^/courses/(?P<course_id>[^/]+/[^/]+/[^/]+)', input_str)\r\n if m_... | [
"0.7170098",
"0.7058149",
"0.70250374",
"0.67529607",
"0.67248166",
"0.6541851",
"0.6528558",
"0.6477524",
"0.64641935",
"0.64081264",
"0.6382256",
"0.6375246",
"0.62365013",
"0.6080567",
"0.60732913",
"0.6056371",
"0.60557353",
"0.6053482",
"0.6018583",
"0.5958772",
"0.59036... | 0.76620525 | 0 |
Given the input string (key words), return the course | def get_course_by_key_words(input): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def course_name(input):\n for course in config.current_courses:\n if strip_string(course) == strip_string(input):\n return course\n\n return input",
"def _course_key_from_string(self, string):\r\n return self.course_locations[string].course_key",
"def get_courses(std):\n retur... | [
"0.693951",
"0.6872825",
"0.6350646",
"0.6082056",
"0.60421014",
"0.6014495",
"0.5844915",
"0.57037026",
"0.5657913",
"0.5654991",
"0.5654512",
"0.5646173",
"0.56458086",
"0.56419003",
"0.55879545",
"0.55596834",
"0.55547255",
"0.5543785",
"0.553146",
"0.5529814",
"0.5440121"... | 0.85511416 | 0 |
Run new owl server for given `pipeline` Returns port of the created server | def new_server(self, name, pipeline, port=None):
if port is None:
port = self.next_port
self.next_port += 1
self.servers[name] = port
args = ["owl-server","--port", str(port)] + pipeline.split()
proc = subprocess.Popen(args)
self.processes[port] = proc
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main(port):\n ps = PathologicalServer(\"localhost\", port, _responses)\n ps.start()",
"def run(*port):\n print(port)\n if port:\n port = port[0]\n else:\n port = 8000\n external_ip = '0.0.0.0:{}'.format(port)\n _manage('runserver %s' % external_ip)",
"async def net_server(pip... | [
"0.6003155",
"0.56016594",
"0.55983025",
"0.5577207",
"0.55736977",
"0.5468409",
"0.5451809",
"0.54441744",
"0.5419513",
"0.5376845",
"0.5339203",
"0.5296844",
"0.5291677",
"0.5291677",
"0.5290636",
"0.5287376",
"0.5261708",
"0.52436334",
"0.5235279",
"0.5222004",
"0.52121824... | 0.79979473 | 0 |
Terminate server for listening on given `port`. | def terminate_server(self, port):
proc = self.processes.pop(port, None)
if proc is None:
raise ValueError(f"Server for port {port} does not exists."
"It might have been closed already."
)
proc.terminate() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def kill_process_by_port(port):\n port = int(port)\n pid = get_pid_by_port(port)\n if pid:\n return kill(pid)",
"def stop_echo_server(self, ip_addr='localhost',\n port=zephyr_constants.DEFAULT_ECHO_PORT):\n out = None\n if (port in self.echo_server_procs and\... | [
"0.6641947",
"0.6628325",
"0.6453124",
"0.6397097",
"0.63918346",
"0.63025546",
"0.6299923",
"0.6299426",
"0.6281496",
"0.6214558",
"0.6181251",
"0.6174334",
"0.61625504",
"0.6139271",
"0.61364913",
"0.61274475",
"0.6123971",
"0.6084454",
"0.60776997",
"0.60655427",
"0.603590... | 0.8301901 | 0 |
Return all client commands | def print_ports(self, file=None):
lines = []
for name, port in self.servers.items():
lines.append(f"{name}:{port}")
if file is not None:
print("\n".join(lines), file=file)
return "\n".join(lines) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_commands(self):\r\n return self._commands",
"def commands(self) -> List[Command]:\n return []",
"def get_commands(self):\n return list(self.commands.values())",
"def list_commands():\n print(' ')\n print('Chat Client Commands')\n print('-----------------------')\n pr... | [
"0.7469627",
"0.7433225",
"0.73863494",
"0.7370501",
"0.7369048",
"0.7327095",
"0.72978747",
"0.7268624",
"0.7262184",
"0.7222672",
"0.7217292",
"0.7210814",
"0.7152034",
"0.71388197",
"0.7100221",
"0.7077035",
"0.7048432",
"0.6971724",
"0.6926512",
"0.69023913",
"0.6901513",... | 0.0 | -1 |
Loads ports from file Loaded servers cannot be terminated | def load_ports_from_file(self, filename):
lines = open(filename, "r").readlines()
for line in lines:
name, port = line.split(":")
self.servers[name] = port.rstrip() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load(self):\n\t\tpath = input(\"Please enter the file name, with full path if needed, to load hosts and open ports -> \")\n\t\ttry:\n\t\t\tf = open(path)\n\t\t\tlines = f.read()\n\t\t\tentries = lines.split('\\n\\n')\n\t\t\tfor entry in entries:\n\t\t\t\thost_ports = entry.split('\\n')\n\t\t\t\tif host_ports[0... | [
"0.72574246",
"0.67828935",
"0.59317714",
"0.56775075",
"0.56608295",
"0.5643025",
"0.56103486",
"0.56080896",
"0.55767304",
"0.55763936",
"0.54733366",
"0.5434388",
"0.54177946",
"0.5403998",
"0.5392675",
"0.5375731",
"0.5347649",
"0.5315801",
"0.5302954",
"0.52818924",
"0.5... | 0.78676033 | 0 |
Computes the GANnotation encoding for a video. | def compute_video_encoding(video):
video_points = []
while True:
ret, frame = video.read()
if not ret:
break
# Find landmarks/points in frame.
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
rects = face_detector(gray, 1)
if (len(rects) == 0):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main(data_dir):\n\n face2face_dir = '{}/manipulated_sequences/Face2Face/c0/videos'.format(data_dir)\n orig_dir = '{}/original_sequences/c0/videos'.format(data_dir)\n base_dir = '{}/manipulated_sequences/GANnotation'.format(data_dir)\n output_enc_dir = '{}/encodings'.format(base_dir)\n output_vid... | [
"0.6518178",
"0.6104392",
"0.59964246",
"0.5801031",
"0.5739885",
"0.5585433",
"0.55486244",
"0.5478121",
"0.5309508",
"0.53071237",
"0.52854246",
"0.5283544",
"0.5250905",
"0.52124584",
"0.5192007",
"0.5182117",
"0.51523244",
"0.5151299",
"0.5132689",
"0.5113917",
"0.5107428... | 0.64678127 | 1 |
Gets a cropped image of a face to the specifications of GANnotation. | def get_gann_cropped_face(image):
# Convert image to RGB.
rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
# Find landmarks/points in frame.
gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY)
rects = face_detector(gray, 1)
if (len(rects) == 0):
return None # No face found.
landmarks = face_p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def crop_face(image,face_rect):\n (x1,y1,x2,y2) = face_rect\n w = abs(x2-x1)\n h = abs(y2-y1)\n return image[y1:y1 + h, x1:x1 + w]",
"def crop_face(image):\n gray_image = cv.cvtColor(image, cv.COLOR_BGR2GRAY)\n face_roi_list = face_detector.detectMultiScale(gray_image, scale_factor, min_neighbo... | [
"0.7231581",
"0.7134207",
"0.7091885",
"0.6756536",
"0.6668364",
"0.6617558",
"0.63952774",
"0.6262327",
"0.6238402",
"0.62260556",
"0.6155058",
"0.61488146",
"0.60976815",
"0.6077309",
"0.6067748",
"0.6025078",
"0.5959691",
"0.5953402",
"0.58816946",
"0.5860862",
"0.58352095... | 0.69182104 | 3 |
Generates videos with GANnotation using the same driving video and source video combinations used with Face2Face. | def main(data_dir):
face2face_dir = '{}/manipulated_sequences/Face2Face/c0/videos'.format(data_dir)
orig_dir = '{}/original_sequences/c0/videos'.format(data_dir)
base_dir = '{}/manipulated_sequences/GANnotation'.format(data_dir)
output_enc_dir = '{}/encodings'.format(base_dir)
output_vid_dir = '{}/... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def encode_videos(self):\n\t\t\n\t\tself.face_detector = MTCNN()\n\t\tencoder = MyVGGFace(self.vgg_l, self.vgg_v)\n\t\t\n\t\tfolder = self.folders['raw_video_folder']\n\t\t\n\t\tfor (dirpath, _, filenames) in os.walk(folder):\n\t\t\tif platform == 'linux' or platform == 'linux2' or platform == 'darwin':\n\t\t\t\t#... | [
"0.6596629",
"0.64612806",
"0.63377756",
"0.6288337",
"0.6274383",
"0.6232385",
"0.61546236",
"0.6031003",
"0.6000362",
"0.5978761",
"0.5973133",
"0.59620225",
"0.59196764",
"0.5911529",
"0.5893759",
"0.5874103",
"0.5867773",
"0.58625805",
"0.58521277",
"0.5817486",
"0.580820... | 0.7005335 | 0 |
A CrossEncoder takes exactly two sentences / texts as input and either predicts a score or label for this sentence pair. It can for example predict the similarity of the sentence pair on a scale of 0 ... 1. It does not yield a sentence embedding and does not work for individually sentences. | def __init__(self, model_name:str, num_labels:int = None, max_length:int = None, device:str = None):
self.config = AutoConfig.from_pretrained(model_name)
classifier_trained = any([arch.endswith('ForSequenceClassification') for arch in self.config.architectures])
if num_labels is None and not c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict(self, texts: List[ParsedText]) -> List[ParsedText]:\n self.model.eval()\n texts = copy.deepcopy(texts)\n\n batches = DataLoader(texts=texts,\n batch_size=self.batch_size,\n vocabulary=self.vocabulary,\n ... | [
"0.5809319",
"0.5734909",
"0.57336724",
"0.5707226",
"0.5680044",
"0.56736326",
"0.56652117",
"0.56223834",
"0.5596532",
"0.5593011",
"0.5583269",
"0.55746573",
"0.5567427",
"0.55424696",
"0.55306464",
"0.5463267",
"0.54625404",
"0.5462516",
"0.54495895",
"0.5441223",
"0.5438... | 0.0 | -1 |
Performs predicts with the CrossEncoder on the given sentence pairs. | def predict(self, sentences: List[List[str]],
batch_size: int = 32,
show_progress_bar: bool = None,
num_workers: int = 0,
activation_fct = None,
convert_to_numpy: bool = True,
convert_to_tensor: bool = False
):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict_tokens(self, tokens):\n return",
"def predict(self, texts: List[ParsedText]) -> List[ParsedText]:\n self.model.eval()\n texts = copy.deepcopy(texts)\n\n batches = DataLoader(texts=texts,\n batch_size=self.batch_size,\n ... | [
"0.6495735",
"0.6470667",
"0.64286774",
"0.6404578",
"0.63536495",
"0.63171744",
"0.63171744",
"0.6305695",
"0.62898153",
"0.62898153",
"0.62898153",
"0.61633193",
"0.6158455",
"0.6141235",
"0.6130706",
"0.61170506",
"0.6076464",
"0.6076464",
"0.6076464",
"0.607452",
"0.60663... | 0.5924504 | 34 |
Runs evaluation during the training | def _eval_during_training(self, evaluator, output_path, save_best_model, epoch, steps, callback):
if evaluator is not None:
score = evaluator(self, output_path=output_path, epoch=epoch, steps=steps)
if callback is not None:
callback(score, epoch, steps)
if sco... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaluate(self):\n self.training = False",
"def _evaluate_during_fit(self, test_loader, epoch):",
"def eval(self):\n self.train(mode=False)",
"def _set_eval(self):\n\n if self.model.__dict__['training']:\n self.model.eval()",
"def train_and_evaluate(model, train_dataloade... | [
"0.8004094",
"0.7960147",
"0.793323",
"0.7607203",
"0.74450403",
"0.7328776",
"0.73260754",
"0.7320131",
"0.72835034",
"0.72698236",
"0.72638726",
"0.7262151",
"0.72481006",
"0.7229681",
"0.72075427",
"0.7180608",
"0.7169582",
"0.71446204",
"0.7122053",
"0.7110365",
"0.708602... | 0.7241664 | 13 |
Saves all model and tokenizer to path | def save(self, path):
if path is None:
return
logging.info("Save model to {}".format(path))
self.model.save_pretrained(path)
self.tokenizer.save_pretrained(path) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save(self, path: utils.URLPath):\n save_somclassifier_config(self.config, path / \"config.json\")\n self.model.save(str(path / \"model.h5\"))\n io_functions.save_joblib(self.binarizer, path / \"binarizer.joblib\")\n\n io_functions.save_json(self.data_ids[\"validation\"], path / \"id... | [
"0.7375198",
"0.73201835",
"0.7275228",
"0.72446775",
"0.71978945",
"0.7173624",
"0.71645725",
"0.71221966",
"0.71123177",
"0.7020637",
"0.69833195",
"0.6982963",
"0.69592774",
"0.6959015",
"0.690435",
"0.68858427",
"0.6864155",
"0.6848267",
"0.684122",
"0.6808882",
"0.679161... | 0.7410444 | 0 |
Same function as save | def save_pretrained(self, path):
return self.save(path) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save():",
"def save():\n pass",
"def save(self, obj):",
"def save (self):\n pass",
"def save(self):\n pass",
"def save(self):\n pass",
"def save(self):\n pass",
"def save(self):\n pass",
"def save(self):\n pass",
"def save(self):\n # TOD... | [
"0.92170054",
"0.8719974",
"0.83308494",
"0.82889223",
"0.8203869",
"0.8203869",
"0.8203869",
"0.8203869",
"0.8203869",
"0.8168083",
"0.80858004",
"0.8025579",
"0.8005009",
"0.7971303",
"0.79261404",
"0.79261404",
"0.79261404",
"0.79249805",
"0.79249805",
"0.79249805",
"0.781... | 0.0 | -1 |
method to create entries | def creating_entry(self):
response = ""
today = str(date.today())
curent_time = str(datetime.time(datetime.now()))
entry = Diary(self.entry_id, self.title, self.body)
lst = {}
lst["entry_id"] = entry.entry_id
lst["title"] = entry.title
lst["date"] = today
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_entry(entry):\n Entry.create(**entry)\n return entry",
"def create_and_add_entry(self, **attrs):\n return self.add_entry(self.create_entry(**attrs))",
"def create(self):",
"def new_entry():\n clear_screen()\n entry = {}\n entry['id'] = get_next_id()\n entry['name'] = input... | [
"0.74073875",
"0.7049438",
"0.673739",
"0.6715712",
"0.66536736",
"0.66536736",
"0.6581046",
"0.65393996",
"0.6529814",
"0.6471664",
"0.6468275",
"0.6409988",
"0.64099157",
"0.64099157",
"0.64099157",
"0.6397284",
"0.6391721",
"0.6385852",
"0.63849086",
"0.6370306",
"0.634165... | 0.717518 | 1 |
method to get all entries | def all_entries(cls):
info = Diary.entries
response = jsonify({"data": info})
response.status_code = 200
return response | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def all(self):\n self.scan()\n return self.entries",
"def get_entries_all(self):\n if self.database is None:\n raise DatabaseNotOpened('No KeePass Database Opened.')\n else:\n return self.database.find_entries_by_title('.*', \n ... | [
"0.81555045",
"0.76694393",
"0.76440334",
"0.74271727",
"0.73591536",
"0.73557824",
"0.7346058",
"0.7323283",
"0.7294528",
"0.7184737",
"0.7123756",
"0.7123756",
"0.70815015",
"0.70392114",
"0.70088154",
"0.6935079",
"0.69260496",
"0.692346",
"0.6865673",
"0.68259686",
"0.681... | 0.73865086 | 4 |
method to get single entry | def single_entry(cls, entryid):
data = "invalid URL,Try again"
response = jsonify({"data": data})
response.status_code = 404
for info in Diary.entries:
if info['entry_id'] == entryid:
response = jsonify({"data": info})
response.status_code = 20... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_entry(self, entry_id):\n entry = self.entries.find_one({'id': entry_id}, projection={'_id': 0})\n return entry",
"def get(self, id):\n return Entry.query.filter(Entry.id == id).one()",
"def fetch_entry(self, entry_id, **args):\n return self.fetch(\"/entry/\" + entry_id, **ar... | [
"0.7979427",
"0.7745298",
"0.7446515",
"0.72231567",
"0.71015435",
"0.70682955",
"0.70370704",
"0.69215214",
"0.6893759",
"0.6842423",
"0.6797373",
"0.6763553",
"0.67345667",
"0.6724843",
"0.6711598",
"0.6514311",
"0.64815724",
"0.64600176",
"0.6412111",
"0.6411839",
"0.64083... | 0.68132854 | 10 |
method to update entries | def updating_entry(cls, entryid, data):
result = "invalid URL, cannot update"
response = jsonify({"data": result})
response.status_code = 404
now = datetime.now()
new_date = now.strftime("%c")
for info in Diary.entries:
if info['entry_id'] == entryid:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_entries(entries: Entries, data: dict) -> None:\n # TODO: Is mutating the list okay, making copies is such a pain in the ass\n for entry in entries:\n entry.update(data)",
"def update():",
"def update():",
"def update( ):\r\n pass",
"def update(*args):",
"def upd... | [
"0.7209996",
"0.7179901",
"0.7179901",
"0.70360386",
"0.7023842",
"0.6919768",
"0.6919768",
"0.6919768",
"0.69104016",
"0.69077516",
"0.68526644",
"0.6843436",
"0.6821559",
"0.68168163",
"0.6752249",
"0.6726927",
"0.66631556",
"0.665054",
"0.6647949",
"0.6647949",
"0.6647949"... | 0.64974666 | 49 |
Takes a naturallanguage sentence and returns a POS tagged version. | def tag(self, text):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_for_pos_tagging(sentence):\n try:\n return \" \".join([token.form + \"/\" + token.upos for token in sentence])\n except TypeError: # if a POS tag is missing\n return \"\"",
"def convert_pos_tag(tag):\n # Source: https://www.programcreek.com/python/example/91610/nltk.corpus.wordn... | [
"0.7141937",
"0.6886522",
"0.66606313",
"0.646352",
"0.6452857",
"0.6313468",
"0.6278701",
"0.6268843",
"0.62244505",
"0.6193162",
"0.6185941",
"0.6173259",
"0.61638516",
"0.6159604",
"0.61551553",
"0.6118951",
"0.60944736",
"0.60944736",
"0.60944736",
"0.60944736",
"0.609447... | 0.0 | -1 |
Forward twisted logs to the python stdlib logger. | def twistedLogObserver(eventDict):
n = 2
module = 'twisted'
while True:
try:
caller = sys._getframe(n)
except ValueError:
break
name = caller.f_globals.get('__name__')
if name not in (None, 'twisted.python.log'):
module = name
b... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _alter_logger(*args, **kwargs):\n\n # TODO: dress up root logger here under Celery\n # configure_logging()\n pass",
"def Log(message):\n log_mod = sys.modules.get('twisted.python.log')\n if log_mod:\n log_mod.msg(message)\n else:\n print message",
"def setup_logger():\n root = logging.... | [
"0.6573398",
"0.6544858",
"0.6533331",
"0.6466651",
"0.6412817",
"0.6195713",
"0.61682737",
"0.61235356",
"0.6119762",
"0.6104155",
"0.60603535",
"0.60477364",
"0.60468274",
"0.6032671",
"0.60320276",
"0.60292095",
"0.60277015",
"0.6025815",
"0.6004273",
"0.60029143",
"0.5961... | 0.660194 | 0 |
Log a Twisted Failure object with traceback. Suitable for use as an errback. | def logFailure(failure, msg='Unhandled exception in deferred:'):
logging.error('%s\n%s', msg, failure.getTraceback()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _logError(self, failure):\r\n try:\r\n failure.printTraceback()\r\n except:\r\n print('Could not print traceback of failure, print error '\r\n 'message instead:')\r\n print(failure.getErrorMessage())",
"def traceback_hook(type, value, traceback)... | [
"0.6952767",
"0.65461653",
"0.65011835",
"0.63761",
"0.6218661",
"0.6216443",
"0.61358964",
"0.6120387",
"0.60622317",
"0.6036452",
"0.6007453",
"0.60013145",
"0.5989881",
"0.5825196",
"0.57672983",
"0.5751573",
"0.5717206",
"0.56846493",
"0.56739634",
"0.5663092",
"0.5657386... | 0.7511296 | 0 |
The differential equation of the Induction Motor. | def electrical_ode(self, state, u_sr_alphabeta, omega, *args):
return np.matmul(self._model_constants, np.array([
# omega, i_alpha, i_beta, psi_ralpha, psi_rbeta, omega * psi_ralpha, omega * psi_rbeta, u_salpha, u_sbeta, u_ralpha, u_rbeta,
omega,
state[self.I_SALPHA_IDX],
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def differential(self):\n return self._differential",
"def f( self , x , u , t ):\n \n dx = np.zeros(self.n) # State derivative vector\n \n ################################################\n # Place holder: put the equations of motion here\n raise NotImplementedEr... | [
"0.65110767",
"0.6499808",
"0.6391697",
"0.63783026",
"0.6355503",
"0.63359916",
"0.6332624",
"0.6305126",
"0.6285576",
"0.6285481",
"0.62696207",
"0.62357086",
"0.61858493",
"0.6168313",
"0.6123732",
"0.61195797",
"0.61195797",
"0.6113994",
"0.6054803",
"0.6033857",
"0.60268... | 0.0 | -1 |
Calculate Flux limits for given current and magneticfield angle | def _flux_limit(self, omega=0, eps_mag=0, u_q_max=0.0, u_rq_max=0.0):
mp = self.motor_parameter
l_s = mp['l_m'] + mp['l_sigs']
l_r = mp['l_m'] + mp['l_sigr']
l_mr = mp['l_m'] / l_r
sigma = (l_s * l_r - mp['l_m'] ** 2) / (l_s * l_r)
# limiting flux for a low omega
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def magnet_limits(self):\n max_currents = self.pv_monitor.get_max_currents()\n\n strengths = [np.array([max_currents[0],\n -max_currents[1],\n max_currents[2], 0, 0]),\n np.array([0, 0, max_currents[2],\n ... | [
"0.67609036",
"0.6139057",
"0.6093792",
"0.60318834",
"0.5932127",
"0.5922429",
"0.58925015",
"0.58271277",
"0.57542443",
"0.57087165",
"0.56882066",
"0.5674291",
"0.5637041",
"0.56301844",
"0.559757",
"0.5552885",
"0.55398893",
"0.5495456",
"0.5447273",
"0.5438389",
"0.54375... | 0.6304191 | 1 |
Loads, scales, add sum and returns the card's ratings per archetype | def get_ratings(self):
df = pd.read_csv(IoManager.CARD_RATINGS_FILE_PATH)
df = IoManager.scale_ratings(df)
df = IoManager.normalize_ratings_per_archetype(df)
df = self.add_ratings_sum(df)
# print(df[["name", "monogreen", "simic_ramp", "general"]].tail(60))
# print(d... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate(self):\n\n rating = 0\n\n props = ['aroma', 'appearance', 'taste', 'palate', 'bottle_style']\n for item in props:\n rating += getattr(self, item, 0)\n\n self.overall = (rating / self.total) / .2",
"def normalize_ratings_per_archetype(ratings):\n archety... | [
"0.6380344",
"0.61968863",
"0.5909384",
"0.55840695",
"0.5580369",
"0.55455184",
"0.55112666",
"0.5488847",
"0.54406595",
"0.5376693",
"0.5336506",
"0.5311914",
"0.53039163",
"0.5274228",
"0.5263589",
"0.52398807",
"0.5232894",
"0.521996",
"0.521996",
"0.52112716",
"0.5173465... | 0.6660048 | 0 |
The gap between a 3 and a 4 is wider than 1/3 better | def scale_ratings(ratings):
mapping = {
2: 3,
3: 8,
4: 30,
5: 60
}
ratings = ratings.applymap(lambda e: mapping[e] if e in mapping else e)
return ratings | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gap(l):\n if l < 3:\n return 0\n\n # places one person in the middle of the gap,\n # and starts over on the new smaller gaps on either side.\n return gap(int(l / 2)) + 1 + gap(ceil(l / 2) - 1)",
"def test_frac_same_gaps(self):\n s1 = self.RNA(\"AAAA\")\n s... | [
"0.6261256",
"0.5986721",
"0.5811899",
"0.5776205",
"0.56696147",
"0.56601644",
"0.5634589",
"0.5604828",
"0.551467",
"0.54931474",
"0.5490927",
"0.5486282",
"0.54767895",
"0.54586583",
"0.5427611",
"0.5420678",
"0.5389195",
"0.5386266",
"0.5353105",
"0.5300111",
"0.52981627"... | 0.0 | -1 |
Divides each rating by a value proportional to the sum of all the ratings in the archetype | def normalize_ratings_per_archetype(ratings):
archetype_cols = [c for c in ratings.columns if c != "name"]
n_cards = len(ratings["monored"])
for arch_col in archetype_cols:
ratings[arch_col] = ratings[arch_col] / (ratings[arch_col].sum() / n_cards)
return ratings | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate(self):\n\n rating = 0\n\n props = ['aroma', 'appearance', 'taste', 'palate', 'bottle_style']\n for item in props:\n rating += getattr(self, item, 0)\n\n self.overall = (rating / self.total) / .2",
"def average_rating(self):\n return ( self.rating_1 + se... | [
"0.6732126",
"0.6466219",
"0.6354308",
"0.6154052",
"0.6071842",
"0.60431087",
"0.601784",
"0.59927374",
"0.59915966",
"0.59524244",
"0.5936136",
"0.5898596",
"0.58605075",
"0.5803156",
"0.5800903",
"0.5756226",
"0.573754",
"0.5710812",
"0.56885886",
"0.56883645",
"0.56880826... | 0.6568107 | 1 |
Returns which cards we have downloaded images for (of the specified language, en or fr) | def get_downloaded_images(lang="en"):
path = IoManager.CARD_IMAGES_PATH_EN if lang == "en" else IoManager.CARD_IMAGES_PATH_FR
Path(path).mkdir(parents=True, exist_ok=True)
file_names_en = [f for f in listdir(path) if
isfile(join(path, f))]
card_names = [f[:-4] fo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def download_card_images(self, card_names, lang=\"en\"):\n for card_name in card_names:\n print(\"Dowloading card imgs for \\'\" + card_name + \"\\' (\" + lang + \")\")\n output_file_name = card_name + \".jpg\"\n output_file_path = IoManager.CARD_IMAGES_PATH_EN + \"/\" + out... | [
"0.6827145",
"0.67701286",
"0.65849847",
"0.5614944",
"0.55986357",
"0.55533844",
"0.5530028",
"0.5465683",
"0.54479086",
"0.5424347",
"0.5316803",
"0.5239201",
"0.5239081",
"0.52309775",
"0.5227534",
"0.519252",
"0.51657206",
"0.515859",
"0.514055",
"0.51235837",
"0.5105135"... | 0.7632202 | 0 |
Returns which cards we miss images for | def get_missing_images(self):
downloaded_images_en = IoManager.get_downloaded_images(lang="en")
downloaded_images_fr = IoManager.get_downloaded_images(lang="fr")
complete_list = self.cube_list + IoManager.BASIC_LANDS
missing_images_en = [card for card in complete_list if card not in down... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def image_comparison(self):\n for result in self.cards:\n if result.image_status:\n return True\n return False",
"def get_images_bytesize_match(self, images):\r\n cnt = 0\r\n MAX_BYTES_SIZE = 15728640\r\n good_images = []\r\n for image in images... | [
"0.6058513",
"0.57476836",
"0.57151556",
"0.5685657",
"0.5677294",
"0.56010586",
"0.55934155",
"0.5563497",
"0.5537158",
"0.55090606",
"0.5498323",
"0.549093",
"0.54860824",
"0.5450436",
"0.5446004",
"0.54443866",
"0.5434272",
"0.54127556",
"0.53991973",
"0.53977275",
"0.5389... | 0.692412 | 0 |
Downloads the en and fr card image of each card | def download_card_images(self, card_names, lang="en"):
for card_name in card_names:
print("Dowloading card imgs for \'" + card_name + "\' (" + lang + ")")
output_file_name = card_name + ".jpg"
output_file_path = IoManager.CARD_IMAGES_PATH_EN + "/" + output_file_name if lang =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_downloaded_images(lang=\"en\"):\n path = IoManager.CARD_IMAGES_PATH_EN if lang == \"en\" else IoManager.CARD_IMAGES_PATH_FR\n Path(path).mkdir(parents=True, exist_ok=True)\n file_names_en = [f for f in listdir(path) if\n isfile(join(path, f))]\n card_name... | [
"0.6921706",
"0.6450962",
"0.6377",
"0.6337459",
"0.60916305",
"0.60854703",
"0.5967566",
"0.5942896",
"0.58616376",
"0.58562416",
"0.5838658",
"0.57420564",
"0.5741461",
"0.57366806",
"0.57327133",
"0.57137054",
"0.56456494",
"0.5644481",
"0.5608249",
"0.56000626",
"0.558310... | 0.80364513 | 0 |
Checks for missing images, and downloads them if any are found | def download_missing_images(self, only_english: bool = True):
print("\nChecking for missing images")
missing_images_en, missing_images_fr = self.get_missing_images()
for card_names, lang in [(missing_images_en, "en"), (missing_images_fr, "fr")]:
if card_names and (not only_english or... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def downloadImages(self):\n\t\ti = 0\n\t\tfor im in self.images:\n\t\t\t# Let's get the file extension and file name and make the final file path. \n\t\t\t# We need to do this to slugify the file name and avoid errors when loading images\n\t\t\tfile_name, file_extension = os.path.splitext(im['url'])\n\t\t\tfile_na... | [
"0.7083034",
"0.68719465",
"0.673285",
"0.6715235",
"0.6713619",
"0.6664665",
"0.659402",
"0.6578242",
"0.652952",
"0.6501214",
"0.6467159",
"0.6465091",
"0.6464454",
"0.6458772",
"0.6445216",
"0.6426162",
"0.64172775",
"0.6410692",
"0.6388483",
"0.6357596",
"0.6347212",
"0... | 0.6853467 | 2 |
Adds the new entries to the db | def save_arch_presence(self, arch_presence_entries):
df = IoManager.get_arch_presence()
print(len(arch_presence_entries[0]))
df2 = pd.DataFrame(data=arch_presence_entries, columns=self.archetypes.get_archetype_names(as_feature_names=True))
new_df = pd.concat([df, df2], sort=False)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_entry_to_db(entry):\n db.session.add(entry)\n db.session.commit()",
"def test_new_entries_are_added(db_session):\n for entry in ENTRIES:\n row = Entries(title=entry[\"title\"], creation_date=entry[\"creation_date\"], body=entry[\"body\"])\n db_session.add(row)\n query = db_s... | [
"0.7461566",
"0.72153276",
"0.7015225",
"0.6997762",
"0.6925729",
"0.68381536",
"0.6832269",
"0.6737517",
"0.6737517",
"0.6718508",
"0.66478074",
"0.66156644",
"0.65608704",
"0.6548754",
"0.65438336",
"0.65438336",
"0.65438336",
"0.6514425",
"0.6510781",
"0.65020245",
"0.6478... | 0.0 | -1 |
Pretty prints a dictionary. | def pretty_print(d, indent=0):
for key, value in d.items():
print('\t' * indent + str(key) + ":")
if isinstance(value, dict):
pretty_print(value, indent + 1)
else:
print('\t' * (indent + 1) + str(value)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pretty_dict(d):\n return '{%s}' % ', '.join('%r: %r' % (k, v)\n for k, v in sorted(d.items(), key=repr))",
"def _format_dict(self, dict_, indent=0):\n prefix = indent*\" \"*4\n output = \"{\\n\"\n for key, val in sorted(dict_.items()):\n if isin... | [
"0.8129485",
"0.7979403",
"0.77767885",
"0.77481365",
"0.7565762",
"0.7528162",
"0.7513119",
"0.7488116",
"0.7456188",
"0.74134594",
"0.7373054",
"0.7295989",
"0.7292516",
"0.72703886",
"0.7220195",
"0.71887636",
"0.71631026",
"0.71572983",
"0.7155567",
"0.7155567",
"0.703044... | 0.78974617 | 2 |
Instantiates an instance of MyLogisticRegression | def __init__(self, sim_size=20, test_size=0.25):
super().__init__(sim_size, test_size)
self.setting = 'n neighbors' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n super().__init__()\n import sklearn\n import sklearn.linear_model\n self.model = sklearn.linear_model.LogisticRegression",
"def __init__(self, reg_penalty='l2', reg_inv=1.0, k_fold=5, random_state=0):\n print(\"Initialize model Logistic Regression\")\n self.reg_pen... | [
"0.8087153",
"0.76647913",
"0.76057726",
"0.74503815",
"0.74361885",
"0.7393527",
"0.73817176",
"0.7339038",
"0.7296387",
"0.7256845",
"0.72353274",
"0.7206931",
"0.7062444",
"0.6916837",
"0.6718341",
"0.6698887",
"0.6692653",
"0.6632343",
"0.6632128",
"0.660655",
"0.6558617"... | 0.0 | -1 |
Train KNN model Return 2 tuple of pandas DataFrame for train and test accuracy score | def train_model(self, X, y, nlist=None, n_jobs=None):
self._X = X
self._y = y
if nlist is None:
nlist = self.nlist
else:
self.nlist = nlist
# Result dataframes
self._df_train = pd.DataFrame()
self._df_test = pd.DataFrame()
with tqdm... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def knn(trainingSetData, testSetData, k):\n trainingSet = trainingSetData.drop([14], axis=1) # drop income\n testSet = testSetData.drop([14], axis=1) # drop income\n\n distances = {}\n # this will store the distances re-sorted in ascending/descending order\n sort = {}\n # income band results (>... | [
"0.6956006",
"0.6943758",
"0.68212664",
"0.681758",
"0.67034423",
"0.6650995",
"0.66190994",
"0.6614645",
"0.65811896",
"0.65773576",
"0.6573686",
"0.65204805",
"0.6511421",
"0.6480069",
"0.6454889",
"0.6438703",
"0.6435534",
"0.6403415",
"0.6373908",
"0.63148457",
"0.631065"... | 0.64175934 | 17 |
Return the top predictors, model must be first trained | def get_toppredictors(self, n_neighbors=None):
if self._df_test is None:
raise RuntimeError('MyKNNClassifier: please train the '
'model first')
elif n_neighbors is None:
n = self.get_bestparameter()
else:
n = n_neighbors
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_top_predictions(preds, top=5):\n results = []\n for pred in preds:\n top_indices = pred.argsort()[-top:][::-1]\n # result = [tuple(CLASS_INDEX[str(i)]) + (pred[i],) for i in top_indices]\n # result.sort(key=lambda x: x[2], reverse=True)\n # results.append(result)\n retu... | [
"0.6860322",
"0.66917396",
"0.66076756",
"0.6452024",
"0.6452024",
"0.6452024",
"0.63425475",
"0.6330959",
"0.62971634",
"0.6219174",
"0.6159492",
"0.6152109",
"0.6101522",
"0.6079387",
"0.60596144",
"0.6025629",
"0.6020034",
"0.6004894",
"0.59797865",
"0.59714454",
"0.593968... | 0.0 | -1 |
Return a confusion matrix, classification report, and matplotlib.axes.Axes of confusion matrix in dictionary form | def get_metric(self, X=None, y=None,
random_state=None, n_neighbors=None, ax=None):
param = self._set_data(X, y, random_state, n_neighbors)
X = param['X']
y = param['y']
ds = train_test_split(X, y, test_size=self.test_size,
random_state=ra... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def conf_matrix(model, X_train, y_train, X_test, y_test, train=True):\n from sklearn.metrics import confusion_matrix\n import itertools\n if train==True: \n ypredTrain = model.predict(X_train)\n cm = confusion_matrix(y_train, ypredTrain)\n def plot_conf_matrix(cm, classes, title='C... | [
"0.68781376",
"0.68362397",
"0.6781775",
"0.6672712",
"0.66222155",
"0.6609204",
"0.65948915",
"0.6585669",
"0.6573767",
"0.65571666",
"0.65413755",
"0.6507808",
"0.6453033",
"0.64469814",
"0.64313364",
"0.6412364",
"0.63966286",
"0.6386278",
"0.63823116",
"0.6377449",
"0.636... | 0.0 | -1 |
Return the best parameter | def get_bestparameter(self):
if self._df_test is None:
raise RuntimeError('get_bestparameter: please the '
'train model first')
mean = self._df_test.mean(axis=1)
if len(mean) == 1:
result = mean.idxmax()
elif len(mean) == 2:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def best_params(self):\n return self.X[np.argmax(self.y.numpy())]",
"def _get_lip_best(self) -> float:\n pass",
"def best_value(self):\r\n return self._best_value",
"def get_optimal_param(data_desc, ml_model_desc):\n if ml_model_desc == 'ANN': \n # return [<num_layers>, <momentum>,... | [
"0.79020077",
"0.7498789",
"0.7307663",
"0.7186653",
"0.7182248",
"0.7182248",
"0.71787816",
"0.714562",
"0.70670503",
"0.7066399",
"0.7063416",
"0.70483625",
"0.69959056",
"0.69871986",
"0.69608027",
"0.6891115",
"0.68689346",
"0.67962205",
"0.6790799",
"0.6789823",
"0.67789... | 0.7805949 | 2 |
Generate images using pretrained network pickle. | def generate_images(
network_pkl,
seeds,
truncation_psi,
noise_mode,
outdir
):
print('Loading networks from "%s"...' % network_pkl)
# device = torch.device('cuda')
device = torch.device('cpu')
with dnnlib.util.open_url(network_pkl) as f:
G = legacy.load_network_pkl(f)['G_e... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_data(self):\n # make sure preprocessing is same as preprocessing as the network\n # reduce mean, and divide by a value to do scaling\n self.train_datagen = ImageDataGenerator(\n rescale=1./ 255,\n shear_range=0.05,\n rotation_range=20, # randomly rota... | [
"0.6521632",
"0.64640135",
"0.6414876",
"0.6319254",
"0.62962353",
"0.62662005",
"0.6203831",
"0.61933243",
"0.6185996",
"0.6172128",
"0.61563635",
"0.6125293",
"0.610219",
"0.6065702",
"0.60526216",
"0.60506034",
"0.6046957",
"0.6046304",
"0.60312176",
"0.60269386",
"0.60013... | 0.6844513 | 0 |
Do not return anything, modify nums inplace instead. | def nextPermutation(self, nums: List[int]) -> None:
inc_index = len(nums) - 1
for i in range(len(nums)-2, -1,-1):
if nums[inc_index] <= nums[i]:
inc_index = i
else:
break
if inc_index == 0:
self.flip(nums, inc_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fn(i):\n if i == len(nums): ans.append(nums.copy())\n for j in range(i, len(nums)): \n nums[i], nums[j] = nums[j], nums[i]\n fn(i+1)\n nums[i], nums[j] = nums[j], nums[i]",
"def double_nums(num_list):",
"def remove_dups(nums):\r\n nums[:... | [
"0.70469916",
"0.67161703",
"0.66934896",
"0.6586775",
"0.6501143",
"0.6482345",
"0.6442288",
"0.6407945",
"0.6376896",
"0.6372343",
"0.63671577",
"0.6365932",
"0.63512594",
"0.6328759",
"0.6298402",
"0.62855035",
"0.62671727",
"0.62472045",
"0.62221444",
"0.6193869",
"0.6188... | 0.0 | -1 |
Write the persistant SPET run number. | def write(lock_file):
try:
run_num = 1
if os.path.isfile(lock_file):
current_value = file.read(lock_file)
if current_value:
run_num = int(current_value) + 1
file.write(lock_file, str(run_num))
except IOError as err:
logging.error(err) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_run(run):\n r=Run(run)\n r.write_all()",
"def saveseed(self, seed):\n savefile = gettempdir() + '/last_test_seed_fate.tmp'\n if args.verbose:\n print('Saving run into ' + savefile)\n with open(savefile, 'w') as f:\n f.write(str(seed))",
"def save(self)... | [
"0.5979915",
"0.5911559",
"0.57724327",
"0.57407415",
"0.5733144",
"0.57181674",
"0.5636713",
"0.5612512",
"0.5544363",
"0.552181",
"0.5496353",
"0.5488646",
"0.54772437",
"0.5449901",
"0.5441456",
"0.5425442",
"0.5416367",
"0.5415051",
"0.5407263",
"0.5366748",
"0.53615004",... | 0.5339735 | 24 |
Get the current SPET run number. | def read(lock_file):
try:
return "{:03d}".format(int(file.read(lock_file).strip()))
except IOError as err:
logging.error(err) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_number(self):\n return self._runNumber",
"def getRunId(self):\n return self.runid",
"def run_id(self) -> str:\n return self._step_execution_context.run_id",
"def RunNumber(self):\n if self._dataframe is DataframeEnum.SkimmedNtuple:\n return self._event.RunNumber\n elif... | [
"0.81349736",
"0.6839166",
"0.6824378",
"0.67494816",
"0.66669965",
"0.66590947",
"0.6639686",
"0.6609071",
"0.65797096",
"0.6563909",
"0.65003437",
"0.63520664",
"0.63520664",
"0.63482714",
"0.62824297",
"0.6149616",
"0.6144756",
"0.6078331",
"0.603124",
"0.5951322",
"0.5950... | 0.0 | -1 |
Plot the prediction on the training and validation set. Inputs | def plot_predictions(net, x_train, y_train, idx_train, x_val, y_val, idx_val):
fig, (ax1, ax2) = plt.subplots(nrows=2, figsize=(20, 30))
pred1 = net.predict(x_val, batch_size=batch_size)
# print("pred1.shape:", pred1.shape)
ax1.plot(idx_val, y_val, label="Actual Data", marker="+")
ax1.plot(idx_val, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_predictions(self):\n\n plt.title(\"Targets vs. Predictions\")\n plt.plot(self.T, label=\"Targets\")\n plt.plot(self.Y, label=\"Predictions\")\n plt.xlabel(\"Sample number\")\n plt.legend()\n plt.show()",
"def plot_predictions(\n train_data, train_labels, test... | [
"0.7995283",
"0.7779081",
"0.7456024",
"0.7397582",
"0.72995585",
"0.7211775",
"0.7208045",
"0.71841884",
"0.7167495",
"0.7039762",
"0.7039762",
"0.7009505",
"0.70035166",
"0.6922596",
"0.69057924",
"0.6867257",
"0.68447304",
"0.6805223",
"0.6787511",
"0.6778143",
"0.67530954... | 0.76417714 | 2 |
Plot training & validation loss values. Inputs | def plot_loss_vs_epoch(history, var_train, var_val, show=False):
plt.figure(figsize=(10, 8))
plt.grid(True)
plt.plot(history.history['loss']/var_train, marker="o")
plt.plot(history.history['val_loss']/var_val, marker="o")
plt.title('Model Loss')
plt.ylabel('Loss (Normalised to variance of datase... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_loss(training_errors, validation_errors):\n plt.xscale('Log')\n plt.xlabel('Epochs')\n plt.ylabel('Mean Actual Error')\n plt.plot(training_errors, label = \"Training Error\", \\\n color = 'blue')\n plt.plot(validation_errors, label = \"Validation Error\", \\\n color = 'red')\n... | [
"0.7867429",
"0.78592646",
"0.7805997",
"0.7769233",
"0.7716918",
"0.76086384",
"0.7583472",
"0.75043344",
"0.7502236",
"0.74993914",
"0.74954724",
"0.7421947",
"0.7350023",
"0.7309471",
"0.7306232",
"0.72990686",
"0.72583",
"0.72438455",
"0.7241214",
"0.7193638",
"0.7188506"... | 0.7015908 | 36 |
Generates a 'learning curve' i.e. the analysis for each data size 0 to full. Obsolete function. | def learning_curve():
loss = []
val_loss = []
data_size = []
x_slid, y_slid = sliding_window_main(x, y)
x_train, y_train, x_val, y_val, x_test, y_test = data_splitting_main(x_slid, y_slid)
m_tot = x_train.shape[0]
batch_step = 50
try:
for m in range(batch_size, m_tot, batch_ste... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def finetune_learningrate_createData():\n acc,auc = [],[]\n for i in tqdm([j*0.005 for j in range(1,31)],desc='Progress(max_depth)',ncols=70,smoothing=0.5):\n X_train, X_test, y_train, y_test, X, y_binary = initializing()\n XGBCla = get_XGBmodel(lr=i)\n XGBCla = XGBCla.fit(X_train, y_tra... | [
"0.65476876",
"0.652535",
"0.63539034",
"0.63355064",
"0.62676394",
"0.6246775",
"0.61720693",
"0.6154492",
"0.61399",
"0.6103736",
"0.60872924",
"0.60743475",
"0.6020889",
"0.60129255",
"0.6007138",
"0.59935564",
"0.59641993",
"0.5947333",
"0.5942775",
"0.59299177",
"0.59045... | 0.66602564 | 0 |
Function finds entropy of a given set of class labels | def entropy ( target_array ):
return -1 * sum (
[
pipe ( np.sum ( target_array == value ) / len ( target_array ), lambda ratio: ratio * np.log ( ratio ) )
for value in set ( target_array )
]
) # End entropy() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __entropy(self, labels):\n class_probs = np.unique(labels, return_counts=True)[1] / labels.size\n class_prob_logs = np.log2(class_probs)\n entropy = -np.sum(class_probs * class_prob_logs)\n return entropy",
"def get_entropy(*labels):\n entropies = [] #list of entropy values fro... | [
"0.81865084",
"0.80822265",
"0.77153903",
"0.7669256",
"0.75980985",
"0.75456953",
"0.7508981",
"0.7403374",
"0.73444664",
"0.73422587",
"0.71964747",
"0.7112142",
"0.7071382",
"0.70541775",
"0.7049735",
"0.6889866",
"0.6841053",
"0.6830166",
"0.6794126",
"0.67489135",
"0.673... | 0.6390812 | 39 |
Function finds the negative mean squared distance from mean for point in Y (variance) | def negative_mse ( target_array ):
return -1 * mse ( target_array )
# End negative_mse() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mse(x, y):\n\n return (x - y).pow(2).sum(dim=1, keepdim=True).mean() / x.size(1)",
"def rmse(x: np.ndarray, y: np.ndarray):\n x, y = np.copy(x), np.copy(y)\n if x.ndim > 1:\n return np.sqrt(np.nanmean((x-y)**2, axis=1))\n return np.sqrt(np.nanmean((x-y)**2))",
"def d_mse(x, y):\n\n re... | [
"0.69241166",
"0.69005483",
"0.6845944",
"0.67627764",
"0.67190903",
"0.66590434",
"0.6627769",
"0.6610583",
"0.6524916",
"0.65237314",
"0.65040076",
"0.64928967",
"0.64775354",
"0.64648354",
"0.6457528",
"0.6452227",
"0.6450612",
"0.6444482",
"0.64413154",
"0.64091843",
"0.6... | 0.0 | -1 |
Function finds mean squared distance from mean for point in Y (variance) | def mse ( target_array ):
return np.mean ( ( target_array - np.mean ( target_array ) ) ** 2 )
# End mse() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mse(x, y):\n\n return (x - y).pow(2).sum(dim=1, keepdim=True).mean() / x.size(1)",
"def rmse(x: np.ndarray, y: np.ndarray):\n x, y = np.copy(x), np.copy(y)\n if x.ndim > 1:\n return np.sqrt(np.nanmean((x-y)**2, axis=1))\n return np.sqrt(np.nanmean((x-y)**2))",
"def d_mean(x, y):\n ret... | [
"0.6901139",
"0.6851943",
"0.6846584",
"0.68131304",
"0.67818093",
"0.6695487",
"0.66594326",
"0.6637449",
"0.6555009",
"0.65388817",
"0.65273666",
"0.65109974",
"0.65004605",
"0.6492552",
"0.64914644",
"0.64914644",
"0.6474629",
"0.64733547",
"0.64600074",
"0.638137",
"0.636... | 0.6005872 | 94 |
Function to update the values of a TreeSplits object. | def updateTreeValues ( self, feature_column, feature_value, node_type, nodes, children = [ ] ):
self.feature_column = feature_column
self.feature_value = feature_value
self.node_type = node_type
self.nodes = nodes
self.children = children
# End updateTreeValues() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def SetSplitValues(self, *args):\n return _ShapeUpgrade.ShapeUpgrade_SplitCurve_SetSplitValues(self, *args)",
"def split(self):\n pos_median = len(self.keys)/2\n key_median = self.keys[pos_median]\n value_median = self.values[pos_median]\n keys_left = self.keys[:pos_median]\n ... | [
"0.5888695",
"0.56457704",
"0.5637454",
"0.55085474",
"0.5473264",
"0.54514945",
"0.54263914",
"0.53565776",
"0.53152966",
"0.52939975",
"0.5229411",
"0.5209243",
"0.5178123",
"0.5173258",
"0.5074526",
"0.50700766",
"0.5065914",
"0.5059103",
"0.50479466",
"0.5044793",
"0.5040... | 0.57885617 | 1 |
Function to determine whether a node is a leaf (i.e., has no children). | def isNodeLeaf ( self ):
return self.nodes is None or len ( self.nodes ) == 0
# End isNodeLeaf | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isLeaf(node):\n\n return node.left is None and node.right is None",
"def is_leaf(self):\n if len(self.children) == 0: #If the Node has no children, it's a leaf\n return True\n else:\n return False",
"def is_leaf(self, node: ... | [
"0.8605668",
"0.85680234",
"0.853242",
"0.849539",
"0.84208226",
"0.840783",
"0.84036934",
"0.83483315",
"0.83079994",
"0.8281862",
"0.82678497",
"0.82634103",
"0.82323253",
"0.8224074",
"0.8210887",
"0.8189795",
"0.8183536",
"0.8168549",
"0.81192285",
"0.81134427",
"0.810838... | 0.8422532 | 4 |
Function to get the midpoints between values of the feature array to score in determining best split. | def get_valid_midpoints ( feature_array: np.ndarray, target_array: np.ndarray ):
# Get sorted indices
indices = np.argsort ( feature_array )
# Get sorted feature array
sorted_feature_array = feature_array [ indices ]
# Get the differences between adjacent values
feature... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def midpoints(self):\n return self.bins[:, 1]",
"def split(self, X, y, feature_array):\n n, p = X.shape\n\n best_gain = 0\n best_split_point = 0\n best_feature_id = -1\n for feature_id in feature_array:\n cur_gain, cur_split_point = self.find_best_split(\n ... | [
"0.7009221",
"0.66867995",
"0.6500667",
"0.6397656",
"0.6387852",
"0.6146362",
"0.6117075",
"0.6101361",
"0.60497683",
"0.60440624",
"0.6034719",
"0.60301876",
"0.6004744",
"0.59204274",
"0.58992785",
"0.5869794",
"0.5834895",
"0.58053046",
"0.57847375",
"0.5784375",
"0.57631... | 0.70583206 | 0 |
Function to evaluate the goodness of the continuous split value. | def get_split_goodness_fit_continuous (
feature_array: np.ndarray, target_array: np.ndarray, split: float, evaluate_function: Callable
):
# Get above and below the split value
above = feature_array >= split
below = feature_array < split
# Get weighted average evaluate_functi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_split_goodness_fit_continuous(\n arr: np.ndarray, y: np.ndarray, split: float, eval_func: Callable\n ):\n # Get above and below the split value\n above = arr >= split\n below = arr < split\n\n # get weighted average eval_func on the splits\n n_above = np.sum(abo... | [
"0.71865433",
"0.6572121",
"0.6329187",
"0.5955071",
"0.59270036",
"0.5801792",
"0.5749482",
"0.57275933",
"0.5726107",
"0.5710863",
"0.5676883",
"0.5616585",
"0.56147176",
"0.56091195",
"0.5603875",
"0.5592451",
"0.55882514",
"0.5582341",
"0.5575127",
"0.5549959",
"0.5546042... | 0.6943928 | 1 |
Function to get the best split (i.e., minimum number) across many proposed splits. | def get_min_across_splits_continuous (
feature_array: np.ndarray, target_array: np.ndarray, splits: np.ndarray, evaluate_function: Callable
):
n = len ( splits )
if n > 500:
# If many split points, use some threading
with multiprocessing.Pool ( processes = 8 ) as p:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def best_split(self):\r\n best_splits = [[0, None, None]]\r\n impurity, best_S, best_xj = 0, None, None\r\n \r\n for xj in self.x_names:\r\n for S in self.potential_splits(xj):\r\n ir = float(self.impurity_reduction(xj, S))\r\n if ir > impurity:\... | [
"0.7596094",
"0.72380716",
"0.7155916",
"0.67890745",
"0.6748498",
"0.6699499",
"0.6628864",
"0.6618509",
"0.6560878",
"0.65409684",
"0.6411355",
"0.6359434",
"0.6302224",
"0.624653",
"0.6240486",
"0.62339056",
"0.622259",
"0.62120956",
"0.61381125",
"0.6124368",
"0.61219037"... | 0.6504366 | 10 |
Function to get the best continuous split for a column | def get_optimal_continuous_feature_split (
self, feature_matrix: np.ndarray, target_array: np.ndarray, feature_column: int
):
midpoints = BaseTree.get_valid_midpoints ( feature_array = feature_matrix [ :, feature_column ], target_array = target_array )
# If midpoints, get the best one
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_optimal_continuous_feature_split(\n self, X: np.ndarray, y: np.ndarray, feature_col: int\n ):\n midpoints = BaseTree.get_valid_midpoints(arr=X[:, feature_col], y=y)\n # If midpoints, get the best one\n if len(midpoints) > 0:\n return BaseTree.get_min_across_splits_... | [
"0.7231365",
"0.7075939",
"0.68824524",
"0.68168825",
"0.6810663",
"0.67609465",
"0.6757198",
"0.6710196",
"0.6624161",
"0.64982873",
"0.648198",
"0.6418159",
"0.64083916",
"0.64015394",
"0.63641125",
"0.63524777",
"0.62306863",
"0.62056756",
"0.61384755",
"0.60775584",
"0.60... | 0.6824757 | 3 |
Function to get the value of making a discrete split. | def get_discrete_split_value ( feature_array: np.ndarray, target_array: np.ndarray, evaluate_function: Callable ):
# First element is the weighted average evaluate_function of the split
# Second term is the intrinsic value to penalize many splits.
return (
sum (
[
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_discrete_split_value(arr: np.ndarray, y: np.ndarray, eval_func: Callable):\n\n # First element is the weighted average eval_func of the split\n # Second term is the intrinsic value to penalize many splits.\n return (\n sum(\n [\n eval_func(y... | [
"0.65154564",
"0.5932024",
"0.5635929",
"0.56241894",
"0.5608168",
"0.5515022",
"0.5504383",
"0.54864615",
"0.53911495",
"0.5371303",
"0.53537226",
"0.5306154",
"0.5295001",
"0.5242035",
"0.5230267",
"0.5224207",
"0.52195615",
"0.52148545",
"0.5210651",
"0.5210651",
"0.521065... | 0.64066917 | 1 |
Function to get the best split value for a discrete columns | def get_optimal_discrete_feature_split (
self, feature_matrix: np.ndarray, target_array: np.ndarray, feature_column: int
):
return BaseTree.get_discrete_split_value (
feature_matrix [ :, feature_column ], target_array, evaluate_function = self.evaluate_function
) # End get_optima... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def determine_best_split(data, potential_splits, mltask):\n\n first_iteration = True\n for column_index in potential_splits:\n for value in potential_splits[column_index]:\n data_below,data_above = split_data(data, column_index, value)\n \n if mltask == 'regression':\n... | [
"0.74880135",
"0.7095881",
"0.69653386",
"0.6910484",
"0.68618083",
"0.67778367",
"0.6647111",
"0.65734416",
"0.6570264",
"0.6497623",
"0.6492311",
"0.644486",
"0.63778055",
"0.6318494",
"0.63056034",
"0.630296",
"0.6181761",
"0.6156663",
"0.6149908",
"0.61427826",
"0.613402"... | 0.58607 | 29 |
Function to create a terminal node. | def get_terminal_node (
self,
feature_column: int,
node: TreeSplits,
feature_value: float,
feature_matrix: np.ndarray,
target_array: np.ndarray,
):
# Get the node type
node_type = self.map_column_node_type [ feature_column ]
if node_type == "c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_terminal() -> str:\n ...",
"def terminal_node(\n self,\n expr: Any = None,\n ) -> None:\n self.data.append(\n {\n \"type\": \"TERMINAL\",\n \"expr\": expr,\n \"id\": len(\n self.data,\n ... | [
"0.77555245",
"0.7163272",
"0.6366092",
"0.62840253",
"0.6274114",
"0.6256749",
"0.6191868",
"0.61676985",
"0.6153323",
"0.6140978",
"0.6128334",
"0.61176777",
"0.6109941",
"0.6029727",
"0.6004716",
"0.5998977",
"0.5952726",
"0.58835274",
"0.5871811",
"0.5863557",
"0.5851825"... | 0.0 | -1 |
Function to create a continuous node split. | def get_continuous_node (
self,
feature_column: int,
feature_value: float,
feature_matrix: np.ndarray,
target_array: np.ndarray,
node: TreeSplits,
):
node.updateTreeValues (
feature_column = feature_column,
feature_value = feature_value... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_split(self) -> NoReturn:\n raise NotImplementedError",
"def _create_split(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\n\n node.attribute.extend([\n helper.make_attribute('axis', op.axis),\n helper.make_attribute('split', op.parts)... | [
"0.66962695",
"0.65341157",
"0.64728427",
"0.62156624",
"0.6158806",
"0.60809195",
"0.5970829",
"0.5816579",
"0.57917887",
"0.5685064",
"0.5624523",
"0.5579703",
"0.5562783",
"0.55390286",
"0.55183446",
"0.5501418",
"0.5480847",
"0.5439089",
"0.54173994",
"0.540672",
"0.54024... | 0.5380758 | 24 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.