0.5 else 'w')\n\n ax.set_xlabel('PREDICTED class')\n ax.set_ylabel('TRUE class')\n ax.set_title('Accuracy: {:.2f}'.format(np.mean(np.diag(conf))))\n\n # If the compression model is a trainable DCN, include it's validation metrics\n if images_y == 3:\n ax = fig.add_subplot(images_y, images_x, 7)\n ax.plot(flow.codec.performance['loss']['validation'], '.', alpha=0.25)\n ax.plot(helpers.stats.ma_conv(flow.codec.performance['loss']['validation'], 0))\n ax.set_ylabel('DCN loss')\n\n ax = fig.add_subplot(images_y, images_x, 8)\n ax.plot(flow.codec.performance['ssim']['validation'], '.', alpha=0.25)\n ax.plot(helpers.stats.ma_conv(flow.codec.performance['ssim']['validation'], 0))\n ax.set_ylabel('DCN ssim')\n ax.set_ylim([0.8, 1])\n\n ax = fig.add_subplot(images_y, images_x, 9)\n ax.plot(flow.codec.performance['entropy']['validation'], '.', alpha=0.25)\n ax.plot(helpers.stats.ma_conv(flow.codec.performance['entropy']['validation'], 0))\n ax.set_ylabel('DCN entropy')\n\n if save_dir is not None:\n if not os.path.exists(save_dir):\n os.makedirs(save_dir)\n fig.savefig('{}/manip_validation_{:05d}.jpg'.format(save_dir, epoch), bbox_inches='tight', dpi=100)\n del fig\n\n else:\n return fig","def 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()","def layer_show_mean(layer, width, accurs, y_wide=None, title=None, path=None):\n fig = plt.figure(dpi=120, figsize=[8, 6])\n plt.plot(layer, accurs.mean(axis=0), '--o', label='mean_accuracy')\n\n plt.ylim(y_wide)\n plt.xticks(layer)\n plt.xlabel('layers number')\n plt.ylabel('accuracy')\n plt.legend()\n # plt.title(title)\n plt.tight_layout()\n fig.savefig(path)","def plot_all(show=True):\n fig, axes = plt.subplots(max_iterations, 1, figsize=(6, 12))\n for t in range(max_iterations):\n with open('results/%s/df_%d.pkl' % (id, t), 'rb') as f:\n df = pickle.load(f)\n with open('results/%s/w_%d.pkl' % (id, t), 'rb') as f:\n w = pickle.load(f)\n axes[t].hist2d(x=df['vision'], y=df['metab'], weights=w, density=True,\n bins=((xticks, yticks)), cmap='magma')\n axes[t].set_ylabel('max metabolism')\n axes[t].set_xticks(vision_domain)\n axes[t].set_yticks((2, 3, 4))\n axes[3].set_xlabel('max vision')\n fig.tight_layout()\n if show:\n plt.show()\n else:\n plt.savefig('results/%s/abc_results.pdf' % id)","def plot_history(trials, tid, scores=[\"loss\", \"f1\", \"accuracy\"],\n figsize=(15, 3)):\n history = trials.train_history(tid)\n fig = plt.figure(figsize=figsize)\n for i, score in enumerate(scores):\n plt.subplot(1, len(scores), i + 1)\n\n plt.plot(history[score], label=\"train\")\n plt.plot(history['val_' + score], label=\"validation\")\n plt.tight_layout()\n plt.title(score)\n plt.ylabel(score)\n plt.xlabel('epoch')\n plt.legend(loc='best')\n return fig","def PlotEnsemblePredictions(self,ens, sampling_freq=10, fontSizeLabels=24, fontSizeLegend=20,rescale=1.,pow10first=False):\n pylab.figure()\n\tpylab.axes([0.15,0.35,0.95-0.15,0.95-0.35])\n\tdata_experiments = self.data.experiments\n for independentValues in data_experiments:\n Xdata = self.data.X[independentValues]\n Ydata = self.data.Y[independentValues]\n\t Xtheory = scipy.logspace(scipy.log10(min(Xdata)),scipy.log10(max(Xdata)),num=100)\n\t pointType = self.data.pointType[independentValues]\n\t errorBar = self.data.errorBar[independentValues]\n\t mean_theory = scipy.zeros(len(Xtheory))\n\t std_theory = scipy.zeros(len(Xtheory))\n for i in range(0, num_to_count):\n\t\t ens_theory = self.theory.Y(Xtheory,ens[i*sampling_freq],independentValues)\n\t\t mean_theory += ens_theory\n\t\t std_theory += (ens_theory)**2\n\t mean_theory = mean_theory/(1.0*num_to_count)\n\t std_theory = scipy.sqrt((std_theory-num_to_count*mean_theory**2)/(num_to_count-1.))\n\t pylab.loglog(Xdata,Ydata,pointType[1])\n\t lb = self.getLabel(self.theory.independentNames,independentValues,pow10first=pow10first)\n\t pylab.errorbar(Xdata,Ydata, yerr=errorBar, fmt=pointType,label=lb)\n\t pylab.loglog(Xtheory,mean_theory,pointType[0])\n\t axis_dep=self.getAxis(Xdata,Ydata)\n\t #upper_bound = mean_theory+std_theory\n\t #lower_bound = mean_theory-std_theory\n\t upper_bound = scipy.exp(scipy.log(mean_theory) + scipy.log(1.+std_theory/mean_theory)*rescale)\n\t lower_bound = scipy.exp(scipy.log(mean_theory)+scipy.log(1.-std_theory/mean_theory)*rescale)\n\t for i in range(0, len(lower_bound)):\n\t\t if lower_bound[i]<=0:\n\t\t\t lower_bound[i]=10.**(-16)\n\t pylab.fill_between(Xtheory,lower_bound,y2=upper_bound,color=pointType[0],alpha=0.2)\n\n\t for i, Ax in enumerate(axis_dep):\n\t\t ax0[i] =i%2 and max(ax0[i],Ax) or min(ax0[i],Ax)\n\tpylab.axis(tuple(ax0))\n\tpylab.legend(loc=(-0.15,-0.52),ncol=3)","def __init__(self, experiment_count: int, total_tr_data: int, tr_accuracy: [int], total_test_data: int,\n test_accuracy: [int], function_name: str, batch_size: int, title: str=\"CNN Accuracy Plot\"):\n self.title = title\n self.total_tr_data = total_tr_data\n self.total_test_data = total_test_data\n\n # accuracy and last epoch\n self.tr_accuracy = tr_accuracy.ravel()\n self.last_epoch = str(int(self.tr_accuracy[CFG.EPOCHS - 1]))\n self.last_epoch_per = self.tr_accuracy[CFG.EPOCHS - 1]\n self.tr_mean = np.mean(self.tr_accuracy[-(CFG.EPOCHS - 10):])\n self.tr_mean_str = \"{:.2f}\".format(self.tr_mean)\n\n self.test_accuracy = test_accuracy.ravel()\n self.last_epoch = str(int(self.test_accuracy[CFG.EPOCHS - 1]))\n self.last_epoch_per = self.test_accuracy[CFG.EPOCHS - 1]\n self.test_mean = np.mean(self.test_accuracy[-(CFG.EPOCHS - 10):])\n self.test_mean_str = \"{:.2f}\".format(self.test_mean)\n\n # hyperparameters and string equivalents (for formatting easily in overleaf)\n self.function_name = function_name\n self.batch_size = batch_size\n\n # data table specifications\n self.cell_length = len(str(\" \" + str(self.total_tr_data) + \"/\" + str(self.total_tr_data) + \" \"))\n self.total_cells = 3\n self.max_length = (self.cell_length + 1) * (self.total_cells)\n self.tablefile = \"table.txt\"\n self.experiment_count = experiment_count"],"string":"[\n \"def accuracy_plot(LS_sizes, data_fun):\\r\\n\\r\\n opt_neigh = []\\r\\n\\r\\n #plot of optimal n_neighbors as a function of the LS size\\r\\n\\r\\n for size in LS_sizes:\\r\\n\\r\\n acc = []\\r\\n neighbors_values = np.arange(1,size+1,1)\\r\\n\\r\\n # For a given LS size, plots of accuracy(n_neighbors)\\r\\n\\r\\n for value in neighbors_values:\\r\\n\\r\\n X_train, y_train, X_test, y_test = data_fun(n_ts=500, n_ls=size)\\r\\n\\r\\n clf = KNeighborsClassifier(n_neighbors = value)\\r\\n clf = clf.fit(X_train, y_train)\\r\\n acc.append(clf.score(X_test,y_test))\\r\\n\\r\\n plt.figure()\\r\\n plt.plot(neighbors_values,acc, '.')\\r\\n plt.title(\\\"Evolution of accuracy as a function \\\\nof n_neighbors for LS_size = {} samples, for {}.\\\".format(size, data_fun.__name__))\\r\\n plt.savefig(\\\"acc(n_neigh)_{}_{}.pdf\\\".format(size, data_fun.__name__))\\r\\n\\r\\n opt_neigh.append(np.argmax(acc)+1)\\r\\n\\r\\n plt.figure()\\r\\n plt.plot(LS_sizes, opt_neigh, '.')\\r\\n plt.title(\\\"Optimal n_neighbors as a function \\\\nof the size of the learning sample, for {}.\\\".format(data_fun.__name__))\\r\\n plt.savefig(\\\"opt_n_neigh(LS_size)_{}.pdf\\\".format(data_fun.__name__))\",\n \"def make_accuracy_plot(num_trials=10):\\n data = load_digits()\\n # print data.DESCR\\n train_percentages = range(5, 95, 5)\\n test_accuracies = numpy.zeros(len(train_percentages))\\n\\n for i in range(len(train_percentages)):\\n individual_trial_accuracies = []\\n for j in range(num_trials):\\n X_train, X_test, y_train, y_test = train_test_split(data.data, data.target, train_size=train_percentages[i]*.01)\\n model = LogisticRegression(C=10**-10)\\n model.fit(X_train, y_train)\\n individual_trial_accuracies.append(model.score(X_test, y_test))\\n test_accuracies[i] = numpy.mean(individual_trial_accuracies)\\n\\n fig = plt.figure()\\n plt.plot(train_percentages, test_accuracies, 'b')\\n plt.xlabel('Percentage of Data Used for Training')\\n plt.ylabel('Accuracy on Test Set')\\n plt.show()\",\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 cross_validation_visualization_accuracy_multiple(epochs, accs, save=False, filename=\\\"cross_validation_acc_multiple\\\"):\\n \\n for i in range(accs.shape[0]):\\n plt.plot(epochs, accs[i], marker=\\\".\\\", color='r', label=str(i+1)+'th accuracy')\\n \\n plt.xlabel(\\\"epoch\\\")\\n plt.ylabel(\\\"accuracy\\\")\\n plt.title(\\\"cross validation\\\")\\n plt.legend(loc=2)\\n plt.grid(True)\\n if (save):\\n plt.savefig(filename)\",\n \"def train_visualization(output_path): \\n log_path = output_path + 'output.log'\\n Train_Cost, Valid_Cost, Test_Cost, Train_Acc, Valid_Acc, Test_Acc = log_reader(log_path)\\n n_epoch = len(Train_Cost)\\n\\n x1 = range(n_epoch)\\n x2 = range(n_epoch)\\n y1 = Train_Cost\\n y2 = Valid_Cost\\n y3 = Test_Cost\\n y4 = Train_Acc\\n y5 = Valid_Acc\\n y6 = Test_Acc\\n plt.subplot(2, 1, 1)\\n plt.plot(x1, y1, label=\\\"Train_Cost\\\", linewidth=2)\\n plt.plot(x1, y2, label=\\\"Valid_Cost\\\", linewidth=2)\\n plt.plot(x1, y3, label=\\\"Test_Cost\\\", linewidth=2)\\n\\n plt.title('binary cross entropy vs. epoches')\\n plt.ylabel('binary cross entropy')\\n plt.legend(loc='best')\\n plt.subplot(2, 1, 2)\\n plt.plot(x2, y4, label=\\\"Train_Acc\\\", linewidth=2)\\n plt.plot(x2, y5, label=\\\"Valid_Acc\\\", linewidth=2)\\n plt.plot(x2, y6, label=\\\"Test_Acc\\\", linewidth=2)\\n plt.xlabel('Accuracy@20 vs. epoches')\\n plt.ylabel('Accuracy@20')\\n plt.legend(loc='best')\\n plt.savefig(output_path + 'loss_fig.png')\\n # plt.show()\",\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 accuracy_plot(training, test, layers, data_size, n_neighbours, learning_rate, dropout_rate):\\n\\n plt.figure()\\n plt.plot(training, label=\\\"Training\\\")\\n plt.plot(test, label=\\\"Test\\\")\\n plt.xlabel(\\\"Iterations\\\", size='medium')\\n plt.ylabel(\\\"Accuracy function (%)\\\", size='medium')\\n plt.suptitle(\\\"Accuracy function while training the neural network\\\", size='medium', ha='center')\\n plt.title(\\\"layers: {} with dropout rate of {}, learning rate: {}\\\".format(layers, dropout_rate, learning_rate),\\n size='small', ha='center')\\n if n_neighbours == 0:\\n plt.figtext(0.83, 0.80, \\\"Neighbours\\\\nexcluded\\\", size='medium')\\n else:\\n plt.figtext(0.83, 0.80, \\\"{} neighbours\\\\nincluded\\\".format(n_neighbours), size='medium')\\n plt.figtext(0.83, 0.70, \\\"{}\\\\nsamples\\\".format(data_size), size='medium')\\n plt.legend(loc='right', bbox_to_anchor=(1.3, 0.5))\\n plt.subplots_adjust(right=0.8)\\n\\n working_dir = os.path.dirname(os.path.abspath(__file__))\\n saving(working_dir + \\\"/output_ANN/accuracy_plots/{}_accuracy_{}\\\".format(n_neighbours, data_size))\",\n \"def plot_testacc_numlabels(dataset, models, results, path, suffix):\\n res = results[results['dataset'] == dataset]\\n plt.close()\\n for mod in models:\\n res_model = res[res['model'] == mod]\\n res_model.sort_values(by=['num_labels'], inplace=True)\\n plt.scatter(res_model['num_labels'], res_model['test_acc'],\\n label=mod, marker='o')\\n plt.ylabel('test accuracy')\\n plt.xlabel('num labels')\\n plt.title('Dataset: {}'.format(dataset))\\n plt.legend()\\n plt.tight_layout()\\n if suffix is None:\\n plt.savefig('{}{}_performance.png'.format(path, dataset))\\n else:\\n plt.savefig('{}{}_performance_{}.png'.format(path, dataset,\\n suffix))\",\n \"def plot_accuracy_and_loss(histories=None):\\n fig = subplots.make_subplots(rows=2, cols=2, subplot_titles=('Training accuracy', 'Validation accuracy',\\n 'Training loss ', 'Validation loss'))\\n\\n def append_trace(model_name, acc, val_acc, loss, val_loss, epochs):\\n e = list(range(epochs))\\n color = random.choice(hex_colors_only)\\n trace_ta = create_trace(e, acc, model_name, color)\\n trace_va = create_trace(e, val_acc, model_name, color)\\n trace_tl = create_trace(e, loss, model_name, color)\\n trace_vl = create_trace(e, val_loss, model_name, color)\\n\\n fig.append_trace(trace_ta, 1, 1)\\n fig.append_trace(trace_va, 1, 2)\\n fig.append_trace(trace_tl, 2, 1)\\n fig.append_trace(trace_vl, 2, 2)\\n\\n if histories is None:\\n df_accuracies, df_losses = get_tensorboard_scalars()\\n for model_name in df_accuracies.model_name.unique():\\n df_acc = df_accuracies.loc[df_accuracies.model_name == model_name]\\n df_l = df_losses.loc[df_losses.model_name == model_name]\\n\\n acc = df_acc.loc[df_acc.result_of == 'train'].accuracy.values.tolist()\\n val_acc = df_acc.loc[df_acc.result_of == 'validation'].accuracy.values.tolist()\\n loss = df_l.loc[df_l.result_of == 'train'].loss.values.tolist()\\n val_loss = df_l.loc[df_l.result_of == 'validation'].loss.values.tolist()\\n epochs = len(df_acc)\\n\\n append_trace(model_name, acc, val_acc, loss, val_loss, epochs)\\n\\n else:\\n for model_name, history in histories.items():\\n acc = history['accuracy']\\n val_acc = history['val_accuracy']\\n loss = history['loss']\\n val_loss = history['val_loss']\\n epochs = list(range(1, len(acc) + 1))\\n\\n append_trace(model_name, acc, val_acc, loss, val_loss, epochs)\\n fig['layout']['xaxis'].update(title='Epoch')\\n fig['layout']['xaxis2'].update(title='Epoch')\\n fig['layout']['yaxis'].update(title='Accuracy', range=[0, 1])\\n fig['layout']['yaxis2'].update(title='Loss', range=[0, 1])\\n\\n iplot(fig, filename='accuracies-losses')\",\n \"def make_accuracy_plot(ax,\\n groundtruth_boxes,\\n hpu_boxes,\\n cpu_boxes,\\n hpu_strategy,\\n label,\\n N=10,\\n num_graph_points=20,\\n match_mode=\\\"ellipse\\\",\\n):\\n print \\\"Making plot for\\\", repr(label)\\n print \\\"TODO: this should graph seconds per image\\\"\\n mix_fractions = np.linspace(0, 1.0, num_graph_points)\\n # Plot confidence intervals\\n min_ci = []\\n max_ci = []\\n mean_accs = []\\n stderr_accs = []\\n for mix_fraction in mix_fractions:\\n accuracies = [\\n maximum_F_score(\\n groundtruth_boxes,\\n hpu_strategy(hpu_boxes, cpu_boxes, mix_fraction),\\n match_mode=match_mode,\\n )\\n for _ in xrange(N)\\n ]\\n mean_accs.append(np.mean(accuracies))\\n stderr_accs.append(np.std(accuracies, ddof=1) / np.sqrt(N))\\n #print mix_fraction, np.mean(accuracies)\\n ax.errorbar(mix_fractions, mean_accs, stderr_accs, label=label)\\n ax.set_xlabel(\\\"Fraction of HPU-labeled images\\\")\\n ax.set_ylabel(\\\"Maximum F-score\\\")\",\n \"def create_val_plots(x_vals, vals_zeros,vals_ones):\\n plt.plot(x_vals, vals_zeros,label=\\\"non-fraud\\\")\\n plt.plot(x_vals, vals_ones,label=\\\"fraud\\\")\\n plt.title('Accuracy per number of iterations')\\n plt.xlabel('Number of Iterations')\\n plt.ylabel('Accuracy')\\n plt.xticks(np.arange(100, 210, 10))\\n plt.legend() \\n plt.show()\\n # plt.savefig('./analysis_deliverable/visualizations/accuracy_plot.png')\",\n \"def plot_accuracy(model_fit, save_folder): \\n train_acc = model_fit.history['binary_accuracy']\\n val_acc = model_fit.history['val_binary_accuracy']\\n epoch_axis = np.arange(1, len(train_acc) + 1)\\n plt.title('Train vs Validation Accuracy')\\n plt.plot(epoch_axis, train_acc, 'b', label='Train Acc')\\n plt.plot(epoch_axis, val_acc,'r', label='Val Acc')\\n plt.xlim([1, len(train_acc)])\\n plt.xticks(np.arange(min(epoch_axis), max(epoch_axis) + 1, round((len(train_acc) / 10) + 0.5)))\\n plt.legend(loc='lower right')\\n plt.ylabel('Accuracy')\\n plt.xlabel('Epochs')\\n plt.savefig(save_folder + '/accuracy.png')\\n plt.show()\\n plt.close()\",\n \"def show_plots(history):\\n loss_vals = history['loss']\\n val_loss_vals = history['val_loss']\\n epochs = range(1, len(history['accuracy'])+1)\\n \\n f, ax = plt.subplots(nrows=1,ncols=2,figsize=(16,4))\\n \\n # plot losses on ax[0]\\n ax[0].plot(epochs, loss_vals, color='navy',marker='o', linestyle=' ', label='Training Loss')\\n ax[0].plot(epochs, val_loss_vals, color='firebrick', marker='*', label='Validation Loss')\\n ax[0].set_title('Training & Validation Loss')\\n ax[0].set_xlabel('Epochs')\\n ax[0].set_ylabel('Loss')\\n ax[0].legend(loc='best')\\n ax[0].grid(True)\\n \\n # plot accuracies\\n acc_vals = history['accuracy']\\n val_acc_vals = history['val_accuracy']\\n\\n ax[1].plot(epochs, acc_vals, color='navy', marker='o', ls=' ', label='Training Accuracy')\\n ax[1].plot(epochs, val_acc_vals, color='firebrick', marker='*', label='Validation Accuracy')\\n ax[1].set_title('Training & Validation Accuracy')\\n ax[1].set_xlabel('Epochs')\\n ax[1].set_ylabel('Accuracy')\\n ax[1].legend(loc='best')\\n ax[1].grid(True)\\n \\n plt.show()\\n plt.close()\\n \\n # delete locals from heap before exiting\\n del loss_vals, val_loss_vals, epochs, acc_vals, val_acc_vals\",\n \"def plot_results(\\n train_data: tuple[Tensor, Tensor],\\n test_data: tuple[Tensor, Tensor],\\n correct_class: Tensor\\n):\\n #fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(21,7), subplot_kw=dict(box_aspect=1))\\n fig1, (ax1, ax2) = plt.subplots(1, 2, figsize=(14,7), subplot_kw=dict(box_aspect=1))\\n fig2, ax3 = plt.subplots(figsize=(7,7), subplot_kw=dict(box_aspect=1))\\n ax1.set_title('Training data')\\n plot_dataset(train_data, ax1)\\n\\n ax2.set_title('Test data')\\n plot_dataset(test_data, ax2)\\n\\n ax3.set_title('Test prediction correctness')\\n plot_dataset((test_data[0], correct_class.int()), ax3, cmap={0: '#ff0000', 1: '#00ff00'})\\n \\n fig1.savefig('plots/datasets')\\n fig2.savefig('plots/predictions')\\n plt.show()\",\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 show_train_images(train_data, train_labels):\\n plt.figure(1, figsize=(8, 8))\\n n = 0\\n\\n for i in range(16):\\n n += 1\\n # each time random images are loaded\\n # r = np.random.randint(0, train_data.shape[0], 1)\\n plt.subplot(4, 4, n)\\n plt.subplots_adjust(hspace=0.5, wspace=0.5)\\n plt.imshow(train_data[i] / 255.)\\n plt.title('{}'.format(train_labels[i]))\\n plt.xticks([]), plt.yticks([])\\n plt.show()\",\n \"def plot_eval_3(trained_model, X_val, y_val, image_name):\\n # FOR EACH CLASS\\n # val_pred = trained_model.predict_proba(X_val, num_iteration=iteration)\\n \\n iterations = trained_model.booster_.current_iteration()\\n# results = np.zeros((2, iterations))\\n results = np.zeros((iterations,))\\n for pos in range(iterations):\\n \\n # Calculate the current iteration (from 1 to iterations)\\n iteration = pos + 1\\n \\n # Predict validation set for the current iteration\\n# start_time = timeit.default_timer()\\n val_pred = trained_model.predict(X_val, num_iteration=iteration)\\n# end_time = timeit.default_timer()\\n# time = end_time - start_time\\n# speed = int(X_val.shape[0] / time)\\n \\n # Number of hits\\n val_ok = (val_pred == y_val)\\n \\n # Percentage of hits\\n val_acc = val_ok.sum() / val_ok.size\\n \\n # Actualize data for plotting results\\n# results[0][pos] = time\\n# results[1][pos] = val_acc\\n results[pos] = val_acc\\n \\n # Generate accuracy plot\\n plt.figure()\\n# plt.plot(results[0], results[1], 'b')\\n plt.plot(results, 'b')\\n plt.title('Validation accuracy')\\n plt.xlabel('iterations')\\n plt.ylabel('accuracy')\\n plt.legend()\\n \\n # Save validation plot\\n plot_file = os.path.join(OUTPUT_DIR, \\\"{}_val_accuracy\\\".format(image_name))\\n plt.savefig(plot_file + \\\".svg\\\", bbox_inches='tight', format='svg')\",\n \"def plot_results(self):\\n\\n\\n f1, ax1 = plt.subplots()\\n h1, = ax1.plot(self.history[\\\"step\\\"], self.history[\\\"trainLoss\\\"],\\\\\\n \\\"b-\\\", label=\\\"Loss - Train\\\")\\n h2, = ax1.plot(self.history[\\\"step\\\"], self.history[\\\"validLoss\\\"],\\\\\\n \\\"b.\\\", label=\\\"Loss - Validation\\\")\\n\\n ax1.set_ylabel(\\\"Loss\\\", color = \\\"blue\\\")\\n ax1.tick_params(\\\"y\\\", color = \\\"blue\\\")\\n ax1.yaxis.label.set_color(\\\"blue\\\")\\n ax1.set_xlabel(\\\"Training Steps [{}]\\\".format(self.FLAGS.eval_every))\\n\\n ax2 = ax1.twinx()\\n h3, = ax2.plot(self.history[\\\"step\\\"], self.history[\\\"trainAccr\\\"], \\\"r-\\\",\\\\\\n label = \\\"Accuracy - Train\\\")\\n h4, = ax2.plot(self.history[\\\"step\\\"], self.history[\\\"validAccr\\\"], \\\"r.\\\",\\\\\\n label = \\\"Accuracy - Validation\\\")\\n\\n ax2.set_ylabel(\\\"Accuracy\\\", color = \\\"red\\\")\\n ax2.tick_params(\\\"y\\\", color = \\\"red\\\")\\n ax2.yaxis.label.set_color(\\\"red\\\")\\n\\n hds = [h1,h2,h3,h4]\\n lbs = [l.get_label() for l in hds]\\n ax1.legend(hds, lbs)\\n f1.tight_layout()\\n plt.savefig(\\\"trainingHistory.png\\\")\\n\\n plt.close(f1)\\n #plt.show()\",\n \"def visualise_dataset_balancer_results_multi_dataset(dataset_results):\\n current_time = datetime.now().strftime(\\\"%Y-%m-%d_%H-%M-%S\\\")\\n file_name = \\\"raw_dump_{0}.txt\\\".format(current_time)\\n with open(os.path.dirname(os.path.realpath(__file__)) + \\\"/../results/\\\" + file_name, \\\"wb\\\") as output_file:\\n output_file.write(str(dataset_results))\\n sns.set(style='ticks')\\n fig = plt.figure(figsize=(10, 10))\\n ax = fig.add_subplot(1, 1, 1)\\n markers = [\\\"s\\\", \\\"o\\\", \\\"^\\\", \\\"d\\\", \\\"*\\\"]\\n sizes = [150, 200, 200, 200, 250]\\n colors = [\\\"#64B3DE\\\", \\\"#1f78b4\\\", \\\"#B9B914\\\", \\\"#FBAC44\\\", \\\"#bc1659\\\", \\\"#33a02c\\\", \\\"#6ABF20\\\", \\\"#ff7f00\\\", \\\"#6a3d9a\\\", \\\"grey\\\", \\\"#b15928\\\", \\\"#e31a1c\\\", \\\"black\\\"]\\n hatches = [None, \\\"////\\\", \\\"..\\\"]\\n color_dict = {}\\n index = 0\\n for (classifier_description, result_arr) in dataset_results[0][1]:\\n color_dict[classifier_description] = colors[index]\\n index += 1\\n\\n # Move left y-axis and bottom x-axis to centre, passing through (0,0)\\n ax.spines['left'].set_position('center')\\n ax.spines['bottom'].set_position((\\\"axes\\\", 0.5))\\n\\n # Eliminate upper and right axes\\n ax.spines['right'].set_color('none')\\n ax.spines['top'].set_color('none')\\n\\n # Show ticks in the left and lower axes only\\n ax.xaxis.set_ticks_position('bottom')\\n ax.yaxis.set_ticks_position('left')\\n ax.set_axis_on()\\n ax.spines['left'].set_color('black')\\n ax.spines['bottom'].set_color('black')\\n plt.xlabel(\\\"Change in TPR\\\")\\n plt.ylabel(\\\"Change in TNR\\\")\\n\\n ax.xaxis.set_label_coords(0.1, 0.53)\\n ax.yaxis.set_label_coords(0.53, 0.9)\\n\\n plt.ylim(-0.3, 0.3)\\n plt.xlim(-0.3, 0.3)\\n data_set_labels = ([], [])\\n balancer_labels = ([], [])\\n data_set_index = 0\\n for (data_set, dataset_result) in dataset_results:\\n balancer_result_pos = {}\\n balancer_result_neg = {}\\n\\n for (classifier_description, result_arr) in dataset_result:\\n for (balancer_description, results) in result_arr:\\n if balancer_description in balancer_result_pos:\\n balancer_result_pos[balancer_description] = balancer_result_pos[balancer_description] + results[3]\\n balancer_result_neg[balancer_description] = balancer_result_neg[balancer_description] + results[4]\\n else:\\n balancer_result_pos[balancer_description] = results[3]\\n balancer_result_neg[balancer_description] = results[4]\\n\\n for (balancer_description, _) in dataset_result[0][1]:\\n balancer_result_pos[balancer_description] = balancer_result_pos[balancer_description] / float(len(dataset_result))\\n balancer_result_neg[balancer_description] = balancer_result_neg[balancer_description] / float(len(dataset_result))\\n\\n true_pos_arr = [value for _, value in balancer_result_pos.iteritems()]\\n true_neg_arr = [value for _, value in balancer_result_neg.iteritems()]\\n\\n i = 0\\n hatch_index = 0\\n for key, value in balancer_result_pos.iteritems():\\n if key != \\\"None\\\":\\n if i != 0 and hatch_index == 0 and i % len(colors) == 0:\\n hatch_index += 1\\n\\n if data_set_index == 0:\\n balancer_labels[0].append(mpatches.Patch(facecolor=colors[i % len(colors)], hatch=hatches[hatch_index], label=key, alpha=0.8, edgecolor=\\\"black\\\"))\\n balancer_labels[1].append(key)\\n\\n ax.scatter(value - balancer_result_pos[\\\"None\\\"], balancer_result_neg[key] - balancer_result_neg[\\\"None\\\"], marker=markers[data_set_index % len(markers)], hatch=hatches[hatch_index],\\n s=sizes[data_set_index % len(markers)], alpha=0.8, color=colors[i % len(colors)], edgecolor=\\\"black\\\" if colors[i % len(colors)] != \\\"black\\\" else \\\"grey\\\",\\n zorder=i % len(markers), lw=0.8)\\n # Work around to get legend entries correct\\n pt = ax.scatter(-99999999999, -9999999999, marker=markers[data_set_index % len(markers)], s=sizes[data_set_index % len(markers)], alpha=0.8, color=\\\"white\\\", edgecolor=\\\"black\\\",\\n zorder=data_set_index, lw=0.8)\\n if i == 0:\\n data_set_labels[0].append(pt)\\n data_set_labels[1].append(data_set)\\n i += 1\\n hatch_index = (hatch_index + 1) % len(hatches)\\n data_set_index += 1\\n legend = plt.legend(data_set_labels[0] + balancer_labels[0], data_set_labels[1] + balancer_labels[1], loc='upper right', bbox_to_anchor=(1, 1), fancybox=False, frameon=False, ncol=1)\\n legend.get_frame().set_facecolor('#ffffff')\\n\\n sns.despine()\\n current_time = datetime.now().strftime(\\\"%Y-%m-%d_%H-%M-%S\\\")\\n plt.savefig(os.path.dirname(os.path.realpath(__file__)) + \\\"/../results/classifier_dataset_plt_{0}.png\\\".format(current_time), bbox_extra_artists=((legend,)), bbox_inches='tight')\\n plt.close(fig)\",\n \"def cross_validation_visualization_accuracy(epochs, accs, save=False, filename=\\\"cross_validation_acc\\\"):\\n plt.plot(epochs, accs, marker=\\\".\\\", color='r', label='accuracy')\\n plt.xlabel(\\\"epoch\\\")\\n plt.ylabel(\\\"accuracy\\\")\\n plt.title(\\\"cross validation\\\")\\n plt.legend(loc=2)\\n plt.grid(True)\\n if (save):\\n plt.savefig(filename)\",\n \"def show_batch(dataloader):\\n bs = dataloader.batch_size\\n num_samples = dataloader.dataset.data.shape[0]\\n batches = num_samples // bs\\n batch_id = np.random.choice(batches)\\n one_batch = list(dataloader)[batch_id]\\n batch_imgs, batch_labels = one_batch[0], one_batch[1]\\n class_idx = dataloader.dataset.class_to_idx\\n idx_class = idx_to_class(class_idx)\\n n_rows = n_cols = int(np.sqrt(len(batch_imgs)))\\n fig, axes = plt.subplots(n_rows, n_cols, figsize=(10, 10))\\n if batch_imgs.shape[1] == 1:\\n cmap = 'gray'\\n else:\\n cmap = None\\n for i, ax in enumerate(axes.flatten()):\\n ax.axis('off')\\n title = f'Class : {idx_class[batch_labels[i].item()]}'\\n single_img = np.clip(batch_imgs[i].squeeze().permute(1, 2, 0).numpy(), 0, 1)\\n ax.imshow(single_img, cmap=cmap)\\n ax.set_title(title)\\n fig.tight_layout()\",\n \"def plot_acc(model_dir):\\n ## extract loss from csv\\n file_dir = os.path.join(model_dir, 'acc.csv')\\n data = pd.read_csv(file_dir)\\n epochs = data['epoch'].ravel()\\n acc_train = data['acc_train'].ravel()\\n acc_test = data['acc_test'].ravel()\\n # epoch,acc_train,acc_test\\n\\n ## Theoretical Loss\\n fig, ax = plt.subplots(1, 1, figsize=(7, 5), sharey=True, sharex=True, dpi=400)\\n ax.plot(epochs, acc_train, label='train', color='green', alpha=0.8)\\n ax.plot(epochs, acc_test, label='test', color='red', alpha=0.8)\\n ax.set_ylabel('Accuracy', fontsize=10)\\n ax.set_xlabel('Epoch', fontsize=10)\\n ax.legend(loc='lower right', prop={\\\"size\\\": 15}, ncol=3, framealpha=0.5)\\n ax.spines['top'].set_visible(False)\\n ax.spines['right'].set_visible(False)\\n plt.tight_layout()\\n\\n ## create saving directory\\n acc_dir = os.path.join(model_dir, 'figures', 'acc')\\n os.makedirs(acc_dir, exist_ok=True)\\n file_name = os.path.join(acc_dir, 'accuracy.png')\\n plt.savefig(file_name, dpi=400)\\n print(\\\"Plot saved to: {}\\\".format(file_name))\\n file_name = os.path.join(acc_dir, 'accuracy.pdf')\\n plt.savefig(file_name, dpi=400)\\n plt.close()\\n print(\\\"Plot saved to: {}\\\".format(file_name))\",\n \"def plot_scatter_n_accuracy_joint(self, data_objects, labels, label_self, markers):\\n dataframes = [self.df] + [data.df for data in data_objects]\\n labels = [label_self] + labels\\n\\n acc = []\\n n = []\\n statistics = []\\n for df, label in zip(dataframes, labels):\\n acc = df.groupby('worker')['correct'].mean()\\n n = df.groupby('worker')['question'].count()\\n df_new = pd.concat([acc, n], axis=1)\\n df_new['dataset'] = label\\n statistics.append(df_new)\\n\\n df = pd.concat(statistics, axis=0)\\n sns.lmplot('question', 'correct', data=df, hue='dataset',\\n markers=markers, fit_reg=False)\\n plt.xlabel('Number of questions answered')\\n plt.ylabel('Accuracy')\\n plt.xlim((0, None))\\n plt.ylim((0, 1))\\n plt.title('')\\n return plt.gca()\",\n \"def plot_results(models,\\n data,\\n batch_size=128,\\n model_name=None):\\n\\n encoder, decoder = models\\n x_test, y_test = data\\n # display a 2D plot of the digit classes in the latent space\\n z_mean = encoder(x_test)\\n plt.figure(figsize=(12, 10))\\n plt.scatter(z_mean[:, 0], z_mean[:, 1], c=y_test)\\n plt.colorbar()\\n plt.xlabel(\\\"z[0]\\\")\\n plt.ylabel(\\\"z[1]\\\")\\n \\n plt.show()\\n if not model_name is None:\\n os.makedirs(model_name, exist_ok=True)\\n filename = os.path.join(model_name, \\\"vae_mean.png\\\")\\n plt.savefig(filename)\\n filename = os.path.join(model_name, \\\"digits_over_latent.png\\\")\\n # display a 30x30 2D manifold of digits\\n n = 30\\n digit_size = 28\\n figure = np.zeros((digit_size * n, digit_size * n))\\n # linearly spaced coordinates corresponding to the 2D plot\\n # of digit classes in the latent space\\n grid_x = np.linspace(-4, 4, n)\\n grid_y = np.linspace(-4, 4, n)[::-1]\\n\\n for i, yi in enumerate(grid_y):\\n for j, xi in enumerate(grid_x):\\n z_sample = np.array([[xi, yi]])\\n x_decoded = decoder(z_sample)\\n digit = x_decoded[0].reshape(digit_size, digit_size)\\n figure[i * digit_size: (i + 1) * digit_size,\\n j * digit_size: (j + 1) * digit_size] = digit\\n\\n plt.figure(figsize=(10, 10))\\n start_range = digit_size // 2\\n end_range = n * digit_size + start_range + 1\\n pixel_range = np.arange(start_range, end_range, digit_size)\\n sample_range_x = np.round(grid_x, 1)\\n sample_range_y = np.round(grid_y, 1)\\n plt.xticks(pixel_range, sample_range_x)\\n plt.yticks(pixel_range, sample_range_y)\\n plt.xlabel(\\\"z[0]\\\")\\n plt.ylabel(\\\"z[1]\\\")\\n plt.imshow(figure, cmap='Greys_r')\\n if not model_name is None:\\n plt.savefig(filename)\\n plt.show()\",\n \"def sample_list3(data_list, rows=15, cols=4, start_with=0, show_every=2, scale=4, fig_name=None, start_inx=0):\\n\\n n_batch = len(data_list)\\n _, ax = plt.subplots(rows, cols, figsize=[scale * cols, scale * rows])\\n\\n for ind in range(n_batch):\\n # read data and calculate average precision\\n input1 = data_list[ind]['slice1']\\n input2 = data_list[ind]['slice2']\\n label = data_list[ind]['label']\\n hu0050 = data_list[ind]['hu0050']\\n overlap = data_list[ind]['overlap']\\n f_score = data_list[ind]['f1']\\n mix_overlap = data_list[ind]['mix_overlap']\\n noncal_eval = data_list[ind]['noncal_eval']\\n file_path = data_list[ind]['file_path']\\n if (ind - start_with) % show_every == 0:\\n i = (ind - start_with) // show_every\\n if i < rows:\\n ax[i, 0].imshow(input1, cmap='gray')\\n ax[i, 0].set_title(\\\"Slice {} ({}) \\\\n {}\\\".format(ind + start_inx, file_path, 'Input with HU(-100~155)'), loc='left')\\n ax[i, 0].axis('off')\\n\\n ax[i, 1].imshow(input2, cmap='gray')\\n ax[i, 1].set_title(\\\"{}\\\".format('Input with HU(200~1200)'))\\n ax[i, 1].axis('off')\\n\\n ax[i, 2].imshow(gray2rgb(label))\\n ax[i, 2].set_title('{}'.format('Label'))\\n ax[i, 2].axis('off')\\n\\n ax[i, 3].imshow(gray2rgb(hu0050))\\n ax[i, 3].set_title('{}'.format('Mask HU(0~50)'))\\n ax[i, 3].axis('off')\\n\\n ax[i, 4].imshow(gray2rgb(overlap))\\n ax[i, 4].set_title('{} (F1= {:.4f})'.format('Overlap', f_score))\\n ax[i, 4].axis('off')\\n\\n # not all red pixels are within HU range 0~50\\n\\n if(np.sum(overlap == 76)) != 0:\\n n_above50, n_below0, topk, buttomk = noncal_eval[0], noncal_eval[1], noncal_eval[2:7], noncal_eval[7:12]\\n ax[i, 4].text(5, 30, \\\"top5 HU: {}\\\".format(topk), color='red')\\n ax[i, 4].text(5, 60, \\\"but5 HU: {}\\\".format(buttomk), color='red')\\n ax[i, 4].text(5, 90, \\\"Num of pixels HU>50: {}\\\".format(n_above50), color='red')\\n ax[i, 4].text(5, 120, \\\"Num of pixels HU<0: {}\\\".format(n_below0), color='red')\\n\\n ax[i, 5].imshow(gray2rgb(mix_overlap))\\n ax[i, 5].set_title('{} (F1= {:.4f})'.format('Label+Overlap', f_score))\\n ax[i, 5].axis('off')\\n\\n # ax[i, 3].scatter(range(0, n_class), f_score)\\n # ax[i, 3].set_title('Slice %d : Ave F-score = %0.2f' % (ind + start_inx, ave_f_score))\\n # ax[i, 3].set_ylabel('F score')\\n # ax[i, 3].set_ylim([-0.1, 1.1])\\n\\n # plt.show()\\n if fig_name:\\n plt.savefig(fig_name + '.pdf')\\n plt.close()\",\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_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 classificationError():\\n print('Computing Classification Test Error')\\n\\n dl1, dl2 = CIFAR10TestLoader() \\n err1, err2 = [], []\\n\\n # load every model \\n with open('classification_error.csv','w') as clf:\\n writer = csv.writer(clf)\\n writer.writerow(['Classification Error Dataset 1','Classification Error Dataset 2'])\\n\\n for i in tqdm(range(5,95,2)):\\n mtl = MTL()\\n PATH = os.getcwd() + '/mtl_model_{d1}_vs_{d2}.pth'.format(d1=i, d2=100-i)\\n mtl.load_state_dict(state_dict=torch.load(PATH))\\n\\n e1, e2 = accuracy(dl1, mtl), accuracy(dl2, mtl)\\n err1.append(e1)\\n err2.append(e2)\\n writer.writerow([e1,e2])\\n \\n fig, ax_left = plt.subplots()\\n ax_right = ax_left.twinx()\\n ax_left.plot([0.05 + 0.02* i for i in range(45)], err1, color='black')\\n ax_right.plot([0.05 + 0.02* i for i in range(45)], err2, color='red')\\n ax_right.set_ylabel('Dataset 2 (red) accuracy')\\n ax_left.set_ylabel('Dataset 1 (black) accuracy')\\n ax_left.set_xlabel('Percentage of points from dataset 1 in training set')\\n plt.title('Classification Accuracy over both datasets')\\n plt.savefig('classification_error_plots.pdf')\",\n \"def visualize_training(features, labels, pl):\\n print(\\\"Visualizing training\\\")\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n\\n # Take out each feature type, one at a time\\n label_map = get_label_map(labels)\\n\\n for key in label_map.keys():\\n like_ind = label_map[key]\\n like_data = np.array([features[i] for i in like_ind])\\n\\n plt.scatter(like_data[:,0],like_data[:,1],label=key)\\n\\n # get limits\\n xmin = features.column_min(0) - .5\\n xmax = features.column_max(0) + .5\\n ymin = features.column_min(1) - .5\\n ymax = features.column_max(1) + .5\\n\\n plt.xlim(xmin,xmax)\\n plt.ylim(ymin,ymax)\\n\\n # Track the current dividing line, as well as the number of epochs passed\\n divider, = plt.plot([],[])\\n epoch_tracker = plt.text(-1,.9, '', fontsize=15)\\n\\n def update(i):\\n \\\"\\\"\\\"\\n 1.) Get the next set of weights from the tracker\\n 2.) Calculate and draw the new divider line\\n 3.) Update the epoch counter\\n 4.) If we are at the end of an epoch, plot a dashed divider line to track progress\\n \\\"\\\"\\\"\\n epoch = i//features.instance_count\\n w = pl.weights_tracker[i]\\n a = pl.accuracy_tracker[epoch]\\n divider.set_data([xmin,xmax],[(-xmin * w[0] - w[2]) / w[1], (-xmax * w[0] - w[2]) / w[1]])\\n epoch_tracker.set_text(\\\"{} {}\\\".format(epoch + 1, a))\\n\\n # Keep a shadow of the hyperplane at the end of each epoch\\n if i % features.instance_count == 0:\\n plot_hyperplane(w,xmin,xmax,iter = i, alpha = .3, color='black',linestyle='dashed')\\n\\n return divider\\n\\n ani = animation.FuncAnimation(fig, update, frames=range(len(pl.weights_tracker)), interval=250,repeat=False)\\n plt.legend()\\n\\n # optional save file\\n if len(sys.argv) >= 3 :\\n ani.save(sys.argv[2], writer='imagemagick', fps=5)\\n\\n plt.show()\",\n \"def draw_num_classes_graphs():\\n values = [10, 50, 100, 250, 1000, 4000]\\n for num_classes in values:\\n print(\\\"Training model on {} most common classes.\\\".format(num_classes))\\n model = create_pretrained_model(num_classes=num_classes)\\n histories = train(model, num_classes, epochs=50)\\n run_name = get_run_name(\\\"{}classes\\\".format(num_classes))\\n save_learning_curves(histories, run_name)\\n csv_path = os.path.join(\\\"plots/\\\", run_name, \\\"data.csv\\\")\\n ut.write_csv_dict(histories,\\n keys=['loss', 'acc', 'val_loss', 'val_acc'],\\n filename=csv_path)\",\n \"def plot_data(self, show=False):\\n\\n fig, ax = plt.subplots(2, 1, figsize = (8, 6))\\n plt.subplots_adjust(hspace=0.5)\\n\\n nrows = 10\\n\\n for _ in range(nrows):\\n\\n # plot nrows random examples from the simulated train data \\n if self.flatten:\\n print ('Plotting data... reshaping the flattened data to %s'%str(input_shape))\\n temp = self.data['data'][np.random.randint(self.n_train * self.n_s)].reshape(input_shape)\\n x, y = temp.T[:,0]\\n else:\\n print ('Plotting data...')\\n temp = self.data['data'][np.random.randint(self.n_train * self.n_s)].reshape(ncombinations,len(ells))\\n Cl = temp[0] # plot the (0,0) autocorrelation bin\\n\\n if self.rescaled:\\n ax[0].plot(ells, Cl)\\n else:\\n ax[0].loglog(ells, ells*(ells+1)*Cl)\\n ax[0].set_title(f'{nrows} examples from training data, Cl (0,0)')\\n ax[0].set_xlabel(r'$\\\\ell$')\\n ax[0].set_xscale('log')\\n if self.rescaled:\\n ax[0].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[0].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n \\n\\n # plot nrows random examples from the simulated test data \\n if self.flatten:\\n temp = self.data['validation_data'][np.random.randint(self.n_s)].reshape(input_shape)\\n x, y = temp.T[:,0]\\n else:\\n temp = self.data['validation_data'][np.random.randint(self.n_train * self.n_s)].reshape(ncombinations,len(ells))\\n Cl = temp[0] # plot the (0,0) autocorrelation bin\\n\\n if self.rescaled:\\n ax[1].plot(ells, Cl)\\n else:\\n ax[1].loglog(ells, ells*(ells+1)*Cl)\\n ax[1].set_title(f'{nrows} examples from test data, Cl (0,0)')\\n ax[1].set_xlabel(r'$\\\\ell$')\\n ax[1].set_xscale('log')\\n if self.rescaled:\\n ax[1].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[1].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n # plt.legend()\\n\\n plt.savefig(f'{self.figuredir}data_visualization_{self.modelversion}.png')\\n if show: plt.show()\\n plt.close()\",\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 plot_observations():\\n plt.plot(history.history['loss'], label='training_loss')\\n plt.plot(history.history['val_loss'], label='val_loss ')\\n plt.xlabel('Epoch')\\n plt.ylabel('Loss')\\n plt.show()\\n\\n plt.plot(history.history['acc'], label='accuracy')\\n plt.plot(history.history['val_acc'], label='val_accuracy')\\n plt.xlabel('Epoch')\\n plt.ylabel('Accuracy')\\n plt.legend(loc='lower right')\\n plt.show()\\n\\n test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)\\n print(\\\"Test Accuracy:\\\", test_acc)\",\n \"def plot_model_performance(train_loss, train_acc, train_val_loss, train_val_acc, save_figure_path):\\n\\n green = '#72C29B'\\n orange = '#FFA577'\\n\\n with plt.xkcd():\\n fig, (ax1, ax2) = plt.subplots(2, figsize=(10, 8))\\n ax1.plot(range(1, len(train_loss) + 1), train_loss, green, linewidth=5,\\n label='training')\\n ax1.plot(range(1, len(train_val_loss) + 1), train_val_loss, orange,\\n linewidth=5, label='validation')\\n ax1.set_xlabel('# epoch')\\n ax1.set_ylabel('loss')\\n ax1.tick_params('y')\\n ax1.legend(loc='upper right', shadow=False)\\n ax1.set_title('Model loss through #epochs', fontweight='bold')\\n\\n ax2.plot(range(1, len(train_acc) + 1), train_acc, green, linewidth=5,\\n label='training')\\n ax2.plot(range(1, len(train_val_acc) + 1), train_val_acc, orange,\\n linewidth=5, label='validation')\\n ax2.set_xlabel('# epoch')\\n ax2.set_ylabel('accuracy')\\n ax2.tick_params('y')\\n ax2.legend(loc='lower right', shadow=False)\\n ax2.set_title('Model accuracy through #epochs', fontweight='bold')\\n\\n plt.tight_layout()\\n plt.show()\\n fig.savefig(save_figure_path)\\n plt.close(fig)\",\n \"def plot_training_results(clfs, train_scores, test_scores):\\n\\n # Set graph format\\n sns.set_style(\\\"whitegrid\\\")\\n sns.set_context(\\\"paper\\\", font_scale=1, rc={\\\"lines.linewidth\\\": 1})\\n ax = plt.subplot(111)\\n w = 0.5\\n x = np.arange(len(train_scores))\\n ax.set_yticks(x + w)\\n ax.legend((train_scores[0], test_scores[0]), (\\\"Train Scores\\\", \\\"Test Scores\\\"))\\n names = ['SVC', 'LR', 'KNN', 'GNB', 'ADA', 'RF']\\n\\n # Loop throuugh classifiers\\n # clfnames = []\\n # for i in range(0, len(clfs)):\\n # # Define temporary variables\\n # clfname = clfnames[i]\\n # # clf_name = clf.__class__.__name__\\n # # Create and store name\\n # name = \\\"{}\\\".format(clf_name)\\n # names.append(name)\\n\\n # Plot all names in horizontal bar plot\\n ax.set_yticklabels((names), fontsize=20)\\n plt.xlim(0.5, 0.56)\\n plt.barh(x, test_scores, color='b', alpha=0.6)\\n plt.title(\\\"Test Data Accuracy Scores\\\", fontsize=30)\\n fig = plt.figure(1)\\n\\n plt.show()\",\n \"def plot_results(models,\\n data,\\n batch_size=128,\\n model_name=\\\"vae_mnist\\\"):\\n\\n encoder, decoder = models\\n x_test, y_test = data\\n os.makedirs(model_name, exist_ok=True)\\n\\n filename = os.path.join(model_name, \\\"vae_mean.png\\\")\\n # display a 2D plot of the digit classes in the latent space\\n z_mean, _, _ = encoder.predict(x_test,\\n batch_size=batch_size)\\n plt.figure(figsize=(12, 10))\\n plt.scatter(z_mean[:, 0], z_mean[:, 1], c=y_test)\\n plt.colorbar()\\n plt.xlabel(\\\"z[0]\\\")\\n plt.ylabel(\\\"z[1]\\\")\\n plt.savefig(filename)\\n plt.show()\\n\\n filename = os.path.join(model_name, \\\"digits_over_latent.png\\\")\\n # display a 30x30 2D manifold of digits\\n n = 30\\n digit_size = 28\\n figure = np.zeros((digit_size * n, digit_size * n))\\n # linearly spaced coordinates corresponding to the 2D plot\\n # of digit classes in the latent space\\n grid_x = np.linspace(-4, 4, n)\\n grid_y = np.linspace(-4, 4, n)[::-1]\\n\\n for i, yi in enumerate(grid_y):\\n for j, xi in enumerate(grid_x):\\n z_sample = np.array([[xi, yi]])\\n x_decoded = decoder.predict(z_sample)\\n digit = x_decoded[0].reshape(digit_size, digit_size)\\n figure[i * digit_size: (i + 1) * digit_size,\\n j * digit_size: (j + 1) * digit_size] = digit\\n\\n plt.figure(figsize=(10, 10))\\n start_range = digit_size // 2\\n end_range = n * digit_size + start_range + 1\\n pixel_range = np.arange(start_range, end_range, digit_size)\\n sample_range_x = np.round(grid_x, 1)\\n sample_range_y = np.round(grid_y, 1)\\n plt.xticks(pixel_range, sample_range_x)\\n plt.yticks(pixel_range, sample_range_y)\\n plt.xlabel(\\\"z[0]\\\")\\n plt.ylabel(\\\"z[1]\\\")\\n plt.imshow(figure, cmap='Greys_r')\\n plt.savefig(filename)\\n plt.show()\",\n \"def sample_list2(data_list, rows=15, start_with=0, show_every=2, scale=4, fig_name=None, start_inx=0, n_class=5):\\n input_cols = len(data_list[0]['input'])\\n if input_cols == 1:\\n input_names = ['input']\\n elif input_cols == 2:\\n input_names = ['input(cal)', 'input(non-cal)']\\n cols = 4 + input_cols - 1\\n # n_class = data_list[0]['pred'].shape[0]\\n n_batch = len(data_list)\\n _, ax = plt.subplots(rows, cols, figsize=[scale * cols, scale * rows])\\n\\n for ind in range(n_batch):\\n # read data and calculate average precision\\n input = data_list[ind]['input']\\n # output = data_list[ind]['output']\\n label = data_list[ind]['GT']\\n pred = data_list[ind]['pred']\\n\\n # calculate F score and average precision\\n # output = np.transpose(output, (1, 2, 0))\\n # output = np.reshape(output, (-1, n_class))\\n label_binary = label_binarize(label.flatten(), classes=range(n_class))\\n pred_binary = label_binarize(pred.flatten(), classes=range(n_class))\\n\\n f_score = np.zeros(n_class, dtype=np.float32)\\n slice_effect_class = 0\\n for i in range(n_class):\\n if np.sum(label_binary[:,i]) == 0:\\n f_score[i] = 0.0\\n else:\\n slice_effect_class += 1\\n f_score[i] = f1_score(label_binary[:,i], pred_binary[:,i])\\n\\n ave_f_score = np.sum(f_score)/slice_effect_class\\n\\n if (ind - start_with) % show_every == 0:\\n i = (ind - start_with) // show_every\\n if i < rows:\\n for col in range(input_cols):\\n ax[i, col].imshow(input[col], cmap='gray')\\n ax[i, col].set_title(\\\"Slice {} : {}\\\".format(ind+start_inx, input_names[col]))\\n ax[i, col].axis('off')\\n\\n ax[i, input_cols].imshow(mask2rgb(label))\\n ax[i, input_cols].set_title('Slice %d : %s' % (ind+start_inx, 'ground truth'))\\n ax[i, input_cols].axis('off')\\n\\n ax[i, input_cols+1].imshow(mask2rgb(pred))\\n ax[i, input_cols+1].set_title('Slice %d : %s' % (ind+start_inx, 'prediction'))\\n ax[i, input_cols+1].axis('off')\\n\\n ax[i, input_cols+2].scatter(range(0,n_class), f_score)\\n ax[i, input_cols+2].set_title('Slice %d : Ave F-score = %0.2f' % (ind+start_inx, ave_f_score))\\n ax[i, input_cols+2].set_ylabel('F score')\\n ax[i, input_cols+2].set_ylim([-0.1, 1.1])\\n\\n # plt.show()\\n if fig_name:\\n plt.savefig(fig_name + '.png')\\n plt.close()\",\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 visualise_dataset_classifier_results(dataset_results):\\n current_time = datetime.now().strftime(\\\"%Y-%m-%d_%H-%M-%S\\\")\\n file_name = \\\"raw_dump_{0}.txt\\\".format(current_time)\\n with open(os.path.dirname(os.path.realpath(__file__)) + \\\"/../results/\\\" + file_name, \\\"wb\\\") as output_file:\\n output_file.write(str(dataset_results))\\n sns.set(style='ticks')\\n fig = plt.figure(figsize=(10, 10))\\n ax = fig.add_subplot(1, 1, 1)\\n markers = [\\\"s\\\", \\\"o\\\", \\\"^\\\", \\\"*\\\"]\\n colors = [\\\"#64B3DE\\\", \\\"#1f78b4\\\", \\\"#B9B914\\\", \\\"#FBAC44\\\", \\\"#bc1659\\\", \\\"#33a02c\\\", \\\"#6ABF20\\\", \\\"#ff7f00\\\", \\\"#6a3d9a\\\", \\\"grey\\\", \\\"#b15928\\\", \\\"#e31a1c\\\", \\\"black\\\"]\\n color_dict = {}\\n index = 0\\n for (_, classifier_description) in dataset_results[0][1]:\\n color_dict[classifier_description] = colors[index]\\n index += 1\\n\\n hatches = [None, \\\"////\\\", \\\"..\\\"]\\n\\n # Move left y-axis and bottom x-axis to centre, passing through (0,0)\\n ax.spines['left'].set_position('center')\\n ax.spines['bottom'].set_position('center')\\n\\n # Eliminate upper and right axes\\n ax.spines['right'].set_color('none')\\n ax.spines['top'].set_color('none')\\n\\n # Show ticks in the left and lower axes only\\n ax.xaxis.set_ticks_position('bottom')\\n ax.yaxis.set_ticks_position('left')\\n ax.set_axis_on()\\n ax.spines['left'].set_color('black')\\n ax.spines['bottom'].set_color('black')\\n plt.xlabel(\\\"Change in TPR\\\")\\n plt.ylabel(\\\"Change in TNR\\\")\\n\\n ax.xaxis.set_label_coords(0.1, 0.52)\\n ax.yaxis.set_label_coords(0.53, 0.9)\\n\\n plt.ylim(-0.2, 0.2)\\n plt.xlim(-0.2, 0.2)\\n data_set_labels = []\\n classifier_labels = []\\n data_set_index = 0\\n for (data_set, dataset_result) in dataset_results:\\n data_set_labels.append(mlines.Line2D(range(1), range(1), color=\\\"white\\\", marker=markers[data_set_index], markeredgecolor=\\\"black\\\", markeredgewidth=1.0, label=data_set.replace(\\\"_\\\", \\\" \\\")))\\n median_true_pos = np.median(np.array([result_arr[3] for (result_arr, classifier_description) in dataset_result]))\\n median_true_neg = np.median(np.array([result_arr[4] for (result_arr, classifier_description) in dataset_result]))\\n\\n i = 0\\n for (result_arr, classifier_description) in dataset_result:\\n if data_set_index == 0:\\n classifier_labels.append(mpatches.Patch(facecolor=color_dict[classifier_description], hatch=hatches[i % len(hatches)], label=classifier_description, alpha=0.8, edgecolor=\\\"black\\\"))\\n ax.scatter(result_arr[3] - median_true_pos, result_arr[4] - median_true_neg, marker=markers[data_set_index], hatch=hatches[i % len(hatches)], s=200, alpha=0.8, color=colors[i],\\n edgecolor=\\\"black\\\", zorder=data_set_index, lw=0.8)\\n i += 1\\n data_set_index += 1\\n\\n plt.legend(handles=data_set_labels + classifier_labels)\\n sns.despine()\\n current_time = datetime.now().strftime(\\\"%Y-%m-%d_%H-%M-%S\\\")\\n plt.savefig(os.path.dirname(os.path.realpath(__file__)) + \\\"/../results/classifier_dataset_plt_{0}.png\\\".format(current_time), bbox_inches='tight')\\n plt.close(fig)\",\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 plots(self, history):\\n print(history.history.keys())\\n plt.plot(history.history['acc'])\\n plt.plot(history.history['val_acc'])\\n plt.title('model accuracy')\\n plt.ylabel('accuracy')\\n plt.xlabel('epoch')\\n plt.legend(['train','test'], loc='upper left')\\n plt.show()\\n\\n plt.plot(history.history['loss'])\\n plt.plot(history.history['val_loss'])\\n plt.title('model loss')\\n plt.ylabel('loss')\\n plt.xlabel('epoch')\\n plt.legend(['train','test'], loc='upper left')\\n plt.show()\",\n \"def plot_results(sgd_train_acc, sgd_train_std, sgd_heldout_acc, sgd_heldout_std, sgd_test_acc,\\n dt_train_acc, dt_train_std, dt_heldout_acc, dt_heldout_std, dt_test_acc,\\n dt4_train_acc, dt4_train_std, dt4_heldout_acc, dt4_heldout_std, dt4_test_acc,\\n stumps_train_acc, stumps_train_std, stumps_heldout_acc, stumps_heldout_std, stumps_test_acc):\\n train_x_pos = [0, 4, 8, 12]\\n cv_x_pos = [1, 5, 9, 13]\\n test_x_pos = [2, 6, 10, 14]\\n ticks = cv_x_pos\\n\\n labels = ['sgd', 'dt', 'dt4', 'stumps (4 x 50)']\\n\\n train_accs = [sgd_train_acc, dt_train_acc, dt4_train_acc, stumps_train_acc]\\n train_errors = [sgd_train_std, dt_train_std, dt4_train_std, stumps_train_std]\\n\\n cv_accs = [sgd_heldout_acc, dt_heldout_acc, dt4_heldout_acc, stumps_heldout_acc]\\n cv_errors = [sgd_heldout_std, dt_heldout_std, dt4_heldout_std, stumps_heldout_std]\\n\\n test_accs = [sgd_test_acc, dt_test_acc, dt4_test_acc, stumps_test_acc]\\n\\n fig, ax = plt.subplots()\\n ax.bar(train_x_pos, train_accs, yerr=train_errors, align='center', alpha=0.5, ecolor='black', capsize=10, label='train')\\n ax.bar(cv_x_pos, cv_accs, yerr=cv_errors, align='center', alpha=0.5, ecolor='black', capsize=10, label='held-out')\\n ax.bar(test_x_pos, test_accs, align='center', alpha=0.5, capsize=10, label='test')\\n ax.set_ylabel('Accuracy')\\n ax.set_xticks(ticks)\\n ax.set_xticklabels(labels)\\n ax.set_title('Models')\\n ax.yaxis.grid(True)\\n ax.legend()\\n plt.tight_layout()\",\n \"def plot_3D_accuracy_list(Y_data_test_list, Y_pred_data_list, ref_shape):\\n sample_len = Y_data_test_list.shape[0]\\n num_classes = int(Y_data_test_list.max()+1)\\n for i in np.arange(0, sample_len):\\n for c in np.arange(1, num_classes):\\n fig = plt.figure()\\n plt.figtext(0.1, 0.1, 'Predicted segmentation for test sample No.: ' + str(i + 1) + ', class: ' + str(c), color='white')\\n true_lab = Y_data_test_list[i, ]\\n # true_loc = np.where(true_lab == c)\\n pred_lab = Y_pred_data_list[i, ]\\n # pred_loc = np.where(pred_lab == c)\\n\\n # concurring locations\\n true_copy = true_lab.copy()\\n np.place(true_copy, true_copy != c, 99)\\n pred_copy = pred_lab.copy()\\n same_loc = np.where(true_copy == pred_copy)\\n np.place(pred_copy, pred_copy != c, 99)\\n not_same_loc = np.where(true_copy != pred_copy)\\n\\n ax = plt.axes(projection=\\\"3d\\\")\\n axl = plt.gca()\\n axl.set_xlim3d([0, ref_shape[0]])\\n axl.set_ylim3d([0, ref_shape[1]])\\n axl.set_zlim3d([0, ref_shape[2]])\\n ax.scatter3D(not_same_loc[0], not_same_loc[1], not_same_loc[2], marker=\\\".\\\", alpha=0.01,\\n edgecolor=\\\"lightcoral\\\", facecolor=\\\"lightcoral\\\")\\n ax.scatter3D(same_loc[0], same_loc[1], same_loc[2], marker=\\\".\\\", alpha=1,\\n edgecolor=\\\"white\\\", facecolor=\\\"white\\\")\\n\\n fig.set_facecolor('black')\\n ax.set_facecolor('black')\\n ax.grid(False)\\n ax.w_xaxis.pane.fill = False\\n ax.w_yaxis.pane.fill = False\\n ax.w_zaxis.pane.fill = False\\n\\n ax.set_xlabel('Width', c='white')\\n ax.set_ylabel('Depth', c='white')\\n ax.set_zlabel('Height', c='white')\\n\\n plt.show()\",\n \"def plt_accuracy(self, lamda_choice, weights_initial):\\n weights_random = []\\n train_accuracy = []\\n test_accuracy = []\\n for i in range(len(lamda_choice)):\\n self.lamda = lamda_choice[i]\\n self.fit(weights_initial)\\n pred_result = self.predict()\\n test_ac = self.evaluate(pred_result)\\n test_accuracy.append(test_ac)\\n train_ac = self.train_accuracy() \\n train_accuracy.append(train_ac)\\n weights_random.append(self.w_result[-1])\\n # print best lamda with highest accuracy\\n print(\\\"choose lambda: %f\\\" % lamda_choice[np.argmax(train_accuracy)])\\n labels = [\\\"Train_accuracy\\\", \\\"Test_accuracy\\\"]\\n fig, ax = plt.subplots()\\n ax.plot(lamda_choice, train_accuracy, 'o-', label='Train_accuracy')\\n ax.plot(lamda_choice, test_accuracy, 'o-', label='Test_accuracy')\\n # Draw absolute weight value corresponding the random feature\\n fig, ax = plt.subplots()\\n ax.plot(lamda_choice, weights_random, label='Weight for random')\\n plt.show()\\n # find the best lamda\\n self.lamda = lamda_choice[np.argmax(train_accuracy)]\",\n \"def plot_predictions(net, x_train, y_train, idx_train, x_val, y_val, idx_val):\\n fig, (ax1, ax2) = plt.subplots(nrows=2, figsize=(20, 30))\\n pred1 = net.predict(x_val, batch_size=batch_size)\\n # print(\\\"pred1.shape:\\\", pred1.shape)\\n ax1.plot(idx_val, y_val, label=\\\"Actual Data\\\", marker=\\\"+\\\")\\n ax1.plot(idx_val, pred1, label=\\\"Prediction\\\", marker=\\\"o\\\")\\n # ax1.set_ylim(-0.1, 1.1)\\n ax1.set_xlabel(\\\"Year\\\")\\n ax1.set_ylabel(\\\"Sunspot Numbers\\\")\\n ax1.legend()\\n ax1.set_title(\\\"Predicted vs Actual Validation Data\\\")\\n\\n pred2 = net.predict(x_train, batch_size=batch_size)\\n # print(\\\"pred2.shape:\\\", pred2.shape)\\n ax2.plot(idx_train, y_train, label=\\\"Actual Data\\\", marker=\\\"+\\\")\\n ax2.plot(idx_train, pred2, label=\\\"Prediction\\\", marker=\\\"o\\\")\\n # ax2.set_ylim(-0.1, 1.1)\\n ax2.set_xlabel(\\\"Year\\\")\\n ax2.set_ylabel(\\\"Sunspot Numbers\\\")\\n ax2.legend()\\n ax2.set_title(\\\"Predicted vs Actual Training Data\\\")\\n\\n plt.tight_layout()\\n\\n filename = \\\"img/\\\"\\n filename += datetime.now().strftime(\\\"%y%m%d_%H%M\\\")\\n filename += \\\"_predicted_vs_actual_data.png\\\"\\n fig.savefig(filename, format=\\\"png\\\")\",\n \"def plot_training_info(case, metrics, save, history):\\n val = False\\n if 'val_accuracy' in history and 'val_loss' in history:\\n val = True\\n plt.ioff()\\n if 'accuracy' in metrics:\\n fig = plt.figure()\\n plt.plot(history['accuracy'])\\n if val:\\n plt.plot(history['val_accuracy'])\\n plt.title('model accuracy')\\n plt.ylabel('accuracy')\\n plt.xlabel('epoch')\\n if val:\\n plt.legend(['train', 'val'], loc='upper left')\\n else:\\n plt.legend(['train'], loc='upper left')\\n if save:\\n plt.savefig(case + 'accuracy.png')\\n plt.gcf().clear()\\n else:\\n plt.show()\\n plt.close(fig)\\n\\n # summarize history for loss\\n if 'loss' in metrics:\\n fig = plt.figure()\\n plt.plot(history['loss'])\\n if val:\\n plt.plot(history['val_loss'])\\n plt.title('model loss')\\n plt.ylabel('loss')\\n plt.xlabel('epoch')\\n # plt.ylim(1e-3, 1e-2)\\n plt.yscale(\\\"log\\\")\\n if val:\\n plt.legend(['train', 'val'], loc='upper left')\\n else:\\n plt.legend(['train'], loc='upper left')\\n if save:\\n plt.savefig(case + 'loss.png')\\n plt.gcf().clear()\\n else:\\n plt.show()\\n plt.close(fig)\",\n \"def plot_metrics(self, title=None, fig_size=None, col_count=3):\\n metric_names = self.tracked_metrics()\\n metric_vals = {metric_name: self.metrics_history[metric_name][\\\"epoch_vals\\\"] for metric_name in metric_names}\\n if self.include_val_metrics:\\n # also has validation metrics\\n for metric_name in metric_names:\\n metric_vals[f\\\"val_{metric_name}\\\"] = self.metrics_history[f\\\"val_{metric_name}\\\"][\\\"epoch_vals\\\"]\\n\\n # we will plot a max of 3 metrics per row\\n MAX_COL_COUNT = col_count\\n col_count = MAX_COL_COUNT if len(metric_names) > MAX_COL_COUNT else len(metric_names)\\n row_count = len(metric_names) // MAX_COL_COUNT\\n row_count += 1 if len(metric_names) % MAX_COL_COUNT != 0 else 0\\n # we'll always have \\\"loss\\\" metric in list, so safest to pick!\\n x_vals = np.arange(1, len(metric_vals[\\\"loss\\\"]) + 1)\\n\\n with sns.axes_style(\\\"darkgrid\\\"):\\n sns.set_context(\\\"notebook\\\") # , font_scale = 1.2)\\n sns.set_style(\\n {\\\"font.sans-serif\\\": [\\\"Segoe UI\\\", \\\"Calibri\\\", \\\"SF Pro Display\\\", \\\"Arial\\\", \\\"DejaVu Sans\\\", \\\"Sans\\\"]}\\n )\\n fig_size = (16, 5) if fig_size is None else fig_size\\n\\n if len(metric_names) == 1:\\n # only loss\\n plt.figure(figsize=fig_size)\\n plt.plot(x_vals, metric_vals[\\\"loss\\\"], lw=2, markersize=7, color=\\\"steelblue\\\", marker=\\\"o\\\")\\n if self.include_val_metrics:\\n plt.plot(x_vals, metric_vals[\\\"val_loss\\\"], lw=2, markersize=7, color=\\\"firebrick\\\", marker=\\\"o\\\")\\n legend = [\\\"train\\\", \\\"valid\\\"] if self.include_val_metrics else [\\\"train\\\"]\\n plt_title = (\\n f\\\"Training & Cross-validation Loss vs Epochs\\\" if len(legend) == 2 else f\\\"Training Loss vs Epochs\\\"\\n )\\n plt.title(plt_title)\\n plt.legend(legend, loc=\\\"best\\\")\\n else:\\n f, ax = plt.subplots(row_count, col_count, figsize=fig_size)\\n for r in range(row_count):\\n for c in range(col_count):\\n index = r * (col_count - 1) + c\\n if index < len(metric_names):\\n metric_name = metric_names[index]\\n if row_count == 1:\\n ax[c].plot(x_vals, metric_vals[metric_name], lw=2, markersize=7, marker=\\\"o\\\")\\n else:\\n ax[r, c].plot(x_vals, metric_vals[metric_name], lw=2, markersize=7, marker=\\\"o\\\")\\n if self.include_val_metrics:\\n if row_count == 1:\\n ax[c].plot(\\n x_vals, metric_vals[f\\\"val_{metric_name}\\\"], lw=2, markersize=7, marker=\\\"o\\\"\\n )\\n else:\\n ax[r, c].plot(\\n x_vals, metric_vals[f\\\"val_{metric_name}\\\"], lw=2, markersize=7, marker=\\\"o\\\"\\n )\\n legend = [\\\"train\\\", \\\"valid\\\"] if self.include_val_metrics else [\\\"train\\\"]\\n ax_title = (\\n f\\\"Training & Cross-validation '{metric_name}' vs Epochs\\\"\\n if len(legend) == 2\\n else f\\\"Training '{metric_name}' vs Epochs\\\"\\n )\\n if row_count == 1:\\n ax[c].legend(legend, loc=\\\"best\\\")\\n ax[c].set_title(ax_title)\\n else:\\n ax[r, c].legend(legend, loc=\\\"best\\\")\\n ax[r, c].set_title(ax_title)\\n\\n if title is not None:\\n plt.suptitle(title)\\n\\n plt.show()\",\n \"def visualize(**images):\\n n_images = len(images)\\n plt.figure(figsize=(20,8))\\n for idx, (name, image) in enumerate(images.items()):\\n plt.subplot(1, n_images, idx + 1)\\n plt.xticks([]); \\n plt.yticks([])\\n # get title from the parameter names\\n plt.title(name.replace('_',' ').title(), fontsize=20)\\n plt.imshow(image)\\n plt.savefig('sample_gt_pred_2_max.jpeg')\\n plt.show()\",\n \"def plot_sorted_accuracies(results):\\n ###TODO\\n #print(results)\\n \\n #step 1 -> sort accuracies and get x and y\\n # x = setting\\n # y = sorted list of accuracies\\n #results.sort(key=lambda x:(x['accuracy'])) \\n # don't use it ->it will change results from main as well\\n \\n #print(results)\\n\\n acc = []\\n \\n x = list(range(len(results)))\\n \\n for d in results:\\n #print('dict=',d)\\n acc.append(d['accuracy'])\\n \\n acc.sort(key=lambda x:(x))\\n #print('acc = ',acc)\\n \\n #step 2 -> plot figure\\n fig1 = plt.figure(1) \\n plt.plot(x,acc)\\n plt.ylabel('accuracy')\\n plt.xlabel('settings')\\n \\n plt.show()\\n \\n fig1.savefig('accuracies.png')\",\n \"def plot_results(infer_images, inference_predicted_class, inference_predictions, class_names=['plants', 'water']):\\n plt.style.use(['dark_background', 'bmh'])\\n rc('figure', figsize=(8, 8), max_open_warning=False)\\n rc('axes', facecolor='none')\\n plt.figure(figsize=(15, 15))\\n\\n for i, (infer_img, _) in enumerate(infer_images.take(10)):\\n ax = plt.subplot(5, 2, i + 1)\\n plt.imshow(infer_img.numpy()/255)\\n\\n # Find the predicted class from predictions\\n m = \\\"Predicted: {}, {:.2f}%\\\".format(\\n class_names[inference_predicted_class[i]], inference_predictions[i]*100)\\n plt.title(m)\\n plt.axis(\\\"off\\\")\\n plt.show()\",\n \"def _show_learning_rate():\\n fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(6.4 * 2, 4.8))\\n\\n # Visualize c_prime\\n c_prime_list = np.linspace(1, 100, num=11)\\n x_label = f\\\"c'\\\"\\n y_label = \\\"Minimum Clusters Size\\\"\\n title = \\\"\\\"\\n\\n ax = axes[0]\\n x_list = c_prime_list\\n\\n # MNIST\\n y_list = [161, 16, 14, 15, 20, 21, 24, 27, 30, 30, 35]\\n ax.plot(x_list, y_list, label=\\\"MNIST\\\")\\n\\n # Fashion MNIST\\n y_list = [63, 12, 12, 15, 18, 19, 22, 25, 26, 28, 30]\\n ax.plot(x_list, y_list, label=\\\"Fashion MNIST\\\")\\n\\n # 20 news groups\\n y_list = [1297, 724, 221, 80, 52, 51, 54, 54, 52, 60, 60]\\n ax.plot(x_list, y_list, label=\\\"Newsgroups\\\")\\n\\n ax.set_xlabel(x_label)\\n ax.set_ylabel(y_label)\\n ax.set_title(title)\\n ax.legend()\\n ax.set_yscale('log')\\n\\n # Visualize t0\\n t0_list = np.linspace(1, 100, num=11)\\n x_label = f\\\"t0\\\"\\n y_label = \\\"Minimum Clusters Size\\\"\\n title = \\\"\\\"\\n\\n ax = axes[1]\\n x_list = t0_list\\n\\n # MNIST\\n y_list = [16, 16, 16, 16, 16, 17, 16, 16, 16, 16, 16]\\n ax.plot(x_list, y_list, label=\\\"MNIST\\\")\\n\\n # Fashion MNIST\\n y_list = [12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12]\\n ax.plot(x_list, y_list, label=\\\"Fashion MNIST\\\")\\n\\n # 20 news groups\\n y_list = [765, 765, 767, 772, 772, 773, 789, 789, 793, 796, 799]\\n ax.plot(x_list, y_list, label=\\\"Newsgroups\\\")\\n\\n ax.set_xlabel(x_label)\\n ax.set_ylabel(y_label)\\n ax.set_title(title)\\n ax.legend()\\n ax.set_yscale('log')\\n\\n plt.show()\",\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 visualize_train_data(train_df, fname):\\r\\n logger = custom_logger.CustomLogger(run_id+':'+file_id)\\r\\n fig, axs = plt.subplots(3, figsize=(15,15))\\r\\n fig.suptitle('EPEX Intraday Continuous market electricity prices')\\r\\n\\r\\n axs[0].plot(train_df.index, train_df['low'], color='red')\\r\\n axs[0].set_title(\\\"Lowest Price\\\")\\r\\n axs[0].set(xlabel='time', ylabel='price (Euros)')\\r\\n\\r\\n axs[1].plot(train_df.index, train_df['high'], color='green')\\r\\n axs[1].set_title(\\\"Highest Pice\\\")\\r\\n axs[1].set(xlabel='time', ylabel='price (Euros)')\\r\\n\\r\\n axs[2].plot(train_df.index, train_df['weight_avg'], color='blue')\\r\\n axs[2].set_title(\\\"volume-weighted Average Price\\\")\\r\\n axs[2].set(xlabel='time', ylabel='price (Euros)')\\r\\n\\r\\n fig.savefig(os.path.join(unique_op_dir, fname))\\r\\n logger.info('Training data plots stored at ', os.path.join(unique_op_dir, fname))\",\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 cross_validation_experiment(train_data, train_labels):\\n accuracies = []\\n for i in range(1, 200):\\n avg = cross_validation(train_data, train_labels, i, 10)\\n accuracies.append(avg)\\n fig = plt.figure()\\n dim = np.arange(1,len(accuracies)+1)\\n plt.plot(dim,accuracies, label='Accuracy')\\n plt.xlabel('k')\\n plt.ylabel('accuracy')\\n plt.grid()\\n plt.legend()\\n plt.tight_layout()\\n fig.savefig('knn_cross_validation.png')\\n best_k = np.argmax(accuracies)+1\\n return best_k\",\n \"def render_data(hdf5_file, runs_per_epoch, window_size=1000):\\n # read input data\\n with h5py.File(hdf5_file, 'r') as f:\\n val_train_losses = f[\\\"validation/train_losses\\\"][()]\\n val_test_losses = f[\\\"validation/test_losses\\\"][()]\\n val_accuracies = f[\\\"validation/accuracies\\\"][()]\\n\\n all_losses = f[\\\"train/all_losses\\\"][()]\\n\\n n_runs = all_losses.shape[0]\\n n_val_points = val_train_losses.shape[0]\\n print(\\\"Total number of runs: %d, number of validation points: %d, runs per epoch: %d, window: %d\\\"\\n % (n_runs, n_val_points, runs_per_epoch, window_size))\\n\\n nsubplots = 0\\n if n_val_points > 0:\\n nsubplots = 1\\n if n_runs > 0:\\n nsubplots += 1\\n\\n\\n fig, axes = plt.subplots(ncols=nsubplots)\\n\\n # Render validation data points\\n if n_val_points > 0:\\n # Convert validation points to pandas data frame\\n df = pd.DataFrame(val_train_losses, columns=['Train Loss'])\\n df['Test Loss'] = pd.Series(val_test_losses, index=df.index)\\n df['Accuracy'] = pd.Series(val_accuracies, index=df.index)\\n\\n axes[0].set_xlim([0, n_val_points])\\n ax = df.plot(secondary_y=['Accuracy'], ax=axes[0], style=['b', 'g', 'r'])\\n axes[0].set_ylabel('loss')\\n axes[0].set_xlabel('epochs')\\n axes[0].right_ax.set_ylabel('accuracy')\\n axes[0].set_title(\\\"Validation Data\\\")\\n else:\\n axes = [None, axes]\\n\\n if n_runs > 0:\\n if runs_per_epoch > 0:\\n axes[1].set_xlim(runs_per_epoch, n_runs)\\n else:\\n axes[1].set_xlim(0, n_runs)\\n\\n x = np.arange(n_runs)\\n\\n plot_with_average(x, all_losses, ax=axes[1], style='r', label='Train Loss', window=window_size)\\n axes[1].set_xlabel('runs')\\n axes[1].set_ylabel('loss')\\n axes[1].set_title(\\\"Training Costs\\\")\\n\\n plt.tight_layout()\\n plt.show()\",\n \"def plot_eval_1(trained_model, image_name):\\n # Get training evaluation data\\n train_accuracy = trained_model.history['acc']\\n train_val_accuracy = trained_model.history['val_acc']\\n train_loss = trained_model.history['loss']\\n train_val_loss = trained_model.history['val_loss']\\n \\n # Generate accuracy plot\\n epochs = range(len(train_accuracy))\\n plt.figure()\\n plt.plot(epochs, train_accuracy, 'bo', label='Training accuracy')\\n plt.plot(epochs, train_val_accuracy, 'b', label='Validation accuracy')\\n plt.title('Training and validation accuracy')\\n plt.legend()\\n \\n # Save accuracy plot\\n plot_file = os.path.join(OUTPUT_DIR,\\n \\\"{}_training_accuracy\\\".format(image_name))\\n plt.savefig(plot_file + \\\".svg\\\", bbox_inches='tight', format='svg')\\n \\n # Generate loss plot\\n plt.figure()\\n plt.plot(epochs, train_loss, 'bo', label='Training loss')\\n plt.plot(epochs, train_val_loss, 'b', label='Validation loss')\\n plt.title('Training and validation loss')\\n plt.legend()\\n \\n # Save loss plot\\n plot_file = os.path.join(OUTPUT_DIR, \\\"{}_training_loss\\\".format(image_name))\\n plt.savefig(plot_file + \\\".svg\\\", bbox_inches='tight', format='svg')\",\n \"def plot_metric(df_metrics, name, batch_size=10, epochs=10):\\n\\n # One groupplot\\n fig, axarr = plt.subplots(3, 4, sharey=True, sharex=True)\\n plotname = 'apfd'\\n subplot_labels = ['(a)', '(b)', '(c)']\\n\\n for column, nr in enumerate(sorted(df_metrics['negative_ratio'].unique())):\\n for row, emb_size in enumerate(df_metrics['emb_size'].unique()):\\n for agidx, (labeltext, task, linestyle) in enumerate(\\n [('Classification', 'True', '-'), ('Regression', 'False', '-.')]):\\n rel_df = df_metrics[\\n (df_metrics['emb_size'] == str(emb_size)) & (df_metrics['negative_ratio'] == str(nr)) &\\n (df_metrics['batch_size'] == str(batch_size)) & (df_metrics['epochs'] == str(epochs))]\\n\\n # rel_df[rel_df['agent'] == agent].plot(x='step', y='napfd', label=labeltext, ylim=[0, 1], linewidth=0.8,\\n # style=linestyle, color=sns.color_palette()[agidx], ax=axarr[row,column])\\n\\n apfd = rel_df.loc[rel_df['classification'] == task, 'apfd']\\n miu = np.round(np.mean(apfd), 2)\\n sigma = np.round(np.std(apfd), 2)\\n label = labeltext + '\\\\n $\\\\mu$ - ' + str(miu) + ' $\\\\sigma$ - ' + str(sigma)\\n\\n # sns.displot(data=rel_df, x=\\\"apfd\\\", hue='classification', kde=True, ax=axarr[row, column])\\n\\n sns.distplot(apfd, kde=True,\\n bins=int(180 / 5), color=sns.color_palette()[agidx],\\n hist_kws={'edgecolor': 'black'},\\n kde_kws={'linewidth': 4, 'clip': (0.0, 1.0)}, label=label, ax=axarr[row, column])\\n\\n axarr[row, column].xaxis.grid(True, which='major')\\n\\n axarr[row, column].set_title('Emb_size - %s - Neg_Ratio - %s' % (emb_size, nr), fontsize=10)\\n\\n if row == 2:\\n axarr[row, column].set_xlabel('APFD')\\n if column == 0:\\n axarr[row, column].set_ylabel('Density')\\n\\n axarr[row, column].legend(frameon=True, prop={'size': 6})\\n\\n # Tweak spacing to prevent clipping of ylabel\\n fig.suptitle('APFD Parameter Tuning - %d Epochs and batch-size - %d' % (epochs, batch_size))\\n fig.tight_layout()\\n plt.savefig(name, bbox_inches='tight')\\n plt.show()\",\n \"def _plot_train_test_experiment(mtrain, mval, metric_name, isState):\\n # axes\\n f, axes = plt.subplots(2,2,figsize=(12,10))\\n ltrain = _plot_experiment(mtrain, axes[:,0], metric_name, isTrain=True)\\n lval = _plot_experiment(mval, axes[:,1], metric_name, isTrain=False)\\n # title\\n target = \\\"State\\\" if isState else \\\"Output\\\"\\n f.suptitle(f\\\"{target} Errors\\\")\\n f.tight_layout()\\n return f, axes\",\n \"def subplot_run_lenet(df, name, subplotids=[1,1,1]):\\n # Get nmber of features to plot\\n n_plot = len(df['Accuracy'])\\n # Create corresponding subplot\\n plt.subplot(subplotids[0], subplotids[1], subplotids[2])\\n for i in range(n_plot):\\n idx = df.index.values[i]\\n val = df.loc[idx, name]\\n if val < 0.1:\\n strLabel = '{:.1e}'.format(val) # Scientific\\n elif val < 1:\\n strLabel = '{:.1f}'.format(val) # Decimal point\\n else:\\n strLabel = '{}'.format(int(val)) # Integer\\n acc_tot = df.loc[idx,'Accuracy']\\n # Check if too much data (limit ot one per 50)\\n if len(acc_tot) > df.loc[idx, 'N iteration']//50:\\n acc_tot = acc_tot[::(len(acc_tot)//50)]\\n acc_span = np.linspace(0, df.loc[idx, 'N iteration'], len(acc_tot))\\n plt.plot(acc_span, acc_tot, '-',label=strLabel, linewidth=2) # Plot feature\\n # Size of the graph will depend on the minimum of iteration\\n plt.xlim([0, df['N iteration'].min()]); plt.ylim([0, 1]); \\n plt.title('Accuracy over ' + name)\\n plt.grid(); plt.legend(loc=4);\",\n \"def plot_loss_curves(results):\\n loss = results[\\\"train_loss\\\"]\\n test_loss = results[\\\"test_loss\\\"]\\n\\n accuracy = results[\\\"train_acc\\\"]\\n test_accuracy = results[\\\"test_acc\\\"]\\n\\n epochs = range(len(results[\\\"train_loss\\\"]))\\n\\n plt.figure(figsize=(15, 7))\\n\\n # Plot loss\\n plt.subplot(1, 2, 1)\\n plt.plot(epochs, loss, label=\\\"train_loss\\\")\\n plt.plot(epochs, test_loss, label=\\\"test_loss\\\")\\n plt.title(\\\"Loss\\\")\\n plt.xlabel(\\\"Epochs\\\")\\n plt.legend()\\n\\n # Plot accuracy\\n plt.subplot(1, 2, 2)\\n plt.plot(epochs, accuracy, label=\\\"train_accuracy\\\")\\n plt.plot(epochs, test_accuracy, label=\\\"test_accuracy\\\")\\n plt.title(\\\"Accuracy\\\")\\n plt.xlabel(\\\"Epochs\\\")\\n plt.legend()\",\n \"def plot_performance(\\n batch_perf_path: str = cst.PERFORMANCE_METRICS_FILE_PATH,\\n train_perf_path: str = cst.TRAIN_PERFORMANCE_METRICS_FILE_PATH,\\n batch_name: str = \\\"batch1.csv\\\",\\n):\\n # TRAINING DATA\\n # GET VALUES OF TRAIN\\n with open(train_perf_path) as json_file:\\n train_perf = json.load(json_file)\\n # saving performance keys\\n train_metrics = list(train_perf.keys())\\n # delete confusion matrix\\n train_metrics.pop(4)\\n train_values = list(train_perf.values())\\n # delete confusion matrix\\n train_values.pop(4)\\n # BATCH DATA\\n # Opening JSON file\\n \\n with open(batch_perf_path) as json_file:\\n performance_metrics = json.load(json_file)\\n \\n batch_perf = _get_batch_metrics(batch_name, performance_metrics) \\n \\n # saving performance keys of chosen batch\\n perf_metrics = list(batch_perf[batch_name].keys())\\n # delete confusion matrix\\n perf_metrics.pop(4)\\n # saving performance values of chosen batch\\n perf_values = list(batch_perf[batch_name].values())\\n # delete confusion matrix\\n perf_values.pop(4)\\n # define bar colors\\n colors = [\\\"rgb(0, 0, 100)\\\", \\\"rgb(0, 200, 200)\\\"]\\n fig = go.Figure(\\n data=[\\n go.Bar(\\n name=\\\"Training Performance\\\",\\n x=train_metrics,\\n y=train_values,\\n text=[f\\\"{np.round(v*100)}%\\\" for v in train_values],\\n textposition=\\\"outside\\\",\\n marker_color=colors[0],\\n ),\\n go.Bar(\\n name=\\\"Batch Performance \\\",\\n x=perf_metrics,\\n y=perf_values,\\n text=[f\\\"{np.round(v*100)}%\\\" for v in perf_values],\\n textposition=\\\"outside\\\",\\n marker_color=colors[1],\\n ),\\n ]\\n )\\n # Change the bar mode\\n fig.update_layout(\\n barmode=\\\"group\\\",\\n title_text=f\\\"Model performance of training sample vs batch\\\",\\n )\\n return fig\",\n \"def model_testing(X_train,y_train):\\n\\n # for testing amount of layers, each layer has 32 neurons\\n # layers = [[32, 32], [32, 32, 32], [32, 32, 32, 32], [32, 32, 32, 32],\\\\\\n # [32, 32, 32, 32, 32], [32, 32, 32, 32, 32, 32]]\\n layers = [[8], [16], [32], [64], [128], [256]]\\n\\n # activation = [\\\"linear\\\", \\\"sigmoid\\\", \\\"relu\\\", \\\"softmax\\\"]\\n activation = [\\\"relu\\\"]\\n runs = 1\\n for i, act in enumerate(activation):\\n val_accs = []\\n for layer in layers:\\n acc_avg = []\\n for run in range(runs):\\n model = create_model_testing(layer, act)\\n\\n # train model on full train set, with 80/20 CV split\\n training = model.fit(X_train, y_train, epochs=100, validation_split=0.2, verbose=0)\\n val_acc = np.mean(training.history['val_accuracy'])\\n print(\\\"Run \\\", run, \\\" - \\\", act + \\\" activation - layer \\\" + str(layer))\\n acc_avg.append(val_acc)\\n\\n # save average accuracy of runs\\n val_accs.append(round(np.mean(acc_avg)*100, 2))\\n print(\\\"accuracy: \\\" + str(np.mean(acc_avg)))\\n\\n # plot line for each activation method\\n plt.plot([1,2,4,8,16,32,64,128,256], val_accs, label=act)\\n # plt.plot(val_accs, label=act)\\n\\n # plotting\\n plt.title(\\\"Accuracy of neural network model with different layers (N=\\\" +\\\\\\n str(len(layers)) + \\\")\\\", fontsize=22)\\n plt.xlabel(\\\"Layers\\\", fontsize=20)\\n # plt.xticks(np.arange(1, len(val_accs) + 1, 1), fontsize=18)\\n plt.ylabel(\\\"Accuracy (%)\\\", fontsize=20)\\n plt.legend()\\n plt.subplots_adjust(bottom=.15, left=.15)\\n plt.savefig(\\\"results/linear-relu-\\\" + str(runs) + \\\"runs.png\\\")\\n plt.show()\",\n \"def img_viewer_examples(images, labels, prediction = None, size=0, greyscale=False):\\n batchSize = min(size, images.shape[0])\\n \\n if size == 0:\\n batchSize = images.shape[0]\\n\\n # I CAN TAKE THE BATCH_SIZE from the images size/shape according the sent data type\\n no_of_columns = round(math.sqrt(batchSize))\\n no_of_rows = math.ceil(batchSize / no_of_columns)\\n print(\\\"batch size {}, no_of_rows {}, no_of_columns {}\\\".format(batchSize, no_of_rows, no_of_columns))\\n fig = plt.figure(figsize=(no_of_columns*1.25, no_of_rows*1.5))\\n # (width, height)\\n for idx in np.arange(batchSize):\\n ax = fig.add_subplot(no_of_rows, no_of_columns,\\n idx+1, xticks=[], yticks=[])\\n if greyscale:\\n ax.imshow(np.squeeze(images[idx]), cmap='gray')\\n else:\\n ax.imshow(np.squeeze(images[idx]))\\n # print out the correct label for each image\\n # .item() gets the value contained in a Tensor\\n # WAIT FOR TASNEEM TO SEE THE RETURNED DATA TYPE\\n if not prediction is None:\\n ax.set_title(\\\"{} ({})\\\".format(str(prediction[idx]), str(labels[idx])),\\n color=(\\\"green\\\" if prediction[idx] == labels[idx] else \\\"red\\\"))\\n else:\\n ax.set_title(str(labels[idx]))\",\n \"def plot_results(self, predictions: list):\\n fig, ax = plt.subplots()\\n cm = confusion_matrix(self.test[1], predictions)\\n conf = confusion_matrix(self.test[1], predictions).ravel()\\n nbr_labels = len(set(self.test[1]))\\n cm = conf.reshape(nbr_labels, nbr_labels)\\n sns.heatmap(cm, annot=True, fmt=\\\"d\\\", cmap=\\\"Spectral\\\")\\n ax.set_xlabel(\\\"predicted label\\\")\\n ax.set_ylabel(\\\"true label\\\")\\n fig.savefig(\\\"confusion_matrix\\\")\\n\\n fig, ax = plt.subplots()\\n x = self.train[0] + self.test[0]\\n y = self.train[1] + self.test[1]\\n x = [i[0] for i in x]\\n y = [i for i in y]\\n results = pd.DataFrame({\\\"polarity strength\\\": x, \\\"true label\\\": y})\\n sns.boxplot(data=results, x=\\\"true label\\\", y=\\\"polarity strength\\\")\\n fig.savefig(\\\"boxplot\\\")\",\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_sorted_accuracies(results):\\n acc = []\\n for comb in results:\\n acc.append(comb[\\\"accuracy\\\"])\\n sorted_list = sorted(acc)\\n plt.plot(range(42),sorted_list,'bo-')\\n plt.ylabel(\\\"Accuracy\\\")\\n plt.xlabel(\\\"Setting\\\")\\n plt.savefig(\\\"accuracies.png\\\")\",\n \"def train_validation_split(tiles_df, valid_set_size = .2, visualize = False):\\n val_tile_indexes = np.random.choice(len(tiles_df), size = round(valid_set_size*len(tiles_df)))\\n tiles_df['dataset']='training'\\n tiles_df.loc[val_tile_indexes, 'dataset'] = 'validation'\\n\\n if visualize:\\n fig, ax = plt.subplots(figsize=(10,10))\\n tiles_df.loc[tiles_df['dataset']=='training'].plot(ax=ax, color='grey', alpha=0.5, edgecolor='red')\\n tiles_df.loc[tiles_df['dataset']=='validation'].plot(ax=ax, color='grey', alpha=0.5, edgecolor='blue')\\n return tiles_df\",\n \"def display_sample_images(self):\\n if self.train_dataset is None:\\n self.init_datasets()\\n\\n images, labels = next(self.train_dataset)\\n plt.figure(figsize=(5,5))\\n for n in range(min(25, images.shape[0])):\\n ax = plt.subplot(5,5,n+1)\\n plt.imshow(images[n])\\n if len(labels.shape) == 1:\\n plt.title(self.class_names[int(labels[n])].title())\\n else:\\n m = np.argmax(labels[n])\\n plt.title(self.class_names[int(labels[n, m])].title())\\n plt.axis('off')\\n\\n plt.tight_layout()\\n plt.show()\",\n \"def display_predictions(self, x, pred, y):\\r\\n fig = plt.figure(figsize=(15, 15))\\r\\n\\r\\n for i in range(self.batch_size):\\r\\n vals = x[i, :, :, :]\\r\\n sub = fig.add_subplot(1, self.batch_size, i + 1)\\r\\n val = pred[i]\\r\\n val2 = y[i]\\r\\n res = self.classes[val]\\r\\n res2 = self.classes[val2]\\r\\n\\r\\n sub.set_title(\\\"predicted = \\\" + res + \\\"\\\\n\\\" + \\\"Actual = \\\" + res2)\\r\\n plt.axis('off')\\r\\n img = np.asarray(vals)\\r\\n img = np.transpose(img, (1, 2, 0))\\r\\n # Get Specific channels for rgb\\r\\n rgbimg = self.get_rgb(img, 61, 38, 19)\\r\\n\\r\\n # Normalize Inputs\\r\\n imgmin, imgmax = rgbimg.min(), rgbimg.max()\\r\\n rgbimg = (rgbimg - imgmin) / (imgmax - imgmin)\\r\\n plt.imshow(rgbimg)\\r\\n file_loc = [str(self.training_path) + '\\\\\\\\checkpoints' +\\r\\n '\\\\\\\\' + 'predictions.jpg']\\r\\n s = \\\"\\\"\\r\\n s = s.join(file_loc)\\r\\n pred_path = Path(s)\\r\\n plt.savefig(pred_path)\\r\\n plt.show()\",\n \"def acc_loss_graph(self):\\n acc = self.history['accuracy']\\n val_acc = self.history['val_accuracy']\\n loss = self.history['loss']\\n val_loss = self.history['val_loss']\\n plt.figure(figsize=(15, 5))\\n plt.subplot(1, 2, 1)\\n plt.plot(acc, label='Train')\\n plt.plot(val_acc, label='Val')\\n plt.legend(loc='lower right')\\n plt.ylabel('Accuracy')\\n plt.xlabel('Epoch')\\n plt.ylim([min(plt.ylim()), 1])\\n plt.title('Accuracy')\\n\\n plt.subplot(1, 2, 2)\\n plt.plot(loss, label='Train')\\n plt.plot(val_loss, label='Val')\\n plt.legend(loc='lower right')\\n plt.ylabel('Loss')\\n plt.xlabel('Epoch')\\n plt.ylim([0, max(plt.ylim())])\\n plt.title('Loss')\\n plt.show();\",\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 test(self, plot=False):\\n accuracy_list = []\\n fobj_avg = self.load_stats()\\n\\n for ii in range(settings.PARS['maxIters']):\\n model = self.load_model(ii)\\n D1 = model['D']\\n W1 = model['W']\\n\\n # classification\\n tic = time.time()\\n accuracy_list.append(self.classification(D1, W1)[1])\\n toc = time.time()\\n print(\\n 'Final recognition rate for OnlineDL is : {} , objective function value: {}, time: {}'\\n .format(accuracy_list[ii], fobj_avg[ii], toc-tic)\\n )\\n\\n accuracy_list = np.asarray(accuracy_list)\\n\\n print('Best recognition rate for OnlineDL is {} at iteration {}'.format(\\n accuracy_list.max(), accuracy_list.argmax()))\\n\\n if plot:\\n # plot the objective function values for all iterations\\n plt.clf()\\n plt.plot(list(fobj_avg.keys()), list(fobj_avg.values()), 'mo--', linewidth=2)\\n plt.xlabel('Iterations')\\n plt.ylabel('Average objective function value')\\n plt.xticks(list(range(0, 20)), list(range(1, 21)))\\n plt.show()\\n\\n plt.clf()\\n plt.plot(accuracy_list, 'rs--', linewidth=2)\\n plt.xticks(list(range(0, 20)), list(range(1, 21)))\\n plt.xlabel('Iterations')\\n plt.ylabel('Accuracy')\\n plt.show()\",\n \"def plot_history(history):\\n ## First retrieve metrics names ## \\n metrics_names = [a for a in history.history.keys() if a[:3]!='val']\\n \\n rows = 1\\n cols = len(metrics_names)\\n\\n for i,a in enumerate(metrics_names,1):\\n plt.subplot(rows,cols,i)\\n plt.title(a)\\n plt.plot(history_epoch.history[a], label=\\\"Train\\\")\\n plt.plot(history_epoch.history[\\\"val_\\\"+a], label=\\\"Validation\\\")\\n plt.legend()\",\n \"def visualize(base_path, test_dataset, plot_dir, batch_size=4, ):\\n device = torch.device('cuda')\\n dataset = HeadDataset(test_dataset,\\n base_path,\\n dataset_param={},\\n train=False)\\n batch_iterator = iter(data.DataLoader(dataset, batch_size,\\n shuffle=False,\\n num_workers=4,\\n collate_fn=coco_collate))\\n for ind, (images, targets) in enumerate(tqdm(batch_iterator)):\\n images = list(img.to(device) for img in images)\\n np_images = [(ims.cpu().numpy()*255.).astype(np.uint8) for ims in images]\\n gt_boxes = [gt['boxes'].numpy().astype(np.float64) for gt in targets]\\n for np_im, gt_box in zip(np_images, gt_boxes):\\n plot_images = plot_ims(np_im, [], gt_box)\\n imsave(osp.join(plot_dir, str(ind) + '.jpg'), plot_images)\",\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(data, colours, line_styles):\\n \\n plt.style.use(\\\"seaborn-poster\\\") # See also seaborn-talk and seaborn-paper.\\n plt.grid(axis=\\\"y\\\", linestyle=\\\"-\\\", color=\\\"#d8dcd6\\\")\\n \\n for name, experiment in data.items():\\n for label, series in experiment.items():\\n epochs = range(1, len(series) + 1)\\n line, = plt.plot(epochs, series, color=colours[name],\\n linestyle=line_styles[label])\\n line.set_label(name + \\\" \\\" + label)\\n \\n plt.legend(loc=\\\"lower right\\\")\\n plt.xlabel(\\\"Epoch\\\")\\n plt.ylabel(\\\"Accuracy\\\")\\n plt.show()\",\n \"def plot_model_performance(train_loss, train_acc, train_val_loss, train_val_acc):\\n \\n green = '#72C29B'\\n orange = '#FFA577'\\n \\n with plt.xkcd():\\n # plot model loss\\n fig, ax1 = plt.subplots()\\n ax1.plot(range(1, len(train_loss) + 1), train_loss, green, linewidth=5,\\n label='training')\\n ax1.plot(range(1, len(train_val_loss) + 1), train_val_loss, orange,\\n linewidth=5, label='validation')\\n ax1.set_xlabel('# epoch')\\n ax1.set_ylabel('loss')\\n ax1.tick_params('y')\\n ax1.legend(loc='upper right', shadow=False)\\n # plot model accuracy\\n fig, ax2 = plt.subplots()\\n ax2.plot(range(1, len(train_acc) + 1), train_acc, green, linewidth=5,\\n label='training')\\n ax2.plot(range(1, len(train_val_acc) + 1), train_val_acc, orange,\\n linewidth=5, label='validation')\\n ax2.set_xlabel('# epoch')\\n ax2.set_ylabel('accuracy')\\n ax2.tick_params('y')\\n ax2.legend(loc='lower right', shadow=False)\\n plt.show()\",\n \"def plotExpectedPredicted(input, output, expected, label, fig, axes):\\n n_batches = len(input)\\n for batch in range(0, n_batches):\\n input_2d = np.clip(np.reshape(input[batch], (28, 28)), 0, 1)#.astype(np.uint8)\\n expected_2d = np.clip(np.reshape(expected[batch], (28, 28)), 0, 1)#.astype(np.uint8)\\n output_2d = np.clip(np.reshape(output[batch], (28, 28)), 0, 1)#.astype(np.uint8)\\n \\n axes[batch, 0].imshow(input_2d, interpolation='nearest', cmap='gray')\\n axes[batch, 0].set_title('Digit Label: {}'.format(label))\\n axes[batch, 0].set_xbound([0,28])\\n \\n axes[batch,1] .imshow(expected_2d, interpolation='nearest', cmap='gray')\\n axes[batch,1] .set_title('Digit Label: {}'.format(label))\\n axes[batch,1] .set_xbound([0,28])\\n \\n axes[batch,2] .imshow(output_2d, interpolation='nearest', cmap='gray')\\n axes[batch,2] .set_title('Digit Label: {}'.format(label))\\n axes[batch,2] .set_xbound([0,28])\",\n \"def showEntireDataset(wl_listG, wl_listV, tsvd_graphlet_vectors, kpca_graphlet_gram, tsvd_shortestpath_vectors,\\n kpca_shortestpath_gram, classes):\\n for i in range(1, 8):\\n if (i == 6):\\n data_tsvd = tsvd_graphlet_vectors\\n data_kpca = kpca_graphlet_gram\\n elif (i == 7):\\n data_tsvd = tsvd_shortestpath_vectors\\n data_kpca = kpca_shortestpath_gram\\n else:\\n data_tsvd = wl_listV[i - 1]\\n data_kpca = wl_listG[i - 1]\\n fig = plt.figure(figsize=(15, 15))\\n if (i == 6):\\n fig.suptitle('Graphlet', fontsize=25)\\n elif (i == 7):\\n fig.suptitle('Shortest Path', fontsize=25)\\n else:\\n fig.suptitle(f'Weisfeiler-Lehman {i}', fontsize=25)\\n ax1 = fig.add_subplot(221)\\n ax2 = fig.add_subplot(222)\\n ax3 = fig.add_subplot(223, projection='3d')\\n ax4 = fig.add_subplot(224, projection='3d')\\n ax1.title.set_text('2D TruncatedSVD')\\n ax2.title.set_text('2D KernelPCA')\\n ax3.title.set_text('3D TruncatedSVD')\\n ax4.title.set_text('3D KernelPCA')\\n ax1.scatter(data_tsvd[:, 0], data_tsvd[:, 1], c=classes)\\n ax2.scatter(data_kpca[:, 0], data_kpca[:, 1], c=classes)\\n ax3.scatter3D(data_tsvd[:, 0], data_tsvd[:, 1], data_tsvd[:, 2], c=classes)\\n ax4.scatter3D(data_kpca[:, 0], data_kpca[:, 1], data_kpca[:, 2], c=classes)\\n plt.show()\\n print(\\\"________________________________________________________________________________________\\\")\\n print()\",\n \"def show_imgs(dataset, n_imgs, plot_size=(15, 15), cmap=None):\\n n_cols = int(np.sqrt(n_imgs))\\n n_rows = int(np.ceil(np.sqrt(n_imgs)))\\n class_idx = dataset.class_to_idx\\n idx_class = idx_to_class(class_idx)\\n\\n fig, axes = plt.subplots(n_rows, n_cols, figsize=plot_size)\\n for i, ax in enumerate(axes.flatten()):\\n ax.axis('off')\\n title = f'Class : {idx_class[dataset.targets[i]]}'\\n ax.imshow(dataset.data[i], cmap=cmap)\\n ax.set_title(title)\\n fig.tight_layout()\",\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 check_dataset(dataset):\\n loader = torch.utils.data.DataLoader(dataset, batch_size=16)\\n dataiter = iter(loader)\\n images, labels = dataiter.next()\\n imgs_grid = make_grid(images, padding=0)\\n np_grid = imgs_grid.numpy()\\n plt.figure(figsize=(10, 7))\\n plt.imshow(np.transpose(np_grid, (1, 2, 0)))\\n for i in labels:\\n print(dataset.classes[i.item()])\\n plt.show()\",\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 view_images(dataset, size):\\n images, labels = dataset\\n assert images.shape[0] == labels.shape[0]\\n\\n num_images = images.shape[0]\\n num_cols = 3\\n num_rows = np.ceil(num_images / num_cols).astype(\\\"int\\\")\\n plt.figure(figsize=size)\\n for i in range(num_images):\\n image = images[i]\\n label = labels[i]\\n ax = plt.subplot(num_rows, num_cols, i + 1)\\n plt.imshow(np.array(image, dtype=\\\"float\\\"))\\n plt.title(\\\"Number: \\\" + str(label))\\n plt.axis(\\\"off\\\")\",\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_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 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 save_accuracy_chart(self):\\n history = self.model.history.history\\n fig = plt.figure()\\n plt.plot(history['accuracy'], label='Training Accuracy')\\n plt.plot(history['val_accuracy'],label='Validation Set Accuracy')\\n plt.legend()\\n fig.savefig('model_accuracy.png')\",\n \"def show_data(self, samples=5):\\n self._samples = samples\\n \\n idx = 0\\n batch = next(iter(self._loader))\\n while idx <= self._samples:\\n\\n (img_batch, label_batch) = batch\\n\\n fig = plt.figure()\\n ax1 = fig.add_subplot(121)\\n ax2 = fig.add_subplot(122)\\n \\n ax1.imshow(np.transpose(img_batch[idx], (1, 2, 0)))\\n ax2.imshow(np.transpose(label_batch[idx], (1, 2, 0)).squeeze(dim=2))\\n\\n plt.show()\\n idx += 1\",\n \"def prediction():\\r\\n\\r\\n loaded_model = load_model('imageTrainedModel.h5')\\r\\n print(loaded_model.summary())\\r\\n\\r\\n # retrieve history also:\\r\\n f = open('history.pckl', 'rb')\\r\\n history = pickle.load(f)\\r\\n f.close()\\r\\n\\r\\n print(history.keys())\\r\\n print(history)\\r\\n\\r\\n epochs = len(history['loss']) # length of the list stored at 'loss'\\r\\n # Plot losses for train and validation\\r\\n plt.figure()\\r\\n plt.title('Loss as training progresses')\\r\\n plt.xlabel('Epoch')\\r\\n plt.ylabel('Loss')\\r\\n plt.plot(history['loss'], label='Train Error')\\r\\n plt.plot(history['val_loss'], label='Val Error')\\r\\n plt.legend()\\r\\n plt.show()\\r\\n\\r\\n # Plot metrics\\r\\n plt.plot(history['acc']) # use same metric that was used for training. 'history' is a dictionary.\\r\\n plt.title('Accuracy as training progresses')\\r\\n plt.ylabel('Accuracy (%)')\\r\\n plt.xlabel('Epoch')\\r\\n ymax = max(history['acc'])\\r\\n xpos = history['acc'].index(ymax)\\r\\n xmax = xpos\\r\\n plt.annotate('Maximum accuracy: %s' % round(ymax, 3),\\r\\n xy=(xmax, ymax), xycoords='data',\\r\\n xytext=(0.5, 0.5), textcoords='axes fraction',\\r\\n fontsize=12)\\r\\n plt.show()\\r\\n\\r\\n # make predictions using x_test\\r\\n test_y_predictions = loaded_model.predict(x_test, batch_size=None, verbose=1, steps=None)\\r\\n test_y_predictions = np.around(test_y_predictions, decimals=0) # round to whole integers\\r\\n true_false_array = np.equal(y_test, test_y_predictions) # test of equality.\\r\\n true_count = np.sum(true_false_array) # number of correctly categorised images\\r\\n false_count = true_false_array.shape[0] - true_count # number of images not correctly categorised\\r\\n\\r\\n # Plot predicted and actual image categories\\r\\n fig = plt.figure()\\r\\n ax1 = fig.add_subplot(111)\\r\\n plt.title('Classification of Image Categories')\\r\\n plt.ylabel('Number of Images')\\r\\n plt.xlabel('Image Classification')\\r\\n label = ['Correct', 'Incorrect']\\r\\n index = np.arange(len(label))\\r\\n plt.xticks(index, label, fontsize=10, rotation=0)\\r\\n ax1.bar(index, [true_count, false_count])\\r\\n plt.show()\",\n \"def plot_eval_2(trained_model, image_name):\\n # Get training evaluation data\\n train_accuracy = trained_model.history['acc']\\n train_val_accuracy = trained_model.history['val_acc']\\n train_loss = trained_model.history['loss']\\n train_val_loss = trained_model.history['val_loss']\\n \\n # Generate accuracy plot\\n epochs = range(len(train_accuracy))\\n plt.figure()\\n plt.plot(epochs, train_accuracy, 'bo', label='Training accuracy')\\n plt.plot(epochs, train_val_accuracy, 'b', label='Validation accuracy')\\n plt.title('Training and validation accuracy')\\n plt.legend()\\n \\n # Save accuracy plot\\n plot_file = os.path.join(OUTPUT_DIR,\\n \\\"{}_training_accuracy\\\".format(image_name))\\n plt.savefig(plot_file + \\\".svg\\\", bbox_inches='tight', format='svg')\\n \\n # Generate loss plot\\n plt.figure()\\n plt.plot(epochs, train_loss, 'bo', label='Training loss')\\n plt.plot(epochs, train_val_loss, 'b', label='Validation loss')\\n plt.title('Training and validation loss')\\n plt.legend()\\n \\n # Save loss plot\\n plot_file = os.path.join(OUTPUT_DIR, \\\"{}_training_loss\\\".format(image_name))\\n plt.savefig(plot_file + \\\".svg\\\", bbox_inches='tight', format='svg')\",\n \"def graph_results(loss, acc):\\n N = len(loss)\\n x = np.linspace(0, N, N)\\n plt.subplot(1,2,1)\\n plt.plot(x, loss)\\n plt.subplot(1,2,2)\\n plt.plot(x,acc)\\n plt.show()\",\n \"def visualize_manipulation_training(flow, epoch, save_dir=None):\\n\\n # Basic figure setup\\n images_x = 3\\n images_y = 3 if isinstance(flow.codec, DCN) else 2\\n fig = Figure(figsize=(18, 10 / images_x * images_y))\\n conf = np.array(flow.fan.performance['confusion'])\\n \\n # Draw the plots\\n ax = fig.add_subplot(images_y, images_x, 1)\\n ax.plot(flow.nip.performance['loss']['training'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.nip.performance['loss']['training'], 0))\\n ax.set_ylabel('{} NIP loss'.format(flow.nip.class_name))\\n ax.set_title('Loss')\\n\\n ax = fig.add_subplot(images_y, images_x, 2)\\n ax.plot(flow.nip.performance['psnr']['validation'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.nip.performance['psnr']['validation'], 0))\\n ax.set_ylabel('{} NIP psnr'.format(flow.nip.class_name))\\n ax.set_title('PSNR')\\n ax.set_ylim([30, 50])\\n\\n ax = fig.add_subplot(images_y, images_x, 3)\\n ax.plot(flow.nip.performance['ssim']['validation'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.nip.performance['ssim']['validation'], 0))\\n ax.set_ylabel('{} NIP ssim'.format(flow.nip.class_name))\\n ax.set_title('SSIM')\\n ax.set_ylim([0.8, 1])\\n \\n ax = fig.add_subplot(images_y, images_x, 4)\\n ax.plot(flow.fan.performance['loss']['training'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.fan.performance['loss']['training'], 0))\\n ax.set_ylabel('FAN loss')\\n\\n ax = fig.add_subplot(images_y, images_x, 5)\\n ax.plot(flow.fan.performance['accuracy']['validation'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.fan.performance['accuracy']['validation'], 0))\\n ax.set_ylabel('FAN accuracy')\\n ax.set_ylim([0, 1])\\n\\n # The confusion matrix\\n ax = fig.add_subplot(images_y, images_x, 6)\\n ax.imshow(conf, vmin=0, vmax=1)\\n\\n ax.set_xticks(range(flow.n_classes))\\n ax.set_xticklabels(flow._forensics_classes, rotation='vertical')\\n ax.set_yticks(range(flow.n_classes))\\n ax.set_yticklabels(flow._forensics_classes)\\n\\n for r in range(flow.n_classes):\\n ax.text(r, r, '{:.2f}'.format(conf[r, r]), horizontalalignment='center', color='b' if conf[r, r] > 0.5 else 'w')\\n\\n ax.set_xlabel('PREDICTED class')\\n ax.set_ylabel('TRUE class')\\n ax.set_title('Accuracy: {:.2f}'.format(np.mean(np.diag(conf))))\\n\\n # If the compression model is a trainable DCN, include it's validation metrics\\n if images_y == 3:\\n ax = fig.add_subplot(images_y, images_x, 7)\\n ax.plot(flow.codec.performance['loss']['validation'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.codec.performance['loss']['validation'], 0))\\n ax.set_ylabel('DCN loss')\\n\\n ax = fig.add_subplot(images_y, images_x, 8)\\n ax.plot(flow.codec.performance['ssim']['validation'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.codec.performance['ssim']['validation'], 0))\\n ax.set_ylabel('DCN ssim')\\n ax.set_ylim([0.8, 1])\\n\\n ax = fig.add_subplot(images_y, images_x, 9)\\n ax.plot(flow.codec.performance['entropy']['validation'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.codec.performance['entropy']['validation'], 0))\\n ax.set_ylabel('DCN entropy')\\n\\n if save_dir is not None:\\n if not os.path.exists(save_dir):\\n os.makedirs(save_dir)\\n fig.savefig('{}/manip_validation_{:05d}.jpg'.format(save_dir, epoch), bbox_inches='tight', dpi=100)\\n del fig\\n\\n else:\\n return fig\",\n \"def 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 layer_show_mean(layer, width, accurs, y_wide=None, title=None, path=None):\\n fig = plt.figure(dpi=120, figsize=[8, 6])\\n plt.plot(layer, accurs.mean(axis=0), '--o', label='mean_accuracy')\\n\\n plt.ylim(y_wide)\\n plt.xticks(layer)\\n plt.xlabel('layers number')\\n plt.ylabel('accuracy')\\n plt.legend()\\n # plt.title(title)\\n plt.tight_layout()\\n fig.savefig(path)\",\n \"def plot_all(show=True):\\n fig, axes = plt.subplots(max_iterations, 1, figsize=(6, 12))\\n for t in range(max_iterations):\\n with open('results/%s/df_%d.pkl' % (id, t), 'rb') as f:\\n df = pickle.load(f)\\n with open('results/%s/w_%d.pkl' % (id, t), 'rb') as f:\\n w = pickle.load(f)\\n axes[t].hist2d(x=df['vision'], y=df['metab'], weights=w, density=True,\\n bins=((xticks, yticks)), cmap='magma')\\n axes[t].set_ylabel('max metabolism')\\n axes[t].set_xticks(vision_domain)\\n axes[t].set_yticks((2, 3, 4))\\n axes[3].set_xlabel('max vision')\\n fig.tight_layout()\\n if show:\\n plt.show()\\n else:\\n plt.savefig('results/%s/abc_results.pdf' % id)\",\n \"def plot_history(trials, tid, scores=[\\\"loss\\\", \\\"f1\\\", \\\"accuracy\\\"],\\n figsize=(15, 3)):\\n history = trials.train_history(tid)\\n fig = plt.figure(figsize=figsize)\\n for i, score in enumerate(scores):\\n plt.subplot(1, len(scores), i + 1)\\n\\n plt.plot(history[score], label=\\\"train\\\")\\n plt.plot(history['val_' + score], label=\\\"validation\\\")\\n plt.tight_layout()\\n plt.title(score)\\n plt.ylabel(score)\\n plt.xlabel('epoch')\\n plt.legend(loc='best')\\n return fig\",\n \"def PlotEnsemblePredictions(self,ens, sampling_freq=10, fontSizeLabels=24, fontSizeLegend=20,rescale=1.,pow10first=False):\\n pylab.figure()\\n\\tpylab.axes([0.15,0.35,0.95-0.15,0.95-0.35])\\n\\tdata_experiments = self.data.experiments\\n for independentValues in data_experiments:\\n Xdata = self.data.X[independentValues]\\n Ydata = self.data.Y[independentValues]\\n\\t Xtheory = scipy.logspace(scipy.log10(min(Xdata)),scipy.log10(max(Xdata)),num=100)\\n\\t pointType = self.data.pointType[independentValues]\\n\\t errorBar = self.data.errorBar[independentValues]\\n\\t mean_theory = scipy.zeros(len(Xtheory))\\n\\t std_theory = scipy.zeros(len(Xtheory))\\n for i in range(0, num_to_count):\\n\\t\\t ens_theory = self.theory.Y(Xtheory,ens[i*sampling_freq],independentValues)\\n\\t\\t mean_theory += ens_theory\\n\\t\\t std_theory += (ens_theory)**2\\n\\t mean_theory = mean_theory/(1.0*num_to_count)\\n\\t std_theory = scipy.sqrt((std_theory-num_to_count*mean_theory**2)/(num_to_count-1.))\\n\\t pylab.loglog(Xdata,Ydata,pointType[1])\\n\\t lb = self.getLabel(self.theory.independentNames,independentValues,pow10first=pow10first)\\n\\t pylab.errorbar(Xdata,Ydata, yerr=errorBar, fmt=pointType,label=lb)\\n\\t pylab.loglog(Xtheory,mean_theory,pointType[0])\\n\\t axis_dep=self.getAxis(Xdata,Ydata)\\n\\t #upper_bound = mean_theory+std_theory\\n\\t #lower_bound = mean_theory-std_theory\\n\\t upper_bound = scipy.exp(scipy.log(mean_theory) + scipy.log(1.+std_theory/mean_theory)*rescale)\\n\\t lower_bound = scipy.exp(scipy.log(mean_theory)+scipy.log(1.-std_theory/mean_theory)*rescale)\\n\\t for i in range(0, len(lower_bound)):\\n\\t\\t if lower_bound[i]<=0:\\n\\t\\t\\t lower_bound[i]=10.**(-16)\\n\\t pylab.fill_between(Xtheory,lower_bound,y2=upper_bound,color=pointType[0],alpha=0.2)\\n\\n\\t for i, Ax in enumerate(axis_dep):\\n\\t\\t ax0[i] =i%2 and max(ax0[i],Ax) or min(ax0[i],Ax)\\n\\tpylab.axis(tuple(ax0))\\n\\tpylab.legend(loc=(-0.15,-0.52),ncol=3)\",\n \"def __init__(self, experiment_count: int, total_tr_data: int, tr_accuracy: [int], total_test_data: int,\\n test_accuracy: [int], function_name: str, batch_size: int, title: str=\\\"CNN Accuracy Plot\\\"):\\n self.title = title\\n self.total_tr_data = total_tr_data\\n self.total_test_data = total_test_data\\n\\n # accuracy and last epoch\\n self.tr_accuracy = tr_accuracy.ravel()\\n self.last_epoch = str(int(self.tr_accuracy[CFG.EPOCHS - 1]))\\n self.last_epoch_per = self.tr_accuracy[CFG.EPOCHS - 1]\\n self.tr_mean = np.mean(self.tr_accuracy[-(CFG.EPOCHS - 10):])\\n self.tr_mean_str = \\\"{:.2f}\\\".format(self.tr_mean)\\n\\n self.test_accuracy = test_accuracy.ravel()\\n self.last_epoch = str(int(self.test_accuracy[CFG.EPOCHS - 1]))\\n self.last_epoch_per = self.test_accuracy[CFG.EPOCHS - 1]\\n self.test_mean = np.mean(self.test_accuracy[-(CFG.EPOCHS - 10):])\\n self.test_mean_str = \\\"{:.2f}\\\".format(self.test_mean)\\n\\n # hyperparameters and string equivalents (for formatting easily in overleaf)\\n self.function_name = function_name\\n self.batch_size = batch_size\\n\\n # data table specifications\\n self.cell_length = len(str(\\\" \\\" + str(self.total_tr_data) + \\\"/\\\" + str(self.total_tr_data) + \\\" \\\"))\\n self.total_cells = 3\\n self.max_length = (self.cell_length + 1) * (self.total_cells)\\n self.tablefile = \\\"table.txt\\\"\\n self.experiment_count = experiment_count\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73184514","0.7299639","0.70774925","0.69942814","0.6946279","0.6922432","0.68750584","0.6874822","0.6822587","0.6822159","0.67851657","0.6782538","0.6775013","0.6749557","0.6698696","0.6659146","0.6657379","0.6631417","0.6601273","0.6561536","0.6523589","0.6515112","0.650381","0.6482415","0.6480102","0.6479879","0.64569193","0.6448005","0.64406526","0.6423089","0.64065534","0.6398776","0.63846827","0.63781404","0.63536245","0.63516515","0.63458896","0.6338252","0.63180864","0.63063425","0.6301345","0.62883717","0.6265367","0.6256217","0.6254795","0.62421495","0.62395406","0.62361264","0.6233229","0.622897","0.6226155","0.6220833","0.6216636","0.6207934","0.6191213","0.618907","0.6180777","0.61679375","0.6163836","0.61574185","0.6151061","0.6147877","0.6140196","0.6138857","0.61356926","0.61352277","0.61318475","0.6114249","0.61135995","0.6108547","0.61079013","0.61067647","0.61038566","0.61014766","0.61013365","0.6094883","0.60895514","0.607358","0.6053616","0.60532117","0.60421926","0.60239255","0.60228777","0.60201657","0.6011203","0.6008256","0.60024124","0.60022116","0.60004926","0.59981984","0.5993433","0.59858114","0.5982556","0.5980839","0.59719974","0.5965832","0.5965605","0.59623426","0.59595054","0.59563166"],"string":"[\n \"0.73184514\",\n \"0.7299639\",\n \"0.70774925\",\n \"0.69942814\",\n \"0.6946279\",\n \"0.6922432\",\n \"0.68750584\",\n \"0.6874822\",\n \"0.6822587\",\n \"0.6822159\",\n \"0.67851657\",\n \"0.6782538\",\n \"0.6775013\",\n \"0.6749557\",\n \"0.6698696\",\n \"0.6659146\",\n \"0.6657379\",\n \"0.6631417\",\n \"0.6601273\",\n \"0.6561536\",\n \"0.6523589\",\n \"0.6515112\",\n \"0.650381\",\n \"0.6482415\",\n \"0.6480102\",\n \"0.6479879\",\n \"0.64569193\",\n \"0.6448005\",\n \"0.64406526\",\n \"0.6423089\",\n \"0.64065534\",\n \"0.6398776\",\n \"0.63846827\",\n \"0.63781404\",\n \"0.63536245\",\n \"0.63516515\",\n \"0.63458896\",\n \"0.6338252\",\n \"0.63180864\",\n \"0.63063425\",\n \"0.6301345\",\n \"0.62883717\",\n \"0.6265367\",\n \"0.6256217\",\n \"0.6254795\",\n \"0.62421495\",\n \"0.62395406\",\n \"0.62361264\",\n \"0.6233229\",\n \"0.622897\",\n \"0.6226155\",\n \"0.6220833\",\n \"0.6216636\",\n \"0.6207934\",\n \"0.6191213\",\n \"0.618907\",\n \"0.6180777\",\n \"0.61679375\",\n \"0.6163836\",\n \"0.61574185\",\n \"0.6151061\",\n \"0.6147877\",\n \"0.6140196\",\n \"0.6138857\",\n \"0.61356926\",\n \"0.61352277\",\n \"0.61318475\",\n \"0.6114249\",\n \"0.61135995\",\n \"0.6108547\",\n \"0.61079013\",\n \"0.61067647\",\n \"0.61038566\",\n \"0.61014766\",\n \"0.61013365\",\n \"0.6094883\",\n \"0.60895514\",\n \"0.607358\",\n \"0.6053616\",\n \"0.60532117\",\n \"0.60421926\",\n \"0.60239255\",\n \"0.60228777\",\n \"0.60201657\",\n \"0.6011203\",\n \"0.6008256\",\n \"0.60024124\",\n \"0.60022116\",\n \"0.60004926\",\n \"0.59981984\",\n \"0.5993433\",\n \"0.59858114\",\n \"0.5982556\",\n \"0.5980839\",\n \"0.59719974\",\n \"0.5965832\",\n \"0.5965605\",\n \"0.59623426\",\n \"0.59595054\",\n \"0.59563166\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.78852516"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":23095,"cells":{"query":{"kind":"string","value":"Initialize a new fraction with the given numerator and denominator (default 1)."},"document":{"kind":"string","value":"def __init__(self, numerator, denominator=1):\n common_div = gcd(numerator, denominator)\n if common_div == 0:\n common_div = 1\n self.numerator = int((numerator / common_div) / copysign(1, denominator))\n self.denominator = int((denominator / common_div) / copysign(1, denominator))\n if self.denominator != 0:\n self.equal = self.numerator / self.denominator\n elif self.denominator == 0:\n self.equal = \"UNDEFINED.\""},"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 __init__(self, numerator, denominator=1):\n gcd1 = math.gcd(numerator, denominator)\n\n if denominator < 0:\n self.numerator = -(int(numerator/gcd1))\n self.denominator = abs(int(denominator/gcd1))\n elif denominator == 0:\n self.numerator = 1\n self.denominator = 0\n else:\n self.numerator = int(numerator/gcd1)\n self.denominator = int(denominator/gcd1)","def __init__(self, numerator, denominator):\n if denominator == 0:\n raise ValueError(\"Denominator must be non-zero\")\n gcd = self.__gcd(numerator, denominator)\n self.numerator = numerator / gcd\n self.denominator = denominator / gcd","def __init__(self, numerator: int, denominator: int):\n self._numerator = numerator\n self._denominator = denominator\n self._reduce()","def __init__(self, fraction: float = 1):\n pass","def __init__(self, numerator, denominator=1):\n if (type(numerator) not in(int,float)):\n raise ValueError('Numerator must be a number')\n if (type(denominator) not in(int,float)):\n raise ValueError('Denominator must be a number')\n if denominator == 0:\n if numerator == 0:\n self.numerator = 0\n self.denominator = 1\n self.inf_size = 0\n else:\n self.numerator = 0\n self.denominator = 0\n self.inf_size = numerator\n else:\n self.inf_size = 0\n self.numerator = numerator\n self.denominator = denominator\n self.__make_denominator_integer()\n self.__make_numerator_integer()\n self.__reduce()","def __init__( self, *arg ):\r\n\t\tif ( len( arg ) == 2 ):\r\n\t\t\t# if one of the arguments is a fraction:\r\n\t\t\tif ( type( self ) in ( type( arg[ 0 ] ), type( arg[ 1 ] ) ) ):\r\n\t\t\t\t# future division is broken, so simple division doesn't work here.\r\n\t\t\t\tif ( type( self ) == type( arg[ 0 ] ) == type( arg[ 1 ] ) ):\r\n\t\t\t\t\t self.numerator = arg[ 0 ].numerator * arg[ 1 ].denominator\r\n\t\t\t\t\t self.denominator = arg[ 0 ].denominator * arg[ 1 ].numerator\r\n\t\t\t\telif ( type( self ) == type( arg[ 0 ] ) ):\r\n\t\t\t\t\tself.numerator = arg[ 0 ].numerator\r\n\t\t\t\t\tself.denominator = arg[ 0 ].denominator * arg[ 1 ]\r\n\t\t\t\telse: #( type( self ) == type( arg[ 1 ] ) ):\r\n\t\t\t\t\tself.numerator = arg[ 0 ] * arg[ 1 ].denominator\r\n\t\t\t\t\tself.denominator = arg[ 1 ].numerator\r\n\t\t\t\t\t\r\n\t\t\telif ( type( arg[ 0 ] ) in FRACTION_VALID_TYPES ) and ( type( arg[ 1 ] ) in FRACTION_VALID_TYPES ):\r\n\t\t\t\tself.numerator = arg[ 0 ]\r\n\t\t\t\tif ( arg[ 1 ] ):\r\n\t\t\t\t\tself.denominator = arg[ 1 ]\r\n\t\t\t\telse:\r\n\t\t\t\t\traise ZeroDivisionError( \"Denominator of a fraction cannot be 0\" )\r\n\t\t\telse:\r\n\t\t\t\traise TypeError( \"Invalid type for Fraction Constructor\" )\r\n\r\n\t\telif ( len( arg ) == 1 ):\r\n\t\t\tif ( type( arg[ 0 ] ) in FRACTION_VALID_TYPES ):\r\n\t\t\t\t self.numerator = arg[ 0 ]\r\n\t\t\t\t self.denominator = 1\r\n\t\t\telif ( type( arg[ 0 ] ) == type( self ) ): # if the argument is a fraction, copy it.\r\n\t\t\t\tself.numerator = arg[ 0 ].numerator\r\n\t\t\t\tself.denominator = arg[ 0 ].denominator\r\n\t\t\telse:\r\n\t\t\t\ttry: # check to see if the object has a __fraction__ method that returns a fraction. If not, raise an error.\r\n\t\t\t\t\tf = arg[ 0 ].__fraction__( )\r\n\t\t\t\texcept AttributeError:\r\n\t\t\t\t\traise TypeError( \"Invalid type for fraction constructor\" )\r\n\t\t\t\tif ( type( f ) == type( self ) ):\r\n\t\t\t\t\tself = f\r\n\t\t\t\telse:\r\n\t\t\t\t\traise TypeError( \"__fraction__( ) method returns incorrect data type for fraction constructor\" )\r\n\t\telif not len( arg ):\r\n\t\t\tself.numerator = 0\r\n\t\t\tself.denominator = 1\r\n\t\telse:\r\n\t\t\traise TypeError( \"fraction constructor takes at most 2 arguments (%d given)\" % len( arg ) )\r\n\r\n\t\t#eliminate any float values, we don't need floats in a fraction.\r\n\t\tif ( types.FloatType in ( type( self.numerator ), type( self.denominator ) ) ):\r\n\t\t\tself.numerator, self.denominator = self._noFloats( self.numerator, self.denominator )\r\n\t\t\t\r\n\t\tself._reduce( )","def __init__ (self,numerator,denominator=1):\n self.debug = False\n if (self.debug): print(f'enter fraction.__init__ with {numerator}, {denominator}')\n sign = int(numerator * denominator / abs(numerator * denominator))\n if (self.debug): print(f'enter sign is {sign}')\n self.value=(sign * abs(numerator),abs(denominator))\n self.simplify()","def __init__(self, numerator, denominator):\n\n if not isinstance(numerator, int) or not isinstance(denominator, int):\n raise TypeError\n elif denominator == 0:\n raise ValueError\n\n self.__numerator = numerator\n self.__denominator = denominator","def __init__(self):\n self.numerator = 1\n self.denominator = 1","def __init__(self,numerator,denominator):\n self.numerator = numerator\n self.denominator = denominator\n if(denominator==0):\n raise ValueError","def __init__(self, numer, denom=1, empty=False):\n self.numer = []\n self.denom = []\n self.neg = False\n\n # Initialize with no contents:\n # For private use only.\n if empty:\n return\n\n # If copy constructing another Fraction:\n if isinstance(numer, RationalFrac):\n self.numer = numer.numer\n self.denom = numer.denom\n self.neg = numer.neg\n return\n\n if numer == 0:\n self.numer = [0, ]\n return\n\n # If initialized with a float:\n elif isinstance(numer, float):\n if numer < 0.0:\n self.neg = True\n numer = abs(numer)\n exp = len(str(numer).split('.')[1])\n # numer = int(str(numer).split('.')[1])\n\n numer = int(round(numer * 10 ** exp))\n self.numer = RationalFrac.factorize(numer)\n self.denom = [2, 5] * exp\n\n # If initialized with a numerator and denominator:\n elif isinstance(numer, int) and isinstance(denom, int):\n self.numer = RationalFrac.factorize(abs(numer))\n self.denom = RationalFrac.factorize(abs(denom))\n self.neg = not ((numer < 0) == (denom < 0))\n if denom == 0:\n raise ZeroDivisionError(\n 'should not initialize with a denominator of zero.')\n\n # If initialized with a string version of a fraction:\n elif isinstance(numer, str):\n split = numer.strip().split('/')\n self.__init__(int(split[0]), int(split[1]))\n\n # Unexpected argument as initialization value:\n else:\n TypeError(\n f'{str(numer)} invalid. '\n f'must initialize with one of:\\n'\n 'int, float, str.')\n\n # If successful, cleanup:\n self.simplify()","def __make_denominator_integer(self):\n while self.denominator % 1 !=0:\n self.denominator *=10\n self.numerator *=10","def __init__(self, n, d):\n # Check that n and d are of type int:\n if type(n) != int or type(d) != int:\n raise ValueError('requires type int')\n # Check that denominator is non-zero:\n if d == 0:\n raise ZeroDivisionError('requires non-zero denominator')\n # If we get here, n and d are ok => initialize Fraction:\n self.num = n\n self.denom = d\n self.reduce()","def __init__(self, num, denom):\n assert type(num) == int and type(denom) == int, \"ints not used\"\n self.num = num\n self.denom = denom\n def simplify(x, y):\n \"\"\" Simplifies a fraction \"\"\"\n if x % 2 > 0:\n if y % x > 0:\n # Check Prime\n prime = check_prime(x, y)\n if prime == 0:\n return str(int(x)) + \"/\" + str(int(y))\n else:\n return simplify ((x / prime), (y / prime))\n else:\n return str(int(x/x)) + \"/\" + str(int(y/x))\n else:\n return simplify ((x / 2), (y / 2))\n def check_prime(x, y):\n \"\"\" Function used by simplify to check prime number division of num and denom \"\"\"\n pri = (3,5,7,11,13,17,19,23)\n for i in pri:\n if (x % i == 0) and (y % i == 0):\n return i\n return 0","def getint(self, fraction) -> int:\n self.numerator_a = fraction.numerator_a\n self.denominator_b = fraction.denominator_b\n self.fraction = str(self.numerator_a) + '/' + str(self.denominator_b)\n return super().__int__()","def __init__(self,top,bottom):\n \n if (type(top) is not int or type(bottom) is not int):\n raise TypeError('Numerator and denominator must be integers.')\n elif bottom == 0:\n raise ZeroDivisionError('The denominator cannot be zero.')\n elif bottom < 0: #store 'minus' in the numerator of the fraction\n top *= -1\n bottom *= -1\n #make irreducible form\n self.num = top // gcd(top,bottom)\n self.den = bottom // gcd(top,bottom)","def getfloat(self, fraction) -> float:\n self.numerator_a = fraction.numerator_a\n self.denominator_b = fraction.denominator_b\n self.fraction = str(self.numerator_a) + '/' + str(self.denominator_b)\n return super().__float__()","def __make_numerator_integer(self):\n while self.numerator % 1 !=0:\n self.denominator *=10\n self.numerator *=10","def __mul__(self,frac):\n if isinstance(frac,Fraction):\n if self.inf_size !=0 or frac.inf_size != 0:\n if abs(self.inf_size) > abs(frac.inf_size):\n return Fraction(self.inf_size,0)\n else:\n return Fraction(frac.inf_size,0)\n if self.numerator == 0 or frac.numerator == 0:\n return 0\n numerator = self.numerator*frac.numerator\n denominator = self.denominator*frac.denominator\n elif type(frac) in(float,int):\n if self.inf_size !=0:\n return self\n numerator = self.numerator *frac\n denominator = self.denominator\n else:\n raise ValueError('Fraction can only multiply with to int float or fractions')\n return Fraction(numerator,denominator)","def __mul__(self, frac):\n numerator = self.numerator * frac.numerator\n denominator = self.denominator * frac.denominator\n gcd = math.gcd(numerator, denominator)\n\n return Fraction(int(numerator/gcd), int(denominator/gcd))","def divide(self, numerator, denominator):\r\n if denominator == 0:\r\n if not self.has_error:\r\n self.has_error = True\r\n self.error += DIVISION_BY_ZERO\r\n return 1\r\n else:\r\n return numerator / denominator","def numerator(num):\n require_type(isa(num,fractions.Fraction) or isa(num,int),\n 'parameter of numerator must be a fraction or integer')\n return num.numerator","def test_init(self):\n f: Fraction = Fraction(3, 4)\n self.assertEqual(f.num, 3)\n self.assertEqual(f.denom, 4)","def denominator(num):\n require_type(isa(num,fractions.Fraction) or isa(num,int),\n 'parameter of denominator must be a fraction or integer')\n return num.denominator","def __add__(self, frac):\n add_new_numerator = (self.numerator * frac.denominator) +\\\n (frac.numerator * self.denominator)\n add_new_denominator = self.denominator * frac.denominator\n if add_new_denominator == 0:\n raise ValueError(\"UNDEFINED.\")\n return Fraction(add_new_numerator, add_new_denominator)","def denominator(self, denominator):\n\n self._denominator = denominator","def test_init(self):\n \n fraction1 = Fraction(1,2)\n self.assertEqual(fraction1.numerator, 1)\n self.assertEqual(fraction1.denominator, 2)","def divide(numerator, denominator):\n ensure_divisibility(numerator, denominator)\n return numerator // denominator","def __init__(self, time, numerator, denominator):\n self.time = time\n self.numerator = numerator\n self.denominator = denominator","def random_fraction():\r\n numerator = random.randint(1,9)\r\n denominator = random.randint(1,9)\r\n frac = Fraction(numerator,denominator)\r\n # print(frac)\r\n return frac","def fraction(self, value: int) -> 'Size':\n raise_not_number(value)\n self.maximum = '{}fr'.format(int(value))\n return self","def __sub__(self, frac):\n if isinstance(frac,Fraction):\n if self.inf_size !=0 or frac.inf_size != 0:\n if self.inf_size == frac.inf_size:\n return 0\n elif abs(self.inf_size) > abs(frac.inf_size):\n return Fraction(self.inf_size,0)\n else:\n return Fraction(-frac.inf_size,0)\n numerator = ((self.numerator*frac.denominator)-(frac.numerator*self.denominator))\n denominator = (self.denominator*frac.denominator)\n elif type(frac) in(float,int):\n if self.inf_size !=0:\n return self\n numerator = self.numerator - (frac*self.denominator)\n denominator = self.denominator\n else:\n raise ValueError('Fraction can only add with to int float or fractions')\n return Fraction(numerator,denominator)","def __reduce(self):\n if self.denominator <0:\n self.denominator *= -1\n self.numerator *= -1\n gcd = math.gcd(int(self.denominator),int(self.numerator))\n if self.denominator != 0 and self.numerator!= 0:\n if gcd > 0:\n self.denominator /= gcd\n self.numerator /= gcd\n self.numerator = int(self.numerator)\n self.denominator = int(self.denominator)","def test_prepare_value_limit_denominator(self):\n field = FractionField(limit_denominator=3)\n result = field.prepare_value(Decimal(1 / 3.0))\n self.assertEqual(\"1/3\", result)","def __add__(self, frac):\n if isinstance(frac,Fraction):\n if self.inf_size !=0 or frac.inf_size != 0:\n if self.inf_size == -frac.inf_size:\n return 0\n elif abs(self.inf_size) > abs(frac.inf_size):\n return Fraction(self.inf_size,0)\n else:\n return Fraction(frac.inf_size,0)\n numerator = ((self.numerator*frac.denominator)+(frac.numerator*self.denominator))\n denominator = (self.denominator*frac.denominator)\n elif type(frac) in(float,int):\n if self.inf_size !=0:\n return self\n numerator = (frac*self.denominator) + self.numerator\n denominator = self.denominator\n else:\n raise ValueError('Fraction can only add with to int float or fractions')\n return Fraction(numerator,denominator)","def __init__(self) -> None:\n self.minimum = '' # type: str\n self.maximum = '' # type: str\n self.fraction(1)","def test_div(self):\n newvalues= Fraction(7,10)/Fraction(4,5)\n fraction1 = Fraction(newvalues[0],newvalues[1])\n self.assertEqual(str(fraction1),\"35/40\")","def test_prepare_value_limit_denominator(self):\n field = DecimalFractionField(limit_denominator=3)\n result = field.prepare_value(Decimal(1 / 3.0))\n self.assertEqual(\"1/3\", result)","def __sub__(self, frac):\n numerator = ((self.numerator * frac.denominator) - (self.denominator * frac.numerator))\n denominator = (self.denominator * frac.denominator)\n return Fraction(numerator, denominator)","def __neg__(self):\n if self.numerator ==0 and self.denominator==0:\n return Fraction(-self.inf_size,0)\n else:\n return Fraction(-self.numerator,self.denominator)","def denominator(self):\n return 1","def parseFraction(f):\n p = f.find(\"/\")\n if p < 1:\n return None\n s1 = f[:p]\n s2 = f[p+1:]\n try:\n v1 = int(s1)\n v2 = int(s2)\n except ValueError:\n return None\n if v2:\n return 1.0 * v1 / v2\n else:\n return None","def divide_by(numerator, denominator):\n try:\n return numerator / denominator\n except ZeroDivisionError:\n logging.getLogger().error('Divide by zero!')\n logging.getLogger().error('It is really not a good idea.')\n raise","def totaled_ratio_calculator(numerator, denominator):\n if denominator != 0:\n ratio = round(float(numerator) / denominator, 3)\n else:\n ratio = 0\n return ratio","def __add__(self, frac):\n numerator = ((self.numerator * frac.denominator) + (self.denominator * frac.numerator))\n denominator = (self.denominator * frac.denominator)\n return Fraction(numerator, denominator)","def fraction_space(self):\n self.custom_space(*[0,0,1,1])","def cancel_fraction(numerator, denominator):\n str_numerator, str_denominator = str(numerator), str(denominator)\n\n for digit in str_numerator:\n # Ignore '0's\n if digit in str_denominator and digit != '0':\n str_numerator = str_numerator.replace(digit, '')\n str_denominator = str_denominator.replace(digit, '')\n # Unless any number is empty or the denominator is '0'...\n if str_numerator and str_denominator and str_denominator != '0':\n return int(str_numerator), int(str_denominator)\n return numerator, denominator","def __mul__(self, other) -> object:\n common_numerator = self.numerator_a * other.numerator_a\n common_denominator = self.denominator_b * other.denominator_b\n\n # check for common divisor\n common_divisor = self.common_divisor(int(common_numerator), common_denominator)\n if common_divisor is None:\n res = Fraction(common_numerator, common_denominator)\n else:\n common_numerator = common_numerator / common_divisor\n common_denominator = common_denominator / common_divisor\n res = Fraction(common_numerator, int(common_denominator))\n return res","def fractions():\n\n pi = 22 / 7\n print(\"22/7\\n====\")\n print_as_text(pi)\n\n pi = 333 / 106\n print(\"333/106\\n=======\")\n print_as_text(pi)\n\n pi = 355 / 113\n print(\"355/113\\n=======\")\n print_as_text(pi)\n\n pi = 52163 / 16604\n print(\"52163/16604\\n===========\")\n print_as_text(pi)\n\n pi = 103993 / 33102\n print(\"103993/33102\\n============\")\n print_as_text(pi)\n\n pi = 245850922 / 78256779\n print(\"245850922/78256779\\n==================\")\n print_as_text(pi)","def __init__(self, ratio=0.3, p=1.7, reduce=True):\n assert ratio > 0 and ratio <= 1, \"ratio should be in range [0, 1]\"\n assert p > 1, \"p should be >1\"\n self.ratio = ratio\n self.p = p\n self.reduce = reduce","def __mul__(self, other):\n new_num = self.num * other.num\n new_denom = self.denom * other.denom\n return Fraction(new_num, new_denom)","def reduce(self):\n import math\n g = math.gcd(self.num, self.den)\n return Fraction(self.num//g, self.den//g)","def divide(numerator, denominator, num_decimal_places):\n \n if denominator == 0 or num_decimal_places < 0:\n raise ValueError\n\n pieces = []\n\n # determine sign of final number, then make both numerator and denominator\n # positive for simplicity\n sign = 1\n if numerator < 0:\n sign = -sign\n numerator = -numerator\n if denominator < 0:\n sign = -sign\n denominator = -denominator\n if sign < 0:\n pieces.append('-')\n\n # determine integral part\n num_units = 0\n while numerator >= denominator:\n numerator -= denominator\n num_units += 1\n pieces.append(str(num_units))\n\n pieces.append('.')\n\n # determine fractional part\n for _ in range(num_decimal_places):\n numerator *= 10\n num_units = 0\n while numerator >= denominator:\n numerator -= denominator\n num_units += 1\n pieces.append(str(num_units))\n\n return float(''.join(pieces))","def fromRational(rat):\n def longDiv(c, e, n):\n \"\"\"\n Divide the numerator by the denominator using long division.\n\n :param c: long\n :param e: long\n :param n: long\n :return: Scientific\n \"\"\"\n if n == 0:\n return Scientific(c, e)\n else:\n # TODO: Use a logarithm here!\n # TODO: Can't use tail recursion like this in python!\n if n < d:\n return longDiv(c * 10, e - 1, n * 10)\n else:\n (q, r) = quotRemInteger(n, d)\n return longDiv(c+q, e, r)\n\n d = rat.denominator\n\n if d == 0:\n raise ZeroDivisionError\n else:\n return rational.positivize(longDiv(0, 0), rat.numerator)","def reciprocal(self):\n return Rational(self.denominator, self.numerator)","def morph_fraction(lex, num, den, digit):\n raise NotImplementedError","def frac_field(self, *gens):\n from sympy.polys.domains import FractionField\n return FractionField(self, *gens)","def __int__(self) -> int:\n integer_number = self.numerator_a // self.denominator_b\n print(f'Fraction {self.fraction} integer number is {integer_number}')\n return integer_number","def test_divide1(self):\n n = Rational(1, 1)\n d = Rational(0, 1)\n with self.assertRaises(ZeroDivisionError):\n \"\"\"Divide by zero\"\"\"\n n.__div__(d)","def frac(num_str, obj_mode=False):\n if obj_mode == False:\n cast_frac = lambda inp: float(Fraction(inp))\n elif obj_mode == True:\n cast_frac = Fraction\n try:\n return cast_frac(num_str)\n except ValueError:\n if num_str == '':\n return cast_frac('0/1')\n elif num_str == '?':\n return np.nan","def from_value(cls, value):\n value = Fraction(value)\n if value.denominator > 1024:\n msg = f\"{value} would result in a very deep game tree.\"\n raise ValueError(msg)\n if value.denominator == 1:\n if value == 0:\n left = set()\n right = set()\n elif value > 0:\n left = {Surreal.from_value(value - 1)}\n right = set()\n else:\n left = set()\n right = {Surreal.from_value(value + 1)}\n else:\n left = {Surreal.from_value(value - 1 / value.denominator)}\n right = {Surreal.from_value(value + 1 / value.denominator)}\n\n return cls(left=left, right=right)","def from_FractionField(K1, a, K0):\n return None","def _divide(self, denominator):\n self.precision = (self.precision / float(denominator))\n self.accuracy = (self.accuracy / float(denominator))\n self.recall = (self.recall / float(denominator))\n self.f_measure = (self.f_measure / float(denominator))","def div(a, b):\r\n if type(b) in inttypes_set:\r\n if not b:\r\n return Infinity(a)\r\n raise ZeroDivisionError('%r / %r' % (a, b))\r\n if b == 1:\r\n return a\r\n if type(a) in inttypes_set:\r\n return normalized_fraction(a, b)\r\n return a / b","def __init__(self):\n BuiltinFunction.__init__(self, \"frac\",\n conversions=dict(sympy='frac'),\n latex_name=r\"\\operatorname{frac}\")","def __init__(G, left=None, right=None):\n if not all(opt.is_number for opt in left | right):\n msg = \"All options must be numbers.\"\n raise ValueError(msg)\n\n G._left = {Surreal(G_L.left, G_L.right) for G_L in left}\n G._right = {Surreal(G_R.left, G_R.right) for G_R in right}\n\n if not all(G_L < G_R for G_L in left for G_R in right):\n msg = \"There exists a G_L >= G_R.\"\n raise ValueError(msg)\n\n if not G._left | G._right:\n G._n = Fraction(0)\n else:\n # non-zero dyadic rational\n if G._left:\n lf = next(iter(G._left)).n\n if G._right:\n rf = next(iter(G._right)).n\n\n if not right:\n # positive integer\n G._n = lf + 1\n elif not left:\n # negative integer\n G._n = rf - 1\n else:\n # dyadic rational\n G._n = (lf + rf) / 2","def __copy__(self):\n copy = RationalFrac(0, empty=True)\n copy.numer = self.numer.copy()\n copy.denom = self.denom.copy()\n copy.neg = bool(self.neg)\n return copy","def fraction_to_proper_fraction(rational):\n assert isinstance(rational, Fraction), repr(rational)\n quotient = int(rational)\n residue = rational - quotient\n return quotient, residue","def __float__(self) -> float:\n float_number = self.numerator_a / self.denominator_b\n print(f'Fraction {self.fraction} float number is {float_number}')\n return float_number","def __truediv__(self, other):\n try:\n assert not other.is_zero(), \"cannot divide by 0.\"\n new_num = (self._num * other._den)\n new_den = (self._den * other._num) \n return Rational(new_num, new_den)\n except AttributeError:\n return (self / Rational.parse_number(other))","def __sub__(self, other) -> object:\n least_common_multiple = self.denominator_b\n # check denominators of fractions and if no define their least common multiple\n if self.denominator_b != other.denominator_b:\n least_common_multiple = self.least_common_multiple_func(other.denominator_b)\n\n common_numerator = (least_common_multiple / self.denominator_b * self.numerator_a) - \\\n (least_common_multiple / other.denominator_b * other.numerator_a)\n\n # check for common divisor\n common_divisor = self.common_divisor(int(common_numerator), least_common_multiple)\n if common_divisor is None:\n res = Fraction(common_numerator, least_common_multiple)\n else:\n common_numerator = common_numerator / common_divisor\n least_common_multiple = least_common_multiple / common_divisor\n res = Fraction(common_numerator, int(least_common_multiple))\n return res","def denominator(self, ???):","def ratio_histogram(numerator, denominator, y_title = 'Data / Background'):\n # Create our result based off of the numerator (it will have bin errors\n # enabled)\n result = combined_histogram(numerator)\n\n # Create the denominator\n combined_denominator = combined_histogram(denominator)\n\n # Disable errors on the denominator (they should be handled in an\n # uncertainty band around unity)\n for bin in xrange(0, combined_denominator.GetNbinsX() + 2):\n combined_denominator.SetBinError(bin, 0.0)\n\n # Divide by the denominator\n result.Divide(combined_denominator)\n\n # Do some styling on the result\n result.SetTitle('')\n result.SetStats(0)\n result.SetMarkerStyle(20)\n #result.SetMarkerSize(1.5)\n\n # Set title\n result.GetYaxis().SetTitle(y_title)\n\n return result","def fraction_gcd(x, y):\n a = x.numerator\n b = x.denominator\n c = y.numerator\n d = y.denominator\n return Fraction(gcd(a, c), lcm(b, d))","def _reduce(self) -> None:\n divisor = self._gcd(self._numerator, self._denominator)\n self._numerator = self._numerator // divisor\n self._denominator = self._denominator // divisor","def ratio_calculator(numerator, denominator):\n ratios = []\n for i in numerator:\n for j in denominator:\n if i[0] == j[0] and j[1] != 0:\n ratios.append([i[0], round(float(i[1]) / j[1], 3)])\n break\n elif i[0] == j[0]:\n ratios.append([i[0], 0])\n return ratios","def test_fraction_math_ops(self):\n fract1 = source.Fraction(5, 3)\n fract2 = source.Fraction(2, 3)\n self.assertEqual(fract1 + fract2, source.Fraction(7, 3))\n self.assertEqual(fract1 + 5, source.Fraction(20, 3))\n self.assertEqual(3 + fract1, source.Fraction(14, 3))\n self.assertEqual(fract1 * fract2, source.Fraction(10, 9))\n self.assertEqual(5 * fract2, source.Fraction(10, 3))","def __mul__(self,f2):\n new_numerator = self.__num * f2.num\n new_denominator = self.__den * f2.den\n return Fraction(new_numerator,new_denominator)","def __init__(self, positive_fraction=0.5, is_static=False):\n if positive_fraction < 0 or positive_fraction > 1:\n raise ValueError('positive_fraction should be in range [0,1]. '\n 'Received: %s.' % positive_fraction)\n self._positive_fraction = positive_fraction\n self._is_static = is_static","def inverse( self ):\r\n\t\treturn fraction( self.denominator, self.numerator )","def format_and_scale_fraction(numerator, denominator, unit):\n\n # simple case for small numbers\n if denominator < 1000:\n return '%d / %d %s' % (numerator, denominator, unit)\n\n # pick a scale\n (scale, suffix) = _pick_scale_and_suffix(denominator)\n\n # decide how many digits after the decimal to display\n scaled_denominator = denominator / scale\n if scaled_denominator < 10.0:\n fmt = '%1.2f / %1.2f %s%s'\n elif scaled_denominator < 100.0:\n fmt = '%1.1f / %1.1f %s%s'\n else:\n fmt = '%1.0f / %1.0f %s%s'\n\n # format it\n scaled_numerator = numerator / scale\n return fmt % (scaled_numerator, scaled_denominator, suffix, unit)","def test_init_exception(self):\n with self.assertRaises(ZeroDivisionError): Fraction(10, 0)","def safe_div(numerator, denominator, name='safe_div'):\n return array_ops.where(\n math_ops.equal(denominator, 0),\n array_ops.zeros_like(numerator),\n math_ops.div(numerator, denominator),\n name=name)","def __rmod__(self, other):\n if self == Rational(0, 1):\n raise ZeroDivisionError('division by zero')\n return Rational(0, 1)","def __sub__(self, other):\n # type: (object) -> Fraction\n dx = other\n if type(other) is float:\n dx = dectofr(other)\n return Fraction(self.numerator * dx.denominator - self.denominator * dx.numerator,\n self.denominator * dx.denominator)","def __div__(self, other):\n if not (isNumeric(other) or isinstance(other, Expression)):\n error_msg = (\n f'Invalid expression during division of {self}: [{other}]'\n )\n raise excep.biogemeError(error_msg)\n return Divide(self, other)","def __mul__(self, otherfraction):\n\n newnum = self.num * otherfraction.num\n newden = self.den * otherfraction.den\n\n #reduce new num over lcm den\n common = gcd(sub_num, new_lcm)\n newnum = sub_num//common\n newden = new_lcm//common\n\n return Fraction(newnum, newden)","def __add__(self, other):\n new_num = self.num * other.denom + other.num * self.denom\n new_denom = self.denom * other.denom\n return Fraction(new_num, new_denom)","def normalized_fraction(p, q=1):\r\n x, y = p, q\r\n while y:\r\n x, y = y, x % y\r\n if x != 1:\r\n p //= x\r\n q //= x\r\n if q == 1:\r\n return p\r\n return mpq((p, q))","def simplify_fraction(a, b):\n c = gcd(a, b)\n return a // c, b // c","def test_mul(self):\n newvalues = Fraction(3,2)*Fraction(1,4)\n fraction1 = Fraction(newvalues[0],newvalues[1])\n self.assertEqual(str(fraction1),\"3/8\")","def reciprocal(self):\n recip = RationalFrac(0, empty=True)\n if 0 in self.numer:\n raise ZeroDivisionError('the reciprocal of zero is undefined.')\n recip.numer = self.denom.copy()\n recip.denom = self.numer.copy()\n recip.neg = bool(self.neg)\n return recip","def __repr__( self ):\r\n\t\treturn ( \"%s/%s\" % ( self.numerator, self.denominator ) )","def render_frac(numerator, denominator):\r\n if len(numerator) == 1:\r\n num_latex = numerator[0].sans_parens\r\n else:\r\n num_latex = r\"\\cdot \".join(k.latex for k in numerator)\r\n\r\n if len(denominator) == 1:\r\n den_latex = denominator[0].sans_parens\r\n else:\r\n den_latex = r\"\\cdot \".join(k.latex for k in denominator)\r\n\r\n latex = ur\"\\frac{{{num}}}{{{den}}}\".format(num=num_latex, den=den_latex)\r\n return latex","def __sub__(self,f2):\n new_numerator = self.__num * f2.den - self.__den * f2.num\n new_denominator = self.__den * f2.den\n return Fraction(new_numerator,new_denominator)","def divide1(a, b):\n if b == 0:\n raise ValueError(\"Zero division Error!\")\n return a * 1.0 / b","def __mul__(self, other):\n new_num = self.num*other.num\n new_den = self.den*other.den\n common = gcd(new_num, new_den)\n\n return Fraction(new_num//common, new_den//common)","def __init__(self, denominator, val, diagram_type):\n Node.__init__(self, denominator, diagram_type=diagram_type)\n self.child_nodes = None\n self.value = val\n self.shape = [1, 1]\n self.d = 0","def rational_frac_tests():\n print('\\n==========================================')\n print('rfrac.py @ rational_frac_tests: //////////\\n')\n print(RationalFrac(-1), RationalFrac(0))\n # __prime_factors()\n frac0 = RationalFrac(4.5)\n frac1 = RationalFrac(-0.125)\n frac2 = RationalFrac(0.99999)\n f = [frac0, frac1, frac2]\n print('float(-0.125) =', float(f[1]))\n print('float(0.99999) =', float(f[2]))\n print('9/2 + -1/8 =', f[0] + f[1])\n print('9/2 * -1/8 =', f[0] * f[1])\n print('-1/8 * 9/2 =', f[1] * f[0])\n print(f)\n print('frac(-0/1) + frac(-0/1) =',\n RationalFrac(-0) + RationalFrac(-0))\n f3 = RationalFrac('-7/29')\n print(f3)\n print(RationalFrac(25, 1000))\n print('\\nrfrac.py @ end of rational_frac_tests ////')\n print('==========================================\\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))"],"string":"[\n \"def __init__(self, numerator, denominator=1):\\n gcd1 = math.gcd(numerator, denominator)\\n\\n if denominator < 0:\\n self.numerator = -(int(numerator/gcd1))\\n self.denominator = abs(int(denominator/gcd1))\\n elif denominator == 0:\\n self.numerator = 1\\n self.denominator = 0\\n else:\\n self.numerator = int(numerator/gcd1)\\n self.denominator = int(denominator/gcd1)\",\n \"def __init__(self, numerator, denominator):\\n if denominator == 0:\\n raise ValueError(\\\"Denominator must be non-zero\\\")\\n gcd = self.__gcd(numerator, denominator)\\n self.numerator = numerator / gcd\\n self.denominator = denominator / gcd\",\n \"def __init__(self, numerator: int, denominator: int):\\n self._numerator = numerator\\n self._denominator = denominator\\n self._reduce()\",\n \"def __init__(self, fraction: float = 1):\\n pass\",\n \"def __init__(self, numerator, denominator=1):\\n if (type(numerator) not in(int,float)):\\n raise ValueError('Numerator must be a number')\\n if (type(denominator) not in(int,float)):\\n raise ValueError('Denominator must be a number')\\n if denominator == 0:\\n if numerator == 0:\\n self.numerator = 0\\n self.denominator = 1\\n self.inf_size = 0\\n else:\\n self.numerator = 0\\n self.denominator = 0\\n self.inf_size = numerator\\n else:\\n self.inf_size = 0\\n self.numerator = numerator\\n self.denominator = denominator\\n self.__make_denominator_integer()\\n self.__make_numerator_integer()\\n self.__reduce()\",\n \"def __init__( self, *arg ):\\r\\n\\t\\tif ( len( arg ) == 2 ):\\r\\n\\t\\t\\t# if one of the arguments is a fraction:\\r\\n\\t\\t\\tif ( type( self ) in ( type( arg[ 0 ] ), type( arg[ 1 ] ) ) ):\\r\\n\\t\\t\\t\\t# future division is broken, so simple division doesn't work here.\\r\\n\\t\\t\\t\\tif ( type( self ) == type( arg[ 0 ] ) == type( arg[ 1 ] ) ):\\r\\n\\t\\t\\t\\t\\t self.numerator = arg[ 0 ].numerator * arg[ 1 ].denominator\\r\\n\\t\\t\\t\\t\\t self.denominator = arg[ 0 ].denominator * arg[ 1 ].numerator\\r\\n\\t\\t\\t\\telif ( type( self ) == type( arg[ 0 ] ) ):\\r\\n\\t\\t\\t\\t\\tself.numerator = arg[ 0 ].numerator\\r\\n\\t\\t\\t\\t\\tself.denominator = arg[ 0 ].denominator * arg[ 1 ]\\r\\n\\t\\t\\t\\telse: #( type( self ) == type( arg[ 1 ] ) ):\\r\\n\\t\\t\\t\\t\\tself.numerator = arg[ 0 ] * arg[ 1 ].denominator\\r\\n\\t\\t\\t\\t\\tself.denominator = arg[ 1 ].numerator\\r\\n\\t\\t\\t\\t\\t\\r\\n\\t\\t\\telif ( type( arg[ 0 ] ) in FRACTION_VALID_TYPES ) and ( type( arg[ 1 ] ) in FRACTION_VALID_TYPES ):\\r\\n\\t\\t\\t\\tself.numerator = arg[ 0 ]\\r\\n\\t\\t\\t\\tif ( arg[ 1 ] ):\\r\\n\\t\\t\\t\\t\\tself.denominator = arg[ 1 ]\\r\\n\\t\\t\\t\\telse:\\r\\n\\t\\t\\t\\t\\traise ZeroDivisionError( \\\"Denominator of a fraction cannot be 0\\\" )\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\traise TypeError( \\\"Invalid type for Fraction Constructor\\\" )\\r\\n\\r\\n\\t\\telif ( len( arg ) == 1 ):\\r\\n\\t\\t\\tif ( type( arg[ 0 ] ) in FRACTION_VALID_TYPES ):\\r\\n\\t\\t\\t\\t self.numerator = arg[ 0 ]\\r\\n\\t\\t\\t\\t self.denominator = 1\\r\\n\\t\\t\\telif ( type( arg[ 0 ] ) == type( self ) ): # if the argument is a fraction, copy it.\\r\\n\\t\\t\\t\\tself.numerator = arg[ 0 ].numerator\\r\\n\\t\\t\\t\\tself.denominator = arg[ 0 ].denominator\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\ttry: # check to see if the object has a __fraction__ method that returns a fraction. If not, raise an error.\\r\\n\\t\\t\\t\\t\\tf = arg[ 0 ].__fraction__( )\\r\\n\\t\\t\\t\\texcept AttributeError:\\r\\n\\t\\t\\t\\t\\traise TypeError( \\\"Invalid type for fraction constructor\\\" )\\r\\n\\t\\t\\t\\tif ( type( f ) == type( self ) ):\\r\\n\\t\\t\\t\\t\\tself = f\\r\\n\\t\\t\\t\\telse:\\r\\n\\t\\t\\t\\t\\traise TypeError( \\\"__fraction__( ) method returns incorrect data type for fraction constructor\\\" )\\r\\n\\t\\telif not len( arg ):\\r\\n\\t\\t\\tself.numerator = 0\\r\\n\\t\\t\\tself.denominator = 1\\r\\n\\t\\telse:\\r\\n\\t\\t\\traise TypeError( \\\"fraction constructor takes at most 2 arguments (%d given)\\\" % len( arg ) )\\r\\n\\r\\n\\t\\t#eliminate any float values, we don't need floats in a fraction.\\r\\n\\t\\tif ( types.FloatType in ( type( self.numerator ), type( self.denominator ) ) ):\\r\\n\\t\\t\\tself.numerator, self.denominator = self._noFloats( self.numerator, self.denominator )\\r\\n\\t\\t\\t\\r\\n\\t\\tself._reduce( )\",\n \"def __init__ (self,numerator,denominator=1):\\n self.debug = False\\n if (self.debug): print(f'enter fraction.__init__ with {numerator}, {denominator}')\\n sign = int(numerator * denominator / abs(numerator * denominator))\\n if (self.debug): print(f'enter sign is {sign}')\\n self.value=(sign * abs(numerator),abs(denominator))\\n self.simplify()\",\n \"def __init__(self, numerator, denominator):\\n\\n if not isinstance(numerator, int) or not isinstance(denominator, int):\\n raise TypeError\\n elif denominator == 0:\\n raise ValueError\\n\\n self.__numerator = numerator\\n self.__denominator = denominator\",\n \"def __init__(self):\\n self.numerator = 1\\n self.denominator = 1\",\n \"def __init__(self,numerator,denominator):\\n self.numerator = numerator\\n self.denominator = denominator\\n if(denominator==0):\\n raise ValueError\",\n \"def __init__(self, numer, denom=1, empty=False):\\n self.numer = []\\n self.denom = []\\n self.neg = False\\n\\n # Initialize with no contents:\\n # For private use only.\\n if empty:\\n return\\n\\n # If copy constructing another Fraction:\\n if isinstance(numer, RationalFrac):\\n self.numer = numer.numer\\n self.denom = numer.denom\\n self.neg = numer.neg\\n return\\n\\n if numer == 0:\\n self.numer = [0, ]\\n return\\n\\n # If initialized with a float:\\n elif isinstance(numer, float):\\n if numer < 0.0:\\n self.neg = True\\n numer = abs(numer)\\n exp = len(str(numer).split('.')[1])\\n # numer = int(str(numer).split('.')[1])\\n\\n numer = int(round(numer * 10 ** exp))\\n self.numer = RationalFrac.factorize(numer)\\n self.denom = [2, 5] * exp\\n\\n # If initialized with a numerator and denominator:\\n elif isinstance(numer, int) and isinstance(denom, int):\\n self.numer = RationalFrac.factorize(abs(numer))\\n self.denom = RationalFrac.factorize(abs(denom))\\n self.neg = not ((numer < 0) == (denom < 0))\\n if denom == 0:\\n raise ZeroDivisionError(\\n 'should not initialize with a denominator of zero.')\\n\\n # If initialized with a string version of a fraction:\\n elif isinstance(numer, str):\\n split = numer.strip().split('/')\\n self.__init__(int(split[0]), int(split[1]))\\n\\n # Unexpected argument as initialization value:\\n else:\\n TypeError(\\n f'{str(numer)} invalid. '\\n f'must initialize with one of:\\\\n'\\n 'int, float, str.')\\n\\n # If successful, cleanup:\\n self.simplify()\",\n \"def __make_denominator_integer(self):\\n while self.denominator % 1 !=0:\\n self.denominator *=10\\n self.numerator *=10\",\n \"def __init__(self, n, d):\\n # Check that n and d are of type int:\\n if type(n) != int or type(d) != int:\\n raise ValueError('requires type int')\\n # Check that denominator is non-zero:\\n if d == 0:\\n raise ZeroDivisionError('requires non-zero denominator')\\n # If we get here, n and d are ok => initialize Fraction:\\n self.num = n\\n self.denom = d\\n self.reduce()\",\n \"def __init__(self, num, denom):\\n assert type(num) == int and type(denom) == int, \\\"ints not used\\\"\\n self.num = num\\n self.denom = denom\\n def simplify(x, y):\\n \\\"\\\"\\\" Simplifies a fraction \\\"\\\"\\\"\\n if x % 2 > 0:\\n if y % x > 0:\\n # Check Prime\\n prime = check_prime(x, y)\\n if prime == 0:\\n return str(int(x)) + \\\"/\\\" + str(int(y))\\n else:\\n return simplify ((x / prime), (y / prime))\\n else:\\n return str(int(x/x)) + \\\"/\\\" + str(int(y/x))\\n else:\\n return simplify ((x / 2), (y / 2))\\n def check_prime(x, y):\\n \\\"\\\"\\\" Function used by simplify to check prime number division of num and denom \\\"\\\"\\\"\\n pri = (3,5,7,11,13,17,19,23)\\n for i in pri:\\n if (x % i == 0) and (y % i == 0):\\n return i\\n return 0\",\n \"def getint(self, fraction) -> int:\\n self.numerator_a = fraction.numerator_a\\n self.denominator_b = fraction.denominator_b\\n self.fraction = str(self.numerator_a) + '/' + str(self.denominator_b)\\n return super().__int__()\",\n \"def __init__(self,top,bottom):\\n \\n if (type(top) is not int or type(bottom) is not int):\\n raise TypeError('Numerator and denominator must be integers.')\\n elif bottom == 0:\\n raise ZeroDivisionError('The denominator cannot be zero.')\\n elif bottom < 0: #store 'minus' in the numerator of the fraction\\n top *= -1\\n bottom *= -1\\n #make irreducible form\\n self.num = top // gcd(top,bottom)\\n self.den = bottom // gcd(top,bottom)\",\n \"def getfloat(self, fraction) -> float:\\n self.numerator_a = fraction.numerator_a\\n self.denominator_b = fraction.denominator_b\\n self.fraction = str(self.numerator_a) + '/' + str(self.denominator_b)\\n return super().__float__()\",\n \"def __make_numerator_integer(self):\\n while self.numerator % 1 !=0:\\n self.denominator *=10\\n self.numerator *=10\",\n \"def __mul__(self,frac):\\n if isinstance(frac,Fraction):\\n if self.inf_size !=0 or frac.inf_size != 0:\\n if abs(self.inf_size) > abs(frac.inf_size):\\n return Fraction(self.inf_size,0)\\n else:\\n return Fraction(frac.inf_size,0)\\n if self.numerator == 0 or frac.numerator == 0:\\n return 0\\n numerator = self.numerator*frac.numerator\\n denominator = self.denominator*frac.denominator\\n elif type(frac) in(float,int):\\n if self.inf_size !=0:\\n return self\\n numerator = self.numerator *frac\\n denominator = self.denominator\\n else:\\n raise ValueError('Fraction can only multiply with to int float or fractions')\\n return Fraction(numerator,denominator)\",\n \"def __mul__(self, frac):\\n numerator = self.numerator * frac.numerator\\n denominator = self.denominator * frac.denominator\\n gcd = math.gcd(numerator, denominator)\\n\\n return Fraction(int(numerator/gcd), int(denominator/gcd))\",\n \"def divide(self, numerator, denominator):\\r\\n if denominator == 0:\\r\\n if not self.has_error:\\r\\n self.has_error = True\\r\\n self.error += DIVISION_BY_ZERO\\r\\n return 1\\r\\n else:\\r\\n return numerator / denominator\",\n \"def numerator(num):\\n require_type(isa(num,fractions.Fraction) or isa(num,int),\\n 'parameter of numerator must be a fraction or integer')\\n return num.numerator\",\n \"def test_init(self):\\n f: Fraction = Fraction(3, 4)\\n self.assertEqual(f.num, 3)\\n self.assertEqual(f.denom, 4)\",\n \"def denominator(num):\\n require_type(isa(num,fractions.Fraction) or isa(num,int),\\n 'parameter of denominator must be a fraction or integer')\\n return num.denominator\",\n \"def __add__(self, frac):\\n add_new_numerator = (self.numerator * frac.denominator) +\\\\\\n (frac.numerator * self.denominator)\\n add_new_denominator = self.denominator * frac.denominator\\n if add_new_denominator == 0:\\n raise ValueError(\\\"UNDEFINED.\\\")\\n return Fraction(add_new_numerator, add_new_denominator)\",\n \"def denominator(self, denominator):\\n\\n self._denominator = denominator\",\n \"def test_init(self):\\n \\n fraction1 = Fraction(1,2)\\n self.assertEqual(fraction1.numerator, 1)\\n self.assertEqual(fraction1.denominator, 2)\",\n \"def divide(numerator, denominator):\\n ensure_divisibility(numerator, denominator)\\n return numerator // denominator\",\n \"def __init__(self, time, numerator, denominator):\\n self.time = time\\n self.numerator = numerator\\n self.denominator = denominator\",\n \"def random_fraction():\\r\\n numerator = random.randint(1,9)\\r\\n denominator = random.randint(1,9)\\r\\n frac = Fraction(numerator,denominator)\\r\\n # print(frac)\\r\\n return frac\",\n \"def fraction(self, value: int) -> 'Size':\\n raise_not_number(value)\\n self.maximum = '{}fr'.format(int(value))\\n return self\",\n \"def __sub__(self, frac):\\n if isinstance(frac,Fraction):\\n if self.inf_size !=0 or frac.inf_size != 0:\\n if self.inf_size == frac.inf_size:\\n return 0\\n elif abs(self.inf_size) > abs(frac.inf_size):\\n return Fraction(self.inf_size,0)\\n else:\\n return Fraction(-frac.inf_size,0)\\n numerator = ((self.numerator*frac.denominator)-(frac.numerator*self.denominator))\\n denominator = (self.denominator*frac.denominator)\\n elif type(frac) in(float,int):\\n if self.inf_size !=0:\\n return self\\n numerator = self.numerator - (frac*self.denominator)\\n denominator = self.denominator\\n else:\\n raise ValueError('Fraction can only add with to int float or fractions')\\n return Fraction(numerator,denominator)\",\n \"def __reduce(self):\\n if self.denominator <0:\\n self.denominator *= -1\\n self.numerator *= -1\\n gcd = math.gcd(int(self.denominator),int(self.numerator))\\n if self.denominator != 0 and self.numerator!= 0:\\n if gcd > 0:\\n self.denominator /= gcd\\n self.numerator /= gcd\\n self.numerator = int(self.numerator)\\n self.denominator = int(self.denominator)\",\n \"def test_prepare_value_limit_denominator(self):\\n field = FractionField(limit_denominator=3)\\n result = field.prepare_value(Decimal(1 / 3.0))\\n self.assertEqual(\\\"1/3\\\", result)\",\n \"def __add__(self, frac):\\n if isinstance(frac,Fraction):\\n if self.inf_size !=0 or frac.inf_size != 0:\\n if self.inf_size == -frac.inf_size:\\n return 0\\n elif abs(self.inf_size) > abs(frac.inf_size):\\n return Fraction(self.inf_size,0)\\n else:\\n return Fraction(frac.inf_size,0)\\n numerator = ((self.numerator*frac.denominator)+(frac.numerator*self.denominator))\\n denominator = (self.denominator*frac.denominator)\\n elif type(frac) in(float,int):\\n if self.inf_size !=0:\\n return self\\n numerator = (frac*self.denominator) + self.numerator\\n denominator = self.denominator\\n else:\\n raise ValueError('Fraction can only add with to int float or fractions')\\n return Fraction(numerator,denominator)\",\n \"def __init__(self) -> None:\\n self.minimum = '' # type: str\\n self.maximum = '' # type: str\\n self.fraction(1)\",\n \"def test_div(self):\\n newvalues= Fraction(7,10)/Fraction(4,5)\\n fraction1 = Fraction(newvalues[0],newvalues[1])\\n self.assertEqual(str(fraction1),\\\"35/40\\\")\",\n \"def test_prepare_value_limit_denominator(self):\\n field = DecimalFractionField(limit_denominator=3)\\n result = field.prepare_value(Decimal(1 / 3.0))\\n self.assertEqual(\\\"1/3\\\", result)\",\n \"def __sub__(self, frac):\\n numerator = ((self.numerator * frac.denominator) - (self.denominator * frac.numerator))\\n denominator = (self.denominator * frac.denominator)\\n return Fraction(numerator, denominator)\",\n \"def __neg__(self):\\n if self.numerator ==0 and self.denominator==0:\\n return Fraction(-self.inf_size,0)\\n else:\\n return Fraction(-self.numerator,self.denominator)\",\n \"def denominator(self):\\n return 1\",\n \"def parseFraction(f):\\n p = f.find(\\\"/\\\")\\n if p < 1:\\n return None\\n s1 = f[:p]\\n s2 = f[p+1:]\\n try:\\n v1 = int(s1)\\n v2 = int(s2)\\n except ValueError:\\n return None\\n if v2:\\n return 1.0 * v1 / v2\\n else:\\n return None\",\n \"def divide_by(numerator, denominator):\\n try:\\n return numerator / denominator\\n except ZeroDivisionError:\\n logging.getLogger().error('Divide by zero!')\\n logging.getLogger().error('It is really not a good idea.')\\n raise\",\n \"def totaled_ratio_calculator(numerator, denominator):\\n if denominator != 0:\\n ratio = round(float(numerator) / denominator, 3)\\n else:\\n ratio = 0\\n return ratio\",\n \"def __add__(self, frac):\\n numerator = ((self.numerator * frac.denominator) + (self.denominator * frac.numerator))\\n denominator = (self.denominator * frac.denominator)\\n return Fraction(numerator, denominator)\",\n \"def fraction_space(self):\\n self.custom_space(*[0,0,1,1])\",\n \"def cancel_fraction(numerator, denominator):\\n str_numerator, str_denominator = str(numerator), str(denominator)\\n\\n for digit in str_numerator:\\n # Ignore '0's\\n if digit in str_denominator and digit != '0':\\n str_numerator = str_numerator.replace(digit, '')\\n str_denominator = str_denominator.replace(digit, '')\\n # Unless any number is empty or the denominator is '0'...\\n if str_numerator and str_denominator and str_denominator != '0':\\n return int(str_numerator), int(str_denominator)\\n return numerator, denominator\",\n \"def __mul__(self, other) -> object:\\n common_numerator = self.numerator_a * other.numerator_a\\n common_denominator = self.denominator_b * other.denominator_b\\n\\n # check for common divisor\\n common_divisor = self.common_divisor(int(common_numerator), common_denominator)\\n if common_divisor is None:\\n res = Fraction(common_numerator, common_denominator)\\n else:\\n common_numerator = common_numerator / common_divisor\\n common_denominator = common_denominator / common_divisor\\n res = Fraction(common_numerator, int(common_denominator))\\n return res\",\n \"def fractions():\\n\\n pi = 22 / 7\\n print(\\\"22/7\\\\n====\\\")\\n print_as_text(pi)\\n\\n pi = 333 / 106\\n print(\\\"333/106\\\\n=======\\\")\\n print_as_text(pi)\\n\\n pi = 355 / 113\\n print(\\\"355/113\\\\n=======\\\")\\n print_as_text(pi)\\n\\n pi = 52163 / 16604\\n print(\\\"52163/16604\\\\n===========\\\")\\n print_as_text(pi)\\n\\n pi = 103993 / 33102\\n print(\\\"103993/33102\\\\n============\\\")\\n print_as_text(pi)\\n\\n pi = 245850922 / 78256779\\n print(\\\"245850922/78256779\\\\n==================\\\")\\n print_as_text(pi)\",\n \"def __init__(self, ratio=0.3, p=1.7, reduce=True):\\n assert ratio > 0 and ratio <= 1, \\\"ratio should be in range [0, 1]\\\"\\n assert p > 1, \\\"p should be >1\\\"\\n self.ratio = ratio\\n self.p = p\\n self.reduce = reduce\",\n \"def __mul__(self, other):\\n new_num = self.num * other.num\\n new_denom = self.denom * other.denom\\n return Fraction(new_num, new_denom)\",\n \"def reduce(self):\\n import math\\n g = math.gcd(self.num, self.den)\\n return Fraction(self.num//g, self.den//g)\",\n \"def divide(numerator, denominator, num_decimal_places):\\n \\n if denominator == 0 or num_decimal_places < 0:\\n raise ValueError\\n\\n pieces = []\\n\\n # determine sign of final number, then make both numerator and denominator\\n # positive for simplicity\\n sign = 1\\n if numerator < 0:\\n sign = -sign\\n numerator = -numerator\\n if denominator < 0:\\n sign = -sign\\n denominator = -denominator\\n if sign < 0:\\n pieces.append('-')\\n\\n # determine integral part\\n num_units = 0\\n while numerator >= denominator:\\n numerator -= denominator\\n num_units += 1\\n pieces.append(str(num_units))\\n\\n pieces.append('.')\\n\\n # determine fractional part\\n for _ in range(num_decimal_places):\\n numerator *= 10\\n num_units = 0\\n while numerator >= denominator:\\n numerator -= denominator\\n num_units += 1\\n pieces.append(str(num_units))\\n\\n return float(''.join(pieces))\",\n \"def fromRational(rat):\\n def longDiv(c, e, n):\\n \\\"\\\"\\\"\\n Divide the numerator by the denominator using long division.\\n\\n :param c: long\\n :param e: long\\n :param n: long\\n :return: Scientific\\n \\\"\\\"\\\"\\n if n == 0:\\n return Scientific(c, e)\\n else:\\n # TODO: Use a logarithm here!\\n # TODO: Can't use tail recursion like this in python!\\n if n < d:\\n return longDiv(c * 10, e - 1, n * 10)\\n else:\\n (q, r) = quotRemInteger(n, d)\\n return longDiv(c+q, e, r)\\n\\n d = rat.denominator\\n\\n if d == 0:\\n raise ZeroDivisionError\\n else:\\n return rational.positivize(longDiv(0, 0), rat.numerator)\",\n \"def reciprocal(self):\\n return Rational(self.denominator, self.numerator)\",\n \"def morph_fraction(lex, num, den, digit):\\n raise NotImplementedError\",\n \"def frac_field(self, *gens):\\n from sympy.polys.domains import FractionField\\n return FractionField(self, *gens)\",\n \"def __int__(self) -> int:\\n integer_number = self.numerator_a // self.denominator_b\\n print(f'Fraction {self.fraction} integer number is {integer_number}')\\n return integer_number\",\n \"def test_divide1(self):\\n n = Rational(1, 1)\\n d = Rational(0, 1)\\n with self.assertRaises(ZeroDivisionError):\\n \\\"\\\"\\\"Divide by zero\\\"\\\"\\\"\\n n.__div__(d)\",\n \"def frac(num_str, obj_mode=False):\\n if obj_mode == False:\\n cast_frac = lambda inp: float(Fraction(inp))\\n elif obj_mode == True:\\n cast_frac = Fraction\\n try:\\n return cast_frac(num_str)\\n except ValueError:\\n if num_str == '':\\n return cast_frac('0/1')\\n elif num_str == '?':\\n return np.nan\",\n \"def from_value(cls, value):\\n value = Fraction(value)\\n if value.denominator > 1024:\\n msg = f\\\"{value} would result in a very deep game tree.\\\"\\n raise ValueError(msg)\\n if value.denominator == 1:\\n if value == 0:\\n left = set()\\n right = set()\\n elif value > 0:\\n left = {Surreal.from_value(value - 1)}\\n right = set()\\n else:\\n left = set()\\n right = {Surreal.from_value(value + 1)}\\n else:\\n left = {Surreal.from_value(value - 1 / value.denominator)}\\n right = {Surreal.from_value(value + 1 / value.denominator)}\\n\\n return cls(left=left, right=right)\",\n \"def from_FractionField(K1, a, K0):\\n return None\",\n \"def _divide(self, denominator):\\n self.precision = (self.precision / float(denominator))\\n self.accuracy = (self.accuracy / float(denominator))\\n self.recall = (self.recall / float(denominator))\\n self.f_measure = (self.f_measure / float(denominator))\",\n \"def div(a, b):\\r\\n if type(b) in inttypes_set:\\r\\n if not b:\\r\\n return Infinity(a)\\r\\n raise ZeroDivisionError('%r / %r' % (a, b))\\r\\n if b == 1:\\r\\n return a\\r\\n if type(a) in inttypes_set:\\r\\n return normalized_fraction(a, b)\\r\\n return a / b\",\n \"def __init__(self):\\n BuiltinFunction.__init__(self, \\\"frac\\\",\\n conversions=dict(sympy='frac'),\\n latex_name=r\\\"\\\\operatorname{frac}\\\")\",\n \"def __init__(G, left=None, right=None):\\n if not all(opt.is_number for opt in left | right):\\n msg = \\\"All options must be numbers.\\\"\\n raise ValueError(msg)\\n\\n G._left = {Surreal(G_L.left, G_L.right) for G_L in left}\\n G._right = {Surreal(G_R.left, G_R.right) for G_R in right}\\n\\n if not all(G_L < G_R for G_L in left for G_R in right):\\n msg = \\\"There exists a G_L >= G_R.\\\"\\n raise ValueError(msg)\\n\\n if not G._left | G._right:\\n G._n = Fraction(0)\\n else:\\n # non-zero dyadic rational\\n if G._left:\\n lf = next(iter(G._left)).n\\n if G._right:\\n rf = next(iter(G._right)).n\\n\\n if not right:\\n # positive integer\\n G._n = lf + 1\\n elif not left:\\n # negative integer\\n G._n = rf - 1\\n else:\\n # dyadic rational\\n G._n = (lf + rf) / 2\",\n \"def __copy__(self):\\n copy = RationalFrac(0, empty=True)\\n copy.numer = self.numer.copy()\\n copy.denom = self.denom.copy()\\n copy.neg = bool(self.neg)\\n return copy\",\n \"def fraction_to_proper_fraction(rational):\\n assert isinstance(rational, Fraction), repr(rational)\\n quotient = int(rational)\\n residue = rational - quotient\\n return quotient, residue\",\n \"def __float__(self) -> float:\\n float_number = self.numerator_a / self.denominator_b\\n print(f'Fraction {self.fraction} float number is {float_number}')\\n return float_number\",\n \"def __truediv__(self, other):\\n try:\\n assert not other.is_zero(), \\\"cannot divide by 0.\\\"\\n new_num = (self._num * other._den)\\n new_den = (self._den * other._num) \\n return Rational(new_num, new_den)\\n except AttributeError:\\n return (self / Rational.parse_number(other))\",\n \"def __sub__(self, other) -> object:\\n least_common_multiple = self.denominator_b\\n # check denominators of fractions and if no define their least common multiple\\n if self.denominator_b != other.denominator_b:\\n least_common_multiple = self.least_common_multiple_func(other.denominator_b)\\n\\n common_numerator = (least_common_multiple / self.denominator_b * self.numerator_a) - \\\\\\n (least_common_multiple / other.denominator_b * other.numerator_a)\\n\\n # check for common divisor\\n common_divisor = self.common_divisor(int(common_numerator), least_common_multiple)\\n if common_divisor is None:\\n res = Fraction(common_numerator, least_common_multiple)\\n else:\\n common_numerator = common_numerator / common_divisor\\n least_common_multiple = least_common_multiple / common_divisor\\n res = Fraction(common_numerator, int(least_common_multiple))\\n return res\",\n \"def denominator(self, ???):\",\n \"def ratio_histogram(numerator, denominator, y_title = 'Data / Background'):\\n # Create our result based off of the numerator (it will have bin errors\\n # enabled)\\n result = combined_histogram(numerator)\\n\\n # Create the denominator\\n combined_denominator = combined_histogram(denominator)\\n\\n # Disable errors on the denominator (they should be handled in an\\n # uncertainty band around unity)\\n for bin in xrange(0, combined_denominator.GetNbinsX() + 2):\\n combined_denominator.SetBinError(bin, 0.0)\\n\\n # Divide by the denominator\\n result.Divide(combined_denominator)\\n\\n # Do some styling on the result\\n result.SetTitle('')\\n result.SetStats(0)\\n result.SetMarkerStyle(20)\\n #result.SetMarkerSize(1.5)\\n\\n # Set title\\n result.GetYaxis().SetTitle(y_title)\\n\\n return result\",\n \"def fraction_gcd(x, y):\\n a = x.numerator\\n b = x.denominator\\n c = y.numerator\\n d = y.denominator\\n return Fraction(gcd(a, c), lcm(b, d))\",\n \"def _reduce(self) -> None:\\n divisor = self._gcd(self._numerator, self._denominator)\\n self._numerator = self._numerator // divisor\\n self._denominator = self._denominator // divisor\",\n \"def ratio_calculator(numerator, denominator):\\n ratios = []\\n for i in numerator:\\n for j in denominator:\\n if i[0] == j[0] and j[1] != 0:\\n ratios.append([i[0], round(float(i[1]) / j[1], 3)])\\n break\\n elif i[0] == j[0]:\\n ratios.append([i[0], 0])\\n return ratios\",\n \"def test_fraction_math_ops(self):\\n fract1 = source.Fraction(5, 3)\\n fract2 = source.Fraction(2, 3)\\n self.assertEqual(fract1 + fract2, source.Fraction(7, 3))\\n self.assertEqual(fract1 + 5, source.Fraction(20, 3))\\n self.assertEqual(3 + fract1, source.Fraction(14, 3))\\n self.assertEqual(fract1 * fract2, source.Fraction(10, 9))\\n self.assertEqual(5 * fract2, source.Fraction(10, 3))\",\n \"def __mul__(self,f2):\\n new_numerator = self.__num * f2.num\\n new_denominator = self.__den * f2.den\\n return Fraction(new_numerator,new_denominator)\",\n \"def __init__(self, positive_fraction=0.5, is_static=False):\\n if positive_fraction < 0 or positive_fraction > 1:\\n raise ValueError('positive_fraction should be in range [0,1]. '\\n 'Received: %s.' % positive_fraction)\\n self._positive_fraction = positive_fraction\\n self._is_static = is_static\",\n \"def inverse( self ):\\r\\n\\t\\treturn fraction( self.denominator, self.numerator )\",\n \"def format_and_scale_fraction(numerator, denominator, unit):\\n\\n # simple case for small numbers\\n if denominator < 1000:\\n return '%d / %d %s' % (numerator, denominator, unit)\\n\\n # pick a scale\\n (scale, suffix) = _pick_scale_and_suffix(denominator)\\n\\n # decide how many digits after the decimal to display\\n scaled_denominator = denominator / scale\\n if scaled_denominator < 10.0:\\n fmt = '%1.2f / %1.2f %s%s'\\n elif scaled_denominator < 100.0:\\n fmt = '%1.1f / %1.1f %s%s'\\n else:\\n fmt = '%1.0f / %1.0f %s%s'\\n\\n # format it\\n scaled_numerator = numerator / scale\\n return fmt % (scaled_numerator, scaled_denominator, suffix, unit)\",\n \"def test_init_exception(self):\\n with self.assertRaises(ZeroDivisionError): Fraction(10, 0)\",\n \"def safe_div(numerator, denominator, name='safe_div'):\\n return array_ops.where(\\n math_ops.equal(denominator, 0),\\n array_ops.zeros_like(numerator),\\n math_ops.div(numerator, denominator),\\n name=name)\",\n \"def __rmod__(self, other):\\n if self == Rational(0, 1):\\n raise ZeroDivisionError('division by zero')\\n return Rational(0, 1)\",\n \"def __sub__(self, other):\\n # type: (object) -> Fraction\\n dx = other\\n if type(other) is float:\\n dx = dectofr(other)\\n return Fraction(self.numerator * dx.denominator - self.denominator * dx.numerator,\\n self.denominator * dx.denominator)\",\n \"def __div__(self, other):\\n if not (isNumeric(other) or isinstance(other, Expression)):\\n error_msg = (\\n f'Invalid expression during division of {self}: [{other}]'\\n )\\n raise excep.biogemeError(error_msg)\\n return Divide(self, other)\",\n \"def __mul__(self, otherfraction):\\n\\n newnum = self.num * otherfraction.num\\n newden = self.den * otherfraction.den\\n\\n #reduce new num over lcm den\\n common = gcd(sub_num, new_lcm)\\n newnum = sub_num//common\\n newden = new_lcm//common\\n\\n return Fraction(newnum, newden)\",\n \"def __add__(self, other):\\n new_num = self.num * other.denom + other.num * self.denom\\n new_denom = self.denom * other.denom\\n return Fraction(new_num, new_denom)\",\n \"def normalized_fraction(p, q=1):\\r\\n x, y = p, q\\r\\n while y:\\r\\n x, y = y, x % y\\r\\n if x != 1:\\r\\n p //= x\\r\\n q //= x\\r\\n if q == 1:\\r\\n return p\\r\\n return mpq((p, q))\",\n \"def simplify_fraction(a, b):\\n c = gcd(a, b)\\n return a // c, b // c\",\n \"def test_mul(self):\\n newvalues = Fraction(3,2)*Fraction(1,4)\\n fraction1 = Fraction(newvalues[0],newvalues[1])\\n self.assertEqual(str(fraction1),\\\"3/8\\\")\",\n \"def reciprocal(self):\\n recip = RationalFrac(0, empty=True)\\n if 0 in self.numer:\\n raise ZeroDivisionError('the reciprocal of zero is undefined.')\\n recip.numer = self.denom.copy()\\n recip.denom = self.numer.copy()\\n recip.neg = bool(self.neg)\\n return recip\",\n \"def __repr__( self ):\\r\\n\\t\\treturn ( \\\"%s/%s\\\" % ( self.numerator, self.denominator ) )\",\n \"def render_frac(numerator, denominator):\\r\\n if len(numerator) == 1:\\r\\n num_latex = numerator[0].sans_parens\\r\\n else:\\r\\n num_latex = r\\\"\\\\cdot \\\".join(k.latex for k in numerator)\\r\\n\\r\\n if len(denominator) == 1:\\r\\n den_latex = denominator[0].sans_parens\\r\\n else:\\r\\n den_latex = r\\\"\\\\cdot \\\".join(k.latex for k in denominator)\\r\\n\\r\\n latex = ur\\\"\\\\frac{{{num}}}{{{den}}}\\\".format(num=num_latex, den=den_latex)\\r\\n return latex\",\n \"def __sub__(self,f2):\\n new_numerator = self.__num * f2.den - self.__den * f2.num\\n new_denominator = self.__den * f2.den\\n return Fraction(new_numerator,new_denominator)\",\n \"def divide1(a, b):\\n if b == 0:\\n raise ValueError(\\\"Zero division Error!\\\")\\n return a * 1.0 / b\",\n \"def __mul__(self, other):\\n new_num = self.num*other.num\\n new_den = self.den*other.den\\n common = gcd(new_num, new_den)\\n\\n return Fraction(new_num//common, new_den//common)\",\n \"def __init__(self, denominator, val, diagram_type):\\n Node.__init__(self, denominator, diagram_type=diagram_type)\\n self.child_nodes = None\\n self.value = val\\n self.shape = [1, 1]\\n self.d = 0\",\n \"def rational_frac_tests():\\n print('\\\\n==========================================')\\n print('rfrac.py @ rational_frac_tests: //////////\\\\n')\\n print(RationalFrac(-1), RationalFrac(0))\\n # __prime_factors()\\n frac0 = RationalFrac(4.5)\\n frac1 = RationalFrac(-0.125)\\n frac2 = RationalFrac(0.99999)\\n f = [frac0, frac1, frac2]\\n print('float(-0.125) =', float(f[1]))\\n print('float(0.99999) =', float(f[2]))\\n print('9/2 + -1/8 =', f[0] + f[1])\\n print('9/2 * -1/8 =', f[0] * f[1])\\n print('-1/8 * 9/2 =', f[1] * f[0])\\n print(f)\\n print('frac(-0/1) + frac(-0/1) =',\\n RationalFrac(-0) + RationalFrac(-0))\\n f3 = RationalFrac('-7/29')\\n print(f3)\\n print(RationalFrac(25, 1000))\\n print('\\\\nrfrac.py @ end of rational_frac_tests ////')\\n print('==========================================\\\\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]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8137715","0.79004323","0.7554975","0.7540042","0.7523119","0.74793065","0.74483407","0.7292548","0.7187293","0.7100966","0.707507","0.68207115","0.67850834","0.67308176","0.6693192","0.66444474","0.6619234","0.6480323","0.64723444","0.6453896","0.63839823","0.6362794","0.63244224","0.63024443","0.6238756","0.622156","0.61604947","0.61167926","0.6054855","0.60505325","0.60314184","0.5998625","0.59695977","0.589527","0.589502","0.58643293","0.5854114","0.58243966","0.5795425","0.5782703","0.5758465","0.5753694","0.57499063","0.5740655","0.5711319","0.5697851","0.5687788","0.56864065","0.5649687","0.5648215","0.5627584","0.56231415","0.56123567","0.55981123","0.55947596","0.5575756","0.5544641","0.5541107","0.5522032","0.55102396","0.5501467","0.5497201","0.5490794","0.5482339","0.54747194","0.5472047","0.5467618","0.5464971","0.54353046","0.5435048","0.54272234","0.5419851","0.54054296","0.53981394","0.538286","0.5382697","0.53796905","0.53713065","0.5348087","0.5346734","0.53378886","0.53343517","0.5332877","0.53263724","0.53183275","0.5314525","0.53093857","0.53084636","0.53015035","0.5280044","0.5277925","0.526269","0.52558476","0.5255766","0.5246693","0.52452856","0.5244832","0.52438706","0.52353257","0.5214363"],"string":"[\n \"0.8137715\",\n \"0.79004323\",\n \"0.7554975\",\n \"0.7540042\",\n \"0.7523119\",\n \"0.74793065\",\n \"0.74483407\",\n \"0.7292548\",\n \"0.7187293\",\n \"0.7100966\",\n \"0.707507\",\n \"0.68207115\",\n \"0.67850834\",\n \"0.67308176\",\n \"0.6693192\",\n \"0.66444474\",\n \"0.6619234\",\n \"0.6480323\",\n \"0.64723444\",\n \"0.6453896\",\n \"0.63839823\",\n \"0.6362794\",\n \"0.63244224\",\n \"0.63024443\",\n \"0.6238756\",\n \"0.622156\",\n \"0.61604947\",\n \"0.61167926\",\n \"0.6054855\",\n \"0.60505325\",\n \"0.60314184\",\n \"0.5998625\",\n \"0.59695977\",\n \"0.589527\",\n \"0.589502\",\n \"0.58643293\",\n \"0.5854114\",\n \"0.58243966\",\n \"0.5795425\",\n \"0.5782703\",\n \"0.5758465\",\n \"0.5753694\",\n \"0.57499063\",\n \"0.5740655\",\n \"0.5711319\",\n \"0.5697851\",\n \"0.5687788\",\n \"0.56864065\",\n \"0.5649687\",\n \"0.5648215\",\n \"0.5627584\",\n \"0.56231415\",\n \"0.56123567\",\n \"0.55981123\",\n \"0.55947596\",\n \"0.5575756\",\n \"0.5544641\",\n \"0.5541107\",\n \"0.5522032\",\n \"0.55102396\",\n \"0.5501467\",\n \"0.5497201\",\n \"0.5490794\",\n \"0.5482339\",\n \"0.54747194\",\n \"0.5472047\",\n \"0.5467618\",\n \"0.5464971\",\n \"0.54353046\",\n \"0.5435048\",\n \"0.54272234\",\n \"0.5419851\",\n \"0.54054296\",\n \"0.53981394\",\n \"0.538286\",\n \"0.5382697\",\n \"0.53796905\",\n \"0.53713065\",\n \"0.5348087\",\n \"0.5346734\",\n \"0.53378886\",\n \"0.53343517\",\n \"0.5332877\",\n \"0.53263724\",\n \"0.53183275\",\n \"0.5314525\",\n \"0.53093857\",\n \"0.53084636\",\n \"0.53015035\",\n \"0.5280044\",\n \"0.5277925\",\n \"0.526269\",\n \"0.52558476\",\n \"0.5255766\",\n \"0.5246693\",\n \"0.52452856\",\n \"0.5244832\",\n \"0.52438706\",\n \"0.52353257\",\n \"0.5214363\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.764352"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":23096,"cells":{"query":{"kind":"string","value":"Return the sum of two fractions as a new fraction. Use the standard formula a/b + c/d = (ad+bc)/(bd)"},"document":{"kind":"string","value":"def __add__(self, frac):\n add_new_numerator = (self.numerator * frac.denominator) +\\\n (frac.numerator * self.denominator)\n add_new_denominator = self.denominator * frac.denominator\n if add_new_denominator == 0:\n raise ValueError(\"UNDEFINED.\")\n return Fraction(add_new_numerator, add_new_denominator)"},"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 simplify_fraction(a, b):\n c = gcd(a, b)\n return a // c, b // c","def __add__ (self, other):\n if (self.debug): print(f'enter fraction.__add__ with {other}')\n lcm = find_lcm(self.value[1], other.value[1])\n if (self.debug): print(f'{int(lcm/self.value[1])} {self.value}')\n f1 = self.equivalent(int(lcm/self.value[1]))\n f2 = other.equivalent(int(lcm/other.value[1]))\n f3 = fraction(f1[0]+f2[0], lcm)\n if (self.debug): print(f'{f3}, {self}, {other}')\n return f3","def __add__(self, other):\n top = self.num*other.denom + self.denom*other.num\n bott = self.denom*other.denom\n return fraction(top, bott)","def test_fraction_math_ops(self):\n fract1 = source.Fraction(5, 3)\n fract2 = source.Fraction(2, 3)\n self.assertEqual(fract1 + fract2, source.Fraction(7, 3))\n self.assertEqual(fract1 + 5, source.Fraction(20, 3))\n self.assertEqual(3 + fract1, source.Fraction(14, 3))\n self.assertEqual(fract1 * fract2, source.Fraction(10, 9))\n self.assertEqual(5 * fract2, source.Fraction(10, 3))","def add(q1, q2):\n return create_rational(get_numerator(q1) * get_denominator(q2) + get_numerator(q2) * get_denominator(q1), get_denominator(q1) * get_denominator(q2))","def __add__(self, other) -> object:\n least_common_multiple = self.denominator_b\n # check denominators of fractions and if no define their least common multiple\n if self.denominator_b != other.denominator_b:\n least_common_multiple = self.least_common_multiple_func(other.denominator_b)\n\n common_numerator = (least_common_multiple / self.denominator_b * self.numerator_a) + \\\n (least_common_multiple / other.denominator_b * other.numerator_a)\n\n # check for common divisor\n common_divisor = self.common_divisor(int(common_numerator), least_common_multiple)\n if common_divisor is None:\n res = Fraction(common_numerator, least_common_multiple)\n else:\n common_numerator = common_numerator / common_divisor\n least_common_multiple = least_common_multiple / common_divisor\n res = Fraction(common_numerator, int(least_common_multiple))\n return res","def __add__(self, other):\n new_num = self.num * other.denom + other.num * self.denom\n new_denom = self.denom * other.denom\n return Fraction(new_num, new_denom)","def __add__(self, other):\n top = self.num*other.denom + self.denom*other.num\n bott = self.denom*other.denom\n return Fraction(top, bott)","def add(self, other):\n return Rational(self.numerator * other.denominator + other.numerator * self.denominator,\n self.denominator * other.denominator)","def __add__(self, frac):\n numerator = ((self.numerator * frac.denominator) + (self.denominator * frac.numerator))\n denominator = (self.denominator * frac.denominator)\n return Fraction(numerator, denominator)","def test_add(self):\n newvalues = Fraction(1,2)+Fraction(1,2)\n fraction1 = Fraction(newvalues[0],newvalues[1])\n self.assertEqual(str(fraction1),\"4/4\")","def __add__(self, other):\n if isinstance(other, RationalFrac):\n if 0 in self.denom or 0 in other.denom:\n raise ZeroDivisionError(\n 'cannot add when either ' +\n 'operand is undefined.')\n\n # Get denominator factors not shared\n # for self and other respectively:\n diff_self = self.denom.copy()\n diff_other = other.denom.copy()\n for factor in self.denom:\n if factor in diff_self and factor in diff_other:\n diff_self.remove(factor)\n diff_other.remove(factor)\n\n # Calculate the new numerator:\n numer_self = RationalFrac.rf_prod(self.numer + diff_other)\n numer_other = RationalFrac.rf_prod(other.numer + diff_self)\n if self.neg:\n numer_self *= -1\n if other.neg:\n numer_other *= -1\n numer = numer_self + numer_other\n\n # Create the new fraction:\n fsum = RationalFrac(0, empty=True)\n fsum.numer = RationalFrac.factorize(abs(numer))\n fsum.denom = self.denom + diff_other\n fsum.neg = numer < 0\n fsum.simplify()\n return fsum\n\n elif isinstance(other, (int, float)):\n return self.__add__(RationalFrac(other))\n else:\n return NotImplemented","def __add__(self, other):\n new_numerator = self._numerator * other.denominator() + other.numerator() * self._denominator\n new_denominator = self._denominator * other.denominator()\n return Rational(new_numerator, new_denominator)","def add(f1, f2):\n num1, den1 = int(f1.split('/')[0]), int(f1.split('/')[1])\n num2, den2 = int(f2.split('/')[0]), int(f2.split('/')[1])\n result = str( num1*den2 + num2*den1 ) + \"/\" + str( den1*den2 )\n return reduce(result)","def div(a: Decimal, b: Decimal) -> Decimal:\n return a / b","def __add__(self,f2):\n new_numerator = self.__num * f2.den + self.__den * f2.num\n new_denominator = self.__den * f2.den\n return Fraction(new_numerator,new_denominator)","def div(a, b):\r\n if type(b) in inttypes_set:\r\n if not b:\r\n return Infinity(a)\r\n raise ZeroDivisionError('%r / %r' % (a, b))\r\n if b == 1:\r\n return a\r\n if type(a) in inttypes_set:\r\n return normalized_fraction(a, b)\r\n return a / b","def fraction_gcd(x, y):\n a = x.numerator\n b = x.denominator\n c = y.numerator\n d = y.denominator\n return Fraction(gcd(a, c), lcm(b, d))","def add(value1, value2):\n return 1 / (1.0 / value1 + 1.0 / value2)","def __add__(self,other):\n self.numerator=self.numerator*other.denominator\n other.numerator=self.denominator*other.numerator\n resultnumerator = self.numerator+other.numerator\n resultdenominator = self.denominator*other.denominator \n newvalues = (resultnumerator,resultdenominator)\n return newvalues","def __sub__ (self,other):\n if (self.debug): print(f'enter fraction.__sub__ with {other}')\n f2 = fraction(-1*other.value[0],other.value[1])\n f3 = self.__add__(f2)\n return f3","def test_div(self):\n newvalues= Fraction(7,10)/Fraction(4,5)\n fraction1 = Fraction(newvalues[0],newvalues[1])\n self.assertEqual(str(fraction1),\"35/40\")","def ratio_func(a, b):\n return a / b","def compute_fraction(x, y): \r\n if x == 'NaN' or y == 'NaN':\r\n return 0.\r\n if x == 0 or y == 0: \r\n return 0\r\n fraction = x / y\r\n return fraction","def divup(a, b):\n return (a + b - 1) // b","def __add__(self, frac):\n if isinstance(frac,Fraction):\n if self.inf_size !=0 or frac.inf_size != 0:\n if self.inf_size == -frac.inf_size:\n return 0\n elif abs(self.inf_size) > abs(frac.inf_size):\n return Fraction(self.inf_size,0)\n else:\n return Fraction(frac.inf_size,0)\n numerator = ((self.numerator*frac.denominator)+(frac.numerator*self.denominator))\n denominator = (self.denominator*frac.denominator)\n elif type(frac) in(float,int):\n if self.inf_size !=0:\n return self\n numerator = (frac*self.denominator) + self.numerator\n denominator = self.denominator\n else:\n raise ValueError('Fraction can only add with to int float or fractions')\n return Fraction(numerator,denominator)","def div(a, b):\n a = float(a)\n b = float(b)\n return a / b","def division(a, b):\n return (a // b, a / b)","def __mul__ (self,other):\n if (self.debug): print(f'enter fraction.__mul__ with {other}')\n f3 = fraction(self.value[0]*other.value[0],self.value[1]*other.value[1])\n if (self.debug): print(f3, self, other)\n f3.simplify()\n return f3","def gcd(self, a, b):\n raise NotImplementedError","def __mul__(self, other) -> object:\n common_numerator = self.numerator_a * other.numerator_a\n common_denominator = self.denominator_b * other.denominator_b\n\n # check for common divisor\n common_divisor = self.common_divisor(int(common_numerator), common_denominator)\n if common_divisor is None:\n res = Fraction(common_numerator, common_denominator)\n else:\n common_numerator = common_numerator / common_divisor\n common_denominator = common_denominator / common_divisor\n res = Fraction(common_numerator, int(common_denominator))\n return res","def division(self, a, b):\n if not check_arguments(a, b): # check if arguments are numbers\n self.last_result = a / b","def Div(a, b):\n\tRequire(b > 0)\n\tc = a / b\n\treturn c","def continued_fraction(a, b, base=10):\n\t(p0, q0), (p1, q1) = (a(0), 1), (a(1) * a(0) + b(1), a(1))\n\tk = 1\n\twhile True:\n\t\t(d0, r0), (d1, r1) = divmod(p0, q0), divmod(p1, q1)\n\t\tif d0 == d1:\n\t\t\tyield d1\n\t\t\tp0, p1 = base * r0, base * r1\n\t\telse:\n\t\t\tk = k + 1\n\t\t\tx, y = a(k), b(k)\n\t\t\t(p0, q0), (p1, q1) = (p1, q1), (x * p1 + y * p0, x * q1 + y * q0)","def the_division_is_aimed(numb1, numb2):\r\n return f\"Your result: {numb1//numb2}\"","def divide(a, b):\n return a / b","def __add__(self, other):\n try:\n new_num = (self._num * other._den) + (self._den * other._num)\n new_den = (self._den * other._den)\n return Rational(new_num, new_den)\n except AttributeError:\n return (self + Rational.parse_number(other))","def reduce(self):\n import math\n g = math.gcd(self.num, self.den)\n return Fraction(self.num//g, self.den//g)","def __mul__(self, other):\n new_num = self.num*other.num\n new_den = self.den*other.den\n common = gcd(new_num, new_den)\n\n return Fraction(new_num//common, new_den//common)","def div(a,b):\r\n return a/b","def __sub__(self, other) -> object:\n least_common_multiple = self.denominator_b\n # check denominators of fractions and if no define their least common multiple\n if self.denominator_b != other.denominator_b:\n least_common_multiple = self.least_common_multiple_func(other.denominator_b)\n\n common_numerator = (least_common_multiple / self.denominator_b * self.numerator_a) - \\\n (least_common_multiple / other.denominator_b * other.numerator_a)\n\n # check for common divisor\n common_divisor = self.common_divisor(int(common_numerator), least_common_multiple)\n if common_divisor is None:\n res = Fraction(common_numerator, least_common_multiple)\n else:\n common_numerator = common_numerator / common_divisor\n least_common_multiple = least_common_multiple / common_divisor\n res = Fraction(common_numerator, int(least_common_multiple))\n return res","def gcd(a, b):\n a = abs(a)\n b = abs(b)\n if a == b:\n return a\n if b > a:\n a, b = b, a\n q = a // b\n r = a - b * q\n while r != 0:\n a = b\n b = r\n q = a // b\n r = a - b * q\n return b","def di(o1, o2):\n return o1/o2","def fractions():\n\n pi = 22 / 7\n print(\"22/7\\n====\")\n print_as_text(pi)\n\n pi = 333 / 106\n print(\"333/106\\n=======\")\n print_as_text(pi)\n\n pi = 355 / 113\n print(\"355/113\\n=======\")\n print_as_text(pi)\n\n pi = 52163 / 16604\n print(\"52163/16604\\n===========\")\n print_as_text(pi)\n\n pi = 103993 / 33102\n print(\"103993/33102\\n============\")\n print_as_text(pi)\n\n pi = 245850922 / 78256779\n print(\"245850922/78256779\\n==================\")\n print_as_text(pi)","def gcd(a, b):\n r0, r1 = abs(a), abs(b)\n while r1 > 0:\n r0, r1 = r1, r0 % r1\n return r0","def gcd(a, b):\n if a == 0 or b == 0:\n return a + b\n # recursive will reach maximum recursion depth\n while a != b:\n a, b = (a - b, b) if a > b else (a, b - a)\n return a","def __mul__(self, frac):\n numerator = self.numerator * frac.numerator\n denominator = self.denominator * frac.denominator\n gcd = math.gcd(numerator, denominator)\n\n return Fraction(int(numerator/gcd), int(denominator/gcd))","def get_divide_ab(a, b): # IN= 2'int' / OUT= 1'foat'\n return float(a/b)","def __mul__(self, other):\n new_num = self.num * other.num\n new_denom = self.denom * other.denom\n return Fraction(new_num, new_denom)","def div1(left: float, right: float) -> float:\n return left / right","def division(numb1, numb2):\r\n return f\"Your result: {numb1/numb2}\"","def add_quad(a, b):\n s = np.sqrt(np.square(a) + np.square(b))\n return s","def divide(self, other):\n return self.multiply(other.reciprocal())","def percentage(a, b):\n return (a * 100.0) / b","def divide(lhs, rhs):\n return _make.divide(lhs, rhs)","def __mul__(self, otherfraction):\n\n newnum = self.num * otherfraction.num\n newden = self.den * otherfraction.den\n\n #reduce new num over lcm den\n common = gcd(sub_num, new_lcm)\n newnum = sub_num//common\n newden = new_lcm//common\n\n return Fraction(newnum, newden)","def __truediv__ (self,other):\n if (self.debug): print(f'enter fraction.__mul__ with {other}')\n f3 = fraction(self.value[0]*other.value[1],self.value[1]*other.value[0])\n if (self.debug): print(f3, self, other)\n return f3","def test_mul(self):\n newvalues = Fraction(3,2)*Fraction(1,4)\n fraction1 = Fraction(newvalues[0],newvalues[1])\n self.assertEqual(str(fraction1),\"3/8\")","def divide(self, a, b):\n return a / b","def multiply(self, other):\n return Rational(self.numerator * other.denominator, self.denominator * other.numerator)","def divide(num1, num2):\n return float(num1) / float(num2)","def getfloat(self, fraction) -> float:\n self.numerator_a = fraction.numerator_a\n self.denominator_b = fraction.denominator_b\n self.fraction = str(self.numerator_a) + '/' + str(self.denominator_b)\n return super().__float__()","def division(a, b):\n if b != 0:\n return a//b","def __sub__(self, other):\n # type: (object) -> Fraction\n dx = other\n if type(other) is float:\n dx = dectofr(other)\n return Fraction(self.numerator * dx.denominator - self.denominator * dx.numerator,\n self.denominator * dx.denominator)","def division(self, first_value, second_value):\n return first_value / second_value","def gcd(self, a, b):\n return self.one","def calc(operand_1, operand_2):\n return operand_1 / operand_2","def simplify (self):\n if (self.debug): print(f'enter fraction.simplify')\n hcf = find_hcf(self.value[0], self.value[1])\n self.value = (self.value[0] // hcf.product(), self.value[1] // hcf.product())\n return","def diff_frac(data_1, data_2):\n\n frac_1 = np.sum(data_1) / len(data_1)\n frac_2 = np.sum(data_2) / len(data_2)\n\n return frac_1 - frac_2","def exquo(self, a, b):\n return a / b","def my(a,b) :\n c = (a+b)\n d = c *100/160\n return d","def test_sub(self):\n newvalues = Fraction(1,2)-Fraction(1,2)\n fraction1 = Fraction(newvalues[0],newvalues[1])\n self.assertEqual(str(fraction1),\"0/4\")","def fraction_to_proper_fraction(rational):\n assert isinstance(rational, Fraction), repr(rational)\n quotient = int(rational)\n residue = rational - quotient\n return quotient, residue","def div(a, b):\n if b == 0:\n raise ValueError('zero division error')\n return a / b","def calc(operand_1, operand_2):\n return operand_1/operand_2","def calc(operand_1, operand_2):\n return operand_1/operand_2","def calc(operand_1, operand_2):\n return operand_1/operand_2","def divide(n1, n2):\n return n1 / n2","def gcd(a, b):\n __check_args(a, b)\n\n if b > a:\n return __calc_gcd(b, a)\n else:\n return __calc_gcd(a, b)","def div2(left: float, right: float) -> float:\n return left / right","def div(num1, num2):\n return num1 / num2","def div(num1, num2):\n return num1 / num2","def division_algo(a, b):\n return a / b, a % b","def divide1(a, b):\n if b == 0:\n raise ValueError(\"Zero division Error!\")\n return a * 1.0 / b","def fraction_program(operation, frac, frac_2):\r\n if operation == \"add\":\r\n question = f\"What is {frac} + {frac_2}?\"\r\n answer = frac+frac_2\r\n elif operation == \"subtract\":\r\n question = f\"What is {frac} - {frac_2}?\"\r\n answer = frac-frac_2\r\n elif operation == \"multiply\":\r\n question = f\"What is {frac} * {frac_2}?\"\r\n answer = frac*frac_2\r\n else:\r\n question = f\"What is {frac} / {frac_2}?\"\r\n answer = frac/frac_2\r\n print(question)\r\n return answer","def gcd(a: int, b: int) -> int:\n if a == 1 or b == 1:\n return 1\n if a == b:\n return a\n if a > b:\n return gcd(a % b, b)\n else:\n return gcd(a, b % a)","def mediant(frac1, frac2):\n\t# print \"%s m %s = %s\" % (frac1, frac2, (frac1[0]+frac2[0], frac1[1]+frac2[1])\n\treturn (frac1[0]+frac2[0], frac1[1]+frac2[1])","def divide(num1, num2):\n quotient = num1 / float(num2)\n return quotient","def div(self, a, b):\n raise NotImplementedError","def _ratio(a1, a2):\n abs_residues = np.abs(a1 - a2).sum()\n avg_abs_sum = 0.5 * np.abs(a1).sum() + 0.5 * np.abs(a2).sum()\n return abs_residues / avg_abs_sum","def calc(operand_1, operand_2):\n\n return operand_1/operand_2","def divide(first, second):\n if second == 0:\n return 'Invalid operation'\n return first / second","def divide(num1, num2):\n return num1 / num2","def extendedGcd(a, b):\n x0 = 1\n x1 = 0\n y0 = 0\n y1 = 1\n\n while b != 0:\n p = a // b\n z = a % b\n a = b\n b = z\n\n w = x1\n x1 = x0 - p * x1\n x0 = w\n \n v = y1\n y1 = y0 - p * y1\n y0 = v\n print(\"returns: gcd, si, ti\")\n return (gcd(a, b), x0, y0)","def _divide_and_round(a, b):\n # Based on the reference implementation for divmod_near\n # in Objects/longobject.c.\n q, r = divmod(a, b)\n # round up if either r / b > 0.5, or r / b == 0.5 and q is odd.\n # The expression r / b > 0.5 is equivalent to 2 * r > b if b is\n # positive, 2 * r < b if b negative.\n r *= 2\n greater_than_half = r > b if b > 0 else r < b\n if greater_than_half or r == b and q % 2 == 1:\n q += 1\n\n return q","def divide_numbers(value_a, value_b):\n # this is a shorthand way to create the division object and added it history in one line\n Calculator.add_calculation_to_history(Division.create(value_a, value_b))\n return Calculator.get_result_of_last_calculation_added_to_history()","def _reduce(self) -> None:\n divisor = self._gcd(self._numerator, self._denominator)\n self._numerator = self._numerator // divisor\n self._denominator = self._denominator // divisor","def ndom_add (a, b):\r\n x=ndom_to_decimal(a)\r\n y=ndom_to_decimal(b)\r\n add=x+y\r\n sumab=decimal_to_ndom(add)\r\n return sumab","def gcd(a, b):\n if not a:\n return b\n else:\n a = abs(a)\n b = abs(b)\n return gcd(b%a, a)","def gcd(a, b):\n if a == 0:\n return b\n if b == 0:\n return a\n\n if isinstance(a, int) and isinstance(b, int):\n _gcd = __internal_gcd\n else:\n def _gcd(g, r):\n if r == 0:\n return g\n else:\n return _gcd(r, g % r)\n\n return _gcd(a, b)"],"string":"[\n \"def simplify_fraction(a, b):\\n c = gcd(a, b)\\n return a // c, b // c\",\n \"def __add__ (self, other):\\n if (self.debug): print(f'enter fraction.__add__ with {other}')\\n lcm = find_lcm(self.value[1], other.value[1])\\n if (self.debug): print(f'{int(lcm/self.value[1])} {self.value}')\\n f1 = self.equivalent(int(lcm/self.value[1]))\\n f2 = other.equivalent(int(lcm/other.value[1]))\\n f3 = fraction(f1[0]+f2[0], lcm)\\n if (self.debug): print(f'{f3}, {self}, {other}')\\n return f3\",\n \"def __add__(self, other):\\n top = self.num*other.denom + self.denom*other.num\\n bott = self.denom*other.denom\\n return fraction(top, bott)\",\n \"def test_fraction_math_ops(self):\\n fract1 = source.Fraction(5, 3)\\n fract2 = source.Fraction(2, 3)\\n self.assertEqual(fract1 + fract2, source.Fraction(7, 3))\\n self.assertEqual(fract1 + 5, source.Fraction(20, 3))\\n self.assertEqual(3 + fract1, source.Fraction(14, 3))\\n self.assertEqual(fract1 * fract2, source.Fraction(10, 9))\\n self.assertEqual(5 * fract2, source.Fraction(10, 3))\",\n \"def add(q1, q2):\\n return create_rational(get_numerator(q1) * get_denominator(q2) + get_numerator(q2) * get_denominator(q1), get_denominator(q1) * get_denominator(q2))\",\n \"def __add__(self, other) -> object:\\n least_common_multiple = self.denominator_b\\n # check denominators of fractions and if no define their least common multiple\\n if self.denominator_b != other.denominator_b:\\n least_common_multiple = self.least_common_multiple_func(other.denominator_b)\\n\\n common_numerator = (least_common_multiple / self.denominator_b * self.numerator_a) + \\\\\\n (least_common_multiple / other.denominator_b * other.numerator_a)\\n\\n # check for common divisor\\n common_divisor = self.common_divisor(int(common_numerator), least_common_multiple)\\n if common_divisor is None:\\n res = Fraction(common_numerator, least_common_multiple)\\n else:\\n common_numerator = common_numerator / common_divisor\\n least_common_multiple = least_common_multiple / common_divisor\\n res = Fraction(common_numerator, int(least_common_multiple))\\n return res\",\n \"def __add__(self, other):\\n new_num = self.num * other.denom + other.num * self.denom\\n new_denom = self.denom * other.denom\\n return Fraction(new_num, new_denom)\",\n \"def __add__(self, other):\\n top = self.num*other.denom + self.denom*other.num\\n bott = self.denom*other.denom\\n return Fraction(top, bott)\",\n \"def add(self, other):\\n return Rational(self.numerator * other.denominator + other.numerator * self.denominator,\\n self.denominator * other.denominator)\",\n \"def __add__(self, frac):\\n numerator = ((self.numerator * frac.denominator) + (self.denominator * frac.numerator))\\n denominator = (self.denominator * frac.denominator)\\n return Fraction(numerator, denominator)\",\n \"def test_add(self):\\n newvalues = Fraction(1,2)+Fraction(1,2)\\n fraction1 = Fraction(newvalues[0],newvalues[1])\\n self.assertEqual(str(fraction1),\\\"4/4\\\")\",\n \"def __add__(self, other):\\n if isinstance(other, RationalFrac):\\n if 0 in self.denom or 0 in other.denom:\\n raise ZeroDivisionError(\\n 'cannot add when either ' +\\n 'operand is undefined.')\\n\\n # Get denominator factors not shared\\n # for self and other respectively:\\n diff_self = self.denom.copy()\\n diff_other = other.denom.copy()\\n for factor in self.denom:\\n if factor in diff_self and factor in diff_other:\\n diff_self.remove(factor)\\n diff_other.remove(factor)\\n\\n # Calculate the new numerator:\\n numer_self = RationalFrac.rf_prod(self.numer + diff_other)\\n numer_other = RationalFrac.rf_prod(other.numer + diff_self)\\n if self.neg:\\n numer_self *= -1\\n if other.neg:\\n numer_other *= -1\\n numer = numer_self + numer_other\\n\\n # Create the new fraction:\\n fsum = RationalFrac(0, empty=True)\\n fsum.numer = RationalFrac.factorize(abs(numer))\\n fsum.denom = self.denom + diff_other\\n fsum.neg = numer < 0\\n fsum.simplify()\\n return fsum\\n\\n elif isinstance(other, (int, float)):\\n return self.__add__(RationalFrac(other))\\n else:\\n return NotImplemented\",\n \"def __add__(self, other):\\n new_numerator = self._numerator * other.denominator() + other.numerator() * self._denominator\\n new_denominator = self._denominator * other.denominator()\\n return Rational(new_numerator, new_denominator)\",\n \"def add(f1, f2):\\n num1, den1 = int(f1.split('/')[0]), int(f1.split('/')[1])\\n num2, den2 = int(f2.split('/')[0]), int(f2.split('/')[1])\\n result = str( num1*den2 + num2*den1 ) + \\\"/\\\" + str( den1*den2 )\\n return reduce(result)\",\n \"def div(a: Decimal, b: Decimal) -> Decimal:\\n return a / b\",\n \"def __add__(self,f2):\\n new_numerator = self.__num * f2.den + self.__den * f2.num\\n new_denominator = self.__den * f2.den\\n return Fraction(new_numerator,new_denominator)\",\n \"def div(a, b):\\r\\n if type(b) in inttypes_set:\\r\\n if not b:\\r\\n return Infinity(a)\\r\\n raise ZeroDivisionError('%r / %r' % (a, b))\\r\\n if b == 1:\\r\\n return a\\r\\n if type(a) in inttypes_set:\\r\\n return normalized_fraction(a, b)\\r\\n return a / b\",\n \"def fraction_gcd(x, y):\\n a = x.numerator\\n b = x.denominator\\n c = y.numerator\\n d = y.denominator\\n return Fraction(gcd(a, c), lcm(b, d))\",\n \"def add(value1, value2):\\n return 1 / (1.0 / value1 + 1.0 / value2)\",\n \"def __add__(self,other):\\n self.numerator=self.numerator*other.denominator\\n other.numerator=self.denominator*other.numerator\\n resultnumerator = self.numerator+other.numerator\\n resultdenominator = self.denominator*other.denominator \\n newvalues = (resultnumerator,resultdenominator)\\n return newvalues\",\n \"def __sub__ (self,other):\\n if (self.debug): print(f'enter fraction.__sub__ with {other}')\\n f2 = fraction(-1*other.value[0],other.value[1])\\n f3 = self.__add__(f2)\\n return f3\",\n \"def test_div(self):\\n newvalues= Fraction(7,10)/Fraction(4,5)\\n fraction1 = Fraction(newvalues[0],newvalues[1])\\n self.assertEqual(str(fraction1),\\\"35/40\\\")\",\n \"def ratio_func(a, b):\\n return a / b\",\n \"def compute_fraction(x, y): \\r\\n if x == 'NaN' or y == 'NaN':\\r\\n return 0.\\r\\n if x == 0 or y == 0: \\r\\n return 0\\r\\n fraction = x / y\\r\\n return fraction\",\n \"def divup(a, b):\\n return (a + b - 1) // b\",\n \"def __add__(self, frac):\\n if isinstance(frac,Fraction):\\n if self.inf_size !=0 or frac.inf_size != 0:\\n if self.inf_size == -frac.inf_size:\\n return 0\\n elif abs(self.inf_size) > abs(frac.inf_size):\\n return Fraction(self.inf_size,0)\\n else:\\n return Fraction(frac.inf_size,0)\\n numerator = ((self.numerator*frac.denominator)+(frac.numerator*self.denominator))\\n denominator = (self.denominator*frac.denominator)\\n elif type(frac) in(float,int):\\n if self.inf_size !=0:\\n return self\\n numerator = (frac*self.denominator) + self.numerator\\n denominator = self.denominator\\n else:\\n raise ValueError('Fraction can only add with to int float or fractions')\\n return Fraction(numerator,denominator)\",\n \"def div(a, b):\\n a = float(a)\\n b = float(b)\\n return a / b\",\n \"def division(a, b):\\n return (a // b, a / b)\",\n \"def __mul__ (self,other):\\n if (self.debug): print(f'enter fraction.__mul__ with {other}')\\n f3 = fraction(self.value[0]*other.value[0],self.value[1]*other.value[1])\\n if (self.debug): print(f3, self, other)\\n f3.simplify()\\n return f3\",\n \"def gcd(self, a, b):\\n raise NotImplementedError\",\n \"def __mul__(self, other) -> object:\\n common_numerator = self.numerator_a * other.numerator_a\\n common_denominator = self.denominator_b * other.denominator_b\\n\\n # check for common divisor\\n common_divisor = self.common_divisor(int(common_numerator), common_denominator)\\n if common_divisor is None:\\n res = Fraction(common_numerator, common_denominator)\\n else:\\n common_numerator = common_numerator / common_divisor\\n common_denominator = common_denominator / common_divisor\\n res = Fraction(common_numerator, int(common_denominator))\\n return res\",\n \"def division(self, a, b):\\n if not check_arguments(a, b): # check if arguments are numbers\\n self.last_result = a / b\",\n \"def Div(a, b):\\n\\tRequire(b > 0)\\n\\tc = a / b\\n\\treturn c\",\n \"def continued_fraction(a, b, base=10):\\n\\t(p0, q0), (p1, q1) = (a(0), 1), (a(1) * a(0) + b(1), a(1))\\n\\tk = 1\\n\\twhile True:\\n\\t\\t(d0, r0), (d1, r1) = divmod(p0, q0), divmod(p1, q1)\\n\\t\\tif d0 == d1:\\n\\t\\t\\tyield d1\\n\\t\\t\\tp0, p1 = base * r0, base * r1\\n\\t\\telse:\\n\\t\\t\\tk = k + 1\\n\\t\\t\\tx, y = a(k), b(k)\\n\\t\\t\\t(p0, q0), (p1, q1) = (p1, q1), (x * p1 + y * p0, x * q1 + y * q0)\",\n \"def the_division_is_aimed(numb1, numb2):\\r\\n return f\\\"Your result: {numb1//numb2}\\\"\",\n \"def divide(a, b):\\n return a / b\",\n \"def __add__(self, other):\\n try:\\n new_num = (self._num * other._den) + (self._den * other._num)\\n new_den = (self._den * other._den)\\n return Rational(new_num, new_den)\\n except AttributeError:\\n return (self + Rational.parse_number(other))\",\n \"def reduce(self):\\n import math\\n g = math.gcd(self.num, self.den)\\n return Fraction(self.num//g, self.den//g)\",\n \"def __mul__(self, other):\\n new_num = self.num*other.num\\n new_den = self.den*other.den\\n common = gcd(new_num, new_den)\\n\\n return Fraction(new_num//common, new_den//common)\",\n \"def div(a,b):\\r\\n return a/b\",\n \"def __sub__(self, other) -> object:\\n least_common_multiple = self.denominator_b\\n # check denominators of fractions and if no define their least common multiple\\n if self.denominator_b != other.denominator_b:\\n least_common_multiple = self.least_common_multiple_func(other.denominator_b)\\n\\n common_numerator = (least_common_multiple / self.denominator_b * self.numerator_a) - \\\\\\n (least_common_multiple / other.denominator_b * other.numerator_a)\\n\\n # check for common divisor\\n common_divisor = self.common_divisor(int(common_numerator), least_common_multiple)\\n if common_divisor is None:\\n res = Fraction(common_numerator, least_common_multiple)\\n else:\\n common_numerator = common_numerator / common_divisor\\n least_common_multiple = least_common_multiple / common_divisor\\n res = Fraction(common_numerator, int(least_common_multiple))\\n return res\",\n \"def gcd(a, b):\\n a = abs(a)\\n b = abs(b)\\n if a == b:\\n return a\\n if b > a:\\n a, b = b, a\\n q = a // b\\n r = a - b * q\\n while r != 0:\\n a = b\\n b = r\\n q = a // b\\n r = a - b * q\\n return b\",\n \"def di(o1, o2):\\n return o1/o2\",\n \"def fractions():\\n\\n pi = 22 / 7\\n print(\\\"22/7\\\\n====\\\")\\n print_as_text(pi)\\n\\n pi = 333 / 106\\n print(\\\"333/106\\\\n=======\\\")\\n print_as_text(pi)\\n\\n pi = 355 / 113\\n print(\\\"355/113\\\\n=======\\\")\\n print_as_text(pi)\\n\\n pi = 52163 / 16604\\n print(\\\"52163/16604\\\\n===========\\\")\\n print_as_text(pi)\\n\\n pi = 103993 / 33102\\n print(\\\"103993/33102\\\\n============\\\")\\n print_as_text(pi)\\n\\n pi = 245850922 / 78256779\\n print(\\\"245850922/78256779\\\\n==================\\\")\\n print_as_text(pi)\",\n \"def gcd(a, b):\\n r0, r1 = abs(a), abs(b)\\n while r1 > 0:\\n r0, r1 = r1, r0 % r1\\n return r0\",\n \"def gcd(a, b):\\n if a == 0 or b == 0:\\n return a + b\\n # recursive will reach maximum recursion depth\\n while a != b:\\n a, b = (a - b, b) if a > b else (a, b - a)\\n return a\",\n \"def __mul__(self, frac):\\n numerator = self.numerator * frac.numerator\\n denominator = self.denominator * frac.denominator\\n gcd = math.gcd(numerator, denominator)\\n\\n return Fraction(int(numerator/gcd), int(denominator/gcd))\",\n \"def get_divide_ab(a, b): # IN= 2'int' / OUT= 1'foat'\\n return float(a/b)\",\n \"def __mul__(self, other):\\n new_num = self.num * other.num\\n new_denom = self.denom * other.denom\\n return Fraction(new_num, new_denom)\",\n \"def div1(left: float, right: float) -> float:\\n return left / right\",\n \"def division(numb1, numb2):\\r\\n return f\\\"Your result: {numb1/numb2}\\\"\",\n \"def add_quad(a, b):\\n s = np.sqrt(np.square(a) + np.square(b))\\n return s\",\n \"def divide(self, other):\\n return self.multiply(other.reciprocal())\",\n \"def percentage(a, b):\\n return (a * 100.0) / b\",\n \"def divide(lhs, rhs):\\n return _make.divide(lhs, rhs)\",\n \"def __mul__(self, otherfraction):\\n\\n newnum = self.num * otherfraction.num\\n newden = self.den * otherfraction.den\\n\\n #reduce new num over lcm den\\n common = gcd(sub_num, new_lcm)\\n newnum = sub_num//common\\n newden = new_lcm//common\\n\\n return Fraction(newnum, newden)\",\n \"def __truediv__ (self,other):\\n if (self.debug): print(f'enter fraction.__mul__ with {other}')\\n f3 = fraction(self.value[0]*other.value[1],self.value[1]*other.value[0])\\n if (self.debug): print(f3, self, other)\\n return f3\",\n \"def test_mul(self):\\n newvalues = Fraction(3,2)*Fraction(1,4)\\n fraction1 = Fraction(newvalues[0],newvalues[1])\\n self.assertEqual(str(fraction1),\\\"3/8\\\")\",\n \"def divide(self, a, b):\\n return a / b\",\n \"def multiply(self, other):\\n return Rational(self.numerator * other.denominator, self.denominator * other.numerator)\",\n \"def divide(num1, num2):\\n return float(num1) / float(num2)\",\n \"def getfloat(self, fraction) -> float:\\n self.numerator_a = fraction.numerator_a\\n self.denominator_b = fraction.denominator_b\\n self.fraction = str(self.numerator_a) + '/' + str(self.denominator_b)\\n return super().__float__()\",\n \"def division(a, b):\\n if b != 0:\\n return a//b\",\n \"def __sub__(self, other):\\n # type: (object) -> Fraction\\n dx = other\\n if type(other) is float:\\n dx = dectofr(other)\\n return Fraction(self.numerator * dx.denominator - self.denominator * dx.numerator,\\n self.denominator * dx.denominator)\",\n \"def division(self, first_value, second_value):\\n return first_value / second_value\",\n \"def gcd(self, a, b):\\n return self.one\",\n \"def calc(operand_1, operand_2):\\n return operand_1 / operand_2\",\n \"def simplify (self):\\n if (self.debug): print(f'enter fraction.simplify')\\n hcf = find_hcf(self.value[0], self.value[1])\\n self.value = (self.value[0] // hcf.product(), self.value[1] // hcf.product())\\n return\",\n \"def diff_frac(data_1, data_2):\\n\\n frac_1 = np.sum(data_1) / len(data_1)\\n frac_2 = np.sum(data_2) / len(data_2)\\n\\n return frac_1 - frac_2\",\n \"def exquo(self, a, b):\\n return a / b\",\n \"def my(a,b) :\\n c = (a+b)\\n d = c *100/160\\n return d\",\n \"def test_sub(self):\\n newvalues = Fraction(1,2)-Fraction(1,2)\\n fraction1 = Fraction(newvalues[0],newvalues[1])\\n self.assertEqual(str(fraction1),\\\"0/4\\\")\",\n \"def fraction_to_proper_fraction(rational):\\n assert isinstance(rational, Fraction), repr(rational)\\n quotient = int(rational)\\n residue = rational - quotient\\n return quotient, residue\",\n \"def div(a, b):\\n if b == 0:\\n raise ValueError('zero division error')\\n return a / b\",\n \"def calc(operand_1, operand_2):\\n return operand_1/operand_2\",\n \"def calc(operand_1, operand_2):\\n return operand_1/operand_2\",\n \"def calc(operand_1, operand_2):\\n return operand_1/operand_2\",\n \"def divide(n1, n2):\\n return n1 / n2\",\n \"def gcd(a, b):\\n __check_args(a, b)\\n\\n if b > a:\\n return __calc_gcd(b, a)\\n else:\\n return __calc_gcd(a, b)\",\n \"def div2(left: float, right: float) -> float:\\n return left / right\",\n \"def div(num1, num2):\\n return num1 / num2\",\n \"def div(num1, num2):\\n return num1 / num2\",\n \"def division_algo(a, b):\\n return a / b, a % b\",\n \"def divide1(a, b):\\n if b == 0:\\n raise ValueError(\\\"Zero division Error!\\\")\\n return a * 1.0 / b\",\n \"def fraction_program(operation, frac, frac_2):\\r\\n if operation == \\\"add\\\":\\r\\n question = f\\\"What is {frac} + {frac_2}?\\\"\\r\\n answer = frac+frac_2\\r\\n elif operation == \\\"subtract\\\":\\r\\n question = f\\\"What is {frac} - {frac_2}?\\\"\\r\\n answer = frac-frac_2\\r\\n elif operation == \\\"multiply\\\":\\r\\n question = f\\\"What is {frac} * {frac_2}?\\\"\\r\\n answer = frac*frac_2\\r\\n else:\\r\\n question = f\\\"What is {frac} / {frac_2}?\\\"\\r\\n answer = frac/frac_2\\r\\n print(question)\\r\\n return answer\",\n \"def gcd(a: int, b: int) -> int:\\n if a == 1 or b == 1:\\n return 1\\n if a == b:\\n return a\\n if a > b:\\n return gcd(a % b, b)\\n else:\\n return gcd(a, b % a)\",\n \"def mediant(frac1, frac2):\\n\\t# print \\\"%s m %s = %s\\\" % (frac1, frac2, (frac1[0]+frac2[0], frac1[1]+frac2[1])\\n\\treturn (frac1[0]+frac2[0], frac1[1]+frac2[1])\",\n \"def divide(num1, num2):\\n quotient = num1 / float(num2)\\n return quotient\",\n \"def div(self, a, b):\\n raise NotImplementedError\",\n \"def _ratio(a1, a2):\\n abs_residues = np.abs(a1 - a2).sum()\\n avg_abs_sum = 0.5 * np.abs(a1).sum() + 0.5 * np.abs(a2).sum()\\n return abs_residues / avg_abs_sum\",\n \"def calc(operand_1, operand_2):\\n\\n return operand_1/operand_2\",\n \"def divide(first, second):\\n if second == 0:\\n return 'Invalid operation'\\n return first / second\",\n \"def divide(num1, num2):\\n return num1 / num2\",\n \"def extendedGcd(a, b):\\n x0 = 1\\n x1 = 0\\n y0 = 0\\n y1 = 1\\n\\n while b != 0:\\n p = a // b\\n z = a % b\\n a = b\\n b = z\\n\\n w = x1\\n x1 = x0 - p * x1\\n x0 = w\\n \\n v = y1\\n y1 = y0 - p * y1\\n y0 = v\\n print(\\\"returns: gcd, si, ti\\\")\\n return (gcd(a, b), x0, y0)\",\n \"def _divide_and_round(a, b):\\n # Based on the reference implementation for divmod_near\\n # in Objects/longobject.c.\\n q, r = divmod(a, b)\\n # round up if either r / b > 0.5, or r / b == 0.5 and q is odd.\\n # The expression r / b > 0.5 is equivalent to 2 * r > b if b is\\n # positive, 2 * r < b if b negative.\\n r *= 2\\n greater_than_half = r > b if b > 0 else r < b\\n if greater_than_half or r == b and q % 2 == 1:\\n q += 1\\n\\n return q\",\n \"def divide_numbers(value_a, value_b):\\n # this is a shorthand way to create the division object and added it history in one line\\n Calculator.add_calculation_to_history(Division.create(value_a, value_b))\\n return Calculator.get_result_of_last_calculation_added_to_history()\",\n \"def _reduce(self) -> None:\\n divisor = self._gcd(self._numerator, self._denominator)\\n self._numerator = self._numerator // divisor\\n self._denominator = self._denominator // divisor\",\n \"def ndom_add (a, b):\\r\\n x=ndom_to_decimal(a)\\r\\n y=ndom_to_decimal(b)\\r\\n add=x+y\\r\\n sumab=decimal_to_ndom(add)\\r\\n return sumab\",\n \"def gcd(a, b):\\n if not a:\\n return b\\n else:\\n a = abs(a)\\n b = abs(b)\\n return gcd(b%a, a)\",\n \"def gcd(a, b):\\n if a == 0:\\n return b\\n if b == 0:\\n return a\\n\\n if isinstance(a, int) and isinstance(b, int):\\n _gcd = __internal_gcd\\n else:\\n def _gcd(g, r):\\n if r == 0:\\n return g\\n else:\\n return _gcd(r, g % r)\\n\\n return _gcd(a, b)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7550767","0.73520947","0.70274425","0.70012","0.68851763","0.68535614","0.6831391","0.6830096","0.6678177","0.66171855","0.6570202","0.6537826","0.6499646","0.6448474","0.64213866","0.6402042","0.63277656","0.6272814","0.62671316","0.62539977","0.61884904","0.61863226","0.61808544","0.61524534","0.61176294","0.61173534","0.6107478","0.60944617","0.60936517","0.60903436","0.6089949","0.6076361","0.6075566","0.6072666","0.6068531","0.6054449","0.6052324","0.6034912","0.6016807","0.6010569","0.5994051","0.5982027","0.59697694","0.59536994","0.5916392","0.5913506","0.59125316","0.5910552","0.5896966","0.58909404","0.5888173","0.58833086","0.5870721","0.5864323","0.5833045","0.582985","0.582593","0.5814784","0.58129704","0.5812715","0.58091086","0.5803279","0.5802703","0.58017623","0.57845557","0.57793194","0.5772984","0.5769112","0.576673","0.57511747","0.5742258","0.5731957","0.5728317","0.572772","0.572161","0.572161","0.572161","0.5720744","0.5713308","0.56813526","0.5679747","0.5679747","0.5678803","0.56707","0.5661303","0.5660766","0.5660659","0.5660385","0.5656222","0.5651533","0.56514776","0.5646785","0.56457424","0.5639524","0.5622594","0.56182027","0.5606811","0.5598198","0.55821735","0.55819124"],"string":"[\n \"0.7550767\",\n \"0.73520947\",\n \"0.70274425\",\n \"0.70012\",\n \"0.68851763\",\n \"0.68535614\",\n \"0.6831391\",\n \"0.6830096\",\n \"0.6678177\",\n \"0.66171855\",\n \"0.6570202\",\n \"0.6537826\",\n \"0.6499646\",\n \"0.6448474\",\n \"0.64213866\",\n \"0.6402042\",\n \"0.63277656\",\n \"0.6272814\",\n \"0.62671316\",\n \"0.62539977\",\n \"0.61884904\",\n \"0.61863226\",\n \"0.61808544\",\n \"0.61524534\",\n \"0.61176294\",\n \"0.61173534\",\n \"0.6107478\",\n \"0.60944617\",\n \"0.60936517\",\n \"0.60903436\",\n \"0.6089949\",\n \"0.6076361\",\n \"0.6075566\",\n \"0.6072666\",\n \"0.6068531\",\n \"0.6054449\",\n \"0.6052324\",\n \"0.6034912\",\n \"0.6016807\",\n \"0.6010569\",\n \"0.5994051\",\n \"0.5982027\",\n \"0.59697694\",\n \"0.59536994\",\n \"0.5916392\",\n \"0.5913506\",\n \"0.59125316\",\n \"0.5910552\",\n \"0.5896966\",\n \"0.58909404\",\n \"0.5888173\",\n \"0.58833086\",\n \"0.5870721\",\n \"0.5864323\",\n \"0.5833045\",\n \"0.582985\",\n \"0.582593\",\n \"0.5814784\",\n \"0.58129704\",\n \"0.5812715\",\n \"0.58091086\",\n \"0.5803279\",\n \"0.5802703\",\n \"0.58017623\",\n \"0.57845557\",\n \"0.57793194\",\n \"0.5772984\",\n \"0.5769112\",\n \"0.576673\",\n \"0.57511747\",\n \"0.5742258\",\n \"0.5731957\",\n \"0.5728317\",\n \"0.572772\",\n \"0.572161\",\n \"0.572161\",\n \"0.572161\",\n \"0.5720744\",\n \"0.5713308\",\n \"0.56813526\",\n \"0.5679747\",\n \"0.5679747\",\n \"0.5678803\",\n \"0.56707\",\n \"0.5661303\",\n \"0.5660766\",\n \"0.5660659\",\n \"0.5660385\",\n \"0.5656222\",\n \"0.5651533\",\n \"0.56514776\",\n \"0.5646785\",\n \"0.56457424\",\n \"0.5639524\",\n \"0.5622594\",\n \"0.56182027\",\n \"0.5606811\",\n \"0.5598198\",\n \"0.55821735\",\n \"0.55819124\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.65008366"},"document_rank":{"kind":"string","value":"12"}}},{"rowIdx":23097,"cells":{"query":{"kind":"string","value":"Two fractions are equal if they have the same value. Fractions are stored in proper form so the internal representation is unique (3/6 is same as 1/2)."},"document":{"kind":"string","value":"def __eq__(self, frac):\n return self.equal == frac.equal"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_equal(self):\n self.assertTrue(Fraction(7,10)==Fraction(7,10))","def test_notequal(self):\n self.assertTrue(Fraction(144,2)!=Fraction(8,4))","def test_frac_same(self):\n s1 = self.RNA(\"ACGU\")\n s2 = self.RNA(\"AACG\")\n s3 = self.RNA(\"GG\")\n s4 = self.RNA(\"A\")\n e = self.RNA(\"\")\n self.assertEqual(s1.frac_same(e), 0)\n self.assertEqual(s1.frac_same(s2), 0.25)\n self.assertEqual(s1.frac_same(s3), 0)\n self.assertEqual(s1.frac_same(s4), 1.0) # note truncation","def __eq__(self, other):\n equal = self.numerator == other.numerator and self.denominator == other.denominator\n\n if equal == False:\n self.numerator = abs(self.numerator)\n self.denominator = abs(self.denominator)\n other.numerator = abs(other.numerator)\n other.denominator = abs(other.denominator)\n\n if self.numerator < other.numerator:\n smallnum = self.numerator\n else:\n smallnum = other.numerator\n\n if self.denominator < other.denominator:\n smallnum2 = self.denominator\n else:\n smallnum2 = other.denominator\n\n num1 = f\"{smallnum}/{smallnum2}\"\n\n gcd1 = math.gcd(self.numerator, other.numerator)\n gcd2 = math.gcd(self.denominator, other.denominator)\n\n num2 = f\"{gcd1}/{gcd2}\"\n\n return num1 == num2\n\n else:\n return equal","def __eq__(self, frac):\n\n if isinstance(frac,Fraction):\n if self.numerator ==0 and self.denominator==0:\n if frac.numerator ==0 and frac.denominator==0:\n return True\n return 0 == frac.numerator/frac.denominator\n return self.numerator == frac.numerator and self.denominator == frac.denominator and self.inf_size == frac.inf_size\n elif type(frac) in(float,int):\n if self.numerator ==0 and self.denominator==0:\n return 0 == frac\n return self.numerator/self.denominator == frac\n else:\n raise ValueError('Fraction can only be compare to int float or fractions')","def test_div(self):\n newvalues= Fraction(7,10)/Fraction(4,5)\n fraction1 = Fraction(newvalues[0],newvalues[1])\n self.assertEqual(str(fraction1),\"35/40\")","def equivalent (self, factor):\n if (self.debug): print(f'enter fraction.equivalent {factor}')\n return (self.value[0] * factor, self.value[1]* factor)","def test_ne(self):\n f12: Fraction = Fraction(1, 2)\n f34: Fraction = Fraction(3, 4)\n f48: Fraction = Fraction(4, 8)\n self.assertTrue(f12 != f34)\n self.assertFalse(f12 != f48)\n self.assertFalse(f12 != f12)","def test_fraction_math_ops(self):\n fract1 = source.Fraction(5, 3)\n fract2 = source.Fraction(2, 3)\n self.assertEqual(fract1 + fract2, source.Fraction(7, 3))\n self.assertEqual(fract1 + 5, source.Fraction(20, 3))\n self.assertEqual(3 + fract1, source.Fraction(14, 3))\n self.assertEqual(fract1 * fract2, source.Fraction(10, 9))\n self.assertEqual(5 * fract2, source.Fraction(10, 3))","def __eq__(self,other):\n self.numerator=self.numerator*other.denominator\n other.numerator=self.denominator*other.numerator\n if(self.numerator==other.numerator):\n return True\n else:\n return False\n return","def test_fraction_rich_comparisson(self):\n fract1 = source.Fraction(5, 2) # 2.5\n fract2 = source.Fraction(3, 2) # 1.5\n fract3 = source.Fraction(25, 10) # 2.5\n\n self.assertFalse(fract1 != fract3) # 2.5 != 2.5\n self.assertTrue(fract1 == fract3) # 2.5 == 2.5\n self.assertTrue(fract2 < fract3) # 1.5 < 2.5\n\n # Let's try the other way\n self.assertTrue(fract1 >= fract2) # 2.5 >= 1.5\n self.assertFalse(fract2 >= fract3) # 1.5 >= 2.5\n\n # Let's try with other types\n self.assertTrue(fract1 >= 2) # 2.5 >= 2\n self.assertTrue(fract2 == 1.5) # 1.5 == 1.5\n\n # Let's try the other way with other types\n self.assertTrue(2 <= fract1) # 2 <= 2.5\n self.assertTrue(1.5 == fract2) # 1.5 == 1.5\n\n self.assertTrue(10 > fract1) # 10 > 2.5\n self.assertFalse(10 < fract1) # 10 < 2.5\n self.assertTrue(fract1 < 10) # 2.5 < 10\n self.assertFalse(fract1 > 10) # 2.5 > 10","def test_frac_same_non_gaps(self):\n s1 = self.RNA(\"AAAA\")\n s2 = self.RNA(\"AGGG\")\n s3 = self.RNA(\"GGGG\")\n s4 = self.RNA(\"AG--GA-G\")\n s5 = self.RNA(\"CU--CU-C\")\n s6 = self.RNA(\"AC--GC-G\")\n s7 = self.RNA(\"--------\")\n s8 = self.RNA(\"AAAA----\")\n s9 = self.RNA(\"A-GG-A-C\")\n e = self.RNA(\"\")\n\n def test(x, y, z):\n return self.assertFloatEqual(x.frac_same_non_gaps(y), z)\n\n test(s1, s2, 0.25)\n test(s1, s3, 0)\n test(s2, s3, 0.75)\n test(s1, s4, 0.5)\n test(s4, s5, 0)\n test(s4, s6, 0.6)\n test(s4, s7, 0)\n test(s4, s8, 0.5)\n test(s4, s9, 2 / 3.0)\n test(e, s4, 0)","def test_frac_similar(self):\n transitions = dict.fromkeys(\n [\n (\"A\", \"A\"),\n (\"A\", \"G\"),\n (\"G\", \"A\"),\n (\"G\", \"G\"),\n (\"U\", \"U\"),\n (\"U\", \"C\"),\n (\"C\", \"U\"),\n (\"C\", \"C\"),\n ]\n )\n\n s1 = self.RNA(\"UCAGGCAA\")\n s2 = self.RNA(\"CCAAAUGC\")\n s3 = self.RNA(\"GGGGGGGG\")\n e = self.RNA(\"\")\n\n def test(x, y, z):\n return self.assertFloatEqual(x.frac_similar(y, transitions), z)\n\n test(e, e, 0)\n test(s1, e, 0)\n test(s1, s1, 1)\n test(s1, s2, 7.0 / 8)\n test(s1, s3, 5.0 / 8)\n test(s2, s3, 4.0 / 8)","def test_mul(self):\n newvalues = Fraction(3,2)*Fraction(1,4)\n fraction1 = Fraction(newvalues[0],newvalues[1])\n self.assertEqual(str(fraction1),\"3/8\")","def test_sub(self):\n newvalues = Fraction(1,2)-Fraction(1,2)\n fraction1 = Fraction(newvalues[0],newvalues[1])\n self.assertEqual(str(fraction1),\"0/4\")","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 test_add(self):\n newvalues = Fraction(1,2)+Fraction(1,2)\n fraction1 = Fraction(newvalues[0],newvalues[1])\n self.assertEqual(str(fraction1),\"4/4\")","def simplify_fraction(a, b):\n c = gcd(a, b)\n return a // c, b // c","def test_frac_same_gaps(self):\n s1 = self.RNA(\"AAAA\")\n s2 = self.RNA(\"GGGG\")\n s3 = self.RNA(\"----\")\n s4 = self.RNA(\"A-A-\")\n s5 = self.RNA(\"-G-G\")\n s6 = self.RNA(\"UU--\")\n s7 = self.RNA(\"-\")\n s8 = self.RNA(\"GGG\")\n e = self.RNA(\"\")\n self.assertEqual(s1.frac_same_gaps(s1), 1)\n self.assertEqual(s1.frac_same_gaps(s2), 1)\n self.assertEqual(s1.frac_same_gaps(s3), 0)\n self.assertEqual(s1.frac_same_gaps(s4), 0.5)\n self.assertEqual(s1.frac_same_gaps(s5), 0.5)\n self.assertEqual(s1.frac_same_gaps(s6), 0.5)\n self.assertEqual(s1.frac_same_gaps(s7), 0)\n self.assertEqual(s1.frac_same_gaps(e), 0)\n self.assertEqual(s3.frac_same_gaps(s3), 1)\n self.assertEqual(s3.frac_same_gaps(s4), 0.5)\n self.assertEqual(s3.frac_same_gaps(s7), 1.0)\n self.assertEqual(e.frac_same_gaps(e), 0.0)\n self.assertEqual(s4.frac_same_gaps(s5), 0.0)\n self.assertEqual(s4.frac_same_gaps(s6), 0.5)\n self.assertFloatEqual(s6.frac_same_gaps(s8), 2 / 3.0)","def test_frac_diff(self):\n s1 = self.RNA(\"ACGU\")\n s2 = self.RNA(\"AACG\")\n s3 = self.RNA(\"GG\")\n s4 = self.RNA(\"A\")\n e = self.RNA(\"\")\n self.assertEqual(s1.frac_diff(e), 0)\n self.assertEqual(s1.frac_diff(s2), 0.75)\n self.assertEqual(s1.frac_diff(s3), 1)\n self.assertEqual(s1.frac_diff(s4), 0) # note truncation","def __add__ (self, other):\n if (self.debug): print(f'enter fraction.__add__ with {other}')\n lcm = find_lcm(self.value[1], other.value[1])\n if (self.debug): print(f'{int(lcm/self.value[1])} {self.value}')\n f1 = self.equivalent(int(lcm/self.value[1]))\n f2 = other.equivalent(int(lcm/other.value[1]))\n f3 = fraction(f1[0]+f2[0], lcm)\n if (self.debug): print(f'{f3}, {self}, {other}')\n return f3","def test_ge(self):\n f12: Fraction = Fraction(1, 2)\n f34: Fraction = Fraction(3, 4)\n f93: Fraction = Fraction(9, 3)\n f124: Fraction = Fraction(12, 4)\n self.assertTrue(f12 >= f34)\n self.assertTrue(f93 >= f124)\n self.assertFalse(f93 >= f12)","def test_str(self):\n f66: Fraction = Fraction(6, 6)\n f24: Fraction = Fraction(2, 4)\n self.assertEqual(str(f66), \"6/6\")\n self.assertNotEqual(str(f24), \"8/6\")\n self.assertTrue(str(f24), \"2/4\")","def __eq__(self, other):\n if isinstance(other, RationalFrac):\n return (self.numer == other.numer and\n self.denom == other.denom and\n self.neg == other.neg)\n elif isinstance(other, (int, float, str)):\n return self.__eq__(RationalFrac(other))\n else:\n return NotImplemented","def __eq__(self, other):\n try: \n same_num = (self._num == other._num)\n same_den = (self._den == other._den)\n return same_num and same_den\n except AttributeError:\n return (self == Rational.parse_number(other))","def __init__(self, numerator, denominator=1):\n common_div = gcd(numerator, denominator)\n if common_div == 0:\n common_div = 1\n self.numerator = int((numerator / common_div) / copysign(1, denominator))\n self.denominator = int((denominator / common_div) / copysign(1, denominator))\n if self.denominator != 0:\n self.equal = self.numerator / self.denominator\n elif self.denominator == 0:\n self.equal = \"UNDEFINED.\"","def test_GreaterThanorEqualto(self):\n self.assertTrue(Fraction(7,10)>=Fraction(7,10))","def __eq__(self, other):\n if self is other:\n return True\n elif not isinstance(other, Rational):\n return False\n else:\n return self._numerator == other.numerator() and \\\n self._denominator == other.denominator()","def test_simplify(self):\n self.assertEqual(Fraction(9, 12).simplify(), Fraction(3, 4))\n self.assertEqual(Fraction(1, 2).simplify(), Fraction(1, 2))\n self.assertEqual(str(Fraction(1, 2).simplify()), str(Fraction(1, 2)))","def almost_equals(self, other, decimal=...): # -> bool:\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 __ne__(self, other):\n self.numerator=self.numerator*other.denominator\n other.numerator=self.denominator*other.numerator\n if(self.numerator!=other.numerator):\n return True\n else:\n return False","def test_3_operands(self):\n f12: Fraction = Fraction(1, 2)\n f34: Fraction = Fraction(3, 4)\n f44: Fraction = Fraction(4, 4)\n f84: Fraction = Fraction(8, 4)\n f48: Fraction = Fraction(4, 8)\n f816: Fraction = Fraction(8, 16)\n self.assertTrue(f12 + f34 + f44 == Fraction(72, 32))\n self.assertTrue(f12 - f34 - f44 == Fraction(-5,4))\n self.assertTrue(f12 * f34 * f44 == Fraction(3, 8))\n self.assertTrue(f12 / f34 / f44 == Fraction(4, 6))\n self.assertTrue(f12 == f48 == f816)\n self.assertFalse(f12 == f816 == f34)\n self.assertTrue(f12 != f34 != f44)\n self.assertFalse(f12 != f48 != f816)\n self.assertTrue(f12 < f34 < f44)\n self.assertFalse(f84 < f44 < f12)\n self.assertTrue(f12 <= f12 <= f48)\n self.assertFalse(f84 <= f44 < f12)\n self.assertTrue(f44 > f34 > f12)\n self.assertFalse(f12 > f44 > f84)\n self.assertTrue(f12 >= f48 >= f816)\n self.assertFalse(f12 >= f44 >= f816)","def __eq__( self, value ):\r\n\t\tif ( type( self ) == type( value ) ):\r\n\t\t\tselfval, valueval = self.numerator / self.denominator, value.numerator / value.denominator\r\n\t\t\tif ( types.ComplexType in ( type( selfval ), type( valueval ) ) ):\r\n\t\t\t\tif not ( types.ComplexType == type( selfval ) == type( valueval ) ):\r\n\t\t\t\t\treturn False\r\n\t\t\t\treturn ( round( selfval.real, FRACTION_FLOAT_ACCURACY ) == round( valueval.real, FRACTION_FLOAT_ACCURACY ) ) and \\\r\n\t\t\t\t\t ( round( selfval.imag, FRACTION_FLOAT_ACCURACY ) == round( valueval.imag, FRACTION_FLOAT_ACCURACY ) )\r\n\t\t\treturn round( self.numerator / self.denominator, FRACTION_FLOAT_ACCURACY ) == round( value.numerator / value.denominator, FRACTION_FLOAT_ACCURACY )\r\n\r\n\t\telif ( type( value ) in ( types.IntType, types.LongType ) ):\r\n\t\t\treturn long( self ) == value\r\n\r\n\t\telif ( type( value ) == types.FloatType ):\r\n\t\t\t return round( float( self ), FRACTION_FLOAT_ACCURACY ) == round( value, FRACTION_FLOAT_ACCURACY )\r\n\t\t\t\r\n\t\telif ( type( value ) == types.ComplexType ):\r\n\t\t\tselfval = self.numerator / self.denominator\r\n\t\t\tif not ( type( selfval ) == types.ComplexType ):\r\n\t\t\t\t\treturn False\r\n\t\t\treturn ( round( selfval.real, FRACTION_FLOAT_ACCURACY ) == round( value.real, FRACTION_FLOAT_ACCURACY ) ) and \\\r\n\t\t\t\t ( round( selfval.imag, FRACTION_FLOAT_ACCURACY ) == round( value.imag, FRACTION_FLOAT_ACCURACY ) )\r\n\r\n\t\t\treturn ( self.numerator / self.denominator ) == value\r\n\r\n\t\telse:\r\n\t\t\treturn NotImplemented","def nearly_equal(a, b, sig_fig=5):\n return a == b or int(a*10**sig_fig) == int(b*10**sig_fig)","def rational_frac_tests():\n print('\\n==========================================')\n print('rfrac.py @ rational_frac_tests: //////////\\n')\n print(RationalFrac(-1), RationalFrac(0))\n # __prime_factors()\n frac0 = RationalFrac(4.5)\n frac1 = RationalFrac(-0.125)\n frac2 = RationalFrac(0.99999)\n f = [frac0, frac1, frac2]\n print('float(-0.125) =', float(f[1]))\n print('float(0.99999) =', float(f[2]))\n print('9/2 + -1/8 =', f[0] + f[1])\n print('9/2 * -1/8 =', f[0] * f[1])\n print('-1/8 * 9/2 =', f[1] * f[0])\n print(f)\n print('frac(-0/1) + frac(-0/1) =',\n RationalFrac(-0) + RationalFrac(-0))\n f3 = RationalFrac('-7/29')\n print(f3)\n print(RationalFrac(25, 1000))\n print('\\nrfrac.py @ end of rational_frac_tests ////')\n print('==========================================\\n')","def test_gt(self):\n f12: Fraction = Fraction(1, 2)\n f34: Fraction = Fraction(3, 4)\n f105: Fraction = Fraction(10, 5)\n self.assertTrue(f34 > f12)\n self.assertFalse(f12 > f105)\n self.assertFalse(f12 > f12)","def __eq__(self, other):\n firstnum = self.num*other.den\n secondnum = self.den*other.num\n\n return firstnum == secondnum","def test_equal_on_equal(self):\n a = Digest(\n hashing_algorithm=self.hashing_algorithm_b,\n digest_value=self.digest_value_b,\n key_format_type=self.key_format_type_b)\n b = Digest(\n hashing_algorithm=self.hashing_algorithm_b,\n digest_value=self.digest_value_b,\n key_format_type=self.key_format_type_b)\n\n self.assertTrue(a == b)\n self.assertTrue(b == a)","def test_lt(self):\n f12: Fraction = Fraction(1, 2)\n f34: Fraction = Fraction(3, 4)\n f44: Fraction = Fraction(4, 4)\n self.assertTrue(f12 < f34)\n self.assertFalse(f44 < f12)","def test_fraction_item_access(self):\n f1 = source.Fraction(7, 2)\n self.assertEqual(len(f1), 2)\n self.assertEqual(f1['num'], 7)\n self.assertEqual(f1[1], 2)\n f1[0] = 5\n f1['den'] = 3\n self.assertEqual(str(f1), \"5/3\")","def fractions():\n\n pi = 22 / 7\n print(\"22/7\\n====\")\n print_as_text(pi)\n\n pi = 333 / 106\n print(\"333/106\\n=======\")\n print_as_text(pi)\n\n pi = 355 / 113\n print(\"355/113\\n=======\")\n print_as_text(pi)\n\n pi = 52163 / 16604\n print(\"52163/16604\\n===========\")\n print_as_text(pi)\n\n pi = 103993 / 33102\n print(\"103993/33102\\n============\")\n print_as_text(pi)\n\n pi = 245850922 / 78256779\n print(\"245850922/78256779\\n==================\")\n print_as_text(pi)","def test_init(self):\n \n fraction1 = Fraction(1,2)\n self.assertEqual(fraction1.numerator, 1)\n self.assertEqual(fraction1.denominator, 2)","def test_equality(self):\n\n s3 = space(curvature=1/5)\n for k in (0, -1, 1, 1.75, 0.325, 1/7, -1.75, -0.325, -1/7):\n s1 = space(fake_curvature=k)\n s2 = space(fake_curvature=k)\n self.assertTrue(s1 == s2)\n self.assertTrue(hash(s1) == hash(s2))\n self.assertTrue(str(s1) == str(s2))\n self.assertTrue(repr(s1) == repr(s2))\n self.assertTrue(s1 != s3)","def fraction_to_proper_fraction(rational):\n assert isinstance(rational, Fraction), repr(rational)\n quotient = int(rational)\n residue = rational - quotient\n return quotient, residue","def test_mixing_ratio():\n p = 998. * units.mbar\n e = 73.75 * units.mbar\n assert_almost_equal(mixing_ratio(e, p), 0.04963, 2)","def testcomparefrac ( self ):\r\n\t\tfor fracTup1, fracTup2, result in self.knownCmpValues:\r\n\t\t\tfrac1 = eval ( 'frac.'+fracTup1 )\r\n\t\t\tfrac2 = eval ( 'frac.'+fracTup2 )\r\n\t\t\tif result != None:\t\t\t\t\t\r\n\t\t\t\tself.assertEqual ( frac1.compare ( frac2 )[0], result )\r\n\t\t\telse:\r\n\t\t\t\tself.assertEqual ( frac1.compare ( frac2 ), result )","def __eq__(self,f2):\n return self.__num * f2.den == self.__den * f2.num","def testEquality(self):\n pass","def value_is_equal(left, right):\n if type(left) is float and type(right) is float:\n if left == right:\n equal = True\n elif left == 0.0 or right == 0.0:\n # exactly one of the values is 0\n equal = False\n else: # (none of the values is 0)\n db_epsilon = 1.0e-10\n left_exp = 10.0 ** int(math.log10(abs(left)))\n right_exp = 10.0 ** int(math.log10(abs(right)))\n if left_exp != right_exp:\n equal = False\n else:\n diff = abs(left / left_exp - right / right_exp)\n equal = diff < db_epsilon\n else:\n equal = left == right\n return equal","def simplify (self):\n if (self.debug): print(f'enter fraction.simplify')\n hcf = find_hcf(self.value[0], self.value[1])\n self.value = (self.value[0] // hcf.product(), self.value[1] // hcf.product())\n return","def test_LessThanorEqualto(self):\n self.assertTrue(Fraction(-7,10)<=Fraction(-7,10))","def test_le(self):\n f12: Fraction = Fraction(1, 2)\n f34: Fraction = Fraction(3, 4)\n f48: Fraction = Fraction(4, 8)\n f66: Fraction = Fraction(6, 6)\n self.assertTrue(f12 <= f34)\n self.assertTrue(f12 <= f48)\n self.assertFalse(f66 <= f12)","def test_equal_on_equal_and_empty(self):\n a = Digest()\n b = Digest()\n\n self.assertTrue(a == b)\n self.assertTrue(b == a)","def getfloat(self, fraction) -> float:\n self.numerator_a = fraction.numerator_a\n self.denominator_b = fraction.denominator_b\n self.fraction = str(self.numerator_a) + '/' + str(self.denominator_b)\n return super().__float__()","def fraction_gcd(x, y):\n a = x.numerator\n b = x.denominator\n c = y.numerator\n d = y.denominator\n return Fraction(gcd(a, c), lcm(b, d))","def test_frac_diffGaps(self):\n s1 = self.RNA(\"AAAA\")\n s2 = self.RNA(\"GGGG\")\n s3 = self.RNA(\"----\")\n s4 = self.RNA(\"A-A-\")\n s5 = self.RNA(\"-G-G\")\n s6 = self.RNA(\"UU--\")\n s7 = self.RNA(\"-\")\n s8 = self.RNA(\"GGG\")\n e = self.RNA(\"\")\n self.assertEqual(s1.frac_diff_gaps(s1), 0)\n self.assertEqual(s1.frac_diff_gaps(s2), 0)\n self.assertEqual(s1.frac_diff_gaps(s3), 1)\n self.assertEqual(s1.frac_diff_gaps(s4), 0.5)\n self.assertEqual(s1.frac_diff_gaps(s5), 0.5)\n self.assertEqual(s1.frac_diff_gaps(s6), 0.5)\n self.assertEqual(s1.frac_diff_gaps(s7), 1)\n self.assertEqual(s1.frac_diff_gaps(e), 0)\n self.assertEqual(s3.frac_diff_gaps(s3), 0)\n self.assertEqual(s3.frac_diff_gaps(s4), 0.5)\n self.assertEqual(s3.frac_diff_gaps(s7), 0.0)\n self.assertEqual(e.frac_diff_gaps(e), 0.0)\n self.assertEqual(s4.frac_diff_gaps(s5), 1.0)\n self.assertEqual(s4.frac_diff_gaps(s6), 0.5)\n self.assertFloatEqual(s6.frac_diff_gaps(s8), 1 / 3.0)","def equivalent_to_float(self, other):\n sfother = type(self)(other, self.sigfigs)\n return str(self) == str(sfother)","def test_init(self):\n f: Fraction = Fraction(3, 4)\n self.assertEqual(f.num, 3)\n self.assertEqual(f.denom, 4)","def test_not_equal_on_equal(self):\n a = Digest(\n hashing_algorithm=self.hashing_algorithm_b,\n digest_value=self.digest_value_b,\n key_format_type=self.key_format_type_b)\n b = Digest(\n hashing_algorithm=self.hashing_algorithm_b,\n digest_value=self.digest_value_b,\n key_format_type=self.key_format_type_b)\n\n self.assertFalse(a != b)\n self.assertFalse(b != a)","def div(a, b):\r\n if type(b) in inttypes_set:\r\n if not b:\r\n return Infinity(a)\r\n raise ZeroDivisionError('%r / %r' % (a, b))\r\n if b == 1:\r\n return a\r\n if type(a) in inttypes_set:\r\n return normalized_fraction(a, b)\r\n return a / b","def test_frac_diffNonGaps(self):\n s1 = self.RNA(\"AAAA\")\n s2 = self.RNA(\"AGGG\")\n s3 = self.RNA(\"GGGG\")\n s4 = self.RNA(\"AG--GA-G\")\n s5 = self.RNA(\"CU--CU-C\")\n s6 = self.RNA(\"AC--GC-G\")\n s7 = self.RNA(\"--------\")\n s8 = self.RNA(\"AAAA----\")\n s9 = self.RNA(\"A-GG-A-C\")\n e = self.RNA(\"\")\n\n def test(x, y, z):\n return self.assertFloatEqual(x.frac_diff_non_gaps(y), z)\n\n test(s1, s2, 0.75)\n test(s1, s3, 1)\n test(s2, s3, 0.25)\n test(s1, s4, 0.5)\n test(s4, s5, 1)\n test(s4, s6, 0.4)\n test(s4, s7, 0)\n test(s4, s8, 0.5)\n test(s4, s9, 1 / 3.0)\n test(e, s4, 0)","def compare_fracs(frac1, frac2):\n\treturn frac1[0]*frac2[1] > frac2[0]*frac1[1]","def testnegfrac_vs_frac ( self ):\r\n\t\tr = re.compile ( 'frac' )\r\n\t\tfor fracTup1, fracTup2 in self.knownNegfrac_vs_fracValues:\r\n\t\t\tfrac1 = eval ( r.sub ( 'frac.frac', fracTup1 ) )\r\n\t\t\tfrac2 = eval ( r.sub ( 'frac.frac', fracTup2 ) )\r\n\t\t\tself.assertEqual ( frac1.toString (), frac2.toString () )","def test_prepare_value_string(self):\n field = FractionField()\n result = field.prepare_value(\"1/4\")\n self.assertEqual(\"1/4\", result)\n\n result = field.prepare_value(\"1 1/4\")\n self.assertEqual(\"1 1/4\", result)","def is_fraction(s: Any) -> bool:\n return bool(re.match(r\"^-?\\d+/\\d+$\", s))","def false_simplify(a, b):\n\n # remember the original fraction\n orig_fraction = Fraction(a, b)\n\n # convert a and b into a list of digits. If the same non-zero digit appears in both a and b,\n # remove it from both, and set a flag which indicates that we've \"simplified\" this\n a, b = list(str(a)), list(str(b))\n simplified = False\n for digit in a:\n if digit != '0' and digit in b:\n simplified = True\n a.remove(digit)\n b.remove(digit)\n break\n\n # convert a and b back into integers\n a, b = int(''.join(a)), int(''.join(b))\n\n # if we didn't simplify anything, or if b == 0, return None\n if not (simplified and b):\n return None\n\n # Create a fraction out of the new a and b, and compare it to the old fraction\n # If they are equivalent to each other, return the Fraction to the caller.\n # Otherwise None is returned when the function terminates\n if Fraction(a, b) == orig_fraction:\n return orig_fraction","def test_GreaterThan(self):\n self.assertTrue(Fraction(9,10)>Fraction(7,10))","def testdiv_X_Y ( self ):\r\n\t\tr = re.compile ( 'frac' )\r\n\t\tfor fracTupX, fracTupY, dictAdd, dictSub, dictMul, dictDiv in self.knownArithResultValues:\r\n\t\t\tfracX = eval ( r.sub ( 'frac.frac', fracTupX ) )\r\n\t\t\tfracY = eval ( r.sub ( 'frac.frac', fracTupY ) )\r\n\t\t\tdiv_fracX_fracY = fracX / fracY\r\n\t\t\tself.assertEqual ( div_fracX_fracY.toString ().split ()[0], dictDiv ['X/Y'] )","def test_equivalent():\n # Positive test\n assert u.equivalent(np.arange(10)*q.um, q.cm)\n\n # Negative units test\n assert not u.equivalent(np.arange(10)*q.um, q.Jy)\n\n # Negative dtype test\n assert not u.equivalent(np.arange(10), q.um)","def test_prepare_value_string(self):\n field = DecimalFractionField()\n result = field.prepare_value(\"1/4\")\n self.assertEqual(\"1/4\", result)\n\n result = field.prepare_value(\"1 1/4\")\n self.assertEqual(\"1 1/4\", result)","def test_prepare_value_limit_denominator(self):\n field = FractionField(limit_denominator=3)\n result = field.prepare_value(Decimal(1 / 3.0))\n self.assertEqual(\"1/3\", result)","def compute_fraction(x, y): \r\n if x == 'NaN' or y == 'NaN':\r\n return 0.\r\n if x == 0 or y == 0: \r\n return 0\r\n fraction = x / y\r\n return fraction","def test_generatedecimalfractions(self):\n ret1 = {\"message\": \"No Random.org api key or api version found.\", \"res\": False}\n self.assertDictEqual(random_org.generateDecimalFractions(), ret1)\n\n ret2 = {\"message\": \"Required argument, number is missing.\", \"res\": False}\n self.assertDictEqual(\n random_org.generateDecimalFractions(api_key=\"peW\", api_version=\"1\"), ret2\n )\n\n ret3 = {\n \"message\": \"Number of decimal fractions must be between 1 and 10000\",\n \"res\": False,\n }\n self.assertDictEqual(\n random_org.generateDecimalFractions(\n api_key=\"peW\",\n api_version=\"1\",\n number=\"5\",\n decimalPlaces=\"4\",\n replacement=True,\n ),\n ret3,\n )\n\n ret4 = {\n \"message\": \"Number of decimal places must be between 1 and 20\",\n \"res\": False,\n }\n self.assertDictEqual(\n random_org.generateDecimalFractions(\n api_key=\"peW\",\n api_version=\"1\",\n number=5,\n decimalPlaces=\"4\",\n replacement=True,\n ),\n ret4,\n )\n\n ret5 = {\"message\": \"Parameter 'apiKey' is malformed\", \"res\": False}\n self.assertDictEqual(\n random_org.generateDecimalFractions(\n api_key=\"peW\",\n api_version=\"1\",\n number=5,\n decimalPlaces=4,\n replacement=True,\n ),\n ret5,\n )","def __ge__(self, other):\n self.numerator=self.numerator*other.denominator\n other.numerator=self.denominator*other.numerator\n if(self.numerator>=other.numerator):\n return True\n else:\n return False","def almost_eq(e1,e2) :\n\treturn round(e1-e2,4) == 0.0","def test_prepare_value_limit_denominator(self):\n field = DecimalFractionField(limit_denominator=3)\n result = field.prepare_value(Decimal(1 / 3.0))\n self.assertEqual(\"1/3\", result)","def testfloat ( self ):\r\n\t\tr = re.compile ( 'frac' )\r\n\t\tfor fracTup1, expRes in self.knownFloatValues:\r\n\t\t\tfrac1 = eval ( r.sub ( 'frac.frac', fracTup1 ) ) \r\n\t\t\tself.assertAlmostEqual ( float ( frac1 ), expRes )","def __init__ (self,numerator,denominator=1):\n self.debug = False\n if (self.debug): print(f'enter fraction.__init__ with {numerator}, {denominator}')\n sign = int(numerator * denominator / abs(numerator * denominator))\n if (self.debug): print(f'enter sign is {sign}')\n self.value=(sign * abs(numerator),abs(denominator))\n self.simplify()","def test_not_equal_on_not_equal(self):\n a = Digest(\n hashing_algorithm=self.hashing_algorithm_b,\n digest_value=self.digest_value_b,\n key_format_type=self.key_format_type_b)\n b = Digest()\n c = Digest(\n hashing_algorithm=self.hashing_algorithm_d,\n digest_value=self.digest_value_b,\n key_format_type=self.key_format_type_c)\n d = Digest(\n key_format_type=self.key_format_type_c)\n\n self.assertTrue(a != b)\n self.assertTrue(b != a)\n self.assertTrue(b != c)\n self.assertTrue(b != d)","def test_hist_not_same_length_numerator_denominator(self):\n with self.assertRaises(AssertionError):\n _, _ = hist_ratio(\n numerator=np.ones(2),\n denominator=np.ones(3),\n numerator_unc=np.ones(3),\n denominator_unc=np.ones(3),\n )","def test_eq_2():\n a = FixedPoint(1, 'Q2.8')\n b = FixedPoint(1, 'Q2.8')\n assert a == b","def nexact(cls, lhs, rhs):\n return lhs != rhs","def __sub__ (self,other):\n if (self.debug): print(f'enter fraction.__sub__ with {other}')\n f2 = fraction(-1*other.value[0],other.value[1])\n f3 = self.__add__(f2)\n return f3","def cmpRatio(subInfo1, subInfo2):\n val1 = subInfo1[VALUE]\n val2 = subInfo2[VALUE]\n work1 = subInfo1[WORK]\n work2 = subInfo2[WORK]\n return float(val1) / work1 > float(val2) / work2","def cmpRatio(subInfo1, subInfo2):\n val1 = subInfo1[VALUE]\n val2 = subInfo2[VALUE]\n work1 = subInfo1[WORK]\n work2 = subInfo2[WORK]\n return float(val1) / work1 > float(val2) / work2","def test_eq():\n x, y = fwd.Variable(), fwd.Variable()\n f = fwd.sin(x) + fwd.cos(y)\n g = fwd.sin(x) + fwd.cos(y)\n h = fwd.sin(y) + fwd.cos(x)\n assert f == g\n assert f != h","def test_not_equal_on_equal_and_empty(self):\n a = Digest()\n b = Digest()\n\n self.assertFalse(a != b)\n self.assertFalse(b != a)","def __truediv__ (self,other):\n if (self.debug): print(f'enter fraction.__mul__ with {other}')\n f3 = fraction(self.value[0]*other.value[1],self.value[1]*other.value[0])\n if (self.debug): print(f3, self, other)\n return f3","def values_eq(self, a, b):\r\n return a == b","def test_eq(self):\n st_1 = State(substance=\"water\", T=Q_(400.0, \"K\"), p=Q_(101325.0, \"Pa\"))\n st_2 = State(substance=\"water\", T=Q_(400.0, \"K\"), p=Q_(101325.0, \"Pa\"))\n assert st_1 == st_2","def test_equal_on_not_equal(self):\n a = Digest(\n hashing_algorithm=self.hashing_algorithm_b,\n digest_value=self.digest_value_b,\n key_format_type=self.key_format_type_b)\n b = Digest()\n\n self.assertFalse(a == b)\n self.assertFalse(b == a)","def __eq__(self, other):\n if isinstance(other, float):\n return self.floatvalue == other\n elif isinstance(other, _InfiniteValue):\n return self.negative == other.negative\n else:\n return False","def check_divisibility(a, b):\n \n float_version = float(a)/b\n int_version = a/b\n if float_version == int_version:\n answer = \"divisible\"\n else:\n answer = \"not divisible\"\n return answer","def test_eq():\n # Test for equality special method with scalar Rnode object and float value\n x = Rnode(2.0)\n try:\n assert (x == 2.0) == True\n assert (x == 1.0) == False\n except AssertionError as e:\n print(e)\n raise AssertionError\n\n # Test for equality special method with two scalar Rnode object\n x = Rnode(2.0)\n y = Rnode(2.0)\n z = Rnode(1.0)\n try:\n assert (x == y) == True\n assert (x == z) == False\n except AssertionError as e:\n print(e)\n raise AssertionError","def testdiv_Y_X ( self ):\r\n\t\tr = re.compile ( 'frac' )\r\n\t\tfor fracTupX, fracTupY, dictAdd, dictSub, dictMul, dictDiv in self.knownArithResultValues:\r\n\t\t\tfracX = eval ( r.sub ( 'frac.frac', fracTupX ) )\r\n\t\t\tfracY = eval ( r.sub ( 'frac.frac', fracTupY ) )\r\n\t\t\tdiv_fracY_fracX = fracY / fracX\r\n\t\t\tself.assertEqual ( div_fracY_fracX.toString ().split ()[0], dictDiv ['Y/X'] )","def normalized_fraction(p, q=1):\r\n x, y = p, q\r\n while y:\r\n x, y = y, x % y\r\n if x != 1:\r\n p //= x\r\n q //= x\r\n if q == 1:\r\n return p\r\n return mpq((p, q))","def _same(p1,p2,prec=0.0001):\n #return num.all(num.equal(p1,p2))\n t1 = num.fabs(p1[0]-p2[0]) < prec\n t2 = num.fabs(p1[1]-p2[1]) < prec\n if t1 and t2:\n #print \"same\", p1,p2\n return True","def reciprocal(self):\n return Rational(self.denominator, self.numerator)","def test_divide3(self):\n n = Rational(5, 2)\n d = Rational(5, 2)\n result = n.__div__(d)\n self.assertEqual(result.n, 1)\n self.assertEqual(result.d, 1)"],"string":"[\n \"def test_equal(self):\\n self.assertTrue(Fraction(7,10)==Fraction(7,10))\",\n \"def test_notequal(self):\\n self.assertTrue(Fraction(144,2)!=Fraction(8,4))\",\n \"def test_frac_same(self):\\n s1 = self.RNA(\\\"ACGU\\\")\\n s2 = self.RNA(\\\"AACG\\\")\\n s3 = self.RNA(\\\"GG\\\")\\n s4 = self.RNA(\\\"A\\\")\\n e = self.RNA(\\\"\\\")\\n self.assertEqual(s1.frac_same(e), 0)\\n self.assertEqual(s1.frac_same(s2), 0.25)\\n self.assertEqual(s1.frac_same(s3), 0)\\n self.assertEqual(s1.frac_same(s4), 1.0) # note truncation\",\n \"def __eq__(self, other):\\n equal = self.numerator == other.numerator and self.denominator == other.denominator\\n\\n if equal == False:\\n self.numerator = abs(self.numerator)\\n self.denominator = abs(self.denominator)\\n other.numerator = abs(other.numerator)\\n other.denominator = abs(other.denominator)\\n\\n if self.numerator < other.numerator:\\n smallnum = self.numerator\\n else:\\n smallnum = other.numerator\\n\\n if self.denominator < other.denominator:\\n smallnum2 = self.denominator\\n else:\\n smallnum2 = other.denominator\\n\\n num1 = f\\\"{smallnum}/{smallnum2}\\\"\\n\\n gcd1 = math.gcd(self.numerator, other.numerator)\\n gcd2 = math.gcd(self.denominator, other.denominator)\\n\\n num2 = f\\\"{gcd1}/{gcd2}\\\"\\n\\n return num1 == num2\\n\\n else:\\n return equal\",\n \"def __eq__(self, frac):\\n\\n if isinstance(frac,Fraction):\\n if self.numerator ==0 and self.denominator==0:\\n if frac.numerator ==0 and frac.denominator==0:\\n return True\\n return 0 == frac.numerator/frac.denominator\\n return self.numerator == frac.numerator and self.denominator == frac.denominator and self.inf_size == frac.inf_size\\n elif type(frac) in(float,int):\\n if self.numerator ==0 and self.denominator==0:\\n return 0 == frac\\n return self.numerator/self.denominator == frac\\n else:\\n raise ValueError('Fraction can only be compare to int float or fractions')\",\n \"def test_div(self):\\n newvalues= Fraction(7,10)/Fraction(4,5)\\n fraction1 = Fraction(newvalues[0],newvalues[1])\\n self.assertEqual(str(fraction1),\\\"35/40\\\")\",\n \"def equivalent (self, factor):\\n if (self.debug): print(f'enter fraction.equivalent {factor}')\\n return (self.value[0] * factor, self.value[1]* factor)\",\n \"def test_ne(self):\\n f12: Fraction = Fraction(1, 2)\\n f34: Fraction = Fraction(3, 4)\\n f48: Fraction = Fraction(4, 8)\\n self.assertTrue(f12 != f34)\\n self.assertFalse(f12 != f48)\\n self.assertFalse(f12 != f12)\",\n \"def test_fraction_math_ops(self):\\n fract1 = source.Fraction(5, 3)\\n fract2 = source.Fraction(2, 3)\\n self.assertEqual(fract1 + fract2, source.Fraction(7, 3))\\n self.assertEqual(fract1 + 5, source.Fraction(20, 3))\\n self.assertEqual(3 + fract1, source.Fraction(14, 3))\\n self.assertEqual(fract1 * fract2, source.Fraction(10, 9))\\n self.assertEqual(5 * fract2, source.Fraction(10, 3))\",\n \"def __eq__(self,other):\\n self.numerator=self.numerator*other.denominator\\n other.numerator=self.denominator*other.numerator\\n if(self.numerator==other.numerator):\\n return True\\n else:\\n return False\\n return\",\n \"def test_fraction_rich_comparisson(self):\\n fract1 = source.Fraction(5, 2) # 2.5\\n fract2 = source.Fraction(3, 2) # 1.5\\n fract3 = source.Fraction(25, 10) # 2.5\\n\\n self.assertFalse(fract1 != fract3) # 2.5 != 2.5\\n self.assertTrue(fract1 == fract3) # 2.5 == 2.5\\n self.assertTrue(fract2 < fract3) # 1.5 < 2.5\\n\\n # Let's try the other way\\n self.assertTrue(fract1 >= fract2) # 2.5 >= 1.5\\n self.assertFalse(fract2 >= fract3) # 1.5 >= 2.5\\n\\n # Let's try with other types\\n self.assertTrue(fract1 >= 2) # 2.5 >= 2\\n self.assertTrue(fract2 == 1.5) # 1.5 == 1.5\\n\\n # Let's try the other way with other types\\n self.assertTrue(2 <= fract1) # 2 <= 2.5\\n self.assertTrue(1.5 == fract2) # 1.5 == 1.5\\n\\n self.assertTrue(10 > fract1) # 10 > 2.5\\n self.assertFalse(10 < fract1) # 10 < 2.5\\n self.assertTrue(fract1 < 10) # 2.5 < 10\\n self.assertFalse(fract1 > 10) # 2.5 > 10\",\n \"def test_frac_same_non_gaps(self):\\n s1 = self.RNA(\\\"AAAA\\\")\\n s2 = self.RNA(\\\"AGGG\\\")\\n s3 = self.RNA(\\\"GGGG\\\")\\n s4 = self.RNA(\\\"AG--GA-G\\\")\\n s5 = self.RNA(\\\"CU--CU-C\\\")\\n s6 = self.RNA(\\\"AC--GC-G\\\")\\n s7 = self.RNA(\\\"--------\\\")\\n s8 = self.RNA(\\\"AAAA----\\\")\\n s9 = self.RNA(\\\"A-GG-A-C\\\")\\n e = self.RNA(\\\"\\\")\\n\\n def test(x, y, z):\\n return self.assertFloatEqual(x.frac_same_non_gaps(y), z)\\n\\n test(s1, s2, 0.25)\\n test(s1, s3, 0)\\n test(s2, s3, 0.75)\\n test(s1, s4, 0.5)\\n test(s4, s5, 0)\\n test(s4, s6, 0.6)\\n test(s4, s7, 0)\\n test(s4, s8, 0.5)\\n test(s4, s9, 2 / 3.0)\\n test(e, s4, 0)\",\n \"def test_frac_similar(self):\\n transitions = dict.fromkeys(\\n [\\n (\\\"A\\\", \\\"A\\\"),\\n (\\\"A\\\", \\\"G\\\"),\\n (\\\"G\\\", \\\"A\\\"),\\n (\\\"G\\\", \\\"G\\\"),\\n (\\\"U\\\", \\\"U\\\"),\\n (\\\"U\\\", \\\"C\\\"),\\n (\\\"C\\\", \\\"U\\\"),\\n (\\\"C\\\", \\\"C\\\"),\\n ]\\n )\\n\\n s1 = self.RNA(\\\"UCAGGCAA\\\")\\n s2 = self.RNA(\\\"CCAAAUGC\\\")\\n s3 = self.RNA(\\\"GGGGGGGG\\\")\\n e = self.RNA(\\\"\\\")\\n\\n def test(x, y, z):\\n return self.assertFloatEqual(x.frac_similar(y, transitions), z)\\n\\n test(e, e, 0)\\n test(s1, e, 0)\\n test(s1, s1, 1)\\n test(s1, s2, 7.0 / 8)\\n test(s1, s3, 5.0 / 8)\\n test(s2, s3, 4.0 / 8)\",\n \"def test_mul(self):\\n newvalues = Fraction(3,2)*Fraction(1,4)\\n fraction1 = Fraction(newvalues[0],newvalues[1])\\n self.assertEqual(str(fraction1),\\\"3/8\\\")\",\n \"def test_sub(self):\\n newvalues = Fraction(1,2)-Fraction(1,2)\\n fraction1 = Fraction(newvalues[0],newvalues[1])\\n self.assertEqual(str(fraction1),\\\"0/4\\\")\",\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 test_add(self):\\n newvalues = Fraction(1,2)+Fraction(1,2)\\n fraction1 = Fraction(newvalues[0],newvalues[1])\\n self.assertEqual(str(fraction1),\\\"4/4\\\")\",\n \"def simplify_fraction(a, b):\\n c = gcd(a, b)\\n return a // c, b // c\",\n \"def test_frac_same_gaps(self):\\n s1 = self.RNA(\\\"AAAA\\\")\\n s2 = self.RNA(\\\"GGGG\\\")\\n s3 = self.RNA(\\\"----\\\")\\n s4 = self.RNA(\\\"A-A-\\\")\\n s5 = self.RNA(\\\"-G-G\\\")\\n s6 = self.RNA(\\\"UU--\\\")\\n s7 = self.RNA(\\\"-\\\")\\n s8 = self.RNA(\\\"GGG\\\")\\n e = self.RNA(\\\"\\\")\\n self.assertEqual(s1.frac_same_gaps(s1), 1)\\n self.assertEqual(s1.frac_same_gaps(s2), 1)\\n self.assertEqual(s1.frac_same_gaps(s3), 0)\\n self.assertEqual(s1.frac_same_gaps(s4), 0.5)\\n self.assertEqual(s1.frac_same_gaps(s5), 0.5)\\n self.assertEqual(s1.frac_same_gaps(s6), 0.5)\\n self.assertEqual(s1.frac_same_gaps(s7), 0)\\n self.assertEqual(s1.frac_same_gaps(e), 0)\\n self.assertEqual(s3.frac_same_gaps(s3), 1)\\n self.assertEqual(s3.frac_same_gaps(s4), 0.5)\\n self.assertEqual(s3.frac_same_gaps(s7), 1.0)\\n self.assertEqual(e.frac_same_gaps(e), 0.0)\\n self.assertEqual(s4.frac_same_gaps(s5), 0.0)\\n self.assertEqual(s4.frac_same_gaps(s6), 0.5)\\n self.assertFloatEqual(s6.frac_same_gaps(s8), 2 / 3.0)\",\n \"def test_frac_diff(self):\\n s1 = self.RNA(\\\"ACGU\\\")\\n s2 = self.RNA(\\\"AACG\\\")\\n s3 = self.RNA(\\\"GG\\\")\\n s4 = self.RNA(\\\"A\\\")\\n e = self.RNA(\\\"\\\")\\n self.assertEqual(s1.frac_diff(e), 0)\\n self.assertEqual(s1.frac_diff(s2), 0.75)\\n self.assertEqual(s1.frac_diff(s3), 1)\\n self.assertEqual(s1.frac_diff(s4), 0) # note truncation\",\n \"def __add__ (self, other):\\n if (self.debug): print(f'enter fraction.__add__ with {other}')\\n lcm = find_lcm(self.value[1], other.value[1])\\n if (self.debug): print(f'{int(lcm/self.value[1])} {self.value}')\\n f1 = self.equivalent(int(lcm/self.value[1]))\\n f2 = other.equivalent(int(lcm/other.value[1]))\\n f3 = fraction(f1[0]+f2[0], lcm)\\n if (self.debug): print(f'{f3}, {self}, {other}')\\n return f3\",\n \"def test_ge(self):\\n f12: Fraction = Fraction(1, 2)\\n f34: Fraction = Fraction(3, 4)\\n f93: Fraction = Fraction(9, 3)\\n f124: Fraction = Fraction(12, 4)\\n self.assertTrue(f12 >= f34)\\n self.assertTrue(f93 >= f124)\\n self.assertFalse(f93 >= f12)\",\n \"def test_str(self):\\n f66: Fraction = Fraction(6, 6)\\n f24: Fraction = Fraction(2, 4)\\n self.assertEqual(str(f66), \\\"6/6\\\")\\n self.assertNotEqual(str(f24), \\\"8/6\\\")\\n self.assertTrue(str(f24), \\\"2/4\\\")\",\n \"def __eq__(self, other):\\n if isinstance(other, RationalFrac):\\n return (self.numer == other.numer and\\n self.denom == other.denom and\\n self.neg == other.neg)\\n elif isinstance(other, (int, float, str)):\\n return self.__eq__(RationalFrac(other))\\n else:\\n return NotImplemented\",\n \"def __eq__(self, other):\\n try: \\n same_num = (self._num == other._num)\\n same_den = (self._den == other._den)\\n return same_num and same_den\\n except AttributeError:\\n return (self == Rational.parse_number(other))\",\n \"def __init__(self, numerator, denominator=1):\\n common_div = gcd(numerator, denominator)\\n if common_div == 0:\\n common_div = 1\\n self.numerator = int((numerator / common_div) / copysign(1, denominator))\\n self.denominator = int((denominator / common_div) / copysign(1, denominator))\\n if self.denominator != 0:\\n self.equal = self.numerator / self.denominator\\n elif self.denominator == 0:\\n self.equal = \\\"UNDEFINED.\\\"\",\n \"def test_GreaterThanorEqualto(self):\\n self.assertTrue(Fraction(7,10)>=Fraction(7,10))\",\n \"def __eq__(self, other):\\n if self is other:\\n return True\\n elif not isinstance(other, Rational):\\n return False\\n else:\\n return self._numerator == other.numerator() and \\\\\\n self._denominator == other.denominator()\",\n \"def test_simplify(self):\\n self.assertEqual(Fraction(9, 12).simplify(), Fraction(3, 4))\\n self.assertEqual(Fraction(1, 2).simplify(), Fraction(1, 2))\\n self.assertEqual(str(Fraction(1, 2).simplify()), str(Fraction(1, 2)))\",\n \"def almost_equals(self, other, decimal=...): # -> bool:\\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 __ne__(self, other):\\n self.numerator=self.numerator*other.denominator\\n other.numerator=self.denominator*other.numerator\\n if(self.numerator!=other.numerator):\\n return True\\n else:\\n return False\",\n \"def test_3_operands(self):\\n f12: Fraction = Fraction(1, 2)\\n f34: Fraction = Fraction(3, 4)\\n f44: Fraction = Fraction(4, 4)\\n f84: Fraction = Fraction(8, 4)\\n f48: Fraction = Fraction(4, 8)\\n f816: Fraction = Fraction(8, 16)\\n self.assertTrue(f12 + f34 + f44 == Fraction(72, 32))\\n self.assertTrue(f12 - f34 - f44 == Fraction(-5,4))\\n self.assertTrue(f12 * f34 * f44 == Fraction(3, 8))\\n self.assertTrue(f12 / f34 / f44 == Fraction(4, 6))\\n self.assertTrue(f12 == f48 == f816)\\n self.assertFalse(f12 == f816 == f34)\\n self.assertTrue(f12 != f34 != f44)\\n self.assertFalse(f12 != f48 != f816)\\n self.assertTrue(f12 < f34 < f44)\\n self.assertFalse(f84 < f44 < f12)\\n self.assertTrue(f12 <= f12 <= f48)\\n self.assertFalse(f84 <= f44 < f12)\\n self.assertTrue(f44 > f34 > f12)\\n self.assertFalse(f12 > f44 > f84)\\n self.assertTrue(f12 >= f48 >= f816)\\n self.assertFalse(f12 >= f44 >= f816)\",\n \"def __eq__( self, value ):\\r\\n\\t\\tif ( type( self ) == type( value ) ):\\r\\n\\t\\t\\tselfval, valueval = self.numerator / self.denominator, value.numerator / value.denominator\\r\\n\\t\\t\\tif ( types.ComplexType in ( type( selfval ), type( valueval ) ) ):\\r\\n\\t\\t\\t\\tif not ( types.ComplexType == type( selfval ) == type( valueval ) ):\\r\\n\\t\\t\\t\\t\\treturn False\\r\\n\\t\\t\\t\\treturn ( round( selfval.real, FRACTION_FLOAT_ACCURACY ) == round( valueval.real, FRACTION_FLOAT_ACCURACY ) ) and \\\\\\r\\n\\t\\t\\t\\t\\t ( round( selfval.imag, FRACTION_FLOAT_ACCURACY ) == round( valueval.imag, FRACTION_FLOAT_ACCURACY ) )\\r\\n\\t\\t\\treturn round( self.numerator / self.denominator, FRACTION_FLOAT_ACCURACY ) == round( value.numerator / value.denominator, FRACTION_FLOAT_ACCURACY )\\r\\n\\r\\n\\t\\telif ( type( value ) in ( types.IntType, types.LongType ) ):\\r\\n\\t\\t\\treturn long( self ) == value\\r\\n\\r\\n\\t\\telif ( type( value ) == types.FloatType ):\\r\\n\\t\\t\\t return round( float( self ), FRACTION_FLOAT_ACCURACY ) == round( value, FRACTION_FLOAT_ACCURACY )\\r\\n\\t\\t\\t\\r\\n\\t\\telif ( type( value ) == types.ComplexType ):\\r\\n\\t\\t\\tselfval = self.numerator / self.denominator\\r\\n\\t\\t\\tif not ( type( selfval ) == types.ComplexType ):\\r\\n\\t\\t\\t\\t\\treturn False\\r\\n\\t\\t\\treturn ( round( selfval.real, FRACTION_FLOAT_ACCURACY ) == round( value.real, FRACTION_FLOAT_ACCURACY ) ) and \\\\\\r\\n\\t\\t\\t\\t ( round( selfval.imag, FRACTION_FLOAT_ACCURACY ) == round( value.imag, FRACTION_FLOAT_ACCURACY ) )\\r\\n\\r\\n\\t\\t\\treturn ( self.numerator / self.denominator ) == value\\r\\n\\r\\n\\t\\telse:\\r\\n\\t\\t\\treturn NotImplemented\",\n \"def nearly_equal(a, b, sig_fig=5):\\n return a == b or int(a*10**sig_fig) == int(b*10**sig_fig)\",\n \"def rational_frac_tests():\\n print('\\\\n==========================================')\\n print('rfrac.py @ rational_frac_tests: //////////\\\\n')\\n print(RationalFrac(-1), RationalFrac(0))\\n # __prime_factors()\\n frac0 = RationalFrac(4.5)\\n frac1 = RationalFrac(-0.125)\\n frac2 = RationalFrac(0.99999)\\n f = [frac0, frac1, frac2]\\n print('float(-0.125) =', float(f[1]))\\n print('float(0.99999) =', float(f[2]))\\n print('9/2 + -1/8 =', f[0] + f[1])\\n print('9/2 * -1/8 =', f[0] * f[1])\\n print('-1/8 * 9/2 =', f[1] * f[0])\\n print(f)\\n print('frac(-0/1) + frac(-0/1) =',\\n RationalFrac(-0) + RationalFrac(-0))\\n f3 = RationalFrac('-7/29')\\n print(f3)\\n print(RationalFrac(25, 1000))\\n print('\\\\nrfrac.py @ end of rational_frac_tests ////')\\n print('==========================================\\\\n')\",\n \"def test_gt(self):\\n f12: Fraction = Fraction(1, 2)\\n f34: Fraction = Fraction(3, 4)\\n f105: Fraction = Fraction(10, 5)\\n self.assertTrue(f34 > f12)\\n self.assertFalse(f12 > f105)\\n self.assertFalse(f12 > f12)\",\n \"def __eq__(self, other):\\n firstnum = self.num*other.den\\n secondnum = self.den*other.num\\n\\n return firstnum == secondnum\",\n \"def test_equal_on_equal(self):\\n a = Digest(\\n hashing_algorithm=self.hashing_algorithm_b,\\n digest_value=self.digest_value_b,\\n key_format_type=self.key_format_type_b)\\n b = Digest(\\n hashing_algorithm=self.hashing_algorithm_b,\\n digest_value=self.digest_value_b,\\n key_format_type=self.key_format_type_b)\\n\\n self.assertTrue(a == b)\\n self.assertTrue(b == a)\",\n \"def test_lt(self):\\n f12: Fraction = Fraction(1, 2)\\n f34: Fraction = Fraction(3, 4)\\n f44: Fraction = Fraction(4, 4)\\n self.assertTrue(f12 < f34)\\n self.assertFalse(f44 < f12)\",\n \"def test_fraction_item_access(self):\\n f1 = source.Fraction(7, 2)\\n self.assertEqual(len(f1), 2)\\n self.assertEqual(f1['num'], 7)\\n self.assertEqual(f1[1], 2)\\n f1[0] = 5\\n f1['den'] = 3\\n self.assertEqual(str(f1), \\\"5/3\\\")\",\n \"def fractions():\\n\\n pi = 22 / 7\\n print(\\\"22/7\\\\n====\\\")\\n print_as_text(pi)\\n\\n pi = 333 / 106\\n print(\\\"333/106\\\\n=======\\\")\\n print_as_text(pi)\\n\\n pi = 355 / 113\\n print(\\\"355/113\\\\n=======\\\")\\n print_as_text(pi)\\n\\n pi = 52163 / 16604\\n print(\\\"52163/16604\\\\n===========\\\")\\n print_as_text(pi)\\n\\n pi = 103993 / 33102\\n print(\\\"103993/33102\\\\n============\\\")\\n print_as_text(pi)\\n\\n pi = 245850922 / 78256779\\n print(\\\"245850922/78256779\\\\n==================\\\")\\n print_as_text(pi)\",\n \"def test_init(self):\\n \\n fraction1 = Fraction(1,2)\\n self.assertEqual(fraction1.numerator, 1)\\n self.assertEqual(fraction1.denominator, 2)\",\n \"def test_equality(self):\\n\\n s3 = space(curvature=1/5)\\n for k in (0, -1, 1, 1.75, 0.325, 1/7, -1.75, -0.325, -1/7):\\n s1 = space(fake_curvature=k)\\n s2 = space(fake_curvature=k)\\n self.assertTrue(s1 == s2)\\n self.assertTrue(hash(s1) == hash(s2))\\n self.assertTrue(str(s1) == str(s2))\\n self.assertTrue(repr(s1) == repr(s2))\\n self.assertTrue(s1 != s3)\",\n \"def fraction_to_proper_fraction(rational):\\n assert isinstance(rational, Fraction), repr(rational)\\n quotient = int(rational)\\n residue = rational - quotient\\n return quotient, residue\",\n \"def test_mixing_ratio():\\n p = 998. * units.mbar\\n e = 73.75 * units.mbar\\n assert_almost_equal(mixing_ratio(e, p), 0.04963, 2)\",\n \"def testcomparefrac ( self ):\\r\\n\\t\\tfor fracTup1, fracTup2, result in self.knownCmpValues:\\r\\n\\t\\t\\tfrac1 = eval ( 'frac.'+fracTup1 )\\r\\n\\t\\t\\tfrac2 = eval ( 'frac.'+fracTup2 )\\r\\n\\t\\t\\tif result != None:\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\tself.assertEqual ( frac1.compare ( frac2 )[0], result )\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\tself.assertEqual ( frac1.compare ( frac2 ), result )\",\n \"def __eq__(self,f2):\\n return self.__num * f2.den == self.__den * f2.num\",\n \"def testEquality(self):\\n pass\",\n \"def value_is_equal(left, right):\\n if type(left) is float and type(right) is float:\\n if left == right:\\n equal = True\\n elif left == 0.0 or right == 0.0:\\n # exactly one of the values is 0\\n equal = False\\n else: # (none of the values is 0)\\n db_epsilon = 1.0e-10\\n left_exp = 10.0 ** int(math.log10(abs(left)))\\n right_exp = 10.0 ** int(math.log10(abs(right)))\\n if left_exp != right_exp:\\n equal = False\\n else:\\n diff = abs(left / left_exp - right / right_exp)\\n equal = diff < db_epsilon\\n else:\\n equal = left == right\\n return equal\",\n \"def simplify (self):\\n if (self.debug): print(f'enter fraction.simplify')\\n hcf = find_hcf(self.value[0], self.value[1])\\n self.value = (self.value[0] // hcf.product(), self.value[1] // hcf.product())\\n return\",\n \"def test_LessThanorEqualto(self):\\n self.assertTrue(Fraction(-7,10)<=Fraction(-7,10))\",\n \"def test_le(self):\\n f12: Fraction = Fraction(1, 2)\\n f34: Fraction = Fraction(3, 4)\\n f48: Fraction = Fraction(4, 8)\\n f66: Fraction = Fraction(6, 6)\\n self.assertTrue(f12 <= f34)\\n self.assertTrue(f12 <= f48)\\n self.assertFalse(f66 <= f12)\",\n \"def test_equal_on_equal_and_empty(self):\\n a = Digest()\\n b = Digest()\\n\\n self.assertTrue(a == b)\\n self.assertTrue(b == a)\",\n \"def getfloat(self, fraction) -> float:\\n self.numerator_a = fraction.numerator_a\\n self.denominator_b = fraction.denominator_b\\n self.fraction = str(self.numerator_a) + '/' + str(self.denominator_b)\\n return super().__float__()\",\n \"def fraction_gcd(x, y):\\n a = x.numerator\\n b = x.denominator\\n c = y.numerator\\n d = y.denominator\\n return Fraction(gcd(a, c), lcm(b, d))\",\n \"def test_frac_diffGaps(self):\\n s1 = self.RNA(\\\"AAAA\\\")\\n s2 = self.RNA(\\\"GGGG\\\")\\n s3 = self.RNA(\\\"----\\\")\\n s4 = self.RNA(\\\"A-A-\\\")\\n s5 = self.RNA(\\\"-G-G\\\")\\n s6 = self.RNA(\\\"UU--\\\")\\n s7 = self.RNA(\\\"-\\\")\\n s8 = self.RNA(\\\"GGG\\\")\\n e = self.RNA(\\\"\\\")\\n self.assertEqual(s1.frac_diff_gaps(s1), 0)\\n self.assertEqual(s1.frac_diff_gaps(s2), 0)\\n self.assertEqual(s1.frac_diff_gaps(s3), 1)\\n self.assertEqual(s1.frac_diff_gaps(s4), 0.5)\\n self.assertEqual(s1.frac_diff_gaps(s5), 0.5)\\n self.assertEqual(s1.frac_diff_gaps(s6), 0.5)\\n self.assertEqual(s1.frac_diff_gaps(s7), 1)\\n self.assertEqual(s1.frac_diff_gaps(e), 0)\\n self.assertEqual(s3.frac_diff_gaps(s3), 0)\\n self.assertEqual(s3.frac_diff_gaps(s4), 0.5)\\n self.assertEqual(s3.frac_diff_gaps(s7), 0.0)\\n self.assertEqual(e.frac_diff_gaps(e), 0.0)\\n self.assertEqual(s4.frac_diff_gaps(s5), 1.0)\\n self.assertEqual(s4.frac_diff_gaps(s6), 0.5)\\n self.assertFloatEqual(s6.frac_diff_gaps(s8), 1 / 3.0)\",\n \"def equivalent_to_float(self, other):\\n sfother = type(self)(other, self.sigfigs)\\n return str(self) == str(sfother)\",\n \"def test_init(self):\\n f: Fraction = Fraction(3, 4)\\n self.assertEqual(f.num, 3)\\n self.assertEqual(f.denom, 4)\",\n \"def test_not_equal_on_equal(self):\\n a = Digest(\\n hashing_algorithm=self.hashing_algorithm_b,\\n digest_value=self.digest_value_b,\\n key_format_type=self.key_format_type_b)\\n b = Digest(\\n hashing_algorithm=self.hashing_algorithm_b,\\n digest_value=self.digest_value_b,\\n key_format_type=self.key_format_type_b)\\n\\n self.assertFalse(a != b)\\n self.assertFalse(b != a)\",\n \"def div(a, b):\\r\\n if type(b) in inttypes_set:\\r\\n if not b:\\r\\n return Infinity(a)\\r\\n raise ZeroDivisionError('%r / %r' % (a, b))\\r\\n if b == 1:\\r\\n return a\\r\\n if type(a) in inttypes_set:\\r\\n return normalized_fraction(a, b)\\r\\n return a / b\",\n \"def test_frac_diffNonGaps(self):\\n s1 = self.RNA(\\\"AAAA\\\")\\n s2 = self.RNA(\\\"AGGG\\\")\\n s3 = self.RNA(\\\"GGGG\\\")\\n s4 = self.RNA(\\\"AG--GA-G\\\")\\n s5 = self.RNA(\\\"CU--CU-C\\\")\\n s6 = self.RNA(\\\"AC--GC-G\\\")\\n s7 = self.RNA(\\\"--------\\\")\\n s8 = self.RNA(\\\"AAAA----\\\")\\n s9 = self.RNA(\\\"A-GG-A-C\\\")\\n e = self.RNA(\\\"\\\")\\n\\n def test(x, y, z):\\n return self.assertFloatEqual(x.frac_diff_non_gaps(y), z)\\n\\n test(s1, s2, 0.75)\\n test(s1, s3, 1)\\n test(s2, s3, 0.25)\\n test(s1, s4, 0.5)\\n test(s4, s5, 1)\\n test(s4, s6, 0.4)\\n test(s4, s7, 0)\\n test(s4, s8, 0.5)\\n test(s4, s9, 1 / 3.0)\\n test(e, s4, 0)\",\n \"def compare_fracs(frac1, frac2):\\n\\treturn frac1[0]*frac2[1] > frac2[0]*frac1[1]\",\n \"def testnegfrac_vs_frac ( self ):\\r\\n\\t\\tr = re.compile ( 'frac' )\\r\\n\\t\\tfor fracTup1, fracTup2 in self.knownNegfrac_vs_fracValues:\\r\\n\\t\\t\\tfrac1 = eval ( r.sub ( 'frac.frac', fracTup1 ) )\\r\\n\\t\\t\\tfrac2 = eval ( r.sub ( 'frac.frac', fracTup2 ) )\\r\\n\\t\\t\\tself.assertEqual ( frac1.toString (), frac2.toString () )\",\n \"def test_prepare_value_string(self):\\n field = FractionField()\\n result = field.prepare_value(\\\"1/4\\\")\\n self.assertEqual(\\\"1/4\\\", result)\\n\\n result = field.prepare_value(\\\"1 1/4\\\")\\n self.assertEqual(\\\"1 1/4\\\", result)\",\n \"def is_fraction(s: Any) -> bool:\\n return bool(re.match(r\\\"^-?\\\\d+/\\\\d+$\\\", s))\",\n \"def false_simplify(a, b):\\n\\n # remember the original fraction\\n orig_fraction = Fraction(a, b)\\n\\n # convert a and b into a list of digits. If the same non-zero digit appears in both a and b,\\n # remove it from both, and set a flag which indicates that we've \\\"simplified\\\" this\\n a, b = list(str(a)), list(str(b))\\n simplified = False\\n for digit in a:\\n if digit != '0' and digit in b:\\n simplified = True\\n a.remove(digit)\\n b.remove(digit)\\n break\\n\\n # convert a and b back into integers\\n a, b = int(''.join(a)), int(''.join(b))\\n\\n # if we didn't simplify anything, or if b == 0, return None\\n if not (simplified and b):\\n return None\\n\\n # Create a fraction out of the new a and b, and compare it to the old fraction\\n # If they are equivalent to each other, return the Fraction to the caller.\\n # Otherwise None is returned when the function terminates\\n if Fraction(a, b) == orig_fraction:\\n return orig_fraction\",\n \"def test_GreaterThan(self):\\n self.assertTrue(Fraction(9,10)>Fraction(7,10))\",\n \"def testdiv_X_Y ( self ):\\r\\n\\t\\tr = re.compile ( 'frac' )\\r\\n\\t\\tfor fracTupX, fracTupY, dictAdd, dictSub, dictMul, dictDiv in self.knownArithResultValues:\\r\\n\\t\\t\\tfracX = eval ( r.sub ( 'frac.frac', fracTupX ) )\\r\\n\\t\\t\\tfracY = eval ( r.sub ( 'frac.frac', fracTupY ) )\\r\\n\\t\\t\\tdiv_fracX_fracY = fracX / fracY\\r\\n\\t\\t\\tself.assertEqual ( div_fracX_fracY.toString ().split ()[0], dictDiv ['X/Y'] )\",\n \"def test_equivalent():\\n # Positive test\\n assert u.equivalent(np.arange(10)*q.um, q.cm)\\n\\n # Negative units test\\n assert not u.equivalent(np.arange(10)*q.um, q.Jy)\\n\\n # Negative dtype test\\n assert not u.equivalent(np.arange(10), q.um)\",\n \"def test_prepare_value_string(self):\\n field = DecimalFractionField()\\n result = field.prepare_value(\\\"1/4\\\")\\n self.assertEqual(\\\"1/4\\\", result)\\n\\n result = field.prepare_value(\\\"1 1/4\\\")\\n self.assertEqual(\\\"1 1/4\\\", result)\",\n \"def test_prepare_value_limit_denominator(self):\\n field = FractionField(limit_denominator=3)\\n result = field.prepare_value(Decimal(1 / 3.0))\\n self.assertEqual(\\\"1/3\\\", result)\",\n \"def compute_fraction(x, y): \\r\\n if x == 'NaN' or y == 'NaN':\\r\\n return 0.\\r\\n if x == 0 or y == 0: \\r\\n return 0\\r\\n fraction = x / y\\r\\n return fraction\",\n \"def test_generatedecimalfractions(self):\\n ret1 = {\\\"message\\\": \\\"No Random.org api key or api version found.\\\", \\\"res\\\": False}\\n self.assertDictEqual(random_org.generateDecimalFractions(), ret1)\\n\\n ret2 = {\\\"message\\\": \\\"Required argument, number is missing.\\\", \\\"res\\\": False}\\n self.assertDictEqual(\\n random_org.generateDecimalFractions(api_key=\\\"peW\\\", api_version=\\\"1\\\"), ret2\\n )\\n\\n ret3 = {\\n \\\"message\\\": \\\"Number of decimal fractions must be between 1 and 10000\\\",\\n \\\"res\\\": False,\\n }\\n self.assertDictEqual(\\n random_org.generateDecimalFractions(\\n api_key=\\\"peW\\\",\\n api_version=\\\"1\\\",\\n number=\\\"5\\\",\\n decimalPlaces=\\\"4\\\",\\n replacement=True,\\n ),\\n ret3,\\n )\\n\\n ret4 = {\\n \\\"message\\\": \\\"Number of decimal places must be between 1 and 20\\\",\\n \\\"res\\\": False,\\n }\\n self.assertDictEqual(\\n random_org.generateDecimalFractions(\\n api_key=\\\"peW\\\",\\n api_version=\\\"1\\\",\\n number=5,\\n decimalPlaces=\\\"4\\\",\\n replacement=True,\\n ),\\n ret4,\\n )\\n\\n ret5 = {\\\"message\\\": \\\"Parameter 'apiKey' is malformed\\\", \\\"res\\\": False}\\n self.assertDictEqual(\\n random_org.generateDecimalFractions(\\n api_key=\\\"peW\\\",\\n api_version=\\\"1\\\",\\n number=5,\\n decimalPlaces=4,\\n replacement=True,\\n ),\\n ret5,\\n )\",\n \"def __ge__(self, other):\\n self.numerator=self.numerator*other.denominator\\n other.numerator=self.denominator*other.numerator\\n if(self.numerator>=other.numerator):\\n return True\\n else:\\n return False\",\n \"def almost_eq(e1,e2) :\\n\\treturn round(e1-e2,4) == 0.0\",\n \"def test_prepare_value_limit_denominator(self):\\n field = DecimalFractionField(limit_denominator=3)\\n result = field.prepare_value(Decimal(1 / 3.0))\\n self.assertEqual(\\\"1/3\\\", result)\",\n \"def testfloat ( self ):\\r\\n\\t\\tr = re.compile ( 'frac' )\\r\\n\\t\\tfor fracTup1, expRes in self.knownFloatValues:\\r\\n\\t\\t\\tfrac1 = eval ( r.sub ( 'frac.frac', fracTup1 ) ) \\r\\n\\t\\t\\tself.assertAlmostEqual ( float ( frac1 ), expRes )\",\n \"def __init__ (self,numerator,denominator=1):\\n self.debug = False\\n if (self.debug): print(f'enter fraction.__init__ with {numerator}, {denominator}')\\n sign = int(numerator * denominator / abs(numerator * denominator))\\n if (self.debug): print(f'enter sign is {sign}')\\n self.value=(sign * abs(numerator),abs(denominator))\\n self.simplify()\",\n \"def test_not_equal_on_not_equal(self):\\n a = Digest(\\n hashing_algorithm=self.hashing_algorithm_b,\\n digest_value=self.digest_value_b,\\n key_format_type=self.key_format_type_b)\\n b = Digest()\\n c = Digest(\\n hashing_algorithm=self.hashing_algorithm_d,\\n digest_value=self.digest_value_b,\\n key_format_type=self.key_format_type_c)\\n d = Digest(\\n key_format_type=self.key_format_type_c)\\n\\n self.assertTrue(a != b)\\n self.assertTrue(b != a)\\n self.assertTrue(b != c)\\n self.assertTrue(b != d)\",\n \"def test_hist_not_same_length_numerator_denominator(self):\\n with self.assertRaises(AssertionError):\\n _, _ = hist_ratio(\\n numerator=np.ones(2),\\n denominator=np.ones(3),\\n numerator_unc=np.ones(3),\\n denominator_unc=np.ones(3),\\n )\",\n \"def test_eq_2():\\n a = FixedPoint(1, 'Q2.8')\\n b = FixedPoint(1, 'Q2.8')\\n assert a == b\",\n \"def nexact(cls, lhs, rhs):\\n return lhs != rhs\",\n \"def __sub__ (self,other):\\n if (self.debug): print(f'enter fraction.__sub__ with {other}')\\n f2 = fraction(-1*other.value[0],other.value[1])\\n f3 = self.__add__(f2)\\n return f3\",\n \"def cmpRatio(subInfo1, subInfo2):\\n val1 = subInfo1[VALUE]\\n val2 = subInfo2[VALUE]\\n work1 = subInfo1[WORK]\\n work2 = subInfo2[WORK]\\n return float(val1) / work1 > float(val2) / work2\",\n \"def cmpRatio(subInfo1, subInfo2):\\n val1 = subInfo1[VALUE]\\n val2 = subInfo2[VALUE]\\n work1 = subInfo1[WORK]\\n work2 = subInfo2[WORK]\\n return float(val1) / work1 > float(val2) / work2\",\n \"def test_eq():\\n x, y = fwd.Variable(), fwd.Variable()\\n f = fwd.sin(x) + fwd.cos(y)\\n g = fwd.sin(x) + fwd.cos(y)\\n h = fwd.sin(y) + fwd.cos(x)\\n assert f == g\\n assert f != h\",\n \"def test_not_equal_on_equal_and_empty(self):\\n a = Digest()\\n b = Digest()\\n\\n self.assertFalse(a != b)\\n self.assertFalse(b != a)\",\n \"def __truediv__ (self,other):\\n if (self.debug): print(f'enter fraction.__mul__ with {other}')\\n f3 = fraction(self.value[0]*other.value[1],self.value[1]*other.value[0])\\n if (self.debug): print(f3, self, other)\\n return f3\",\n \"def values_eq(self, a, b):\\r\\n return a == b\",\n \"def test_eq(self):\\n st_1 = State(substance=\\\"water\\\", T=Q_(400.0, \\\"K\\\"), p=Q_(101325.0, \\\"Pa\\\"))\\n st_2 = State(substance=\\\"water\\\", T=Q_(400.0, \\\"K\\\"), p=Q_(101325.0, \\\"Pa\\\"))\\n assert st_1 == st_2\",\n \"def test_equal_on_not_equal(self):\\n a = Digest(\\n hashing_algorithm=self.hashing_algorithm_b,\\n digest_value=self.digest_value_b,\\n key_format_type=self.key_format_type_b)\\n b = Digest()\\n\\n self.assertFalse(a == b)\\n self.assertFalse(b == a)\",\n \"def __eq__(self, other):\\n if isinstance(other, float):\\n return self.floatvalue == other\\n elif isinstance(other, _InfiniteValue):\\n return self.negative == other.negative\\n else:\\n return False\",\n \"def check_divisibility(a, b):\\n \\n float_version = float(a)/b\\n int_version = a/b\\n if float_version == int_version:\\n answer = \\\"divisible\\\"\\n else:\\n answer = \\\"not divisible\\\"\\n return answer\",\n \"def test_eq():\\n # Test for equality special method with scalar Rnode object and float value\\n x = Rnode(2.0)\\n try:\\n assert (x == 2.0) == True\\n assert (x == 1.0) == False\\n except AssertionError as e:\\n print(e)\\n raise AssertionError\\n\\n # Test for equality special method with two scalar Rnode object\\n x = Rnode(2.0)\\n y = Rnode(2.0)\\n z = Rnode(1.0)\\n try:\\n assert (x == y) == True\\n assert (x == z) == False\\n except AssertionError as e:\\n print(e)\\n raise AssertionError\",\n \"def testdiv_Y_X ( self ):\\r\\n\\t\\tr = re.compile ( 'frac' )\\r\\n\\t\\tfor fracTupX, fracTupY, dictAdd, dictSub, dictMul, dictDiv in self.knownArithResultValues:\\r\\n\\t\\t\\tfracX = eval ( r.sub ( 'frac.frac', fracTupX ) )\\r\\n\\t\\t\\tfracY = eval ( r.sub ( 'frac.frac', fracTupY ) )\\r\\n\\t\\t\\tdiv_fracY_fracX = fracY / fracX\\r\\n\\t\\t\\tself.assertEqual ( div_fracY_fracX.toString ().split ()[0], dictDiv ['Y/X'] )\",\n \"def normalized_fraction(p, q=1):\\r\\n x, y = p, q\\r\\n while y:\\r\\n x, y = y, x % y\\r\\n if x != 1:\\r\\n p //= x\\r\\n q //= x\\r\\n if q == 1:\\r\\n return p\\r\\n return mpq((p, q))\",\n \"def _same(p1,p2,prec=0.0001):\\n #return num.all(num.equal(p1,p2))\\n t1 = num.fabs(p1[0]-p2[0]) < prec\\n t2 = num.fabs(p1[1]-p2[1]) < prec\\n if t1 and t2:\\n #print \\\"same\\\", p1,p2\\n return True\",\n \"def reciprocal(self):\\n return Rational(self.denominator, self.numerator)\",\n \"def test_divide3(self):\\n n = Rational(5, 2)\\n d = Rational(5, 2)\\n result = n.__div__(d)\\n self.assertEqual(result.n, 1)\\n self.assertEqual(result.d, 1)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8099188","0.7660002","0.74295694","0.72934115","0.7253576","0.7143537","0.6919099","0.6876407","0.6799766","0.67680925","0.6742922","0.67288","0.6660526","0.6650963","0.66349375","0.6611294","0.6571344","0.64932424","0.64467835","0.64218277","0.64188033","0.64181554","0.6368539","0.634839","0.63404876","0.6322666","0.6318647","0.62409943","0.62083983","0.6198244","0.6180926","0.61740804","0.6137659","0.6111801","0.6006392","0.59839183","0.5964794","0.5958019","0.59439725","0.5941652","0.5935442","0.59208935","0.58518845","0.5827041","0.58014095","0.5800003","0.5786386","0.5786165","0.57683283","0.5753251","0.57524747","0.57451046","0.5722069","0.5718063","0.5704789","0.5693685","0.56519777","0.5643333","0.5640672","0.5640628","0.5635573","0.5619351","0.5615116","0.56055486","0.5603948","0.55926794","0.5591993","0.5590749","0.5582411","0.5577283","0.55742216","0.5569115","0.55612427","0.5556468","0.5552555","0.554848","0.5542935","0.5541693","0.55374044","0.5532009","0.5497827","0.5486517","0.5483699","0.5480903","0.54758114","0.54758114","0.5469255","0.54675645","0.546233","0.5460577","0.54525876","0.5442342","0.543943","0.54347485","0.5432843","0.54244435","0.5417001","0.5414351","0.5414017","0.54042184"],"string":"[\n \"0.8099188\",\n \"0.7660002\",\n \"0.74295694\",\n \"0.72934115\",\n \"0.7253576\",\n \"0.7143537\",\n \"0.6919099\",\n \"0.6876407\",\n \"0.6799766\",\n \"0.67680925\",\n \"0.6742922\",\n \"0.67288\",\n \"0.6660526\",\n \"0.6650963\",\n \"0.66349375\",\n \"0.6611294\",\n \"0.6571344\",\n \"0.64932424\",\n \"0.64467835\",\n \"0.64218277\",\n \"0.64188033\",\n \"0.64181554\",\n \"0.6368539\",\n \"0.634839\",\n \"0.63404876\",\n \"0.6322666\",\n \"0.6318647\",\n \"0.62409943\",\n \"0.62083983\",\n \"0.6198244\",\n \"0.6180926\",\n \"0.61740804\",\n \"0.6137659\",\n \"0.6111801\",\n \"0.6006392\",\n \"0.59839183\",\n \"0.5964794\",\n \"0.5958019\",\n \"0.59439725\",\n \"0.5941652\",\n \"0.5935442\",\n \"0.59208935\",\n \"0.58518845\",\n \"0.5827041\",\n \"0.58014095\",\n \"0.5800003\",\n \"0.5786386\",\n \"0.5786165\",\n \"0.57683283\",\n \"0.5753251\",\n \"0.57524747\",\n \"0.57451046\",\n \"0.5722069\",\n \"0.5718063\",\n \"0.5704789\",\n \"0.5693685\",\n \"0.56519777\",\n \"0.5643333\",\n \"0.5640672\",\n \"0.5640628\",\n \"0.5635573\",\n \"0.5619351\",\n \"0.5615116\",\n \"0.56055486\",\n \"0.5603948\",\n \"0.55926794\",\n \"0.5591993\",\n \"0.5590749\",\n \"0.5582411\",\n \"0.5577283\",\n \"0.55742216\",\n \"0.5569115\",\n \"0.55612427\",\n \"0.5556468\",\n \"0.5552555\",\n \"0.554848\",\n \"0.5542935\",\n \"0.5541693\",\n \"0.55374044\",\n \"0.5532009\",\n \"0.5497827\",\n \"0.5486517\",\n \"0.5483699\",\n \"0.5480903\",\n \"0.54758114\",\n \"0.54758114\",\n \"0.5469255\",\n \"0.54675645\",\n \"0.546233\",\n \"0.5460577\",\n \"0.54525876\",\n \"0.5442342\",\n \"0.543943\",\n \"0.54347485\",\n \"0.5432843\",\n \"0.54244435\",\n \"0.5417001\",\n \"0.5414351\",\n \"0.5414017\",\n \"0.54042184\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7083102"},"document_rank":{"kind":"string","value":"6"}}},{"rowIdx":23098,"cells":{"query":{"kind":"string","value":"Enables some of the global JAX flags for debugging."},"document":{"kind":"string","value":"def enable_jax_debugging_flags():\n\n # Enable the NaN-checker behavior to cause JAX to hard-break on the first\n # occurrence of a NaN.\n jax.config.update('jax_debug_nans', True)\n\n # Enable the compilation logger to check whether or not we're accidentally\n # causing a lot of re-compilation (inspect logs for excessive jitting).\n jax.config.update('jax_log_compiles', True)\n\n # Detect numpy-style automatic rank promotion and force strict, explicit\n # casts. We can use `raise` instead of warn to raise an error.\n jax.config.update('jax_numpy_rank_promotion', 'warn')\n\n # Print global JAX flags in logs.\n logging.info('Global JAX flags: %s', jax.config.values)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def set_debug(flag):\n global debug\n debug = flag\n XLM.XLM_Object.debug = flag\n XLM.xlm_library.debug = flag\n XLM.ms_stack_transformer.debug = flag\n XLM.stack_transformer.debug = flag\n XLM.excel2007.debug = flag","def setDebug():\n\tglobal debug\n\tdebug = True","def _pma_set_debug_flag(flag):\n global _pma_debug\n\n if not isinstance(flag, (bool)):\n raise Exception(\"flag argument must be of class bool\")\n _pma_debug = flag\n if flag is True:\n print(\"Debug flag enabled. You will receive extra feedback and messages from pma_python (like this one)\")","def set_global_flags(self):\n\n import rpki.http, rpki.x509, rpki.sql, rpki.async, rpki.log\n\n try:\n rpki.http.debug_http = self.getboolean(\"debug_http\")\n except ConfigParser.NoOptionError:\n pass\n\n try:\n rpki.http.want_persistent_client = self.getboolean(\"want_persistent_client\")\n except ConfigParser.NoOptionError:\n pass\n\n try:\n rpki.http.want_persistent_server = self.getboolean(\"want_persistent_server\")\n except ConfigParser.NoOptionError:\n pass\n\n try:\n rpki.http.use_adns = self.getboolean(\"use_adns\")\n except ConfigParser.NoOptionError:\n pass\n\n try:\n rpki.http.enable_ipv6_clients = self.getboolean(\"enable_ipv6_clients\")\n except ConfigParser.NoOptionError:\n pass\n\n try:\n rpki.http.enable_ipv6_servers = self.getboolean(\"enable_ipv6_servers\")\n except ConfigParser.NoOptionError:\n pass\n\n try:\n rpki.x509.CMS_object.debug_cms_certs = self.getboolean(\"debug_cms_certs\")\n except ConfigParser.NoOptionError:\n pass\n\n try:\n rpki.sql.sql_persistent.sql_debug = self.getboolean(\"sql_debug\")\n except ConfigParser.NoOptionError:\n pass\n\n try:\n rpki.async.timer.gc_debug = self.getboolean(\"gc_debug\")\n except ConfigParser.NoOptionError:\n pass\n\n try:\n rpki.async.timer.run_debug = self.getboolean(\"timer_debug\")\n except ConfigParser.NoOptionError:\n pass\n\n try:\n rpki.x509.XML_CMS_object.dump_outbound_cms = rpki.x509.DeadDrop(self.get(\"dump_outbound_cms\"))\n except ConfigParser.NoOptionError:\n pass\n\n try:\n rpki.x509.XML_CMS_object.dump_inbound_cms = rpki.x509.DeadDrop(self.get(\"dump_inbound_cms\"))\n except ConfigParser.NoOptionError:\n pass\n\n try:\n rpki.async.gc_summary(self.getint(\"gc_summary\"), self.getint(\"gc_summary_threshold\", 0))\n except ConfigParser.NoOptionError:\n pass\n\n try:\n rpki.log.enable_tracebacks = self.getboolean(\"enable_tracebacks\")\n except ConfigParser.NoOptionError:\n pass","def vv_flag():\n log.setLevel(logging.DEBUG)","def _set_debug(debug):\n global _DEBUG\n _DEBUG = debug\n if debug:\n logging.disable(logging.NOTSET)\n else:\n logging.disable(logging.DEBUG)","def set_debug_flag(flag):\n pma._pma_set_debug_flag(flag)","def debug_mode(x):\n if x:\n logger.setLevel(logging.DEBUG)\n ch.setLevel(logging.DEBUG)\n _DEBUG = True\n KEEP_TEMPFILES = True\n logger.info(\n 'Debug mode enabled. You may also want to set '\n 'pybedtools.KEEP_TEMPFILES=True to prevent automatic deletion '\n 'of files upon exit.')\n else:\n logger.setLevel(logging.INFO)\n ch.setLevel(logging.INFO)\n _DEBUG = False\n KEEP_TEMPFILES = False\n logger.info('Debug mode disabled')","def set_debug(state):\n global _DEBUG\n _DEBUG = bool(state)","def set_debug_mode(self):\n self.debug_mode = True","def fault_debug(value: bool = False) -> None:","def set_debug_mode(debug_bool):\n\n MKL.MKL_DEBUG = debug_bool","def _enableDebugPrint(self):\n self._dbPrint = Printer(debugPrint=True)","def v_flag():\n log.setLevel(logging.INFO)","def SetDebugMode(enabled=True):\n global option\n option['debug_mode'] = enabled","def set_debug(debug_val):\n global _DEBUG # noqa: PLW0603\n _DEBUG = debug_val","def toggle_debug(self):\n self.__debug = not self.__debug","def setup_requests_debugging(self):\n\n # These two lines enable debugging at httplib level (requests->urllib3->http.client)\n # You will see the REQUEST, including HEADERS and DATA, and RESPONSE with HEADERS but without DATA.\n # The only thing missing will be the response.body which is not logged.\n try:\n import http.client as http_client\n except ImportError:\n # Python 2\n import httplib as http_client\n http_client.HTTPConnection.debuglevel = 1\n\n # You must initialize logging, otherwise you'll not see debug output.\n self.logger.setLevel(logging.DEBUG)\n requests_log = logging.getLogger(\"requests.packages.urllib3\")\n requests_log.setLevel(logging.DEBUG)\n requests_log.propagate = True","def set_debug(self, value=True):\n self.debug = value","def setVerboseDebugOn(self):\n self.edLogging.setVerboseDebugOn()","def debug_requests_on():\n HTTPConnection.debuglevel = 2\n\n logging.basicConfig(filename='example1.log', filemode='w', level=logging.INFO, format='%(asctime)s %(message)s',\n datefmt='%m/%d/%Y %I:%M:%S %p')\n logging.getLogger().setLevel(logging.DEBUG)\n\n requests_log = logging.getLogger(\"requests.packages.urllib3\")\n requests_log.setLevel(logging.DEBUG)\n requests_log.propagate = True","def debug():\n return bool(_environ.get(\"ACCELPY_DEBUG\", False))","def debug(mode=True):\r\n global DEBUG\r\n DEBUG = bool(mode)","def catalogSetDebug(level):\n ret = libxml2mod.xmlCatalogSetDebug(level)\n return ret","def enable_debugger(app):\n import aiohttp_debugtoolbar\n\n # dev mode only\n # this will be served at API_SERVER_URL/_debugtoolbar\n aiohttp_debugtoolbar.setup(app)","def enable_debugger(app):\n import aiohttp_debugtoolbar\n\n # dev mode only\n # this will be served at API_SERVER_URL/_debugtoolbar\n aiohttp_debugtoolbar.setup(app)","def enable_rendering(flag=True):\n global _rendering_enabled\n _rendering_enabled = flag","def debug():\n assert current_app.debug == False, \"Don't panic! You're here by request of debug()\"","def _debug():\n return _DEBUG","def enableCLangLogger(self):","def setup_debugging():\n import sys\n sys.path.append('/root/pycharm-debug-py3k.egg')\n import pydevd\n pydevd.settrace('192.168.4.47', port=5422, stdoutToServer=True, stderrToServer=True, suspend=False)","def set_debug(self):\n self.logger.setLevel(5)\n if self.uses_adc:\n self.adc.logger.setLevel(5)","def _set_trace_on(trace_on):\n AceQLHttpApi.set_trace_on(trace_on)","def debug():","def main(config, debug):\n config.debug = debug\n if config.debug:\n click.echo('Debug info...')","def setdebug(self):\n self.debug = True\n irclib.DEBUG = True\n print \"Debug mode on\"","def setDebugFLags(sessionId):\n try:\n if not authentication.checkSessionId(sessionId, ADMIN):\n abort(403)\n if request.data is None:\n abort(400)\n debugFlags = json.loads(request.data)\n DebugFlags.setDebugFlags(debugFlags)\n return jsonify({\"status\": \"OK\"})\n except:\n print \"Unexpected error:\", sys.exc_info()[0]\n print sys.exc_info()\n traceback.print_exc()\n util.logStackTrace(sys.exc_info())\n raise","def NeedsDebugInfo(self):\n return False","def enableTrace(tracable):\r\n global traceEnabled\r\n traceEnabled = tracable\r\n if tracable:\r\n if not logger.handlers:\r\n logger.addHandler(logging.StreamHandler())\r\n logger.setLevel(logging.DEBUG)","def NeedsDebugInfo(self):\n return True","def enableAccessedFlags(self):\n pass","def enable_verbose(self):\n self.verbose = True","def runtime_enabled_flags(self):\n raise exceptions.NotImplementedError()","def set_debug(self, debug):\n self.debug = debug","def verbose():\n GLOBAL['VERBOSE'] = True","def enable_traceback_filtering():\n if sys.version_info.major != 3 or sys.version_info.minor < 7:\n raise RuntimeError(\n f'Traceback filtering is only available with Python 3.7 or higher. '\n f'This Python version: {sys.version}')\n global _ENABLE_TRACEBACK_FILTERING\n _ENABLE_TRACEBACK_FILTERING.value = True","def _enable(self):\n self.debug_log(\"Enabling...\")\n self._register_handlers()","def cli(debug):\n print(f\"Debug mode is {'on' if debug else 'off'}\")","def enableDebugLoadOutput(self):\n key = \"NatlinkmainDebugLoad\"\n self.userregnl.set(key, 1)","def set_debuglevel(self, level):\n self.debugging = level","def install_debuginfo(self) -> None:\n pass","def setup_logging(verbose=False):\n\n logger = logging.getLogger()\n logger.setLevel(logging.INFO if not verbose else logging.DEBUG)","def minimal_director_config(project_env_devel_environment, monkeypatch):\n monkeypatch.setenv(\"DIRECTOR_ENABLED\", \"1\")\n monkeypatch.setenv(\"POSTGRES_ENABLED\", \"0\")\n monkeypatch.setenv(\"DIRECTOR_V2_DYNAMIC_SCHEDULER_ENABLED\", \"false\")\n monkeypatch.setenv(\"DIRECTOR_V0_ENABLED\", \"1\")\n monkeypatch.setenv(\"DIRECTOR_V2_POSTGRES_ENABLED\", \"0\")\n monkeypatch.setenv(\"DIRECTOR_V2_CATALOG\", \"null\")\n monkeypatch.setenv(\"COMPUTATIONAL_BACKEND_DASK_CLIENT_ENABLED\", \"0\")\n monkeypatch.setenv(\"COMPUTATIONAL_BACKEND_ENABLED\", \"0\")","def enablePyLangLogger(self):","def opt_spew(self):\n from twisted.python.util import spewer\n sys.settrace(spewer)","def RecordExperimentalSetup(log_dir: Path) -> None:\n with open(log_dir / \"flags.txt\", \"w\") as f:\n f.write(FLAGS.flags_into_string())\n with open(log_dir / \"build_info.json\", \"w\") as f:\n json.dump({}, f, sort_keys=True, indent=2, separators=(\",\", \": \"))","def main(ctx, debug):\n if debug:\n logger.setLevel(logging.DEBUG)","def _modified_option_defaults(self) -> Dict[str, Any]:\n return {\n # Change 'debug.traceback' default to True if debug logging is enabled.\n 'debug.traceback': logging.getLogger('pyocd').isEnabledFor(logging.DEBUG),\n }","def set_debug(self, debug):\n self.debug_flag = debug\n self.debug_log(\"%s: debug = %s\" % (self.__class__.__name__,\n self.debug_flag),\n flag=True)\n return debug","def debug(state: bool, /) -> None:","def debug(self):\n raise NotImplementedError","def debug() -> bool:","def get_debug():\n return _DEBUG","def debug(x=''):\n project_settings = get_settings()\n print project_settings.EXTRA_APPS","def pre_start_hook(self):\n\n LOG.debug(_('XManager pre_start_hook...'))\n\n pass","def set_debug_mode(self, value):\n self.debug = value","def test_addFlagsSilently(self):\n self._flagsSilentlyTest('addFlags', b'+FLAGS.SILENT')","def debug_info(self, enable):\n\n if not isinstance(enable, bool):\n raise TypeError('expected a bool')\n dll.wasmtime_config_debug_info_set(self.__ptr__, enable)","def set_trace():\n Bdb().set_trace()","def debug_option(args, run):\n run.debug = True","def is_debug(cls):\n return Traceable.debug & cls.DEBUG_ENABLE","def debugMemory(activate):\n ret = libxml2mod.xmlDebugMemory(activate)\n return ret","def toggle_debug(self):\n return self.set_debug(not self.debug_flag)","def initGlobals():\n libxml2mod.xmlInitGlobals()","def SetDebugLevel(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def setup_external_logging() -> None:\n logging.getLogger(\"web3\").setLevel(logging.INFO) # web3 logger","def SetVerbose(new_verbose=True):\n global _verbose\n _verbose = new_verbose","def debug(self, *args, **kwargs):","def configure_logging(self):\n\n if self.options.debug:\n # --debug forces verbose_level 3\n # Set this here so cliff.app.configure_logging() can work\n self.options.verbose_level = 3\n\n super(Servizor, self).configure_logging()\n root_logger = logging.getLogger('')\n\n # Requests logs some stuff at INFO that we don't want\n # unless we have DEBUG\n requests_log = logging.getLogger(\"requests\")\n requests_log.setLevel(logging.ERROR)\n\n # Other modules we don't want DEBUG output for so\n # don't reset them below\n iso8601_log = logging.getLogger(\"iso8601\")\n iso8601_log.setLevel(logging.ERROR)\n\n # Set logging to the requested level\n self.dump_stack_trace = False\n if self.options.verbose_level == 0:\n # --quiet\n root_logger.setLevel(logging.ERROR)\n elif self.options.verbose_level == 1:\n # This is the default case, no --debug, --verbose or --quiet\n root_logger.setLevel(logging.WARNING)\n elif self.options.verbose_level == 2:\n # One --verbose\n root_logger.setLevel(logging.INFO)\n elif self.options.verbose_level >= 3:\n # Two or more --verbose\n root_logger.setLevel(logging.DEBUG)\n requests_log.setLevel(logging.DEBUG)\n\n if self.options.debug:\n # --debug forces traceback\n self.dump_stack_trace = True","def _AddCommonFlags(self, resource):\n self.flags['format'] = 'json'\n self.additional_flags.extend(FLAGS.openstack_additional_flags or ())","def enable_instance_inspection(self):\n self._request({\"enable-instance-inspection\": True})","def main(debug):\n click.echo('Debug mode is {{}}'.format(debug))","def setup_logging(debug):\n root = logging.getLogger()\n root.setLevel(debug and logging.DEBUG or logging.INFO)\n handler = logging.StreamHandler()\n formatter = ColorFormatter(fmt='[%(levelname)s] %(message)s')\n handler.setFormatter(formatter)\n root.addHandler(handler)","def is_debug ():\n\n return __debug__ and DEBUG","def set_parameters(tensor_tracer_params=None):\n enable_flags = '--%s=1' % tensor_tracer_flags.FLAG_NAME_ENABLE\n if tensor_tracer_params:\n for key, value in tensor_tracer_params.items():\n enable_flags += ' --%s=%s' % (key, value)\n os.environ[tensor_tracer_flags.FLAGS_ENV_VAR] = enable_flags","def setup():\n global log_handler\n\n if vaex.settings.main.logging.setup:\n logger.setLevel(logging.DEBUG)\n\n # create console handler and accept all loglevels\n if vaex.settings.main.logging.rich:\n from rich.logging import RichHandler\n log_handler = RichHandler()\n else:\n log_handler = logging.StreamHandler()\n\n # create formatter\n formatter = logging.Formatter('%(levelname)s:%(threadName)s:%(name)s:%(message)s')\n\n\n # add formatter to console handler\n log_handler.setFormatter(formatter)\n log_handler.setLevel(logging.DEBUG)\n\n # add console handler to logger\n logger.addHandler(log_handler)\n\n logging.getLogger(\"vaex\").setLevel(logging.ERROR) # default to higest level\n _set_log_level(vaex.settings.main.logging.error, logging.ERROR)\n _set_log_level(vaex.settings.main.logging.warning, logging.WARNING)\n _set_log_level(vaex.settings.main.logging.info, logging.INFO)\n _set_log_level(vaex.settings.main.logging.debug, logging.DEBUG)\n # VAEX_DEBUG behaves similar to VAEX_LOGGING_DEBUG, but has more effect\n DEBUG_MODE = os.environ.get('VAEX_DEBUG', '')\n if DEBUG_MODE:\n _set_log_level(DEBUG_MODE, logging.DEBUG)","def enableDebugCallbackOutput(self):\n key = \"NatlinkmainDebugCallback\"\n self.userregnl.set(key, 1)","def register_globals ():\n\n # This feature is used to determine which OS we're on.\n # In future, this may become <target-os> and <host-os>\n # TODO: check this. Compatibility with bjam names? Subfeature for version?\n os = sys.platform\n feature.feature ('os', [os], ['propagated', 'link-incompatible'])\n\n\n # The two OS features define a known set of abstract OS names. The host-os is\n # the OS under which bjam is running. Even though this should really be a fixed\n # property we need to list all the values to prevent unknown value errors. Both\n # set the default value to the current OS to account for the default use case of\n # building on the target OS.\n feature.feature('host-os', __os_names)\n feature.set_default('host-os', default_host_os())\n\n feature.feature('target-os', __os_names, ['propagated', 'link-incompatible'])\n feature.set_default('target-os', default_host_os())\n\n feature.feature ('toolset', [], ['implicit', 'propagated' ,'symmetric'])\n\n feature.feature ('stdlib', ['native'], ['propagated', 'composite'])\n\n feature.feature ('link', ['shared', 'static'], ['propagated'])\n feature.feature ('runtime-link', ['shared', 'static'], ['propagated'])\n feature.feature ('runtime-debugging', ['on', 'off'], ['propagated'])\n\n\n feature.feature ('optimization', ['off', 'speed', 'space'], ['propagated'])\n feature.feature ('profiling', ['off', 'on'], ['propagated'])\n feature.feature ('inlining', ['off', 'on', 'full'], ['propagated'])\n\n feature.feature ('threading', ['single', 'multi'], ['propagated'])\n feature.feature ('rtti', ['on', 'off'], ['propagated'])\n feature.feature ('exception-handling', ['on', 'off'], ['propagated'])\n\n # Whether there is support for asynchronous EH (e.g. catching SEGVs).\n feature.feature ('asynch-exceptions', ['off', 'on'], ['propagated'])\n\n # Whether all extern \"C\" functions are considered nothrow by default.\n feature.feature ('extern-c-nothrow', ['off', 'on'], ['propagated'])\n\n feature.feature ('debug-symbols', ['on', 'off'], ['propagated'])\n feature.feature ('define', [], ['free'])\n feature.feature ('undef', [], ['free'])\n feature.feature ('include', [], ['free', 'path']) #order-sensitive\n feature.feature ('cflags', [], ['free'])\n feature.feature ('cxxflags', [], ['free'])\n feature.feature ('asmflags', [], ['free'])\n feature.feature ('linkflags', [], ['free'])\n feature.feature ('archiveflags', [], ['free'])\n feature.feature ('version', [], ['free'])\n\n feature.feature ('location-prefix', [], ['free'])\n\n feature.feature ('action', [], ['free'])\n\n\n # The following features are incidental, since\n # in themself they have no effect on build products.\n # Not making them incidental will result in problems in corner\n # cases, for example:\n #\n # unit-test a : a.cpp : <use>b ;\n # lib b : a.cpp b ;\n #\n # Here, if <use> is not incidental, we'll decide we have two\n # targets for a.obj with different properties, and will complain.\n #\n # Note that making feature incidental does not mean it's ignored. It may\n # be ignored when creating the virtual target, but the rest of build process\n # will use them.\n feature.feature ('use', [], ['free', 'dependency', 'incidental'])\n feature.feature ('dependency', [], ['free', 'dependency', 'incidental'])\n feature.feature ('implicit-dependency', [], ['free', 'dependency', 'incidental'])\n\n feature.feature('warnings', [\n 'on', # Enable default/\"reasonable\" warning level for the tool.\n 'all', # Enable all possible warnings issued by the tool.\n 'off'], # Disable all warnings issued by the tool.\n ['incidental', 'propagated'])\n\n feature.feature('warnings-as-errors', [\n 'off', # Do not fail the compilation if there are warnings.\n 'on'], # Fail the compilation if there are warnings.\n ['incidental', 'propagated'])\n\n feature.feature('c++-template-depth',\n [str(i) for i in range(64,1024+1,64)] +\n [str(i) for i in range(20,1000+1,10)] +\n # Maximum template instantiation depth guaranteed for ANSI/ISO C++\n # conforming programs.\n ['17'],\n ['incidental', 'optional', 'propagated'])\n\n feature.feature ('source', [], ['free', 'dependency', 'incidental'])\n feature.feature ('library', [], ['free', 'dependency', 'incidental'])\n feature.feature ('file', [], ['free', 'dependency', 'incidental'])\n feature.feature ('find-shared-library', [], ['free']) #order-sensitive ;\n feature.feature ('find-static-library', [], ['free']) #order-sensitive ;\n feature.feature ('library-path', [], ['free', 'path']) #order-sensitive ;\n # Internal feature.\n feature.feature ('library-file', [], ['free', 'dependency'])\n\n feature.feature ('name', [], ['free'])\n feature.feature ('tag', [], ['free'])\n feature.feature ('search', [], ['free', 'path']) #order-sensitive ;\n feature.feature ('location', [], ['free', 'path'])\n\n feature.feature ('dll-path', [], ['free', 'path'])\n feature.feature ('hardcode-dll-paths', ['true', 'false'], ['incidental'])\n\n\n # This is internal feature which holds the paths of all dependency\n # dynamic libraries. On Windows, it's needed so that we can all\n # those paths to PATH, when running applications.\n # On Linux, it's needed to add proper -rpath-link command line options.\n feature.feature ('xdll-path', [], ['free', 'path'])\n\n #provides means to specify def-file for windows dlls.\n feature.feature ('def-file', [], ['free', 'dependency'])\n\n # This feature is used to allow specific generators to run.\n # For example, QT tools can only be invoked when QT library\n # is used. In that case, <allow>qt will be in usage requirement\n # of the library.\n feature.feature ('allow', [], ['free'])\n\n # The addressing model to generate code for. Currently a limited set only\n # specifying the bit size of pointers.\n feature.feature('address-model', ['16', '32', '64'], ['propagated', 'optional'])\n\n # Type of CPU architecture to compile for.\n feature.feature('architecture', [\n # x86 and x86-64\n 'x86',\n\n # ia64\n 'ia64',\n\n # Sparc\n 'sparc',\n\n # RS/6000 & PowerPC\n 'power',\n\n # MIPS/SGI\n 'mips1', 'mips2', 'mips3', 'mips4', 'mips32', 'mips32r2', 'mips64',\n\n # HP/PA-RISC\n 'parisc',\n\n # Advanced RISC Machines\n 'arm',\n\n # Combined architectures for platforms/toolsets that support building for\n # multiple architectures at once. \"combined\" would be the default multi-arch\n # for the toolset.\n 'combined',\n 'combined-x86-power'],\n\n ['propagated', 'optional'])\n\n # The specific instruction set in an architecture to compile.\n feature.feature('instruction-set', [\n # x86 and x86-64\n 'native', 'i486', 'i586', 'i686', 'pentium', 'pentium-mmx', 'pentiumpro', 'pentium2', 'pentium3',\n 'pentium3m', 'pentium-m', 'pentium4', 'pentium4m', 'prescott', 'nocona', 'core2', 'corei7', 'corei7-avx', 'core-avx-i',\n 'conroe', 'conroe-xe', 'conroe-l', 'allendale', 'merom', 'merom-xe', 'kentsfield', 'kentsfield-xe', 'penryn', 'wolfdale',\n 'yorksfield', 'nehalem', 'sandy-bridge', 'ivy-bridge', 'haswell', 'k6', 'k6-2', 'k6-3', 'athlon', 'athlon-tbird', 'athlon-4', 'athlon-xp',\n 'athlon-mp', 'k8', 'opteron', 'athlon64', 'athlon-fx', 'k8-sse3', 'opteron-sse3', 'athlon64-sse3', 'amdfam10', 'barcelona',\n 'bdver1', 'bdver2', 'bdver3', 'btver1', 'btver2', 'winchip-c6', 'winchip2', 'c3', 'c3-2', 'atom',\n\n # ia64\n 'itanium', 'itanium1', 'merced', 'itanium2', 'mckinley',\n\n # Sparc\n 'v7', 'cypress', 'v8', 'supersparc', 'sparclite', 'hypersparc', 'sparclite86x', 'f930', 'f934',\n 'sparclet', 'tsc701', 'v9', 'ultrasparc', 'ultrasparc3',\n\n # RS/6000 & PowerPC\n '401', '403', '405', '405fp', '440', '440fp', '505', '601', '602',\n '603', '603e', '604', '604e', '620', '630', '740', '7400',\n '7450', '750', '801', '821', '823', '860', '970', '8540',\n 'power-common', 'ec603e', 'g3', 'g4', 'g5', 'power', 'power2',\n 'power3', 'power4', 'power5', 'powerpc', 'powerpc64', 'rios',\n 'rios1', 'rsc', 'rios2', 'rs64a',\n\n # MIPS\n '4kc', '4kp', '5kc', '20kc', 'm4k', 'r2000', 'r3000', 'r3900', 'r4000',\n 'r4100', 'r4300', 'r4400', 'r4600', 'r4650',\n 'r6000', 'r8000', 'rm7000', 'rm9000', 'orion', 'sb1', 'vr4100',\n 'vr4111', 'vr4120', 'vr4130', 'vr4300',\n 'vr5000', 'vr5400', 'vr5500',\n\n # HP/PA-RISC\n '700', '7100', '7100lc', '7200', '7300', '8000',\n\n # Advanced RISC Machines\n 'armv2', 'armv2a', 'armv3', 'armv3m', 'armv4', 'armv4t', 'armv5',\n 'armv5t', 'armv5te', 'armv6', 'armv6j', 'iwmmxt', 'ep9312'],\n\n ['propagated', 'optional'])\n\n feature.feature('conditional', [], ['incidental', 'free'])\n\n # The value of 'no' prevents building of a target.\n feature.feature('build', ['yes', 'no'], ['optional'])\n\n # Windows-specific features\n feature.feature ('user-interface', ['console', 'gui', 'wince', 'native', 'auto'], [])\n feature.feature ('variant', [], ['implicit', 'composite', 'propagated', 'symmetric'])\n\n\n variant ('debug', ['<optimization>off', '<debug-symbols>on', '<inlining>off', '<runtime-debugging>on'])\n variant ('release', ['<optimization>speed', '<debug-symbols>off', '<inlining>full',\n '<runtime-debugging>off', '<define>NDEBUG'])\n variant ('profile', ['release'], ['<profiling>on', '<debug-symbols>on'])","def javaEnabled(self):\n return False","def output_debug_info(self):","def _trace(self):\n self.__aceQLHttpApi.trace()","def test_setFlagsSilently(self):\n self._flagsSilentlyTest('setFlags', b'FLAGS.SILENT')","def set_tracing(self, tracing: bool) -> None:\n self.tracing = tracing","def toggle_remote_debug():\n import sys\n import os\n\n debug_on = len(sys.argv) >= 2 and '--remote-debug' in sys.argv[1]\n\n if debug_on:\n egg_path = os.path.abspath(os.path.join(os.path.dirname(__file__), \"pycharm-debug-py3k.egg\"))\n sys.path.append(egg_path)\n import pydevd\n pydevd.settrace('localhost', port=9090)\n\n yield\n\n if debug_on:\n import pydevd\n pydevd.stoptrace()","def setup_options(parser):\n help_str = \"Turn on debug\"\n parser.add_argument(\"-d\", \"--debug\", action=\"store_true\", default=False,\n help=help_str)","def debug(self):\n return Config.DEBUG","def enable(self):\n LOGGER.info('Enabling WebAPI plugin WEB ...')","def setVerboseDebugOff(self):\n self.edLogging.setVerboseDebugOff()","def debug():\n return exported_res_dict","def set_pretty_print(value):\n global _with_colors\n _with_colors = True if value else False"],"string":"[\n \"def set_debug(flag):\\n global debug\\n debug = flag\\n XLM.XLM_Object.debug = flag\\n XLM.xlm_library.debug = flag\\n XLM.ms_stack_transformer.debug = flag\\n XLM.stack_transformer.debug = flag\\n XLM.excel2007.debug = flag\",\n \"def setDebug():\\n\\tglobal debug\\n\\tdebug = True\",\n \"def _pma_set_debug_flag(flag):\\n global _pma_debug\\n\\n if not isinstance(flag, (bool)):\\n raise Exception(\\\"flag argument must be of class bool\\\")\\n _pma_debug = flag\\n if flag is True:\\n print(\\\"Debug flag enabled. You will receive extra feedback and messages from pma_python (like this one)\\\")\",\n \"def set_global_flags(self):\\n\\n import rpki.http, rpki.x509, rpki.sql, rpki.async, rpki.log\\n\\n try:\\n rpki.http.debug_http = self.getboolean(\\\"debug_http\\\")\\n except ConfigParser.NoOptionError:\\n pass\\n\\n try:\\n rpki.http.want_persistent_client = self.getboolean(\\\"want_persistent_client\\\")\\n except ConfigParser.NoOptionError:\\n pass\\n\\n try:\\n rpki.http.want_persistent_server = self.getboolean(\\\"want_persistent_server\\\")\\n except ConfigParser.NoOptionError:\\n pass\\n\\n try:\\n rpki.http.use_adns = self.getboolean(\\\"use_adns\\\")\\n except ConfigParser.NoOptionError:\\n pass\\n\\n try:\\n rpki.http.enable_ipv6_clients = self.getboolean(\\\"enable_ipv6_clients\\\")\\n except ConfigParser.NoOptionError:\\n pass\\n\\n try:\\n rpki.http.enable_ipv6_servers = self.getboolean(\\\"enable_ipv6_servers\\\")\\n except ConfigParser.NoOptionError:\\n pass\\n\\n try:\\n rpki.x509.CMS_object.debug_cms_certs = self.getboolean(\\\"debug_cms_certs\\\")\\n except ConfigParser.NoOptionError:\\n pass\\n\\n try:\\n rpki.sql.sql_persistent.sql_debug = self.getboolean(\\\"sql_debug\\\")\\n except ConfigParser.NoOptionError:\\n pass\\n\\n try:\\n rpki.async.timer.gc_debug = self.getboolean(\\\"gc_debug\\\")\\n except ConfigParser.NoOptionError:\\n pass\\n\\n try:\\n rpki.async.timer.run_debug = self.getboolean(\\\"timer_debug\\\")\\n except ConfigParser.NoOptionError:\\n pass\\n\\n try:\\n rpki.x509.XML_CMS_object.dump_outbound_cms = rpki.x509.DeadDrop(self.get(\\\"dump_outbound_cms\\\"))\\n except ConfigParser.NoOptionError:\\n pass\\n\\n try:\\n rpki.x509.XML_CMS_object.dump_inbound_cms = rpki.x509.DeadDrop(self.get(\\\"dump_inbound_cms\\\"))\\n except ConfigParser.NoOptionError:\\n pass\\n\\n try:\\n rpki.async.gc_summary(self.getint(\\\"gc_summary\\\"), self.getint(\\\"gc_summary_threshold\\\", 0))\\n except ConfigParser.NoOptionError:\\n pass\\n\\n try:\\n rpki.log.enable_tracebacks = self.getboolean(\\\"enable_tracebacks\\\")\\n except ConfigParser.NoOptionError:\\n pass\",\n \"def vv_flag():\\n log.setLevel(logging.DEBUG)\",\n \"def _set_debug(debug):\\n global _DEBUG\\n _DEBUG = debug\\n if debug:\\n logging.disable(logging.NOTSET)\\n else:\\n logging.disable(logging.DEBUG)\",\n \"def set_debug_flag(flag):\\n pma._pma_set_debug_flag(flag)\",\n \"def debug_mode(x):\\n if x:\\n logger.setLevel(logging.DEBUG)\\n ch.setLevel(logging.DEBUG)\\n _DEBUG = True\\n KEEP_TEMPFILES = True\\n logger.info(\\n 'Debug mode enabled. You may also want to set '\\n 'pybedtools.KEEP_TEMPFILES=True to prevent automatic deletion '\\n 'of files upon exit.')\\n else:\\n logger.setLevel(logging.INFO)\\n ch.setLevel(logging.INFO)\\n _DEBUG = False\\n KEEP_TEMPFILES = False\\n logger.info('Debug mode disabled')\",\n \"def set_debug(state):\\n global _DEBUG\\n _DEBUG = bool(state)\",\n \"def set_debug_mode(self):\\n self.debug_mode = True\",\n \"def fault_debug(value: bool = False) -> None:\",\n \"def set_debug_mode(debug_bool):\\n\\n MKL.MKL_DEBUG = debug_bool\",\n \"def _enableDebugPrint(self):\\n self._dbPrint = Printer(debugPrint=True)\",\n \"def v_flag():\\n log.setLevel(logging.INFO)\",\n \"def SetDebugMode(enabled=True):\\n global option\\n option['debug_mode'] = enabled\",\n \"def set_debug(debug_val):\\n global _DEBUG # noqa: PLW0603\\n _DEBUG = debug_val\",\n \"def toggle_debug(self):\\n self.__debug = not self.__debug\",\n \"def setup_requests_debugging(self):\\n\\n # These two lines enable debugging at httplib level (requests->urllib3->http.client)\\n # You will see the REQUEST, including HEADERS and DATA, and RESPONSE with HEADERS but without DATA.\\n # The only thing missing will be the response.body which is not logged.\\n try:\\n import http.client as http_client\\n except ImportError:\\n # Python 2\\n import httplib as http_client\\n http_client.HTTPConnection.debuglevel = 1\\n\\n # You must initialize logging, otherwise you'll not see debug output.\\n self.logger.setLevel(logging.DEBUG)\\n requests_log = logging.getLogger(\\\"requests.packages.urllib3\\\")\\n requests_log.setLevel(logging.DEBUG)\\n requests_log.propagate = True\",\n \"def set_debug(self, value=True):\\n self.debug = value\",\n \"def setVerboseDebugOn(self):\\n self.edLogging.setVerboseDebugOn()\",\n \"def debug_requests_on():\\n HTTPConnection.debuglevel = 2\\n\\n logging.basicConfig(filename='example1.log', filemode='w', level=logging.INFO, format='%(asctime)s %(message)s',\\n datefmt='%m/%d/%Y %I:%M:%S %p')\\n logging.getLogger().setLevel(logging.DEBUG)\\n\\n requests_log = logging.getLogger(\\\"requests.packages.urllib3\\\")\\n requests_log.setLevel(logging.DEBUG)\\n requests_log.propagate = True\",\n \"def debug():\\n return bool(_environ.get(\\\"ACCELPY_DEBUG\\\", False))\",\n \"def debug(mode=True):\\r\\n global DEBUG\\r\\n DEBUG = bool(mode)\",\n \"def catalogSetDebug(level):\\n ret = libxml2mod.xmlCatalogSetDebug(level)\\n return ret\",\n \"def enable_debugger(app):\\n import aiohttp_debugtoolbar\\n\\n # dev mode only\\n # this will be served at API_SERVER_URL/_debugtoolbar\\n aiohttp_debugtoolbar.setup(app)\",\n \"def enable_debugger(app):\\n import aiohttp_debugtoolbar\\n\\n # dev mode only\\n # this will be served at API_SERVER_URL/_debugtoolbar\\n aiohttp_debugtoolbar.setup(app)\",\n \"def enable_rendering(flag=True):\\n global _rendering_enabled\\n _rendering_enabled = flag\",\n \"def debug():\\n assert current_app.debug == False, \\\"Don't panic! You're here by request of debug()\\\"\",\n \"def _debug():\\n return _DEBUG\",\n \"def enableCLangLogger(self):\",\n \"def setup_debugging():\\n import sys\\n sys.path.append('/root/pycharm-debug-py3k.egg')\\n import pydevd\\n pydevd.settrace('192.168.4.47', port=5422, stdoutToServer=True, stderrToServer=True, suspend=False)\",\n \"def set_debug(self):\\n self.logger.setLevel(5)\\n if self.uses_adc:\\n self.adc.logger.setLevel(5)\",\n \"def _set_trace_on(trace_on):\\n AceQLHttpApi.set_trace_on(trace_on)\",\n \"def debug():\",\n \"def main(config, debug):\\n config.debug = debug\\n if config.debug:\\n click.echo('Debug info...')\",\n \"def setdebug(self):\\n self.debug = True\\n irclib.DEBUG = True\\n print \\\"Debug mode on\\\"\",\n \"def setDebugFLags(sessionId):\\n try:\\n if not authentication.checkSessionId(sessionId, ADMIN):\\n abort(403)\\n if request.data is None:\\n abort(400)\\n debugFlags = json.loads(request.data)\\n DebugFlags.setDebugFlags(debugFlags)\\n return jsonify({\\\"status\\\": \\\"OK\\\"})\\n except:\\n print \\\"Unexpected error:\\\", sys.exc_info()[0]\\n print sys.exc_info()\\n traceback.print_exc()\\n util.logStackTrace(sys.exc_info())\\n raise\",\n \"def NeedsDebugInfo(self):\\n return False\",\n \"def enableTrace(tracable):\\r\\n global traceEnabled\\r\\n traceEnabled = tracable\\r\\n if tracable:\\r\\n if not logger.handlers:\\r\\n logger.addHandler(logging.StreamHandler())\\r\\n logger.setLevel(logging.DEBUG)\",\n \"def NeedsDebugInfo(self):\\n return True\",\n \"def enableAccessedFlags(self):\\n pass\",\n \"def enable_verbose(self):\\n self.verbose = True\",\n \"def runtime_enabled_flags(self):\\n raise exceptions.NotImplementedError()\",\n \"def set_debug(self, debug):\\n self.debug = debug\",\n \"def verbose():\\n GLOBAL['VERBOSE'] = True\",\n \"def enable_traceback_filtering():\\n if sys.version_info.major != 3 or sys.version_info.minor < 7:\\n raise RuntimeError(\\n f'Traceback filtering is only available with Python 3.7 or higher. '\\n f'This Python version: {sys.version}')\\n global _ENABLE_TRACEBACK_FILTERING\\n _ENABLE_TRACEBACK_FILTERING.value = True\",\n \"def _enable(self):\\n self.debug_log(\\\"Enabling...\\\")\\n self._register_handlers()\",\n \"def cli(debug):\\n print(f\\\"Debug mode is {'on' if debug else 'off'}\\\")\",\n \"def enableDebugLoadOutput(self):\\n key = \\\"NatlinkmainDebugLoad\\\"\\n self.userregnl.set(key, 1)\",\n \"def set_debuglevel(self, level):\\n self.debugging = level\",\n \"def install_debuginfo(self) -> None:\\n pass\",\n \"def setup_logging(verbose=False):\\n\\n logger = logging.getLogger()\\n logger.setLevel(logging.INFO if not verbose else logging.DEBUG)\",\n \"def minimal_director_config(project_env_devel_environment, monkeypatch):\\n monkeypatch.setenv(\\\"DIRECTOR_ENABLED\\\", \\\"1\\\")\\n monkeypatch.setenv(\\\"POSTGRES_ENABLED\\\", \\\"0\\\")\\n monkeypatch.setenv(\\\"DIRECTOR_V2_DYNAMIC_SCHEDULER_ENABLED\\\", \\\"false\\\")\\n monkeypatch.setenv(\\\"DIRECTOR_V0_ENABLED\\\", \\\"1\\\")\\n monkeypatch.setenv(\\\"DIRECTOR_V2_POSTGRES_ENABLED\\\", \\\"0\\\")\\n monkeypatch.setenv(\\\"DIRECTOR_V2_CATALOG\\\", \\\"null\\\")\\n monkeypatch.setenv(\\\"COMPUTATIONAL_BACKEND_DASK_CLIENT_ENABLED\\\", \\\"0\\\")\\n monkeypatch.setenv(\\\"COMPUTATIONAL_BACKEND_ENABLED\\\", \\\"0\\\")\",\n \"def enablePyLangLogger(self):\",\n \"def opt_spew(self):\\n from twisted.python.util import spewer\\n sys.settrace(spewer)\",\n \"def RecordExperimentalSetup(log_dir: Path) -> None:\\n with open(log_dir / \\\"flags.txt\\\", \\\"w\\\") as f:\\n f.write(FLAGS.flags_into_string())\\n with open(log_dir / \\\"build_info.json\\\", \\\"w\\\") as f:\\n json.dump({}, f, sort_keys=True, indent=2, separators=(\\\",\\\", \\\": \\\"))\",\n \"def main(ctx, debug):\\n if debug:\\n logger.setLevel(logging.DEBUG)\",\n \"def _modified_option_defaults(self) -> Dict[str, Any]:\\n return {\\n # Change 'debug.traceback' default to True if debug logging is enabled.\\n 'debug.traceback': logging.getLogger('pyocd').isEnabledFor(logging.DEBUG),\\n }\",\n \"def set_debug(self, debug):\\n self.debug_flag = debug\\n self.debug_log(\\\"%s: debug = %s\\\" % (self.__class__.__name__,\\n self.debug_flag),\\n flag=True)\\n return debug\",\n \"def debug(state: bool, /) -> None:\",\n \"def debug(self):\\n raise NotImplementedError\",\n \"def debug() -> bool:\",\n \"def get_debug():\\n return _DEBUG\",\n \"def debug(x=''):\\n project_settings = get_settings()\\n print project_settings.EXTRA_APPS\",\n \"def pre_start_hook(self):\\n\\n LOG.debug(_('XManager pre_start_hook...'))\\n\\n pass\",\n \"def set_debug_mode(self, value):\\n self.debug = value\",\n \"def test_addFlagsSilently(self):\\n self._flagsSilentlyTest('addFlags', b'+FLAGS.SILENT')\",\n \"def debug_info(self, enable):\\n\\n if not isinstance(enable, bool):\\n raise TypeError('expected a bool')\\n dll.wasmtime_config_debug_info_set(self.__ptr__, enable)\",\n \"def set_trace():\\n Bdb().set_trace()\",\n \"def debug_option(args, run):\\n run.debug = True\",\n \"def is_debug(cls):\\n return Traceable.debug & cls.DEBUG_ENABLE\",\n \"def debugMemory(activate):\\n ret = libxml2mod.xmlDebugMemory(activate)\\n return ret\",\n \"def toggle_debug(self):\\n return self.set_debug(not self.debug_flag)\",\n \"def initGlobals():\\n libxml2mod.xmlInitGlobals()\",\n \"def SetDebugLevel(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def setup_external_logging() -> None:\\n logging.getLogger(\\\"web3\\\").setLevel(logging.INFO) # web3 logger\",\n \"def SetVerbose(new_verbose=True):\\n global _verbose\\n _verbose = new_verbose\",\n \"def debug(self, *args, **kwargs):\",\n \"def configure_logging(self):\\n\\n if self.options.debug:\\n # --debug forces verbose_level 3\\n # Set this here so cliff.app.configure_logging() can work\\n self.options.verbose_level = 3\\n\\n super(Servizor, self).configure_logging()\\n root_logger = logging.getLogger('')\\n\\n # Requests logs some stuff at INFO that we don't want\\n # unless we have DEBUG\\n requests_log = logging.getLogger(\\\"requests\\\")\\n requests_log.setLevel(logging.ERROR)\\n\\n # Other modules we don't want DEBUG output for so\\n # don't reset them below\\n iso8601_log = logging.getLogger(\\\"iso8601\\\")\\n iso8601_log.setLevel(logging.ERROR)\\n\\n # Set logging to the requested level\\n self.dump_stack_trace = False\\n if self.options.verbose_level == 0:\\n # --quiet\\n root_logger.setLevel(logging.ERROR)\\n elif self.options.verbose_level == 1:\\n # This is the default case, no --debug, --verbose or --quiet\\n root_logger.setLevel(logging.WARNING)\\n elif self.options.verbose_level == 2:\\n # One --verbose\\n root_logger.setLevel(logging.INFO)\\n elif self.options.verbose_level >= 3:\\n # Two or more --verbose\\n root_logger.setLevel(logging.DEBUG)\\n requests_log.setLevel(logging.DEBUG)\\n\\n if self.options.debug:\\n # --debug forces traceback\\n self.dump_stack_trace = True\",\n \"def _AddCommonFlags(self, resource):\\n self.flags['format'] = 'json'\\n self.additional_flags.extend(FLAGS.openstack_additional_flags or ())\",\n \"def enable_instance_inspection(self):\\n self._request({\\\"enable-instance-inspection\\\": True})\",\n \"def main(debug):\\n click.echo('Debug mode is {{}}'.format(debug))\",\n \"def setup_logging(debug):\\n root = logging.getLogger()\\n root.setLevel(debug and logging.DEBUG or logging.INFO)\\n handler = logging.StreamHandler()\\n formatter = ColorFormatter(fmt='[%(levelname)s] %(message)s')\\n handler.setFormatter(formatter)\\n root.addHandler(handler)\",\n \"def is_debug ():\\n\\n return __debug__ and DEBUG\",\n \"def set_parameters(tensor_tracer_params=None):\\n enable_flags = '--%s=1' % tensor_tracer_flags.FLAG_NAME_ENABLE\\n if tensor_tracer_params:\\n for key, value in tensor_tracer_params.items():\\n enable_flags += ' --%s=%s' % (key, value)\\n os.environ[tensor_tracer_flags.FLAGS_ENV_VAR] = enable_flags\",\n \"def setup():\\n global log_handler\\n\\n if vaex.settings.main.logging.setup:\\n logger.setLevel(logging.DEBUG)\\n\\n # create console handler and accept all loglevels\\n if vaex.settings.main.logging.rich:\\n from rich.logging import RichHandler\\n log_handler = RichHandler()\\n else:\\n log_handler = logging.StreamHandler()\\n\\n # create formatter\\n formatter = logging.Formatter('%(levelname)s:%(threadName)s:%(name)s:%(message)s')\\n\\n\\n # add formatter to console handler\\n log_handler.setFormatter(formatter)\\n log_handler.setLevel(logging.DEBUG)\\n\\n # add console handler to logger\\n logger.addHandler(log_handler)\\n\\n logging.getLogger(\\\"vaex\\\").setLevel(logging.ERROR) # default to higest level\\n _set_log_level(vaex.settings.main.logging.error, logging.ERROR)\\n _set_log_level(vaex.settings.main.logging.warning, logging.WARNING)\\n _set_log_level(vaex.settings.main.logging.info, logging.INFO)\\n _set_log_level(vaex.settings.main.logging.debug, logging.DEBUG)\\n # VAEX_DEBUG behaves similar to VAEX_LOGGING_DEBUG, but has more effect\\n DEBUG_MODE = os.environ.get('VAEX_DEBUG', '')\\n if DEBUG_MODE:\\n _set_log_level(DEBUG_MODE, logging.DEBUG)\",\n \"def enableDebugCallbackOutput(self):\\n key = \\\"NatlinkmainDebugCallback\\\"\\n self.userregnl.set(key, 1)\",\n \"def register_globals ():\\n\\n # This feature is used to determine which OS we're on.\\n # In future, this may become <target-os> and <host-os>\\n # TODO: check this. Compatibility with bjam names? Subfeature for version?\\n os = sys.platform\\n feature.feature ('os', [os], ['propagated', 'link-incompatible'])\\n\\n\\n # The two OS features define a known set of abstract OS names. The host-os is\\n # the OS under which bjam is running. Even though this should really be a fixed\\n # property we need to list all the values to prevent unknown value errors. Both\\n # set the default value to the current OS to account for the default use case of\\n # building on the target OS.\\n feature.feature('host-os', __os_names)\\n feature.set_default('host-os', default_host_os())\\n\\n feature.feature('target-os', __os_names, ['propagated', 'link-incompatible'])\\n feature.set_default('target-os', default_host_os())\\n\\n feature.feature ('toolset', [], ['implicit', 'propagated' ,'symmetric'])\\n\\n feature.feature ('stdlib', ['native'], ['propagated', 'composite'])\\n\\n feature.feature ('link', ['shared', 'static'], ['propagated'])\\n feature.feature ('runtime-link', ['shared', 'static'], ['propagated'])\\n feature.feature ('runtime-debugging', ['on', 'off'], ['propagated'])\\n\\n\\n feature.feature ('optimization', ['off', 'speed', 'space'], ['propagated'])\\n feature.feature ('profiling', ['off', 'on'], ['propagated'])\\n feature.feature ('inlining', ['off', 'on', 'full'], ['propagated'])\\n\\n feature.feature ('threading', ['single', 'multi'], ['propagated'])\\n feature.feature ('rtti', ['on', 'off'], ['propagated'])\\n feature.feature ('exception-handling', ['on', 'off'], ['propagated'])\\n\\n # Whether there is support for asynchronous EH (e.g. catching SEGVs).\\n feature.feature ('asynch-exceptions', ['off', 'on'], ['propagated'])\\n\\n # Whether all extern \\\"C\\\" functions are considered nothrow by default.\\n feature.feature ('extern-c-nothrow', ['off', 'on'], ['propagated'])\\n\\n feature.feature ('debug-symbols', ['on', 'off'], ['propagated'])\\n feature.feature ('define', [], ['free'])\\n feature.feature ('undef', [], ['free'])\\n feature.feature ('include', [], ['free', 'path']) #order-sensitive\\n feature.feature ('cflags', [], ['free'])\\n feature.feature ('cxxflags', [], ['free'])\\n feature.feature ('asmflags', [], ['free'])\\n feature.feature ('linkflags', [], ['free'])\\n feature.feature ('archiveflags', [], ['free'])\\n feature.feature ('version', [], ['free'])\\n\\n feature.feature ('location-prefix', [], ['free'])\\n\\n feature.feature ('action', [], ['free'])\\n\\n\\n # The following features are incidental, since\\n # in themself they have no effect on build products.\\n # Not making them incidental will result in problems in corner\\n # cases, for example:\\n #\\n # unit-test a : a.cpp : <use>b ;\\n # lib b : a.cpp b ;\\n #\\n # Here, if <use> is not incidental, we'll decide we have two\\n # targets for a.obj with different properties, and will complain.\\n #\\n # Note that making feature incidental does not mean it's ignored. It may\\n # be ignored when creating the virtual target, but the rest of build process\\n # will use them.\\n feature.feature ('use', [], ['free', 'dependency', 'incidental'])\\n feature.feature ('dependency', [], ['free', 'dependency', 'incidental'])\\n feature.feature ('implicit-dependency', [], ['free', 'dependency', 'incidental'])\\n\\n feature.feature('warnings', [\\n 'on', # Enable default/\\\"reasonable\\\" warning level for the tool.\\n 'all', # Enable all possible warnings issued by the tool.\\n 'off'], # Disable all warnings issued by the tool.\\n ['incidental', 'propagated'])\\n\\n feature.feature('warnings-as-errors', [\\n 'off', # Do not fail the compilation if there are warnings.\\n 'on'], # Fail the compilation if there are warnings.\\n ['incidental', 'propagated'])\\n\\n feature.feature('c++-template-depth',\\n [str(i) for i in range(64,1024+1,64)] +\\n [str(i) for i in range(20,1000+1,10)] +\\n # Maximum template instantiation depth guaranteed for ANSI/ISO C++\\n # conforming programs.\\n ['17'],\\n ['incidental', 'optional', 'propagated'])\\n\\n feature.feature ('source', [], ['free', 'dependency', 'incidental'])\\n feature.feature ('library', [], ['free', 'dependency', 'incidental'])\\n feature.feature ('file', [], ['free', 'dependency', 'incidental'])\\n feature.feature ('find-shared-library', [], ['free']) #order-sensitive ;\\n feature.feature ('find-static-library', [], ['free']) #order-sensitive ;\\n feature.feature ('library-path', [], ['free', 'path']) #order-sensitive ;\\n # Internal feature.\\n feature.feature ('library-file', [], ['free', 'dependency'])\\n\\n feature.feature ('name', [], ['free'])\\n feature.feature ('tag', [], ['free'])\\n feature.feature ('search', [], ['free', 'path']) #order-sensitive ;\\n feature.feature ('location', [], ['free', 'path'])\\n\\n feature.feature ('dll-path', [], ['free', 'path'])\\n feature.feature ('hardcode-dll-paths', ['true', 'false'], ['incidental'])\\n\\n\\n # This is internal feature which holds the paths of all dependency\\n # dynamic libraries. On Windows, it's needed so that we can all\\n # those paths to PATH, when running applications.\\n # On Linux, it's needed to add proper -rpath-link command line options.\\n feature.feature ('xdll-path', [], ['free', 'path'])\\n\\n #provides means to specify def-file for windows dlls.\\n feature.feature ('def-file', [], ['free', 'dependency'])\\n\\n # This feature is used to allow specific generators to run.\\n # For example, QT tools can only be invoked when QT library\\n # is used. In that case, <allow>qt will be in usage requirement\\n # of the library.\\n feature.feature ('allow', [], ['free'])\\n\\n # The addressing model to generate code for. Currently a limited set only\\n # specifying the bit size of pointers.\\n feature.feature('address-model', ['16', '32', '64'], ['propagated', 'optional'])\\n\\n # Type of CPU architecture to compile for.\\n feature.feature('architecture', [\\n # x86 and x86-64\\n 'x86',\\n\\n # ia64\\n 'ia64',\\n\\n # Sparc\\n 'sparc',\\n\\n # RS/6000 & PowerPC\\n 'power',\\n\\n # MIPS/SGI\\n 'mips1', 'mips2', 'mips3', 'mips4', 'mips32', 'mips32r2', 'mips64',\\n\\n # HP/PA-RISC\\n 'parisc',\\n\\n # Advanced RISC Machines\\n 'arm',\\n\\n # Combined architectures for platforms/toolsets that support building for\\n # multiple architectures at once. \\\"combined\\\" would be the default multi-arch\\n # for the toolset.\\n 'combined',\\n 'combined-x86-power'],\\n\\n ['propagated', 'optional'])\\n\\n # The specific instruction set in an architecture to compile.\\n feature.feature('instruction-set', [\\n # x86 and x86-64\\n 'native', 'i486', 'i586', 'i686', 'pentium', 'pentium-mmx', 'pentiumpro', 'pentium2', 'pentium3',\\n 'pentium3m', 'pentium-m', 'pentium4', 'pentium4m', 'prescott', 'nocona', 'core2', 'corei7', 'corei7-avx', 'core-avx-i',\\n 'conroe', 'conroe-xe', 'conroe-l', 'allendale', 'merom', 'merom-xe', 'kentsfield', 'kentsfield-xe', 'penryn', 'wolfdale',\\n 'yorksfield', 'nehalem', 'sandy-bridge', 'ivy-bridge', 'haswell', 'k6', 'k6-2', 'k6-3', 'athlon', 'athlon-tbird', 'athlon-4', 'athlon-xp',\\n 'athlon-mp', 'k8', 'opteron', 'athlon64', 'athlon-fx', 'k8-sse3', 'opteron-sse3', 'athlon64-sse3', 'amdfam10', 'barcelona',\\n 'bdver1', 'bdver2', 'bdver3', 'btver1', 'btver2', 'winchip-c6', 'winchip2', 'c3', 'c3-2', 'atom',\\n\\n # ia64\\n 'itanium', 'itanium1', 'merced', 'itanium2', 'mckinley',\\n\\n # Sparc\\n 'v7', 'cypress', 'v8', 'supersparc', 'sparclite', 'hypersparc', 'sparclite86x', 'f930', 'f934',\\n 'sparclet', 'tsc701', 'v9', 'ultrasparc', 'ultrasparc3',\\n\\n # RS/6000 & PowerPC\\n '401', '403', '405', '405fp', '440', '440fp', '505', '601', '602',\\n '603', '603e', '604', '604e', '620', '630', '740', '7400',\\n '7450', '750', '801', '821', '823', '860', '970', '8540',\\n 'power-common', 'ec603e', 'g3', 'g4', 'g5', 'power', 'power2',\\n 'power3', 'power4', 'power5', 'powerpc', 'powerpc64', 'rios',\\n 'rios1', 'rsc', 'rios2', 'rs64a',\\n\\n # MIPS\\n '4kc', '4kp', '5kc', '20kc', 'm4k', 'r2000', 'r3000', 'r3900', 'r4000',\\n 'r4100', 'r4300', 'r4400', 'r4600', 'r4650',\\n 'r6000', 'r8000', 'rm7000', 'rm9000', 'orion', 'sb1', 'vr4100',\\n 'vr4111', 'vr4120', 'vr4130', 'vr4300',\\n 'vr5000', 'vr5400', 'vr5500',\\n\\n # HP/PA-RISC\\n '700', '7100', '7100lc', '7200', '7300', '8000',\\n\\n # Advanced RISC Machines\\n 'armv2', 'armv2a', 'armv3', 'armv3m', 'armv4', 'armv4t', 'armv5',\\n 'armv5t', 'armv5te', 'armv6', 'armv6j', 'iwmmxt', 'ep9312'],\\n\\n ['propagated', 'optional'])\\n\\n feature.feature('conditional', [], ['incidental', 'free'])\\n\\n # The value of 'no' prevents building of a target.\\n feature.feature('build', ['yes', 'no'], ['optional'])\\n\\n # Windows-specific features\\n feature.feature ('user-interface', ['console', 'gui', 'wince', 'native', 'auto'], [])\\n feature.feature ('variant', [], ['implicit', 'composite', 'propagated', 'symmetric'])\\n\\n\\n variant ('debug', ['<optimization>off', '<debug-symbols>on', '<inlining>off', '<runtime-debugging>on'])\\n variant ('release', ['<optimization>speed', '<debug-symbols>off', '<inlining>full',\\n '<runtime-debugging>off', '<define>NDEBUG'])\\n variant ('profile', ['release'], ['<profiling>on', '<debug-symbols>on'])\",\n \"def javaEnabled(self):\\n return False\",\n \"def output_debug_info(self):\",\n \"def _trace(self):\\n self.__aceQLHttpApi.trace()\",\n \"def test_setFlagsSilently(self):\\n self._flagsSilentlyTest('setFlags', b'FLAGS.SILENT')\",\n \"def set_tracing(self, tracing: bool) -> None:\\n self.tracing = tracing\",\n \"def toggle_remote_debug():\\n import sys\\n import os\\n\\n debug_on = len(sys.argv) >= 2 and '--remote-debug' in sys.argv[1]\\n\\n if debug_on:\\n egg_path = os.path.abspath(os.path.join(os.path.dirname(__file__), \\\"pycharm-debug-py3k.egg\\\"))\\n sys.path.append(egg_path)\\n import pydevd\\n pydevd.settrace('localhost', port=9090)\\n\\n yield\\n\\n if debug_on:\\n import pydevd\\n pydevd.stoptrace()\",\n \"def setup_options(parser):\\n help_str = \\\"Turn on debug\\\"\\n parser.add_argument(\\\"-d\\\", \\\"--debug\\\", action=\\\"store_true\\\", default=False,\\n help=help_str)\",\n \"def debug(self):\\n return Config.DEBUG\",\n \"def enable(self):\\n LOGGER.info('Enabling WebAPI plugin WEB ...')\",\n \"def setVerboseDebugOff(self):\\n self.edLogging.setVerboseDebugOff()\",\n \"def debug():\\n return exported_res_dict\",\n \"def set_pretty_print(value):\\n global _with_colors\\n _with_colors = True if value else False\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7106474","0.6122721","0.6115534","0.59994066","0.59944767","0.599425","0.5859546","0.5831815","0.57899874","0.574849","0.5723658","0.57184064","0.5690623","0.56572646","0.56189394","0.56183857","0.55708146","0.55087733","0.55059654","0.549461","0.54930943","0.54761434","0.5454504","0.54366446","0.537866","0.537866","0.53625095","0.5348113","0.5342462","0.5334421","0.5329275","0.5326629","0.5319068","0.5312043","0.52978224","0.5289878","0.5272157","0.5258334","0.5250351","0.52417594","0.5228035","0.52102154","0.51988566","0.518808","0.5180559","0.5144089","0.51421094","0.513945","0.5094415","0.50925255","0.50792754","0.5069366","0.50658345","0.5064651","0.504744","0.5024281","0.5022026","0.5021948","0.50195116","0.5006911","0.49973747","0.49947655","0.49903378","0.49865368","0.49835506","0.4981057","0.49802527","0.49732903","0.49717334","0.4964685","0.4963016","0.4957518","0.49534443","0.49500355","0.4946547","0.4940441","0.49323872","0.49229974","0.4904894","0.4899099","0.4896801","0.48915505","0.48816338","0.48699299","0.486906","0.48621327","0.4858806","0.48538375","0.48526636","0.48520207","0.48486283","0.48379737","0.4832819","0.48246416","0.48116082","0.4811158","0.48093432","0.48061535","0.48027527","0.48024708"],"string":"[\n \"0.7106474\",\n \"0.6122721\",\n \"0.6115534\",\n \"0.59994066\",\n \"0.59944767\",\n \"0.599425\",\n \"0.5859546\",\n \"0.5831815\",\n \"0.57899874\",\n \"0.574849\",\n \"0.5723658\",\n \"0.57184064\",\n \"0.5690623\",\n \"0.56572646\",\n \"0.56189394\",\n \"0.56183857\",\n \"0.55708146\",\n \"0.55087733\",\n \"0.55059654\",\n \"0.549461\",\n \"0.54930943\",\n \"0.54761434\",\n \"0.5454504\",\n \"0.54366446\",\n \"0.537866\",\n \"0.537866\",\n \"0.53625095\",\n \"0.5348113\",\n \"0.5342462\",\n \"0.5334421\",\n \"0.5329275\",\n \"0.5326629\",\n \"0.5319068\",\n \"0.5312043\",\n \"0.52978224\",\n \"0.5289878\",\n \"0.5272157\",\n \"0.5258334\",\n \"0.5250351\",\n \"0.52417594\",\n \"0.5228035\",\n \"0.52102154\",\n \"0.51988566\",\n \"0.518808\",\n \"0.5180559\",\n \"0.5144089\",\n \"0.51421094\",\n \"0.513945\",\n \"0.5094415\",\n \"0.50925255\",\n \"0.50792754\",\n \"0.5069366\",\n \"0.50658345\",\n \"0.5064651\",\n \"0.504744\",\n \"0.5024281\",\n \"0.5022026\",\n \"0.5021948\",\n \"0.50195116\",\n \"0.5006911\",\n \"0.49973747\",\n \"0.49947655\",\n \"0.49903378\",\n \"0.49865368\",\n \"0.49835506\",\n \"0.4981057\",\n \"0.49802527\",\n \"0.49732903\",\n \"0.49717334\",\n \"0.4964685\",\n \"0.4963016\",\n \"0.4957518\",\n \"0.49534443\",\n \"0.49500355\",\n \"0.4946547\",\n \"0.4940441\",\n \"0.49323872\",\n \"0.49229974\",\n \"0.4904894\",\n \"0.4899099\",\n \"0.4896801\",\n \"0.48915505\",\n \"0.48816338\",\n \"0.48699299\",\n \"0.486906\",\n \"0.48621327\",\n \"0.4858806\",\n \"0.48538375\",\n \"0.48526636\",\n \"0.48520207\",\n \"0.48486283\",\n \"0.48379737\",\n \"0.4832819\",\n \"0.48246416\",\n \"0.48116082\",\n \"0.4811158\",\n \"0.48093432\",\n \"0.48061535\",\n \"0.48027527\",\n \"0.48024708\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.84278125"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":23099,"cells":{"query":{"kind":"string","value":"Prints out shape of parameters and total number of trainable parameters."},"document":{"kind":"string","value":"def log_param_shapes(params: Any,\n print_params_nested_dict: bool = False) -> int:\n if print_params_nested_dict:\n shape_dict = tree_map(lambda x: str(x.shape), params)\n # We use json.dumps for pretty printing nested dicts.\n logging.info('Printing model param shape:/n%s',\n json.dumps(shape_dict, sort_keys=True, indent=4))\n parameter_overview.log_parameter_overview(params)\n total_params = jax.tree_util.tree_reduce(operator.add,\n tree_map(lambda x: x.size, params))\n logging.info('Total params: %d', total_params)\n return total_params"},"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 print_trainable_params(scope=None):\n n_params = 0\n print('name \\t| shape \\t| num parameters')\n\n for var in tf.trainable_variables(scope):\n # shape is an array of tf.Dimension\n shape = var.get_shape()\n n_elems = shape.num_elements()\n print(var.name, shape, n_elems)\n n_params += n_elems\n\n print('Total parameters:', n_params)","def print_params_shape(scope, param_type):\n shapes = [var.get_shape().as_list() for var in get_trainable_vars(scope)]\n nb_params = sum([reduce(lambda x, y: x * y, shape) for shape in shapes])\n print(' {} shapes: {}'.format(param_type, shapes))\n print(' {} params: {}'.format(param_type, nb_params))","def printParameters(self):\n print(\"----------Model Parameters----------\")\n print(\"Initial Conv. Depth : \" + str(self.conv_depth))\n print(\"Number of Classes : \" + str(self.n_classes))\n print(\"Dropout : \" + str(self.dropout))\n print(\"Activation Function : Relu\")\n print(\"Input Shape : \" + str(self.input_shape))\n print(\"Batch Size : \" + str(self.batch_size))\n print(\"--------Optimizer Parameters--------\")\n print(\"Learning Rate : \" + str(self.optimizer.lr))\n print(\"Momentum : \" + str(self.optimizer.momentum))\n print(\"Initial Decay : \" + str(self.optimizer.initial_decay))","def print_total_params(print_function=tf.logging.info):\n\n total_parameters = 0\n for variable in tf.trainable_variables():\n # shape is an array of tf.Dimension\n shape = variable.get_shape()\n variable_parametes = 1\n for dim in shape:\n variable_parametes *= dim.value\n total_parameters += variable_parametes\n print_function(f'TOTAL NUMBER OF PARAMTERS:{total_parameters}')\n print_function(f'Memory Estimate:{total_parameters*32/8/1024/1024} MB')","def count_parameters():\n total_parameters = 0\n for variable in tf.trainable_variables():\n # shape is an array of tf.Dimension\n name = variable.name\n shape = variable.get_shape()\n #print(shape)\n #print(len(shape))\n variable_parameters = 1\n for dim in shape:\n #print(dim)\n variable_parameters *= dim.value\n print(name, [dim for dim in shape], variable_parameters)\n total_parameters += variable_parameters\n print('Number of trainable parameters = {}'.format(total_parameters))","def print_network(net):\n num_params = 0\n for param in net.parameters():\n num_params += param.numel()\n print(net)\n print(\"Total number of parameters: {}\".format(num_params))","def print_network(self, model, name):\n num_params = 0\n for p in model.parameters():\n num_params += p.numel()\n print(model)\n print(name)\n print(\"The number of parameters: {}\".format(num_params))","def describe_model():\n train_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)\n msg = [\"\"]\n total = 0\n for v in train_vars:\n shape = v.get_shape()\n ele = shape.num_elements()\n total += ele\n msg.append(\"{}: shape={}, dim={}\".format(\n v.name, shape.as_list(), ele))\n size_mb = total * 4 / 1024.0**2\n msg.append(colored(\n \"Total param={} ({:01f} MB assuming all float32)\".format(total, size_mb), 'cyan'))\n logger.info(colored(\"Model Parameters: \", 'cyan') + '\\n'.join(msg))","def print_network(self, model, name):\r\n num_params = 0\r\n for p in model.parameters():\r\n num_params += p.numel()\r\n print(model)\r\n print(name)\r\n print(\"The number of parameters: {}\".format(num_params))","def print_network(self, model, name):\r\n num_params = 0\r\n for p in model.parameters():\r\n num_params += p.numel()\r\n print(model)\r\n print(name)\r\n print(\"The number of parameters: {}\".format(num_params))","def print_network(self, model, name):\n num_params = 0\n for p in model.parameters():\n num_params += p.numel()\n print(model)\n print(name)\n print(\"The number of parameters: {}\".format(num_params))","def print_network(self, model, name):\n num_params = 0\n for p in model.parameters():\n num_params += p.numel()\n print(model)\n print(name)\n print(\"The number of parameters: {}\".format(num_params))","def print_network(self, model, name):\n num_params = 0\n for p in model.parameters():\n num_params += p.numel()\n print(model)\n print(name)\n print(\"The number of parameters: {}\".format(num_params))","def print_network(self, model, name):\n num_params = 0\n for p in model.parameters():\n num_params += p.numel()\n print(model)\n print(name)\n print(\"The number of parameters: {}\".format(num_params))","def print_network(model, name):\r\n num_params = 0\r\n for p in model.parameters():\r\n num_params += p.numel()\r\n print(model)\r\n print(name)\r\n print(\"The number of parameters: {}\".format(num_params))","def print_num_params(model: nn.Module):\n if type(model) == DistributedDataParallel:\n model = model.module\n\n # Count all parameteres\n sum_params = count_params(model)\n\n # Count SPN parameters\n spn_params = sum_params\n\n # Print\n logger.info(f\"Number of parameters:\")\n # logger.info(f\"- Total: {sum_params / 1e6: >8.3f}M\")\n logger.info(\n f\"- SPN: {spn_params / 1e6: >8.3f}M ({spn_params / sum_params * 100:.1f}%)\"\n )\n # logger.info(f\"- NN: {nn_params / 1e6: >8.3f}M ({nn_params / sum_params * 100:.1f}%)\")","def print_shape(self):\n print(\"X_train: \", self.X_train.shape)\n print(\"X_test: \", self.X_test.shape)\n print(\"y_train: \", self.y_train.shape)\n print(\"y_test: \", self.y_test.shape)","def count_parameters(sess):\n\n variables_names = [v.name for v in tf.trainable_variables()]\n values = sess.run(variables_names)\n n_params = 0\n\n for k, v in zip(variables_names, values):\n print '-'.center(140, '-')\n print '{:60s}\\t\\tShape: {:20s}\\t{:20} parameters'.format(k, v.shape, v.size)\n\n n_params += v.size\n\n print '-'.center(140, '-')\n print 'Total # parameters:\\t\\t{}\\n\\n'.format(n_params)\n\n return n_params","def print_param_names(model):\n for (param_name, param) in model.get_parameters().items():\n print(param_name, param.shape)","def show_parameters(self):\n with np.printoptions(precision=3, suppress=True):\n print('number of wind phase = {}'.format(self.ncomp))\n print('galactic parameter = {}'.format(self.scaling_field))\n print('reference height = {}'.format(self.z0))\n for p in ['cool_params','hot_params','params','ref_params','scaling_params']:\n params = getattr(self,p)\n print(p)\n for k,v in params.items():\n print(' {} = {}'.format(k,v))","def print_network(self, model, name):\n num_params = 0\n for p in model.parameters():\n num_params += p.numel()\n print(\"\\nModel Name: \\\"{}\\\"\".format(name))\n print(model)\n print(\"The number of parameters: {}\".format(num_params))","def print_network(self, model, name):\n num_params = 0\n for p in model.parameters():\n num_params += p.numel()\n print(\"\\nModel Name: \\\"{}\\\"\".format(name))\n print(model)\n print(\"The number of parameters: {}\".format(num_params))","def printParameters(self):\n with self._graph.as_default():\n for var in tf.global_variables():\n print(var.name)\n val = self._sess.run(var)\n print(val)","def count_parameters(also_print=True):\n total = 0\n if also_print:\n logging.info('Model Parameters:')\n for (_, v) in get_vars_to_save_and_restore().items():\n shape = v.get_shape()\n if also_print:\n logging.info('%s %s: %s', v.op.name, shape,\n format_number(shape.num_elements()))\n total += shape.num_elements()\n if also_print:\n logging.info('Total: %s', format_number(total))\n return total","def print_info(self):\n print(\"Num samples (train/test/val): {} tot: {}\\n\"\n \"Samples per class: {}\\n\"\n \"Sample type {}\\n\"\n \"Sample shape: {}\\n\"\n \"Label type {}\\n\"\n \"Label shape: {}\\n\"\n \"Root dirs: {}\".format([int(np.floor(frac * len(self.__labels))) for frac in self.split_fraction],\n len(self.__labels),\n self.__samples_per_class,\n self.train.output_types[0], self.train.output_shapes[0][1:],\n self.train.output_types[1], self.train.output_shapes[1][1:],\n self.__root_directory_list))","def print_params(self):\n print(self._list_params())","def show(self):\n print \"Name: \"+str(self.name)\n ss = self.y.shape[0]\n for i in xrange(ss):\n print \"Actual: \"+str(self.y[i])\n print \"Prediction: \"+str(self.a[i])\n print \"\"\n print \"\\n\"","def _print_model_parameters(labels, parameters, errors):\n for label, parameter, error in zip(labels, parameters, errors):\n print(f\"{label} = {parameter:.5f} +- {error:.5f}\")","def __str__(self):\n model_parameters = filter(lambda p: p.requires_grad, self.parameters())\n params = sum([np.prod(p.size()) for p in model_parameters])\n return super(BaseModel, self).__str__() + '\\nTrainable parameters: {}'.format(params)\n # print(super(BaseModel, self))","def print_params(self):\n s = self._list_params()+\"\\n\"\n if 'scale_params' in self.__dict__.keys():\n s += self.scale_params._list_params()+\"\\n\"\n if 'atmospheric_params' in self.__dict__.keys():\n if self.atmospheric_params is not None:\n s += self.atmospheric_params._list_params()+\"\\n\"\n\n if 'atemperature_params' in self.__dict__.keys():\n if self.atemperature_params is not None:\n s += self.atemperature_params._list_params()+\"\\n\"\n\n if 'oceanic_params' in self.__dict__.keys():\n if self.oceanic_params is not None:\n s += self.oceanic_params._list_params()+\"\\n\"\n\n if 'ground_params' in self.__dict__.keys():\n if self.ground_params is not None:\n s += self.ground_params._list_params()+\"\\n\"\n\n if 'gotemperature_params' in self.__dict__.keys():\n if self.gotemperature_params is not None:\n s += self.gotemperature_params._list_params() + \"\\n\"\n\n print(\"Qgs v0.2.8 parameters summary\")\n print(\"=============================\\n\")\n print(s)","def print_info(self):\n\n print \"\\nALGORITHM INFO\"\n print \"modelnumber:\", self.modelnumber\n print \"restart:\", self.restart\n print \"particles:\", self.particles\n print \"beta:\", self.beta\n print \"dt:\", self.dt\n if self.mode != 1:\n if len(self.final_epsilon) == 0:\n print \"manual epsilon:\"\n for i in range(self.epsilon.shape[0]):\n print \"\\t\",\n for j in range(self.epsilon.shape[1]):\n print \"\", self.epsilon[i, j],\n print \"\"\n else:\n print \"auto epsilon:\"\n print \"\\t\", self.final_epsilon\n print \"\\talpha:\", self.alpha\n\n print \"kernel:\", self.kernel\n print \"model kernel:\", self.modelkernel\n print \"model prior:\", self.modelprior\n\n print \"DATA:\"\n print \"\\ttimes:\", self.times\n if self.mode == 0:\n print \"\\tvars:\"\n for i in range(len(self.data[0, :])):\n print \"\\t\",\n for j in range(self.ntimes):\n print \"\", self.data[j, i],\n print \"\"\n\n print \"MODELS:\", self.nmodels\n for i in range(self.nmodels):\n print \"\\t\", \"npar:\", self.nparameters[i]\n print \"\\t\", \"nspecies:\", self.nspecies[i]\n print \"\\t\", \"name:\", self.name[i]\n print \"\\t\", \"source:\", self.source[i]\n print \"\\t\", \"type:\", self.type[i]\n print \"\\t\", \"fit:\", self.fit[i]\n print \"\\t\", \"init:\", self.x0prior[i]\n print \"\\t\", \"prior:\", self.prior[i]\n print \"\\t\", \"logp:\", self.logp[i]\n print \"\\n\"","def summarize(self):\n # go recursively in the model architecture\n summary_str = self.recursive_summarize(self, 0, self.name)\n\n # Sum the model parameters.\n num_total_params = sum([np.prod(p.size()) for p in self.parameters()])\n mod_trainable_params = filter(lambda p: p.requires_grad, self.parameters())\n num_trainable_params = sum([np.prod(p.size()) for p in mod_trainable_params])\n\n summary_str += 'Total Trainable Params: {}\\n'.format(num_trainable_params)\n summary_str += 'Total Non-trainable Params: {}\\n'.format(num_total_params-num_trainable_params) \n summary_str += '='*80 + '\\n'\n\n return summary_str","def print_network(self, model, name):\n num_params = 0\n for p in model.parameters():\n num_params += p.numel()\n #print(model)\n print(name)\n print(\"The number of parameters: {}\".format(num_params))\n\n with open(os.path.join(self.train_dir,'model_arch.txt'), 'a') as fp:\n print(model, file=fp)\n print(name, file=fp)\n print(\"The number of parameters: {}\".format(num_params),file=fp)","def _report_model_parameters(self):\n\n all_params = sum(p.numel() for p in self.parameters())\n trainable_params = sum(p.numel() for p in self.parameters() if p.requires_grad)\n size = all_params * (32 / 8) # Bytes\n logger.info(\"Model has %.1f M parameters (%.1f M trainable) with an estimated size of %.1f MB\", all_params / 1e6, trainable_params / 1.0e6, size / 1.0e6)","def print_networks(self, verbose):\n print('---------- Networks initialized -------------')\n for name in self.model_names:\n if isinstance(name, str):\n net = getattr(self, 'net' + name)\n num_params = 0\n for param in net.parameters():\n num_params += param.numel()\n if verbose:\n print(net)\n print('[Network %s] Total number of parameters : %.3f M' % (name, num_params / 1e6))\n print('-----------------------------------------------')","def display_parameters(self):\n ips = GAConfig[\"initial_population_size\"]\n ps = GAConfig[\"population_size\"]\n nomp = GAConfig[\"num_mating_pairs\"]\n mf = GAConfig[\"base_mutation_factor\"]\n ne = GAConfig[\"num_evolutions\"]\n noc = GAConfig[\"num_categories\"]\n nog = len(self.phones)\n\n display_string = \"\"\"\n Genetic Algorithm Parameters\n ----------------------------\n Initial Population Size %s\n Population Size %s\n Number of Mating Pairs %s\n Base Mutation Factor %s\n Number of Evolutions %s\n Number of Categories %s\n Number of Genes %s\n \"\"\" % (ips, ps, nomp, mf, ne, noc, nog)\n\n print(display_string)","def print_grid_params(params):\n tot = 1\n for key, p in params.items():\n tot *= len(p)\n print(f'{key}: {p}')\n\n print(f'\\nTotal models: {tot}\\n')\n print('=' * 40)","def display_layer_parameters(self):\n pprint.pprint(vars(self))\n return","def printConf(self):\n print \"\"\n for pname, pvalue in self.neededParams.items():\n print pname, pvalue\n for pname, pvalue in self.optionalParams.items():\n print pname, pvalue","def display(self):\n print(\"{}, {}\".format(self.label, self.params))","def summary(self):\n\n print(\n \"\\nModel trained with dataset %s that has maxlen=%d and charset=%s for %d epochs.\"\n % (self.dataset_name, self.maxlen, self.charset, self.epochs)\n )\n\n print(\n \"noise_std: %.6f, lstm_dim: %d, dec_layers: %d, td_dense_dim: %d, batch_size: %d, codelayer_dim: %d, lr: %.6f.\"\n % (\n self.noise_std,\n self.lstm_dim,\n self.dec_layers,\n self.td_dense_dim,\n self.batch_size,\n self.codelayer_dim,\n self.lr,\n )\n )","def print_info(name, params):\n print \"{} initialized for split: {}, with bs: {}, im_shape: {}.\".format(\n name,\n params['split'],\n params['batch_size'],\n params['im_shape'])","def print_info(name, params):\n print \"{} initialized for split: {}, with bs: {}, im_shape: {}.\".format(\n name,\n params['split'],\n params['batch_size'],\n params['im_shape'])","def print_networks(self, verbose: bool) -> None:\n print('---------- Networks initialized -------------')\n for name, module in self.modules.items():\n num_params = 0\n for param in module.parameters():\n num_params += param.numel()\n if verbose:\n print(module)\n print('[Network %s] Total number of parameters: %.3f M' % (name, num_params / 1e6))\n print('-----------------------------------------------')\n return","def print_params(self):\n\n logger.info('SimulatedMaps has been initialised with the following attributes:')\n for key in self.params.keys():\n logger.info('{} = {}'.format(key, self.params[key]))","def print_shapes(self):\n total_filter = 0\n for layer_name, blob in self.net.blobs.iteritems():\n ts = ''\n for x in blob.data.shape:\n ts += '%5i' % x\n print ts, ' ' * (25 - len(ts)), layer_name","def display_sim_parameters(self):\n pprint.pprint(vars(self))\n return","def summary(self):\n print('est0: %s (%s) shape: %s' % (str(self.est0.name),\\\n str(self.est0.type_name),str(self.shape0)))\n print('est1: %s (%s) shape: %s' % (str(self.est1.name),\\\n str(self.est1.type_name),str(self.shape1)))","def print_model_params(model):\n for param, value in zip(model.param_names, model.parameters):\n print(\"{:0.4f}\\t{}\".format(value, param))","def summary(self, verbose=False):\n for i, layer in enumerate(self._layers):\n print('%d: %s' % (i, str(layer)))\n if verbose:\n print('weights:', layer.get_weights())\n if layer._use_bias:\n print('bias:', layer._bias)\n print()","def format():\n train_data.info() # retreiving general info about train data\n print('Number of rows and columns of train set:', train_data.shape)\n print('dtype: ', train_data.dtypes) # analyse data type of each column\n print('First 3 rows of the train data:', train_data.head(3))","def print_layers(model):\r\n for i in range(len(model.layers)):\r\n print(\"Printing layer shape: %d\" % i, model.layers[i])\r\n weights = model.layers[i].get_weights()\r\n for weight in weights: # Layer type\r\n print(weight.shape)","def print_configuration_info():\n print(\"Selected dataset:\", DATASET) \n print(\"Dataset base directory:\", BASE_INPUT_DIR) \n print(\"Daytime option:\", DAYTIME) \n print(\"Nones option:\", NONES) \n print(\"Selected action/activity representation:\", OP)\n print(\"Number of epochs: \", EPOCHS)\n print(\"Number of folds for cross-validation: \", FOLDS)\n print(\"Input directory for data files:\", INPUT_DIR) \n print(\"Embedding matrix file:\", EMBEDDING_WEIGHTS)\n print(\"Action sequences (X) file:\", X_FILE) \n print(\"Word embedding file for activities:\", ACTIVITY_EMBEDDINGS) \n print(\"Activity to int mappings:\", ACTIVITY_TO_INT)\n print(\"Int to activity mappings:\", INT_TO_ACTIVITY) \n print(\"Experiment ID:\", EXPERIMENT_ID)\n print(\"Treat imbalance data:\", TREAT_IMBALANCE)\n print(\"Save intermediate plots:\", SAVE)\n print(\"Batch size:\", BATCH_SIZE)\n print(\"Dropout:\", DROPOUT)\n print(\"Loss:\", LOSS)","def num_prunable_parameters(self) -> int:\n return sum(l.weight.numel() for l in self.out_layers) + \\\n sum(weight.numel() for weight in self.out_projs)","def num_prunable_parameters(self) -> int:\n return sum(l.weight.numel() for l in self.out_layers) + \\\n sum(weight.numel() for weight in self.out_projs)","def print_model_definitions(self):\n sys.stdout.write(\"Model Dimensions\\n\")\n sys.stdout.write(\"----------------\\n\")\n for key, val in self.dimensions.iteritems():\n sys.stdout.write(\"{key}: {val}\\n\".format(key=key, val=val))","def num_params(self):","def print_networks(self):\n print('Networks initialized')\n for name in self.network_names:\n if isinstance(name, str):\n net = getattr(self, 'net')\n num_params = 0\n for param in net.parameters():\n num_params += param.numel()\n print(net)\n print('[Network {0}] Total number of parameters : {1:.3f} M'.format(name, num_params / 1e6))","def show_shape_metrics(shape):","def inspect_state(self):\n for name in self._param_store.get_all_param_names():\n self._logger.info(\"Param [%s]: %r\", name,\n pyro.param(name).data.numpy())","def print_shape(self, data):\n print(data.shape)","def display_parameters(self):\n\n self.logging.debug(\"============\")\n for attr in self.parm_list:\n self.logging.debug(attr.label + \" (\" + attr.when + \")\" + \" = \" + str(attr.value))\n self.logging.debug(\"============\")","def num_params():\n total_num = 0\n for var in tf.trainable_variables():\n shape = var.get_shape()\n total_num += functools.reduce(operator.mul, [dim.value for dim in shape], 1)\n return total_num","def _pprint_params(self):\n return {'x_range': self.x_range, 'y_range': self.y_range,\n 'step': self.step, 'shape': self.shape,\n 'type': self.type}","def __str__(self):\n return 'Tensor product {}: {} params, wires {}'.format([i.name for i in self.obs], len(self.params), self.wires)","def getParams(self):\n return self.trainError, self.trainAcc, self.w","def num_parameters(self) -> int:\n if vocabulary.is_empty(self.vocab, self.config.features.configured_namespaces):\n self._LOGGER.warning(\n \"At least one vocabulary of your features is still empty! \"\n \"The number of trainable parameters usually depends on the size of your vocabulary.\"\n )\n return sum(p.numel() for p in self._model.parameters())","def get_total_trainable_parameter_size():\n total_parameters = 0\n import tensorflow as tf\n for variable in tf.trainable_variables():\n # shape is an array of tf.Dimension\n total_parameters += np.product([x.value for x in variable.get_shape()])\n return total_parameters","def debug(self):\n \n #path\n print('Path information:')\n for k, v in self.__path.items():\n print(k, v)\n \n #sample count\n print('Sample statistic of each phase')\n for k, v in self.__phase_sample_count.items():\n print(k, v)\n \n print('Sample statistic of each class')\n for k, v in self.__area_sample_count.items():\n print(k, v)\n \n print('Sample statistic of each train')\n for k, v in self.__train_sample_count.items():\n print(k, v)","def describe(self):\n print(\"Number of nodes: {0}\".format(self.nnodes))\n print(\"Number of interfaces: {0}\".format(self.ninterfaces))\n print(\"Number of elements: {0}\".format(self.nelements))","def print_params():\n\n help_out = convert_phil_to_text(master_phil, att_level=1)\n txt_out = convert_phil_to_text(master_phil)\n\n return help_out, txt_out","def paramDetails(cls):\n return {\n 'dim': (10, 20, 2, 20),\n 'nIter': (1, 10, 2, 5),\n 'lamb': (.1, 1., .1, .05),\n 'alph': (30, 50, 5, 40)\n }","def num_prunable_parameters(self) -> int:\n return sum(l.weight.numel() for l in self.emb_layers) + \\\n sum(weight.numel() for weight in self.emb_projs)","def num_prunable_parameters(self) -> int:\n return sum(l.weight.numel() for l in self.emb_layers) + \\\n sum(weight.numel() for weight in self.emb_projs)","def get_parameter_numbers(self) -> int:\n # TODO(jeikeilim): return the number of parameter list of each layers.\n n_param = sum([x.numel() for x in self.model.parameters()])\n return n_param","def printGraph(self):\n print \"-----\"\n for feature in self.features:\n feature.printFeature()\n for constraint in self.constraints:\n constraint.printConstraint()\n print \"-----\"","def training_info(self):\n pass","def view_shapes(xm_train, xm_dev, xm_test, ym_train, ym_dev, ym_test):\n\n print('X_train shape: ' + str(xm_train.shape))\n print('Y_train shape: ' + str(ym_train.shape))\n print('X_dev shape: ' + str(xm_dev.shape))\n print('Y_dev shape: ' + str(ym_dev.shape))\n print('X_test shape: ' + str(xm_test.shape))\n print('Y_test shape: ' + str(ym_test.shape))\n print('\\n')","def count_params(model):\n total = 0\n for x in model.trainable_variables:\n total += np.prod(x.shape)\n return total","def count_weights(print_perlayer=True):\n acc_total = 0\n for v in tf.trainable_variables():\n dims = v.get_shape().as_list()\n total = np.prod(dims)\n acc_total += total\n if print_perlayer:\n print('{}: {}, {}'.format(v.name, dims, total))\n\n return acc_total","def print_all_variables():\n for idx, v in enumerate(tf.all_variables()):\n print(\" var %d: %s %s\" % (idx, v.get_shape(), v.name))","def num_parameters(self) -> int:\n return len(self.w) + prod(self.v.shape) - len(self.v)","def print_me(self):\n\n print(\"----- Model:\",self.name,\" -----\")\n print(\"Mass (in M_sun): %.5f\" % (self.glb[imass]/constants.solar_mass))\n print(\"Radius (in R_sun): %.5f\" % (self.glb[iradius]/constants.solar_radius))\n print(\"Reference frequency (in uHz): %.3f\" % self.glb[ifreq_ref])\n print(\"Temperature (in K): %.1f\" % self.glb[itemperature])\n print(\"Luminosity (in L_sun): %.3g\" % (self.glb[iluminosity]/constants.solar_luminosity))\n print(\"Age (in Myrs): %.2f\" % self.glb[iage])\n print(\"Z: %.4f\" % self.glb[iz0])\n print(\"X: %.4f\" % self.glb[ix0])\n for (name, latex_name) in config.user_params:\n print(\"{0:29} {1:.5e}\".format(name,self.glb[user_params_index[name]]))\n print(\"Modes (in muHz):\")\n size = self.modes.shape[0]\n for i in range(size):\n print(\" (n,l,freq,IK) = (%d, %d, %.15f, %.5e)\" % \\\n (self.modes['n'][i], self.modes['l'][i], \\\n self.modes['freq'][i]*self.glb[ifreq_ref],\\\n self.modes['inertia'][i]))","def model_summary():\n print(\"\\n\")\n print(\"=\" * 30 + \"Model Structure\" + \"=\" * 30)\n model_vars = tf.trainable_variables()\n slim.model_analyzer.analyze_vars(model_vars, print_info=True)\n print(\"=\" * 60 + \"\\n\")","def print_Twiss(self):\n\n print(\"Twiss parameters in use:\")\n print(\"betax : {}\".format(self._betax))\n print(\"betay : {}\".format(self._betay))\n print(\"alphax : {}\".format(self._alphax))\n print(\"alphay : {}\".format(self._alphay))\n print(\"gammax : {}\".format(self._gammax))\n print(\"gammay : {}\".format(self._gammay))","def __str__(self):\n\n print(\"\")\n s = \"NAME : \"+self._name+\"\\n\\n\"\n s += \"PARAMS :\"\n print(s)\n\n for key, val in self.params.items():\n l = (21-len(key))//7\n print(\"{0}\".format(key)+\"\\t\"*l+\":\\t{0}\".format(val))\n\n s = \"\\nRuns stored in DEFAULT_RUNS = \"+str(len(self.default_runs))\n print(s)\n\n s = \"\\nRuns stored in MOD_RUNS = \"+str(len(self.mod_runs))\n print(s)\n\n return \"\"","def num_trainable_parameters(self) -> int:\n if vocabulary.is_empty(self.vocab, self.config.features.configured_namespaces):\n self._LOGGER.warning(\n \"At least one vocabulary of your features is still empty! \"\n \"The number of trainable parameters usually depends on the size of your vocabulary.\"\n )\n return sum(p.numel() for p in self._model.parameters() if p.requires_grad)","def print(self):\n for l in range(self.h+1):\n print(\"Weight matrix between layer \" + str(l) + \" and layer \" + str(l+1))\n print(self.W[l])","def __str__(self):\n return \"{}: {} params, wires {}\".format(self.name, len(self.params), self.wires)","def select_params( model, contains=[]):\n names = []\n for name, param in model.named_parameters():\n param.requires_grad = False\n if any(name.find(c) != -1 for c in contains):\n param.requires_grad = True\n names.append([name,param.numel()])\n\n total = sum(p.numel() for p in model.parameters()) \n p_str = \"\\nParameters: \\n\\nTotal: {} \\n\\nTrained: {} \\n\"\n print(p_str.format(total,sum([p for n,p in names])))\n for n,t in names: print(n,t)\n print(\"\\n\")","def params_desc(self):\n return \"{}/{}/{}/{}\".format(\n self.learning_rate, self.movement, self.milestones, self.gamma\n )","def show_properties(self):\n print(\"L:\", self.L)\n print(\"d:\", self.d)\n print(\"D:\", self.D)\n print(\"dtype:\", self.dtype)\n print(\"R[-1]:\", self.R[-1])\n print(\"F[-1]:\", self.F[-1])\n print(\"Cummulated norm C:\", self.normC)","def print_all_params(self, disp=True):\n descriptions = {'general': {}}\n for name, param in self.params.items():\n descriptions['general'][name] = param.get_description()\n\n for comp, comp_obj in self.components.items():\n descriptions[comp] = {}\n for name in comp_obj.get_params():\n descriptions[comp][name] = comp_obj.get_param_description(name)\n return self._print_params(descriptions, disp)","def print_inference_result(self):\n if (\n self.params.model_str == 'optfixedsig'\n or self.params.model_str == 'opt'\n or self.params.model_str == 'fixedparam'\n ):\n print('*ls pt est = ' + str(self.sample_list[0].ls) + '.')\n print('*alpha pt est = ' + str(self.sample_list[0].alpha) + '.')\n print('*sigma pt est = ' + str(self.sample_list[0].sigma) + '.')\n elif self.params.model_str == 'samp' or self.params.model_str == 'sampfixedsig':\n ls_arr = np.array([ns.ls for ns in self.sample_list])\n alpha_arr = np.array([ns.alpha for ns in self.sample_list])\n sigma_arr = np.array([ns.sigma for ns in self.sample_list])\n print('*ls mean = ' + str(ls_arr.mean()) + '.')\n print('*ls std = ' + str(ls_arr.std()) + '.')\n print('*alpha mean = ' + str(alpha_arr.mean()) + '.')\n print('*alpha std = ' + str(alpha_arr.std()) + '.')\n print('*sigma mean = ' + str(sigma_arr.mean()) + '.')\n print('*sigma std = ' + str(sigma_arr.std()) + '.')\n print('-----')","def num_parameters(self) -> int:\n if self._model:\n return self._model.num_parameters()\n return 0","def summary(self):\r\n print(self.model.summary())","def print_brief_summary(self):\n print (\"Model {}\".format(self.modelName))\n print (\"Precision {}\".format(self.precision))\n print (\"Recall {}\".format(self.recall))\n print (\"f1 score {}\".format(self.f1))\n \n # work here\n print (\"\\nGold NER label counts:\")\n for ner in self.gold_cts.keys():\n print (\"{} : {} (tag{})\".format(self.gold_cts[ner], self.nerTags.ids_to_words([ner]), ner))\n print (\"\\nPredicted NER label counts:\")\n for ner in self.pred_cts.keys():\n print (\"{} : {} (tag{})\".format(self.pred_cts[ner], self.nerTags.ids_to_words([ner]), ner))","def count_parameters(model):\n return sum(p.numel() for p in model.parameters())","def __str__(self):\n string = 'input dim: {} \\noutput dim: {} \\n'.format(\n self.dim_inputs, self.dim_outputs\n )\n string += 'sequence length: {} \\n'.format(\n self.tensors[0].shape[1]\n )\n key = 'train' if self.train else 'test'\n string += '{}_samples: {} \\n{}_sequences: {} \\n'.format(\n key, self.experiment_length, key, self.tensors[0].shape[0]\n )\n return string","def print_data(self):\n for chain, gen in self.generations.items():\n print('Generations for chain %s: %d' % (chain, gen))\n print('Log likelihood effective size: %d' % self.loglik_effsize)\n print('Log likelihood relative difference: %f' % self.loglik_rel_diff)\n print('Max diff: %f' % self.max_diff)"],"string":"[\n \"def print_trainable_params(scope=None):\\n n_params = 0\\n print('name \\\\t| shape \\\\t| num parameters')\\n\\n for var in tf.trainable_variables(scope):\\n # shape is an array of tf.Dimension\\n shape = var.get_shape()\\n n_elems = shape.num_elements()\\n print(var.name, shape, n_elems)\\n n_params += n_elems\\n\\n print('Total parameters:', n_params)\",\n \"def print_params_shape(scope, param_type):\\n shapes = [var.get_shape().as_list() for var in get_trainable_vars(scope)]\\n nb_params = sum([reduce(lambda x, y: x * y, shape) for shape in shapes])\\n print(' {} shapes: {}'.format(param_type, shapes))\\n print(' {} params: {}'.format(param_type, nb_params))\",\n \"def printParameters(self):\\n print(\\\"----------Model Parameters----------\\\")\\n print(\\\"Initial Conv. Depth : \\\" + str(self.conv_depth))\\n print(\\\"Number of Classes : \\\" + str(self.n_classes))\\n print(\\\"Dropout : \\\" + str(self.dropout))\\n print(\\\"Activation Function : Relu\\\")\\n print(\\\"Input Shape : \\\" + str(self.input_shape))\\n print(\\\"Batch Size : \\\" + str(self.batch_size))\\n print(\\\"--------Optimizer Parameters--------\\\")\\n print(\\\"Learning Rate : \\\" + str(self.optimizer.lr))\\n print(\\\"Momentum : \\\" + str(self.optimizer.momentum))\\n print(\\\"Initial Decay : \\\" + str(self.optimizer.initial_decay))\",\n \"def print_total_params(print_function=tf.logging.info):\\n\\n total_parameters = 0\\n for variable in tf.trainable_variables():\\n # shape is an array of tf.Dimension\\n shape = variable.get_shape()\\n variable_parametes = 1\\n for dim in shape:\\n variable_parametes *= dim.value\\n total_parameters += variable_parametes\\n print_function(f'TOTAL NUMBER OF PARAMTERS:{total_parameters}')\\n print_function(f'Memory Estimate:{total_parameters*32/8/1024/1024} MB')\",\n \"def count_parameters():\\n total_parameters = 0\\n for variable in tf.trainable_variables():\\n # shape is an array of tf.Dimension\\n name = variable.name\\n shape = variable.get_shape()\\n #print(shape)\\n #print(len(shape))\\n variable_parameters = 1\\n for dim in shape:\\n #print(dim)\\n variable_parameters *= dim.value\\n print(name, [dim for dim in shape], variable_parameters)\\n total_parameters += variable_parameters\\n print('Number of trainable parameters = {}'.format(total_parameters))\",\n \"def print_network(net):\\n num_params = 0\\n for param in net.parameters():\\n num_params += param.numel()\\n print(net)\\n print(\\\"Total number of parameters: {}\\\".format(num_params))\",\n \"def print_network(self, model, name):\\n num_params = 0\\n for p in model.parameters():\\n num_params += p.numel()\\n print(model)\\n print(name)\\n print(\\\"The number of parameters: {}\\\".format(num_params))\",\n \"def describe_model():\\n train_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)\\n msg = [\\\"\\\"]\\n total = 0\\n for v in train_vars:\\n shape = v.get_shape()\\n ele = shape.num_elements()\\n total += ele\\n msg.append(\\\"{}: shape={}, dim={}\\\".format(\\n v.name, shape.as_list(), ele))\\n size_mb = total * 4 / 1024.0**2\\n msg.append(colored(\\n \\\"Total param={} ({:01f} MB assuming all float32)\\\".format(total, size_mb), 'cyan'))\\n logger.info(colored(\\\"Model Parameters: \\\", 'cyan') + '\\\\n'.join(msg))\",\n \"def print_network(self, model, name):\\r\\n num_params = 0\\r\\n for p in model.parameters():\\r\\n num_params += p.numel()\\r\\n print(model)\\r\\n print(name)\\r\\n print(\\\"The number of parameters: {}\\\".format(num_params))\",\n \"def print_network(self, model, name):\\r\\n num_params = 0\\r\\n for p in model.parameters():\\r\\n num_params += p.numel()\\r\\n print(model)\\r\\n print(name)\\r\\n print(\\\"The number of parameters: {}\\\".format(num_params))\",\n \"def print_network(self, model, name):\\n num_params = 0\\n for p in model.parameters():\\n num_params += p.numel()\\n print(model)\\n print(name)\\n print(\\\"The number of parameters: {}\\\".format(num_params))\",\n \"def print_network(self, model, name):\\n num_params = 0\\n for p in model.parameters():\\n num_params += p.numel()\\n print(model)\\n print(name)\\n print(\\\"The number of parameters: {}\\\".format(num_params))\",\n \"def print_network(self, model, name):\\n num_params = 0\\n for p in model.parameters():\\n num_params += p.numel()\\n print(model)\\n print(name)\\n print(\\\"The number of parameters: {}\\\".format(num_params))\",\n \"def print_network(self, model, name):\\n num_params = 0\\n for p in model.parameters():\\n num_params += p.numel()\\n print(model)\\n print(name)\\n print(\\\"The number of parameters: {}\\\".format(num_params))\",\n \"def print_network(model, name):\\r\\n num_params = 0\\r\\n for p in model.parameters():\\r\\n num_params += p.numel()\\r\\n print(model)\\r\\n print(name)\\r\\n print(\\\"The number of parameters: {}\\\".format(num_params))\",\n \"def print_num_params(model: nn.Module):\\n if type(model) == DistributedDataParallel:\\n model = model.module\\n\\n # Count all parameteres\\n sum_params = count_params(model)\\n\\n # Count SPN parameters\\n spn_params = sum_params\\n\\n # Print\\n logger.info(f\\\"Number of parameters:\\\")\\n # logger.info(f\\\"- Total: {sum_params / 1e6: >8.3f}M\\\")\\n logger.info(\\n f\\\"- SPN: {spn_params / 1e6: >8.3f}M ({spn_params / sum_params * 100:.1f}%)\\\"\\n )\\n # logger.info(f\\\"- NN: {nn_params / 1e6: >8.3f}M ({nn_params / sum_params * 100:.1f}%)\\\")\",\n \"def print_shape(self):\\n print(\\\"X_train: \\\", self.X_train.shape)\\n print(\\\"X_test: \\\", self.X_test.shape)\\n print(\\\"y_train: \\\", self.y_train.shape)\\n print(\\\"y_test: \\\", self.y_test.shape)\",\n \"def count_parameters(sess):\\n\\n variables_names = [v.name for v in tf.trainable_variables()]\\n values = sess.run(variables_names)\\n n_params = 0\\n\\n for k, v in zip(variables_names, values):\\n print '-'.center(140, '-')\\n print '{:60s}\\\\t\\\\tShape: {:20s}\\\\t{:20} parameters'.format(k, v.shape, v.size)\\n\\n n_params += v.size\\n\\n print '-'.center(140, '-')\\n print 'Total # parameters:\\\\t\\\\t{}\\\\n\\\\n'.format(n_params)\\n\\n return n_params\",\n \"def print_param_names(model):\\n for (param_name, param) in model.get_parameters().items():\\n print(param_name, param.shape)\",\n \"def show_parameters(self):\\n with np.printoptions(precision=3, suppress=True):\\n print('number of wind phase = {}'.format(self.ncomp))\\n print('galactic parameter = {}'.format(self.scaling_field))\\n print('reference height = {}'.format(self.z0))\\n for p in ['cool_params','hot_params','params','ref_params','scaling_params']:\\n params = getattr(self,p)\\n print(p)\\n for k,v in params.items():\\n print(' {} = {}'.format(k,v))\",\n \"def print_network(self, model, name):\\n num_params = 0\\n for p in model.parameters():\\n num_params += p.numel()\\n print(\\\"\\\\nModel Name: \\\\\\\"{}\\\\\\\"\\\".format(name))\\n print(model)\\n print(\\\"The number of parameters: {}\\\".format(num_params))\",\n \"def print_network(self, model, name):\\n num_params = 0\\n for p in model.parameters():\\n num_params += p.numel()\\n print(\\\"\\\\nModel Name: \\\\\\\"{}\\\\\\\"\\\".format(name))\\n print(model)\\n print(\\\"The number of parameters: {}\\\".format(num_params))\",\n \"def printParameters(self):\\n with self._graph.as_default():\\n for var in tf.global_variables():\\n print(var.name)\\n val = self._sess.run(var)\\n print(val)\",\n \"def count_parameters(also_print=True):\\n total = 0\\n if also_print:\\n logging.info('Model Parameters:')\\n for (_, v) in get_vars_to_save_and_restore().items():\\n shape = v.get_shape()\\n if also_print:\\n logging.info('%s %s: %s', v.op.name, shape,\\n format_number(shape.num_elements()))\\n total += shape.num_elements()\\n if also_print:\\n logging.info('Total: %s', format_number(total))\\n return total\",\n \"def print_info(self):\\n print(\\\"Num samples (train/test/val): {} tot: {}\\\\n\\\"\\n \\\"Samples per class: {}\\\\n\\\"\\n \\\"Sample type {}\\\\n\\\"\\n \\\"Sample shape: {}\\\\n\\\"\\n \\\"Label type {}\\\\n\\\"\\n \\\"Label shape: {}\\\\n\\\"\\n \\\"Root dirs: {}\\\".format([int(np.floor(frac * len(self.__labels))) for frac in self.split_fraction],\\n len(self.__labels),\\n self.__samples_per_class,\\n self.train.output_types[0], self.train.output_shapes[0][1:],\\n self.train.output_types[1], self.train.output_shapes[1][1:],\\n self.__root_directory_list))\",\n \"def print_params(self):\\n print(self._list_params())\",\n \"def show(self):\\n print \\\"Name: \\\"+str(self.name)\\n ss = self.y.shape[0]\\n for i in xrange(ss):\\n print \\\"Actual: \\\"+str(self.y[i])\\n print \\\"Prediction: \\\"+str(self.a[i])\\n print \\\"\\\"\\n print \\\"\\\\n\\\"\",\n \"def _print_model_parameters(labels, parameters, errors):\\n for label, parameter, error in zip(labels, parameters, errors):\\n print(f\\\"{label} = {parameter:.5f} +- {error:.5f}\\\")\",\n \"def __str__(self):\\n model_parameters = filter(lambda p: p.requires_grad, self.parameters())\\n params = sum([np.prod(p.size()) for p in model_parameters])\\n return super(BaseModel, self).__str__() + '\\\\nTrainable parameters: {}'.format(params)\\n # print(super(BaseModel, self))\",\n \"def print_params(self):\\n s = self._list_params()+\\\"\\\\n\\\"\\n if 'scale_params' in self.__dict__.keys():\\n s += self.scale_params._list_params()+\\\"\\\\n\\\"\\n if 'atmospheric_params' in self.__dict__.keys():\\n if self.atmospheric_params is not None:\\n s += self.atmospheric_params._list_params()+\\\"\\\\n\\\"\\n\\n if 'atemperature_params' in self.__dict__.keys():\\n if self.atemperature_params is not None:\\n s += self.atemperature_params._list_params()+\\\"\\\\n\\\"\\n\\n if 'oceanic_params' in self.__dict__.keys():\\n if self.oceanic_params is not None:\\n s += self.oceanic_params._list_params()+\\\"\\\\n\\\"\\n\\n if 'ground_params' in self.__dict__.keys():\\n if self.ground_params is not None:\\n s += self.ground_params._list_params()+\\\"\\\\n\\\"\\n\\n if 'gotemperature_params' in self.__dict__.keys():\\n if self.gotemperature_params is not None:\\n s += self.gotemperature_params._list_params() + \\\"\\\\n\\\"\\n\\n print(\\\"Qgs v0.2.8 parameters summary\\\")\\n print(\\\"=============================\\\\n\\\")\\n print(s)\",\n \"def print_info(self):\\n\\n print \\\"\\\\nALGORITHM INFO\\\"\\n print \\\"modelnumber:\\\", self.modelnumber\\n print \\\"restart:\\\", self.restart\\n print \\\"particles:\\\", self.particles\\n print \\\"beta:\\\", self.beta\\n print \\\"dt:\\\", self.dt\\n if self.mode != 1:\\n if len(self.final_epsilon) == 0:\\n print \\\"manual epsilon:\\\"\\n for i in range(self.epsilon.shape[0]):\\n print \\\"\\\\t\\\",\\n for j in range(self.epsilon.shape[1]):\\n print \\\"\\\", self.epsilon[i, j],\\n print \\\"\\\"\\n else:\\n print \\\"auto epsilon:\\\"\\n print \\\"\\\\t\\\", self.final_epsilon\\n print \\\"\\\\talpha:\\\", self.alpha\\n\\n print \\\"kernel:\\\", self.kernel\\n print \\\"model kernel:\\\", self.modelkernel\\n print \\\"model prior:\\\", self.modelprior\\n\\n print \\\"DATA:\\\"\\n print \\\"\\\\ttimes:\\\", self.times\\n if self.mode == 0:\\n print \\\"\\\\tvars:\\\"\\n for i in range(len(self.data[0, :])):\\n print \\\"\\\\t\\\",\\n for j in range(self.ntimes):\\n print \\\"\\\", self.data[j, i],\\n print \\\"\\\"\\n\\n print \\\"MODELS:\\\", self.nmodels\\n for i in range(self.nmodels):\\n print \\\"\\\\t\\\", \\\"npar:\\\", self.nparameters[i]\\n print \\\"\\\\t\\\", \\\"nspecies:\\\", self.nspecies[i]\\n print \\\"\\\\t\\\", \\\"name:\\\", self.name[i]\\n print \\\"\\\\t\\\", \\\"source:\\\", self.source[i]\\n print \\\"\\\\t\\\", \\\"type:\\\", self.type[i]\\n print \\\"\\\\t\\\", \\\"fit:\\\", self.fit[i]\\n print \\\"\\\\t\\\", \\\"init:\\\", self.x0prior[i]\\n print \\\"\\\\t\\\", \\\"prior:\\\", self.prior[i]\\n print \\\"\\\\t\\\", \\\"logp:\\\", self.logp[i]\\n print \\\"\\\\n\\\"\",\n \"def summarize(self):\\n # go recursively in the model architecture\\n summary_str = self.recursive_summarize(self, 0, self.name)\\n\\n # Sum the model parameters.\\n num_total_params = sum([np.prod(p.size()) for p in self.parameters()])\\n mod_trainable_params = filter(lambda p: p.requires_grad, self.parameters())\\n num_trainable_params = sum([np.prod(p.size()) for p in mod_trainable_params])\\n\\n summary_str += 'Total Trainable Params: {}\\\\n'.format(num_trainable_params)\\n summary_str += 'Total Non-trainable Params: {}\\\\n'.format(num_total_params-num_trainable_params) \\n summary_str += '='*80 + '\\\\n'\\n\\n return summary_str\",\n \"def print_network(self, model, name):\\n num_params = 0\\n for p in model.parameters():\\n num_params += p.numel()\\n #print(model)\\n print(name)\\n print(\\\"The number of parameters: {}\\\".format(num_params))\\n\\n with open(os.path.join(self.train_dir,'model_arch.txt'), 'a') as fp:\\n print(model, file=fp)\\n print(name, file=fp)\\n print(\\\"The number of parameters: {}\\\".format(num_params),file=fp)\",\n \"def _report_model_parameters(self):\\n\\n all_params = sum(p.numel() for p in self.parameters())\\n trainable_params = sum(p.numel() for p in self.parameters() if p.requires_grad)\\n size = all_params * (32 / 8) # Bytes\\n logger.info(\\\"Model has %.1f M parameters (%.1f M trainable) with an estimated size of %.1f MB\\\", all_params / 1e6, trainable_params / 1.0e6, size / 1.0e6)\",\n \"def print_networks(self, verbose):\\n print('---------- Networks initialized -------------')\\n for name in self.model_names:\\n if isinstance(name, str):\\n net = getattr(self, 'net' + name)\\n num_params = 0\\n for param in net.parameters():\\n num_params += param.numel()\\n if verbose:\\n print(net)\\n print('[Network %s] Total number of parameters : %.3f M' % (name, num_params / 1e6))\\n print('-----------------------------------------------')\",\n \"def display_parameters(self):\\n ips = GAConfig[\\\"initial_population_size\\\"]\\n ps = GAConfig[\\\"population_size\\\"]\\n nomp = GAConfig[\\\"num_mating_pairs\\\"]\\n mf = GAConfig[\\\"base_mutation_factor\\\"]\\n ne = GAConfig[\\\"num_evolutions\\\"]\\n noc = GAConfig[\\\"num_categories\\\"]\\n nog = len(self.phones)\\n\\n display_string = \\\"\\\"\\\"\\n Genetic Algorithm Parameters\\n ----------------------------\\n Initial Population Size %s\\n Population Size %s\\n Number of Mating Pairs %s\\n Base Mutation Factor %s\\n Number of Evolutions %s\\n Number of Categories %s\\n Number of Genes %s\\n \\\"\\\"\\\" % (ips, ps, nomp, mf, ne, noc, nog)\\n\\n print(display_string)\",\n \"def print_grid_params(params):\\n tot = 1\\n for key, p in params.items():\\n tot *= len(p)\\n print(f'{key}: {p}')\\n\\n print(f'\\\\nTotal models: {tot}\\\\n')\\n print('=' * 40)\",\n \"def display_layer_parameters(self):\\n pprint.pprint(vars(self))\\n return\",\n \"def printConf(self):\\n print \\\"\\\"\\n for pname, pvalue in self.neededParams.items():\\n print pname, pvalue\\n for pname, pvalue in self.optionalParams.items():\\n print pname, pvalue\",\n \"def display(self):\\n print(\\\"{}, {}\\\".format(self.label, self.params))\",\n \"def summary(self):\\n\\n print(\\n \\\"\\\\nModel trained with dataset %s that has maxlen=%d and charset=%s for %d epochs.\\\"\\n % (self.dataset_name, self.maxlen, self.charset, self.epochs)\\n )\\n\\n print(\\n \\\"noise_std: %.6f, lstm_dim: %d, dec_layers: %d, td_dense_dim: %d, batch_size: %d, codelayer_dim: %d, lr: %.6f.\\\"\\n % (\\n self.noise_std,\\n self.lstm_dim,\\n self.dec_layers,\\n self.td_dense_dim,\\n self.batch_size,\\n self.codelayer_dim,\\n self.lr,\\n )\\n )\",\n \"def print_info(name, params):\\n print \\\"{} initialized for split: {}, with bs: {}, im_shape: {}.\\\".format(\\n name,\\n params['split'],\\n params['batch_size'],\\n params['im_shape'])\",\n \"def print_info(name, params):\\n print \\\"{} initialized for split: {}, with bs: {}, im_shape: {}.\\\".format(\\n name,\\n params['split'],\\n params['batch_size'],\\n params['im_shape'])\",\n \"def print_networks(self, verbose: bool) -> None:\\n print('---------- Networks initialized -------------')\\n for name, module in self.modules.items():\\n num_params = 0\\n for param in module.parameters():\\n num_params += param.numel()\\n if verbose:\\n print(module)\\n print('[Network %s] Total number of parameters: %.3f M' % (name, num_params / 1e6))\\n print('-----------------------------------------------')\\n return\",\n \"def print_params(self):\\n\\n logger.info('SimulatedMaps has been initialised with the following attributes:')\\n for key in self.params.keys():\\n logger.info('{} = {}'.format(key, self.params[key]))\",\n \"def print_shapes(self):\\n total_filter = 0\\n for layer_name, blob in self.net.blobs.iteritems():\\n ts = ''\\n for x in blob.data.shape:\\n ts += '%5i' % x\\n print ts, ' ' * (25 - len(ts)), layer_name\",\n \"def display_sim_parameters(self):\\n pprint.pprint(vars(self))\\n return\",\n \"def summary(self):\\n print('est0: %s (%s) shape: %s' % (str(self.est0.name),\\\\\\n str(self.est0.type_name),str(self.shape0)))\\n print('est1: %s (%s) shape: %s' % (str(self.est1.name),\\\\\\n str(self.est1.type_name),str(self.shape1)))\",\n \"def print_model_params(model):\\n for param, value in zip(model.param_names, model.parameters):\\n print(\\\"{:0.4f}\\\\t{}\\\".format(value, param))\",\n \"def summary(self, verbose=False):\\n for i, layer in enumerate(self._layers):\\n print('%d: %s' % (i, str(layer)))\\n if verbose:\\n print('weights:', layer.get_weights())\\n if layer._use_bias:\\n print('bias:', layer._bias)\\n print()\",\n \"def format():\\n train_data.info() # retreiving general info about train data\\n print('Number of rows and columns of train set:', train_data.shape)\\n print('dtype: ', train_data.dtypes) # analyse data type of each column\\n print('First 3 rows of the train data:', train_data.head(3))\",\n \"def print_layers(model):\\r\\n for i in range(len(model.layers)):\\r\\n print(\\\"Printing layer shape: %d\\\" % i, model.layers[i])\\r\\n weights = model.layers[i].get_weights()\\r\\n for weight in weights: # Layer type\\r\\n print(weight.shape)\",\n \"def print_configuration_info():\\n print(\\\"Selected dataset:\\\", DATASET) \\n print(\\\"Dataset base directory:\\\", BASE_INPUT_DIR) \\n print(\\\"Daytime option:\\\", DAYTIME) \\n print(\\\"Nones option:\\\", NONES) \\n print(\\\"Selected action/activity representation:\\\", OP)\\n print(\\\"Number of epochs: \\\", EPOCHS)\\n print(\\\"Number of folds for cross-validation: \\\", FOLDS)\\n print(\\\"Input directory for data files:\\\", INPUT_DIR) \\n print(\\\"Embedding matrix file:\\\", EMBEDDING_WEIGHTS)\\n print(\\\"Action sequences (X) file:\\\", X_FILE) \\n print(\\\"Word embedding file for activities:\\\", ACTIVITY_EMBEDDINGS) \\n print(\\\"Activity to int mappings:\\\", ACTIVITY_TO_INT)\\n print(\\\"Int to activity mappings:\\\", INT_TO_ACTIVITY) \\n print(\\\"Experiment ID:\\\", EXPERIMENT_ID)\\n print(\\\"Treat imbalance data:\\\", TREAT_IMBALANCE)\\n print(\\\"Save intermediate plots:\\\", SAVE)\\n print(\\\"Batch size:\\\", BATCH_SIZE)\\n print(\\\"Dropout:\\\", DROPOUT)\\n print(\\\"Loss:\\\", LOSS)\",\n \"def num_prunable_parameters(self) -> int:\\n return sum(l.weight.numel() for l in self.out_layers) + \\\\\\n sum(weight.numel() for weight in self.out_projs)\",\n \"def num_prunable_parameters(self) -> int:\\n return sum(l.weight.numel() for l in self.out_layers) + \\\\\\n sum(weight.numel() for weight in self.out_projs)\",\n \"def print_model_definitions(self):\\n sys.stdout.write(\\\"Model Dimensions\\\\n\\\")\\n sys.stdout.write(\\\"----------------\\\\n\\\")\\n for key, val in self.dimensions.iteritems():\\n sys.stdout.write(\\\"{key}: {val}\\\\n\\\".format(key=key, val=val))\",\n \"def num_params(self):\",\n \"def print_networks(self):\\n print('Networks initialized')\\n for name in self.network_names:\\n if isinstance(name, str):\\n net = getattr(self, 'net')\\n num_params = 0\\n for param in net.parameters():\\n num_params += param.numel()\\n print(net)\\n print('[Network {0}] Total number of parameters : {1:.3f} M'.format(name, num_params / 1e6))\",\n \"def show_shape_metrics(shape):\",\n \"def inspect_state(self):\\n for name in self._param_store.get_all_param_names():\\n self._logger.info(\\\"Param [%s]: %r\\\", name,\\n pyro.param(name).data.numpy())\",\n \"def print_shape(self, data):\\n print(data.shape)\",\n \"def display_parameters(self):\\n\\n self.logging.debug(\\\"============\\\")\\n for attr in self.parm_list:\\n self.logging.debug(attr.label + \\\" (\\\" + attr.when + \\\")\\\" + \\\" = \\\" + str(attr.value))\\n self.logging.debug(\\\"============\\\")\",\n \"def num_params():\\n total_num = 0\\n for var in tf.trainable_variables():\\n shape = var.get_shape()\\n total_num += functools.reduce(operator.mul, [dim.value for dim in shape], 1)\\n return total_num\",\n \"def _pprint_params(self):\\n return {'x_range': self.x_range, 'y_range': self.y_range,\\n 'step': self.step, 'shape': self.shape,\\n 'type': self.type}\",\n \"def __str__(self):\\n return 'Tensor product {}: {} params, wires {}'.format([i.name for i in self.obs], len(self.params), self.wires)\",\n \"def getParams(self):\\n return self.trainError, self.trainAcc, self.w\",\n \"def num_parameters(self) -> int:\\n if vocabulary.is_empty(self.vocab, self.config.features.configured_namespaces):\\n self._LOGGER.warning(\\n \\\"At least one vocabulary of your features is still empty! \\\"\\n \\\"The number of trainable parameters usually depends on the size of your vocabulary.\\\"\\n )\\n return sum(p.numel() for p in self._model.parameters())\",\n \"def get_total_trainable_parameter_size():\\n total_parameters = 0\\n import tensorflow as tf\\n for variable in tf.trainable_variables():\\n # shape is an array of tf.Dimension\\n total_parameters += np.product([x.value for x in variable.get_shape()])\\n return total_parameters\",\n \"def debug(self):\\n \\n #path\\n print('Path information:')\\n for k, v in self.__path.items():\\n print(k, v)\\n \\n #sample count\\n print('Sample statistic of each phase')\\n for k, v in self.__phase_sample_count.items():\\n print(k, v)\\n \\n print('Sample statistic of each class')\\n for k, v in self.__area_sample_count.items():\\n print(k, v)\\n \\n print('Sample statistic of each train')\\n for k, v in self.__train_sample_count.items():\\n print(k, v)\",\n \"def describe(self):\\n print(\\\"Number of nodes: {0}\\\".format(self.nnodes))\\n print(\\\"Number of interfaces: {0}\\\".format(self.ninterfaces))\\n print(\\\"Number of elements: {0}\\\".format(self.nelements))\",\n \"def print_params():\\n\\n help_out = convert_phil_to_text(master_phil, att_level=1)\\n txt_out = convert_phil_to_text(master_phil)\\n\\n return help_out, txt_out\",\n \"def paramDetails(cls):\\n return {\\n 'dim': (10, 20, 2, 20),\\n 'nIter': (1, 10, 2, 5),\\n 'lamb': (.1, 1., .1, .05),\\n 'alph': (30, 50, 5, 40)\\n }\",\n \"def num_prunable_parameters(self) -> int:\\n return sum(l.weight.numel() for l in self.emb_layers) + \\\\\\n sum(weight.numel() for weight in self.emb_projs)\",\n \"def num_prunable_parameters(self) -> int:\\n return sum(l.weight.numel() for l in self.emb_layers) + \\\\\\n sum(weight.numel() for weight in self.emb_projs)\",\n \"def get_parameter_numbers(self) -> int:\\n # TODO(jeikeilim): return the number of parameter list of each layers.\\n n_param = sum([x.numel() for x in self.model.parameters()])\\n return n_param\",\n \"def printGraph(self):\\n print \\\"-----\\\"\\n for feature in self.features:\\n feature.printFeature()\\n for constraint in self.constraints:\\n constraint.printConstraint()\\n print \\\"-----\\\"\",\n \"def training_info(self):\\n pass\",\n \"def view_shapes(xm_train, xm_dev, xm_test, ym_train, ym_dev, ym_test):\\n\\n print('X_train shape: ' + str(xm_train.shape))\\n print('Y_train shape: ' + str(ym_train.shape))\\n print('X_dev shape: ' + str(xm_dev.shape))\\n print('Y_dev shape: ' + str(ym_dev.shape))\\n print('X_test shape: ' + str(xm_test.shape))\\n print('Y_test shape: ' + str(ym_test.shape))\\n print('\\\\n')\",\n \"def count_params(model):\\n total = 0\\n for x in model.trainable_variables:\\n total += np.prod(x.shape)\\n return total\",\n \"def count_weights(print_perlayer=True):\\n acc_total = 0\\n for v in tf.trainable_variables():\\n dims = v.get_shape().as_list()\\n total = np.prod(dims)\\n acc_total += total\\n if print_perlayer:\\n print('{}: {}, {}'.format(v.name, dims, total))\\n\\n return acc_total\",\n \"def print_all_variables():\\n for idx, v in enumerate(tf.all_variables()):\\n print(\\\" var %d: %s %s\\\" % (idx, v.get_shape(), v.name))\",\n \"def num_parameters(self) -> int:\\n return len(self.w) + prod(self.v.shape) - len(self.v)\",\n \"def print_me(self):\\n\\n print(\\\"----- Model:\\\",self.name,\\\" -----\\\")\\n print(\\\"Mass (in M_sun): %.5f\\\" % (self.glb[imass]/constants.solar_mass))\\n print(\\\"Radius (in R_sun): %.5f\\\" % (self.glb[iradius]/constants.solar_radius))\\n print(\\\"Reference frequency (in uHz): %.3f\\\" % self.glb[ifreq_ref])\\n print(\\\"Temperature (in K): %.1f\\\" % self.glb[itemperature])\\n print(\\\"Luminosity (in L_sun): %.3g\\\" % (self.glb[iluminosity]/constants.solar_luminosity))\\n print(\\\"Age (in Myrs): %.2f\\\" % self.glb[iage])\\n print(\\\"Z: %.4f\\\" % self.glb[iz0])\\n print(\\\"X: %.4f\\\" % self.glb[ix0])\\n for (name, latex_name) in config.user_params:\\n print(\\\"{0:29} {1:.5e}\\\".format(name,self.glb[user_params_index[name]]))\\n print(\\\"Modes (in muHz):\\\")\\n size = self.modes.shape[0]\\n for i in range(size):\\n print(\\\" (n,l,freq,IK) = (%d, %d, %.15f, %.5e)\\\" % \\\\\\n (self.modes['n'][i], self.modes['l'][i], \\\\\\n self.modes['freq'][i]*self.glb[ifreq_ref],\\\\\\n self.modes['inertia'][i]))\",\n \"def model_summary():\\n print(\\\"\\\\n\\\")\\n print(\\\"=\\\" * 30 + \\\"Model Structure\\\" + \\\"=\\\" * 30)\\n model_vars = tf.trainable_variables()\\n slim.model_analyzer.analyze_vars(model_vars, print_info=True)\\n print(\\\"=\\\" * 60 + \\\"\\\\n\\\")\",\n \"def print_Twiss(self):\\n\\n print(\\\"Twiss parameters in use:\\\")\\n print(\\\"betax : {}\\\".format(self._betax))\\n print(\\\"betay : {}\\\".format(self._betay))\\n print(\\\"alphax : {}\\\".format(self._alphax))\\n print(\\\"alphay : {}\\\".format(self._alphay))\\n print(\\\"gammax : {}\\\".format(self._gammax))\\n print(\\\"gammay : {}\\\".format(self._gammay))\",\n \"def __str__(self):\\n\\n print(\\\"\\\")\\n s = \\\"NAME : \\\"+self._name+\\\"\\\\n\\\\n\\\"\\n s += \\\"PARAMS :\\\"\\n print(s)\\n\\n for key, val in self.params.items():\\n l = (21-len(key))//7\\n print(\\\"{0}\\\".format(key)+\\\"\\\\t\\\"*l+\\\":\\\\t{0}\\\".format(val))\\n\\n s = \\\"\\\\nRuns stored in DEFAULT_RUNS = \\\"+str(len(self.default_runs))\\n print(s)\\n\\n s = \\\"\\\\nRuns stored in MOD_RUNS = \\\"+str(len(self.mod_runs))\\n print(s)\\n\\n return \\\"\\\"\",\n \"def num_trainable_parameters(self) -> int:\\n if vocabulary.is_empty(self.vocab, self.config.features.configured_namespaces):\\n self._LOGGER.warning(\\n \\\"At least one vocabulary of your features is still empty! \\\"\\n \\\"The number of trainable parameters usually depends on the size of your vocabulary.\\\"\\n )\\n return sum(p.numel() for p in self._model.parameters() if p.requires_grad)\",\n \"def print(self):\\n for l in range(self.h+1):\\n print(\\\"Weight matrix between layer \\\" + str(l) + \\\" and layer \\\" + str(l+1))\\n print(self.W[l])\",\n \"def __str__(self):\\n return \\\"{}: {} params, wires {}\\\".format(self.name, len(self.params), self.wires)\",\n \"def select_params( model, contains=[]):\\n names = []\\n for name, param in model.named_parameters():\\n param.requires_grad = False\\n if any(name.find(c) != -1 for c in contains):\\n param.requires_grad = True\\n names.append([name,param.numel()])\\n\\n total = sum(p.numel() for p in model.parameters()) \\n p_str = \\\"\\\\nParameters: \\\\n\\\\nTotal: {} \\\\n\\\\nTrained: {} \\\\n\\\"\\n print(p_str.format(total,sum([p for n,p in names])))\\n for n,t in names: print(n,t)\\n print(\\\"\\\\n\\\")\",\n \"def params_desc(self):\\n return \\\"{}/{}/{}/{}\\\".format(\\n self.learning_rate, self.movement, self.milestones, self.gamma\\n )\",\n \"def show_properties(self):\\n print(\\\"L:\\\", self.L)\\n print(\\\"d:\\\", self.d)\\n print(\\\"D:\\\", self.D)\\n print(\\\"dtype:\\\", self.dtype)\\n print(\\\"R[-1]:\\\", self.R[-1])\\n print(\\\"F[-1]:\\\", self.F[-1])\\n print(\\\"Cummulated norm C:\\\", self.normC)\",\n \"def print_all_params(self, disp=True):\\n descriptions = {'general': {}}\\n for name, param in self.params.items():\\n descriptions['general'][name] = param.get_description()\\n\\n for comp, comp_obj in self.components.items():\\n descriptions[comp] = {}\\n for name in comp_obj.get_params():\\n descriptions[comp][name] = comp_obj.get_param_description(name)\\n return self._print_params(descriptions, disp)\",\n \"def print_inference_result(self):\\n if (\\n self.params.model_str == 'optfixedsig'\\n or self.params.model_str == 'opt'\\n or self.params.model_str == 'fixedparam'\\n ):\\n print('*ls pt est = ' + str(self.sample_list[0].ls) + '.')\\n print('*alpha pt est = ' + str(self.sample_list[0].alpha) + '.')\\n print('*sigma pt est = ' + str(self.sample_list[0].sigma) + '.')\\n elif self.params.model_str == 'samp' or self.params.model_str == 'sampfixedsig':\\n ls_arr = np.array([ns.ls for ns in self.sample_list])\\n alpha_arr = np.array([ns.alpha for ns in self.sample_list])\\n sigma_arr = np.array([ns.sigma for ns in self.sample_list])\\n print('*ls mean = ' + str(ls_arr.mean()) + '.')\\n print('*ls std = ' + str(ls_arr.std()) + '.')\\n print('*alpha mean = ' + str(alpha_arr.mean()) + '.')\\n print('*alpha std = ' + str(alpha_arr.std()) + '.')\\n print('*sigma mean = ' + str(sigma_arr.mean()) + '.')\\n print('*sigma std = ' + str(sigma_arr.std()) + '.')\\n print('-----')\",\n \"def num_parameters(self) -> int:\\n if self._model:\\n return self._model.num_parameters()\\n return 0\",\n \"def summary(self):\\r\\n print(self.model.summary())\",\n \"def print_brief_summary(self):\\n print (\\\"Model {}\\\".format(self.modelName))\\n print (\\\"Precision {}\\\".format(self.precision))\\n print (\\\"Recall {}\\\".format(self.recall))\\n print (\\\"f1 score {}\\\".format(self.f1))\\n \\n # work here\\n print (\\\"\\\\nGold NER label counts:\\\")\\n for ner in self.gold_cts.keys():\\n print (\\\"{} : {} (tag{})\\\".format(self.gold_cts[ner], self.nerTags.ids_to_words([ner]), ner))\\n print (\\\"\\\\nPredicted NER label counts:\\\")\\n for ner in self.pred_cts.keys():\\n print (\\\"{} : {} (tag{})\\\".format(self.pred_cts[ner], self.nerTags.ids_to_words([ner]), ner))\",\n \"def count_parameters(model):\\n return sum(p.numel() for p in model.parameters())\",\n \"def __str__(self):\\n string = 'input dim: {} \\\\noutput dim: {} \\\\n'.format(\\n self.dim_inputs, self.dim_outputs\\n )\\n string += 'sequence length: {} \\\\n'.format(\\n self.tensors[0].shape[1]\\n )\\n key = 'train' if self.train else 'test'\\n string += '{}_samples: {} \\\\n{}_sequences: {} \\\\n'.format(\\n key, self.experiment_length, key, self.tensors[0].shape[0]\\n )\\n return string\",\n \"def print_data(self):\\n for chain, gen in self.generations.items():\\n print('Generations for chain %s: %d' % (chain, gen))\\n print('Log likelihood effective size: %d' % self.loglik_effsize)\\n print('Log likelihood relative difference: %f' % self.loglik_rel_diff)\\n print('Max diff: %f' % self.max_diff)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.81262803","0.76609623","0.7620059","0.75991726","0.7555964","0.7479064","0.74128604","0.74116015","0.73896194","0.73896194","0.73891115","0.73891115","0.73891115","0.73891115","0.73185104","0.7250894","0.72192323","0.7219136","0.7195513","0.7163983","0.7126555","0.7126555","0.7091954","0.69808555","0.69806194","0.6964307","0.6958118","0.6898432","0.6851638","0.6825383","0.6794213","0.6767285","0.6747359","0.67045873","0.67024744","0.6675586","0.66381234","0.6610989","0.66087765","0.66036814","0.65815496","0.65776217","0.65776217","0.6539106","0.65305084","0.6509652","0.6506684","0.64936054","0.6492976","0.6477059","0.6392234","0.6391479","0.63834655","0.63817126","0.63817126","0.63502216","0.63395363","0.63364106","0.6335257","0.6331891","0.6319453","0.6317102","0.63074887","0.62847435","0.62731785","0.6268059","0.62673473","0.6267041","0.6259155","0.62424356","0.6224158","0.62236404","0.62176937","0.62176937","0.62032396","0.6189988","0.61827934","0.6179247","0.6158897","0.61379683","0.6107441","0.6099866","0.60659444","0.6061743","0.60479975","0.6047423","0.6042322","0.60257757","0.60250074","0.602232","0.6019273","0.6015893","0.6004617","0.6002656","0.5987606","0.5974671","0.59745115","0.5973956","0.59735304","0.5971379"],"string":"[\n \"0.81262803\",\n \"0.76609623\",\n \"0.7620059\",\n \"0.75991726\",\n \"0.7555964\",\n \"0.7479064\",\n \"0.74128604\",\n \"0.74116015\",\n \"0.73896194\",\n \"0.73896194\",\n \"0.73891115\",\n \"0.73891115\",\n \"0.73891115\",\n \"0.73891115\",\n \"0.73185104\",\n \"0.7250894\",\n \"0.72192323\",\n \"0.7219136\",\n \"0.7195513\",\n \"0.7163983\",\n \"0.7126555\",\n \"0.7126555\",\n \"0.7091954\",\n \"0.69808555\",\n \"0.69806194\",\n \"0.6964307\",\n \"0.6958118\",\n \"0.6898432\",\n \"0.6851638\",\n \"0.6825383\",\n \"0.6794213\",\n \"0.6767285\",\n \"0.6747359\",\n \"0.67045873\",\n \"0.67024744\",\n \"0.6675586\",\n \"0.66381234\",\n \"0.6610989\",\n \"0.66087765\",\n \"0.66036814\",\n \"0.65815496\",\n \"0.65776217\",\n \"0.65776217\",\n \"0.6539106\",\n \"0.65305084\",\n \"0.6509652\",\n \"0.6506684\",\n \"0.64936054\",\n \"0.6492976\",\n \"0.6477059\",\n \"0.6392234\",\n \"0.6391479\",\n \"0.63834655\",\n \"0.63817126\",\n \"0.63817126\",\n \"0.63502216\",\n \"0.63395363\",\n \"0.63364106\",\n \"0.6335257\",\n \"0.6331891\",\n \"0.6319453\",\n \"0.6317102\",\n \"0.63074887\",\n \"0.62847435\",\n \"0.62731785\",\n \"0.6268059\",\n \"0.62673473\",\n \"0.6267041\",\n \"0.6259155\",\n \"0.62424356\",\n \"0.6224158\",\n \"0.62236404\",\n \"0.62176937\",\n \"0.62176937\",\n \"0.62032396\",\n \"0.6189988\",\n \"0.61827934\",\n \"0.6179247\",\n \"0.6158897\",\n \"0.61379683\",\n \"0.6107441\",\n \"0.6099866\",\n \"0.60659444\",\n \"0.6061743\",\n \"0.60479975\",\n \"0.6047423\",\n \"0.6042322\",\n \"0.60257757\",\n \"0.60250074\",\n \"0.602232\",\n \"0.6019273\",\n \"0.6015893\",\n \"0.6004617\",\n \"0.6002656\",\n \"0.5987606\",\n \"0.5974671\",\n \"0.59745115\",\n \"0.5973956\",\n \"0.59735304\",\n \"0.5971379\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7029052"},"document_rank":{"kind":"string","value":"23"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":230,"numItemsPerPage":100,"numTotalItems":95772,"offset":23000,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjY2NzIzNiwianRpIjoiMjRhNWI5NmQtYjdkZi00NmNkLWIzMjAtOGU2ZWQ2ZmYxZGI0Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODY2NzA4MzYsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.bqQMxKeRpmWeXldDgoG8WOKRGhiMJhS91N07looGaEjSoNY9V2FUpxDcQTKIOGQWzoEvFt1TyY1W-VusTn6jDg","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 |
|---|---|---|---|---|---|---|
Creates a list of random minibatches from (X, Y) | def random_mini_batches(X, mini_batch_size = 64, seed = 0):
X = X.T
m = X.shape[1] # number of training examples
mini_batches = []
np.random.seed(seed)
# Step 1: Shuffle (X, Y)
permutation = list(np.random.permutation(m))
shuffled_X = X[:, permutation]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def random_mini_batches(X, Y, mini_batch_size = 64):\n\n\n\tm = X.shape[1]\n\tmini_batches = []\n\n\t#Shuffling around the data randomly according to the 'permutation' list\n\tpermutation = list(np.random.permutation(m))\n\tshuffled_X = X[:, permutation]\n\tshuffled_Y = Y[:, permutation].reshape((1,m))\n\n\tcomple... | [
"0.6538483",
"0.6306659",
"0.6229192",
"0.62188995",
"0.62120205",
"0.6201539",
"0.6146375",
"0.61380875",
"0.60996467",
"0.60977423",
"0.60959804",
"0.60713136",
"0.60708785",
"0.6014206",
"0.59900105",
"0.5939547",
"0.5883283",
"0.5870768",
"0.58435774",
"0.58415437",
"0.58... | 0.5779349 | 21 |
Helper function to export card fulfillments to a text file. NB Will only work with Samen Doen cards due to Profile class arrangements. Hooks available to move this out of CC3 core to Samen Doen | def process_card_fulfillment_list(card_fulfillment_list):
processed_card_fulfillments = []
for fulfillment in card_fulfillment_list:
try:
user_profile = fulfillment.profile.user.get_profile()
except ObjectDoesNotExist:
# Can do better when this fn is moved out of CC3 cor... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_fr_cards(bc_file, bc_class):\n fr = bc_class.friction_controls\n if not fr.empty:\n bc_file.write('! Friction Controls\\n')\n bc_file.write(fr.to_csv(sep=' ', na_rep='', index=False, header=False,).replace('\\r\\n', '\\n'))\n bc_file.write('\\n') # blank line after Friction Co... | [
"0.5858813",
"0.5749492",
"0.5727883",
"0.56262463",
"0.5562148",
"0.55313855",
"0.54979175",
"0.5494233",
"0.54761094",
"0.5467645",
"0.5434945",
"0.54304004",
"0.5409987",
"0.54044443",
"0.5396171",
"0.5390876",
"0.5382627",
"0.53750294",
"0.5354081",
"0.534875",
"0.5336105... | 0.5015489 | 61 |
GET returns 200 with a specific term instructor schedule course schedule data in json format | def get(self, request, *args, **kwargs):
timer = Timer()
section_id = kwargs.get('section_id')
try:
return self.make_http_resp(timer, request, section_id)
except Exception as ex:
return handle_exception(logger, timer, traceback) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_schedule(self):\n response = self.client.open('/v1/schedule/{id}'.format(id=56),\n method='GET',\n content_type='application/json')\n self.assert200(response, \"Response body is : \" + response.data.decode('utf-8'))",
... | [
"0.63574547",
"0.61109036",
"0.6101973",
"0.60870665",
"0.59486985",
"0.58191013",
"0.5787258",
"0.5783781",
"0.57551056",
"0.57121354",
"0.5707875",
"0.57006395",
"0.56668895",
"0.56541514",
"0.56425047",
"0.56286216",
"0.5623365",
"0.55335736",
"0.55180854",
"0.55138856",
"... | 0.0 | -1 |
instructor schedule data in json format | def make_http_resp(self, timer, request, section_id):
self.processed_primary = False
try:
section_id = self.validate_section_id(request, section_id)
except NotSectionInstructorException:
return not_instructor_error()
schedule = get_instructor_section(request,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_schedules():\n return json.dumps(calendar.get_schedules())",
"def schedule_json(self) -> Optional[Dict]:\n if not self.schedule:\n return None\n else:\n start_time = conv_to_schedule(\n self.start_time if self.start_time else datetime.now()\n ... | [
"0.67919123",
"0.64717513",
"0.63028455",
"0.6294236",
"0.62216735",
"0.61730635",
"0.5869249",
"0.58010226",
"0.56957936",
"0.56477994",
"0.5646666",
"0.56341016",
"0.56084347",
"0.557858",
"0.55746126",
"0.5516498",
"0.5488573",
"0.54806674",
"0.5478912",
"0.5469763",
"0.54... | 0.0 | -1 |
Add common arguments to argument parser. | def _add_common_to_parser(parser):
parser.add_argument(
"--filename-pattern-image", action="store", type=str,
default="{name:s}-{start_time:%Y%m%d_%H%M}.tiff",
help="Filename pattern for output image files.")
parser.add_argument(
"--filename-pattern-video", actio... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __add_common_args(parser: argparse.ArgumentParser):\n parser.add_argument(\"--model\", help=\"name of the model to use. Use query --get-models to get a list of valid names.\")\n parser.add_argument(\"--grid-type\", help=\"type of the grid to use.\")\n parser.add_argument(\"--level-type\", help=\"type ... | [
"0.7948395",
"0.75996715",
"0.75399613",
"0.7516411",
"0.74951726",
"0.7462638",
"0.7419608",
"0.739864",
"0.739864",
"0.7369051",
"0.7357307",
"0.73173416",
"0.72960037",
"0.7179414",
"0.71674997",
"0.7102145",
"0.7091434",
"0.708741",
"0.7082599",
"0.70595914",
"0.7022085",... | 0.7148122 | 15 |
Get the argument parser for passing files. | def get_parser_files():
parser = argparse.ArgumentParser(
description=__doc__,
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument(
"outdir", action="store", type=pathlib.Path,
help="Directory where to write resulting images.")
parser... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_parser():\n p = argparse.ArgumentParser(description='such a good program')\n p.add_argument('infile')\n p.add_argument('outfile')\n return p",
"def get_parser():\n parser = argparse.ArgumentParser()\n # parser = argparse.ArgumentParser(description=__doc__, formatter_class=argpar... | [
"0.79019636",
"0.7870106",
"0.7787764",
"0.75685984",
"0.74728954",
"0.72674626",
"0.71568024",
"0.7144376",
"0.71342105",
"0.71342105",
"0.7131248",
"0.7063849",
"0.7038956",
"0.7009244",
"0.6967036",
"0.6923422",
"0.6912022",
"0.69116515",
"0.6897074",
"0.68824583",
"0.6878... | 0.6530431 | 70 |
Get the argument parser for passing times. | def get_parser_times():
parser = argparse.ArgumentParser(
description=__doc__,
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument(
"start_time", action="store", type=pandas.Timestamp)
parser.add_argument(
"end_time", action="store", ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--date\", \"-d\", help=\"Date of this lab session\")\n parser.add_argument(\"--time-in\", \"-ti\", help=\"Time string representing the time lab began\")\n parser.add_argument(\"--time-out\", \"-to\", help=\"Time string repre... | [
"0.6568716",
"0.59897435",
"0.59649503",
"0.5915204",
"0.5913862",
"0.5864289",
"0.5827687",
"0.5750248",
"0.57498866",
"0.57411927",
"0.57269704",
"0.56963646",
"0.56855893",
"0.5682023",
"0.5682023",
"0.56393063",
"0.56157017",
"0.56120384",
"0.5598651",
"0.55702114",
"0.55... | 0.74796635 | 0 |
Parse the command line. | def parse_cmdline(get_parser=get_parser_files):
return get_parser().parse_args() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_command_line(self, argv):\n from optparse import OptionParser\n usage = \"usage: %prog [options]\"\n parser = OptionParser(usage)\n\n (options, args) = parser.parse_args(argv)",
"def parse(self, command_line=sys.argv[1:]):\n return self._parser.parse_args(command_line... | [
"0.798914",
"0.77689564",
"0.74818027",
"0.74296236",
"0.7251311",
"0.723808",
"0.7231153",
"0.7195712",
"0.7111324",
"0.7103113",
"0.7076255",
"0.70687413",
"0.7030809",
"0.70304805",
"0.7001228",
"0.69465584",
"0.6926082",
"0.6920621",
"0.69191545",
"0.68995804",
"0.6887038... | 0.6510488 | 79 |
Parse commandline and call visualisation routines. | def video_files():
p = parse_cmdline(get_parser=get_parser_files)
log.setup_main_handler(
mods=("fogtools", "typhon", "fogpy", "sattools", "fcitools", "satpy",
"pyresample"),
level=logging.INFO)
vis.show_video_abi_glm(
files=p.files,
img_out=p.filename_p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main(command=None):\r\n if command is None:\r\n my_command = CommandLine() # read options from the command line\r\n else:\r\n my_command = CommandLine(command) # interpret the list passed from the caller of main\r\n\r\n input_file = my_command.args.input_file\r\n style_sheet = my_co... | [
"0.7309777",
"0.7190999",
"0.6903792",
"0.68515545",
"0.6790966",
"0.67772627",
"0.6772432",
"0.6749553",
"0.6726485",
"0.6726485",
"0.6726485",
"0.6726485",
"0.6726485",
"0.6726485",
"0.6726485",
"0.6726485",
"0.6726485",
"0.6726485",
"0.6726485",
"0.6726485",
"0.6726485",
... | 0.0 | -1 |
Parse commandline and call visualisation routines. | def video_times():
p = parse_cmdline(get_parser=get_parser_times)
log.setup_main_handler(
mods=("fogtools", "typhon", "fogpy", "sattools", "fcitools", "satpy",
"pyresample"),
level=logging.DEBUG)
vis.show_video_abi_glm_times(
start_date=p.start_time,
end... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main(command=None):\r\n if command is None:\r\n my_command = CommandLine() # read options from the command line\r\n else:\r\n my_command = CommandLine(command) # interpret the list passed from the caller of main\r\n\r\n input_file = my_command.args.input_file\r\n style_sheet = my_co... | [
"0.7309777",
"0.7190999",
"0.6903792",
"0.68515545",
"0.6790966",
"0.67772627",
"0.6772432",
"0.6749553",
"0.6726485",
"0.6726485",
"0.6726485",
"0.6726485",
"0.6726485",
"0.6726485",
"0.6726485",
"0.6726485",
"0.6726485",
"0.6726485",
"0.6726485",
"0.6726485",
"0.6726485",
... | 0.0 | -1 |
Checks if Python version is supported by Cuckoo. | def check_python_version():
version = sys.version.split()[0]
if version < "2.6" or version >= "3":
raise CuckooStartupError("You are running an incompatible version of Python, please use 2.6 or 2.7") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def python_compatible():\n result = False\n req_ver = vers.convert('3.9.5')\n pythonver = vers.convert('{major}.{minor}.{micro}'.format(major=sys.version_info.major,\n minor=sys.version_info.minor,\n ... | [
"0.7637709",
"0.7555077",
"0.72389746",
"0.7111935",
"0.70349747",
"0.7027567",
"0.70126307",
"0.70126307",
"0.70126307",
"0.70080096",
"0.6967738",
"0.68840957",
"0.6819389",
"0.6783709",
"0.676768",
"0.6756775",
"0.6746007",
"0.67407185",
"0.6651795",
"0.66268104",
"0.65999... | 0.795639 | 0 |
Checks if working directories are ready. | def check_working_directory():
if not os.path.exists(CUCKOO_ROOT):
raise CuckooStartupError("You specified a non-existing root directory: %s" % CUCKOO_ROOT)
cwd = os.path.join(os.getcwd(), "cuckoo.py")
if not os.path.exists(cwd):
raise CuckooStartupError("You are not running Cuckoo from it'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_all_systems_ready(self):\n self._check_all_sensors_ready()\n return True",
"def _check_all_systems_ready(self):\n self._check_all_sensors_ready()\n return True",
"def _check_all_systems_ready(self):\n raise NotImplementedError()",
"def is_ready() -> bool:\n ... | [
"0.6585585",
"0.6585585",
"0.6461984",
"0.64543515",
"0.64328486",
"0.63897145",
"0.6369198",
"0.63275504",
"0.62811655",
"0.6223177",
"0.62050366",
"0.6193372",
"0.61837643",
"0.61824787",
"0.6179181",
"0.61762285",
"0.6173104",
"0.61561316",
"0.6148442",
"0.61197335",
"0.60... | 0.6141566 | 19 |
Checks if dependencies are installed. | def check_dependencies():
check_python_version()
dependencies = ["sqlite3"]
for dependency in dependencies:
try:
__import__(dependency)
except ImportError as e:
raise CuckooStartupError("Unable to import \"%s\"" % dependency)
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_dependencies(self):\n imgmin = exists('imgmin')\n image_optim = exists('image_optim')\n\n if not imgmin or not image_optim:\n puts(p('Dependencies have not been installed:'))\n\n message = 'imgmin - https://github.com/rflynn/imgmin'\n message = s('✓ ... | [
"0.793422",
"0.7930604",
"0.7912953",
"0.78336424",
"0.76999456",
"0.76947135",
"0.7686539",
"0.7666271",
"0.76288325",
"0.7572292",
"0.75151587",
"0.7492932",
"0.74447614",
"0.74242735",
"0.73918897",
"0.736468",
"0.7360159",
"0.7314458",
"0.72915107",
"0.7267136",
"0.725657... | 0.82182187 | 0 |
Checks if config files exist. | def check_configs():
configs = [os.path.join(CUCKOO_ROOT, "conf", "cuckoo.conf"),
os.path.join(CUCKOO_ROOT, "conf", "reporting.conf")]
for config in configs:
if not os.path.exists(config):
raise CuckooStartupError("Config file does not exist at path: %s" % config)
return... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_configfiles():\n return (all(os.path.isdir(x) for x in CONFIG_DIRS) and\n os.path.isfile(CONFIG_FILE) and os.path.isfile(LOG_CONFIG_FILE))",
"def __check_config(self):\n if not os.path.exists(self.__config_path):\n return False\n else:\n return True",
... | [
"0.8346882",
"0.78028643",
"0.77522177",
"0.77137613",
"0.7490861",
"0.72511786",
"0.7087832",
"0.7071221",
"0.70583725",
"0.7033269",
"0.7024421",
"0.69919306",
"0.69578743",
"0.6946059",
"0.6932018",
"0.68946105",
"0.6867093",
"0.6830978",
"0.6827687",
"0.6827188",
"0.67988... | 0.8165395 | 1 |
Randomly transform image data. Given an input image list (possibly multimodal) and an optional corresponding segmentation image list, this function will perform data augmentation with | def data_augmentation(input_image_list,
segmentation_image_list=None,
number_of_simulations=10,
reference_image=None,
transform_type='affineAndDeformation',
noise_model='additivegaussian',
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def data_augmentation(image, aug):\n if (aug == \"random_crop\") and (random.randint(0,1)):\n image = random_crop(image) \n if (aug == \"random_rotation\") and (random.randint(0,1)): \n image = random_rotation(image) \n if (aug == \"random_flip\") and (random.randint(0,1)): \n image =... | [
"0.6911291",
"0.6776172",
"0.6606806",
"0.6512269",
"0.64750767",
"0.64673746",
"0.6444081",
"0.62625486",
"0.6222153",
"0.62075675",
"0.61686075",
"0.6148961",
"0.6134152",
"0.61139226",
"0.6082042",
"0.6072987",
"0.605287",
"0.6020677",
"0.6015514",
"0.6012553",
"0.6000056"... | 0.7687681 | 0 |
Returns an ``Iterable`` containing all the instances in the specified dataset. If ``self.lazy`` is False, this calls ``self._read()``, ensures that the result is a list, then returns the resulting list. If ``self.lazy`` is True, this returns an object whose ``__iter__`` method calls ``self._read()`` each iteration. In ... | def read(self, *args, **kwargs) -> Iterable[Instance]:
lazy = getattr(self, 'lazy', None)
if lazy is None:
logger.warning("DatasetReader.lazy is not set, "
"did you forget to call the superclass constructor?")
if lazy:
return _LazyInstances(lam... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __iter__(self):\n return iter(self._datasets)",
"def __iter__(self) -> Iterator:\n return iter(self.get_data_loader())",
"def __iter__(self) -> Union[Iterator[int], Iterator[Tuple[int, Any]]]:\n self.size = self._data._dataset_size\n if (not self._data._fully_cached or\n ... | [
"0.7040597",
"0.6643148",
"0.6294192",
"0.62414855",
"0.61743397",
"0.61443645",
"0.60582954",
"0.6047906",
"0.59985113",
"0.5981316",
"0.5973242",
"0.59701633",
"0.5944178",
"0.5882069",
"0.58764064",
"0.58696884",
"0.5857583",
"0.5841389",
"0.58389926",
"0.5835787",
"0.5801... | 0.8134299 | 0 |
Helper method for changing password. | def change_password(self):
self.test_user.set_password(self.create_user_data()['password1'])
self.test_user.save() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setpassword(self, pwd):\n pass",
"def change_password(change_account):\n change_data(change_account, changed_data='password')",
"def change_password(self, new_password):\n dev = self.nearest_pandevice()\n self.password_hash = dev.request_password_hash(new_password)\n self.upd... | [
"0.83203053",
"0.8311983",
"0.80322033",
"0.7970062",
"0.78713304",
"0.7853417",
"0.7846718",
"0.7818966",
"0.7744164",
"0.76641804",
"0.7636149",
"0.7597402",
"0.7588872",
"0.7561001",
"0.7524474",
"0.74891347",
"0.7479619",
"0.74788195",
"0.7476977",
"0.7459346",
"0.7455279... | 0.7484463 | 16 |
Test the login page elements like button, username field and password field is loded properly or not. | def test_login_page_elements(self):
response = self.client.get(reverse('users:login'))
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'users/login.html')
self.assertContains(response, ' <input type="text" name="username"')
self.assertContains(respon... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_login(self):\n url_extend = 'user_auth/login/'\n self.browser.get(self.url + url_extend)\n\n # enter the username and password.\n username_field = self.browser.find_element_by_name('user_name')\n username_field.send_keys('user4')\n password_field = self.browser.fi... | [
"0.81608397",
"0.7807469",
"0.7750099",
"0.7648665",
"0.7499904",
"0.74693316",
"0.7445929",
"0.7401844",
"0.7391671",
"0.73524094",
"0.73394597",
"0.7300667",
"0.72945255",
"0.7244298",
"0.7213896",
"0.7185873",
"0.7171691",
"0.7159399",
"0.7155342",
"0.7133687",
"0.7129667"... | 0.8222996 | 0 |
Check login page is redirected to home page or not . | def test_post_login_page(self):
response = self.client.post(
reverse('users:login'), {'username': self.user['username'], 'password': self.user['password1']}, follow=True
)
self.assertRedirects(response, reverse('users:home')) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_home_page_redirect_when_loggin_attempt_successful(self):\n\t\tpass",
"def view_login(self):\n with self.client.get(\"/login\", catch_response=True) as response:\n for r_hist in response.history:\n if r_hist.status_code > 200 and r_hist.status_code < 400:\n ... | [
"0.78158134",
"0.7318312",
"0.7259517",
"0.7234029",
"0.71897537",
"0.7179481",
"0.70696545",
"0.7032853",
"0.7031419",
"0.6956722",
"0.694599",
"0.6892971",
"0.68414986",
"0.68354315",
"0.68219674",
"0.6789293",
"0.6781092",
"0.6761577",
"0.67566794",
"0.67533886",
"0.675035... | 0.61683476 | 95 |
Check for invalid username and invalid password should not be able to login | def test_invalid_username_invalid_password(self):
response = self.client.post(
reverse('users:login'), {
'username': self.create_user_data()['username'],
'password': self.create_user_data()['password1']
}
)
self.assertEqual(response.status_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_auth_user_fail_bad_username(self):\n\n self.assertFalse(User.authenticate(\"invalid\", \"allison\"))",
"def test_login_wrong_credentials(self):\n\t\tdata = {'username' : 'nonexistentuser', 'password' : 'nopasswordlol'}\n\t\tresponse = self.login(data)\n\n\t\terror_text = \"Unable to log in with p... | [
"0.7901798",
"0.77217233",
"0.77012146",
"0.76538616",
"0.7576865",
"0.7574334",
"0.755077",
"0.7488525",
"0.74578387",
"0.744723",
"0.74460363",
"0.74412745",
"0.74403954",
"0.7430433",
"0.7425823",
"0.7395681",
"0.7395213",
"0.7375655",
"0.7326853",
"0.7312103",
"0.7311579"... | 0.7513344 | 7 |
Check for valid username and invalid password should not be able to login | def test_valid_username_invalid_password(self):
response = self.client.post(reverse('users:login'), {'username': self.user['username'], 'password': '1sfsdf'})
self.assertEqual(response.status_code, 200)
self.assertFormError(response, 'form', None, ERROR_MSG) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_authentication(self, username, password):\n return self.user_table[username]['pwd'] == password",
"def test_auth_user_fail_bad_username(self):\n\n self.assertFalse(User.authenticate(\"invalid\", \"allison\"))",
"def check_auth(username, password, expected_user, expected_pw):\n ... | [
"0.7802883",
"0.778277",
"0.7756373",
"0.7752627",
"0.7586923",
"0.75375336",
"0.7489758",
"0.7483796",
"0.74812096",
"0.7474361",
"0.74624926",
"0.7450919",
"0.74466735",
"0.7442546",
"0.74277145",
"0.7423208",
"0.74196374",
"0.74130267",
"0.7404624",
"0.7398643",
"0.7396676... | 0.7786559 | 1 |
Check for invalid username and valid password should not be able to login | def test_invalid_username_valid_password(self):
response = self.client.post(reverse('users:login'), {'username': 'xyzabe', 'password': self.user['password1']})
self.assertEqual(response.status_code, 200)
self.assertFormError(response, 'form', None, ERROR_MSG) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_auth_user_fail_bad_username(self):\n\n self.assertFalse(User.authenticate(\"invalid\", \"allison\"))",
"def test_valid_username_invalid_password(self):\n response = self.client.post(reverse('users:login'), {'username': self.user['username'], 'password': '1sfsdf'})\n self.assertEqual... | [
"0.7951096",
"0.7841457",
"0.7711811",
"0.76967174",
"0.7688351",
"0.7644936",
"0.76221037",
"0.760486",
"0.7591186",
"0.75574297",
"0.7532108",
"0.75310373",
"0.7526137",
"0.7497212",
"0.74888337",
"0.74736017",
"0.7467855",
"0.74638116",
"0.7450047",
"0.7411747",
"0.7391035... | 0.7611962 | 7 |
Check for blank username and blank password should not be able to login | def test_blank_username_blank_password(self):
response = self.client.post(reverse('users:login'), {'username': '', 'password': ''})
self.assertEqual(response.status_code, 200)
self.assertFormError(response, 'form', 'username', 'This field is required.')
self.assertFormError(response, 'fo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_login_empty_username(self):\n self.client.post('api/v2/auth/signup', json=self.user,\n headers={'Content-Type': 'application/json'})\n\n res_other = self.client.post('/api/v2/auth/login', json={\n 'username': None, 'password': 'mikemike... | [
"0.7467626",
"0.7417053",
"0.73873866",
"0.73845154",
"0.7267287",
"0.7184474",
"0.7178433",
"0.7175828",
"0.7163327",
"0.71527857",
"0.71351755",
"0.71197534",
"0.70886356",
"0.7087536",
"0.70774215",
"0.7072684",
"0.7067899",
"0.70463395",
"0.7042235",
"0.7033119",
"0.70229... | 0.76699674 | 0 |
Check for After changing password users should be able to login | def test_login_after_password_change(self):
old_password = self.user['password1']
self.change_password()
response = self.client.post(
reverse('users:login'), {'username': self.user['username'], 'password': old_password}
)
self.assertEqual(response.status_code, 200) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_correct_user(self, login, password):\n pass",
"def test_no_forced_password_change(self):\r\n\r\n email, password = self._setup_user()\r\n self._login(email, password)\r\n\r\n email, password = self._setup_user(is_staff=True)\r\n self._login(email, password)",
"def test... | [
"0.74237895",
"0.73377043",
"0.72924936",
"0.72834015",
"0.71276367",
"0.7053073",
"0.70174813",
"0.70155585",
"0.69883895",
"0.69872814",
"0.69835067",
"0.6974151",
"0.6954494",
"0.69419676",
"0.6923948",
"0.6913977",
"0.69104934",
"0.68806005",
"0.68394154",
"0.6821562",
"0... | 0.7121998 | 5 |
Check for users should not be able to login from old password | def test_old_password_login_check(self):
old_password = self.user['password1']
self.change_password()
response = self.client.post(reverse('users:login'), {'username': self.user['username'], 'password': old_password})
self.assertEqual(response.status_code, 200)
self.assertFormErro... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_no_forced_password_change(self):\r\n\r\n email, password = self._setup_user()\r\n self._login(email, password)\r\n\r\n email, password = self._setup_user(is_staff=True)\r\n self._login(email, password)",
"def test_disabled_too_frequent_password_resets(self):\r\n studen... | [
"0.71566904",
"0.7139833",
"0.70374",
"0.69580734",
"0.69088155",
"0.6857486",
"0.6838342",
"0.67982876",
"0.6719867",
"0.67038935",
"0.6684486",
"0.66533893",
"0.66437966",
"0.66162145",
"0.6593299",
"0.6592775",
"0.65780205",
"0.6563781",
"0.6559912",
"0.65482986",
"0.65358... | 0.68825674 | 5 |
Return True if dropping an egg results in it's destruction, otherwise return False. Once destroyed an egg cannot be reused! | def drop(self, fromFloor):
self.__drop_count += 1
if self.__smashed:
# You cannot drop an egg which has already been smashed!
raise AttemptedToDropADesroyedEgg()
if fromFloor > self.__strength:
self.__smashed = True
log.info("I dr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _nonforce_drop(self) -> bool:\n if self.closed:\n return True\n if self.zero_failures():\n return False\n return random.random() < self.failurerate",
"def remove(self, egg):",
"def is_destroyed(self) -> bool:\n return self._coords == self.damaged_cells",
... | [
"0.6458748",
"0.6121517",
"0.59280527",
"0.58651847",
"0.584907",
"0.57872874",
"0.57657474",
"0.5701933",
"0.56951636",
"0.5681737",
"0.56644017",
"0.56603515",
"0.5633385",
"0.55955076",
"0.5491876",
"0.54897475",
"0.5488751",
"0.5484713",
"0.54588217",
"0.54502827",
"0.538... | 0.60147166 | 2 |
Retrieves all info needed for worker and puts it into a dictionary | def get_task_worker(self):
start, end = self.get_block()
return {
'task_id':self.id,
'finished':self.finished,
'free_block':(start != end),
'keyword':self.keyword,
'chars':self.chars,
'algorithm':self.algorithm,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def read_worker_metadata(self) -> Dict[str, Any]:\n response = await self._client.get(\"collections/views/aggregate-worker-metadata\")\n response.raise_for_status()\n return response.json()",
"def get_information(self):\n info_dict = dict()\n info_dict['run'] = self._runN... | [
"0.678594",
"0.6314804",
"0.61548144",
"0.60795724",
"0.6061691",
"0.60179424",
"0.60070586",
"0.6003615",
"0.6000852",
"0.5975921",
"0.5956673",
"0.59529394",
"0.5952804",
"0.59031546",
"0.5901462",
"0.58881104",
"0.58605975",
"0.58536565",
"0.58536565",
"0.5828623",
"0.5828... | 0.6506152 | 1 |
Retrives the next block to be worked on and updates current_point | def get_block(self):
current_value = self.get_value(self.current_point)
endpoint_value = self.get_value(self.end_point)
worker_start = self.current_point
if (endpoint_value - current_value) > self.searchwidth:
worker_end = self.get_word_from_value(current_value + self.se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_next_position(self):",
"def updateBlock(self):\n self.blkno = self.blknoSpinBox.value() - 1\n self.initDataParms()\n self.updateCurveList()\n self.compute()",
"def next_line():\r\n set_point(point().next_line())",
"def InsertNextPoint(self, ):\n ...",
"def comput... | [
"0.6269478",
"0.61071306",
"0.6065598",
"0.605103",
"0.60347897",
"0.60193807",
"0.6014046",
"0.5979615",
"0.59784544",
"0.59410185",
"0.59170794",
"0.58443856",
"0.5820316",
"0.5779748",
"0.5770897",
"0.5764013",
"0.5760746",
"0.57168615",
"0.57011765",
"0.56897867",
"0.5672... | 0.5988784 | 7 |
Beregner verdien fra base xtall til base 10tall | def get_value(self, str):
base = len(self.chars)
base_placement = len(str) - 1
value = 0
for symbol in str:
valueChar = self.chars.find(symbol)
value += valueChar * (base ** base_placement)
base_placement -= 1
return value | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convertebasenbase10(baseorig, numero):\n base10 = 0\n for i in range(len(numero)-1, -1, -1):\n base10 += DIGITOS.index(numero[i]) * baseorig**(len(numero)-i-1)\n\n return base10",
"def convertebase10basen(basedest, numero):\n ret = \"\"\n while True:\n digit = numero%basedest\n ... | [
"0.69762754",
"0.660738",
"0.6280264",
"0.61839783",
"0.6165925",
"0.60826427",
"0.6078281",
"0.6041513",
"0.5987892",
"0.5951344",
"0.5911084",
"0.5903381",
"0.5859326",
"0.58539116",
"0.5836696",
"0.58148897",
"0.57990456",
"0.578782",
"0.5783043",
"0.57668954",
"0.57554835... | 0.0 | -1 |
Beregner basex ordet gitt base10 verdien, og returnerer denne Variabler value = base10 verdien av kodeordet str = verdiene kodeordet skal beregnes fra self.chars = alle tegnene som brukes (f.eks. "abcdefghij") | def get_word_from_value(self, value):
base = len(self.chars)
str = ""
while value != 0:
remainder = value % base
value = int((value - remainder) / base)
str = self.chars[remainder] + str
return str | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def char2bf(char):\n\n result_code = \"\"\n ascii_value = ord(char)\n #print(ascii_value)\n factor = int(ascii_value / 10)\n #print(factor)\n remaining = int(ascii_value % 10)\n #print(remaining)\n\n result_code += \"%s\\n\" % (\"+\" * 10)\n result_code += \"[\\n\"\n result_code += \"... | [
"0.6319352",
"0.59468013",
"0.5832483",
"0.57488376",
"0.5731045",
"0.56868696",
"0.5657961",
"0.56209755",
"0.56140286",
"0.5613853",
"0.5583171",
"0.55587304",
"0.55219233",
"0.54779905",
"0.5461078",
"0.54544",
"0.54473144",
"0.5445014",
"0.5431559",
"0.5415982",
"0.540977... | 0.4973494 | 90 |
Handles standard GETrequests and get_jobrequests | def do_GET(self):
path = self.path
status_code, res = webServer.handle_get_msg(path)
self.send_response(status_code)
self.end_headers()
self.wfile.write(res.encode()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_GET(self):\n self._try_to_process_request(self._handle_get_request)",
"def on_get(self, req, resp):\n try:\n n_reqs = int(req.params.get('n', self.default_reqs))\n except ValueError:\n error_response(resp, 'ERROR: Incorrect number of requests')\n retur... | [
"0.708641",
"0.68929356",
"0.6749446",
"0.67281705",
"0.6490519",
"0.6429551",
"0.63998663",
"0.6372085",
"0.63160455",
"0.62698215",
"0.62575865",
"0.6090804",
"0.6070183",
"0.60638535",
"0.6025948",
"0.59976333",
"0.59892786",
"0.597048",
"0.59660536",
"0.59596616",
"0.5955... | 0.53607714 | 98 |
Handles all POSTrequests, message is decoded in handle_post_msg() | def do_POST(self):
content_length = int(self.headers['Content-Length'])
body = self.rfile.read(content_length)
response = BytesIO()
try:
res = webServer.handle_post_msg(body)
print(res)
self.send_response(200)
except Exception as e:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_POST(self): # pylint: disable=invalid-name\n self.handle_request()",
"def do_POST(self):\n self._try_to_process_request(self._handle_post_request)",
"def handle_post_msg(body):\r\n request = json.loads(body)\r\n type = request['type']\r\n subtype = request['su... | [
"0.6977046",
"0.6908505",
"0.6876362",
"0.66455024",
"0.66303426",
"0.65271676",
"0.65047675",
"0.6497064",
"0.63782585",
"0.63608754",
"0.63462037",
"0.63272667",
"0.6258365",
"0.6229079",
"0.6213434",
"0.6196621",
"0.616209",
"0.6155476",
"0.60837656",
"0.60646325",
"0.6053... | 0.6169068 | 16 |
Takes in a request, converts to dictionary and handles request according to type specified in request Required type subtype | def handle_post_msg(body):
request = json.loads(body)
type = request['type']
subtype = request['subtype']
if type == 'get':
if subtype == 'job':
job = {'job':get_next_job()}
return webServer.add_json_successfull_status(job)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_request_dict(request: Union[str, bytes, HttpRequest, dict]) -> Dict[str, str]:\n if isinstance(request, (str, bytes)):\n try:\n return json.loads(request)\n except Exception:\n print('Must be given a valid JSON')\n raise\n if not isinstance(request, dict... | [
"0.66045016",
"0.6057629",
"0.6054783",
"0.6026459",
"0.60111326",
"0.5992731",
"0.59388953",
"0.59353733",
"0.59153354",
"0.59043115",
"0.5894454",
"0.58504784",
"0.58270943",
"0.57932085",
"0.5791295",
"0.57862103",
"0.5760113",
"0.5708097",
"0.56899875",
"0.5688118",
"0.56... | 0.0 | -1 |
Gets the Updated job template right now changes from active to inactive. | def get_updated_jobtemplate(self):
return self.response_json | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Updated(self):\n return self._get_attr('Updated')",
"def getChanges():",
"def last_status_update(self):\n try:\n return StatusUpdate.objects.filter(section=self).latest(\"created_at\")\n except StatusUpdate.DoesNotExist:\n return None",
"def changes(self) -> dic... | [
"0.5720681",
"0.5635518",
"0.5623788",
"0.5566456",
"0.55534095",
"0.5552222",
"0.5476115",
"0.5407608",
"0.5343847",
"0.5331713",
"0.53309363",
"0.5325143",
"0.5319297",
"0.5319297",
"0.5319297",
"0.5319297",
"0.5312014",
"0.5278158",
"0.52175415",
"0.52158743",
"0.52158743"... | 0.73913294 | 0 |
First message to the user. | def openingMessage():
print("=" * 55)
print("\nNote: ")
print("Input of an RSA Encrypted message is required.")
print("Public parameters of the system are n=31313 and e=4913\n")
print("=" * 55) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def client_first_message(self):\n self.nonce = str(uuid4()).replace(\"-\", \"\")\n client_first_bare = \"n={},r={}\".format(self.user, self.nonce)\n self.auth_message = client_first_bare\n return \"n,,\" + client_first_bare",
"def _send_msg(self, contact):\n msg_content = input... | [
"0.67874026",
"0.6723854",
"0.66218483",
"0.65833837",
"0.65342826",
"0.6512653",
"0.6380038",
"0.6366027",
"0.6304767",
"0.6303987",
"0.6287261",
"0.62694854",
"0.6222925",
"0.61418635",
"0.61328685",
"0.6127601",
"0.6061265",
"0.6028994",
"0.6011218",
"0.5975677",
"0.597244... | 0.0 | -1 |
The largest positive integer that divides each of the params. | def gcd(x:int, y:int) -> int:
if x == 0:
return y
return gcd(y % x, x) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def max_div(self):\n if self._max_div is not None:\n return self._max_div\n n = self.degree\n if n == 1:\n return 1\n for x in sieve:\n if n % x == 0:\n d = n//x\n self._max_div = d\n return d",
"def find_la... | [
"0.72691697",
"0.68096185",
"0.66286135",
"0.66143864",
"0.65909207",
"0.64670926",
"0.644061",
"0.63005096",
"0.6291326",
"0.6288224",
"0.6266296",
"0.62133557",
"0.6212883",
"0.6203084",
"0.6184084",
"0.61810917",
"0.61790323",
"0.61790323",
"0.617845",
"0.6175247",
"0.6130... | 0.0 | -1 |
Euler's Totient Function, returns number of totatives of n | def phi(n: int) -> int:
result = 1
for i in range(2, n):
if gcd(i, n) == 1:
result += 1
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def eulerTotient(n): #\n result = 1\n for i in range(2, n): \n if (nt.gcd(i, n) == 1): \n result+=1\n return result",
"def eulers_totient(n):\n return int(n * product(1 - 1 / p for p in prime_factors(n)))",
"def eulerphi(n):\r\n\treturn euler_phi(n)",
"def euler_phi(n):\n\n ... | [
"0.8072356",
"0.8067203",
"0.74935395",
"0.74776405",
"0.74699026",
"0.73793525",
"0.7322867",
"0.7098295",
"0.7066441",
"0.70519406",
"0.6925338",
"0.64791536",
"0.64176416",
"0.6406807",
"0.63801664",
"0.6270723",
"0.6220426",
"0.6215612",
"0.62123954",
"0.6190173",
"0.6165... | 0.6527361 | 11 |
Translates the plaintext back into ordinary English text | def decryptMessage():
exponents = [2, 1, 0]
encryptedMessage = input("Please enter the RSA encrypted message: \n")
messageSplit = encryptedMessage.split(" ")
print("")
for c in messageSplit:
d = modInverse(PUBLIC_KEY["e"], phi(PUBLIC_KEY["n"]))
p = (int(c) ** d) % PUBLIC_KEY["n"]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def translateText(text):\r\n\treturn translator.translate(text, src='en', dest='ro')",
"def translate():\n pass",
"def translate_text(target, text):\n return text",
"def ta2en(text):\n return IITB_translator(\"ta\", \"en\", text)",
"def translate_leet(phrase):",
"def retranslate(self):\r\n ... | [
"0.79665506",
"0.728794",
"0.72659403",
"0.7104326",
"0.7055434",
"0.70127326",
"0.70127326",
"0.693319",
"0.6868713",
"0.67893815",
"0.67630345",
"0.670048",
"0.664606",
"0.6633309",
"0.66160625",
"0.6613145",
"0.6588977",
"0.6535806",
"0.6502176",
"0.65011525",
"0.6491229",... | 0.0 | -1 |
Compares a plain string to a hashed password | def verify_password(plain_password: str, hashed_password: str) -> bool:
return pwd_context.verify(plain_password, hashed_password) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_password(raw_password, enc_password):\n algo, salt, hsh = enc_password.split('$')\n return constant_time_compare(hsh, get_hexdigest(algo, salt, raw_password))",
"def check_password(raw_password, enc_password):\n algo, salt, hsh = enc_password.split('$')\n return hsh == get_hexdigest(algo, s... | [
"0.7576271",
"0.74892336",
"0.74892336",
"0.74081683",
"0.7389026",
"0.7322922",
"0.7288965",
"0.7263801",
"0.72267926",
"0.71997774",
"0.71876806",
"0.71660066",
"0.7122997",
"0.707954",
"0.7066134",
"0.7062869",
"0.70221514",
"0.6994417",
"0.69662356",
"0.6947845",
"0.69309... | 0.71074784 | 13 |
Takes in a raw password and hashes it. Used prior to saving a new password to the database. | def get_password_hash(password: str) -> str:
return pwd_context.hash(password) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hash_password(self):\n self.__password = self.str_to_hash(self.__password)",
"def hash_password(self, original_password):\n self.password = generate_password_hash(original_password)",
"def hash_password(self, password):\n self.password_hash = generate_password_hash(password)",
"def s... | [
"0.7692625",
"0.76232475",
"0.7447069",
"0.7431796",
"0.7431796",
"0.73878235",
"0.7385752",
"0.7378277",
"0.7317121",
"0.7237397",
"0.7199203",
"0.71626663",
"0.7114192",
"0.7088237",
"0.70874846",
"0.7057534",
"0.70349723",
"0.7000121",
"0.6976634",
"0.69596976",
"0.6918479... | 0.68872106 | 22 |
Tokenizes a given text and determines the postags. Lowercases the text. | def pos_tag(text, simple=False):
tokens = nltk.word_tokenize(text.lower())
pos = nltk.pos_tag(tokens)
# simplify tags if requested
if simple:
simple_pos = []
for word, tag in pos:
new_tag = nltk.tag.mapping.map_tag('en-ptb', 'universal',tag)
# simplificati... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preprocess(text):\n return text.lower()",
"def preprocess_sent(sent):\n #tokenized = word_tokenize(sent.lower())\n tokenizer = Tok()\n tokenized = tokenizer.tokenize(sent.lower())\n return tokenized",
"def process_text(text, tokenize=tokenize1, filter=filter1, stem=None, lower=True):\n as... | [
"0.73638403",
"0.71996164",
"0.70776325",
"0.70369464",
"0.70350385",
"0.699438",
"0.6974615",
"0.69460094",
"0.6889723",
"0.6881596",
"0.6870311",
"0.68678427",
"0.68667",
"0.682271",
"0.6777725",
"0.6755323",
"0.67493415",
"0.6743987",
"0.6711147",
"0.67024463",
"0.66992223... | 0.0 | -1 |
Stops the current video. | def stop_video(self):
global value
if value>0:
value=0
print(f"Stopping video: {name}")
else:
print("Cannot stop video: No video is currently playing") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stop_video(self):\n\n if self.current_video is None:\n print(\"Cannot stop video: No video is currently playing\")\n else:\n print(\"Stopping video:\", self.current_video.title)\n self.current_video = None",
"def stop_video(self):\n if self._current_video... | [
"0.88741636",
"0.8774506",
"0.8441174",
"0.8365092",
"0.8315334",
"0.75267285",
"0.7508737",
"0.7479121",
"0.7374416",
"0.73499715",
"0.73044616",
"0.7266504",
"0.7158296",
"0.71389854",
"0.7137596",
"0.70946974",
"0.706027",
"0.6946775",
"0.6921336",
"0.6860272",
"0.68469775... | 0.7786517 | 5 |
Plays a random video from the video library. | def play_random_video(self):
print("play_random_video needs implementation") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def play_random_video(self):\n num_videos = len(self._video_library.get_all_videos())\n videos = self._video_library.get_all_videos()\n random_index = randint(0, num_videos-1)\n self.play_video(videos[random_index].video_id)\n # print(\"play_random_video needs implementation\")",... | [
"0.8968212",
"0.88889474",
"0.8764582",
"0.86797124",
"0.74386805",
"0.6433095",
"0.6404907",
"0.63862103",
"0.6253938",
"0.6234064",
"0.610353",
"0.61004305",
"0.6057416",
"0.6026028",
"0.59989953",
"0.5998689",
"0.5952484",
"0.5926255",
"0.5915889",
"0.5892517",
"0.5839559"... | 0.85630876 | 4 |
Pauses the current video. | def pause_video(self):
global value
if value==1:
value=2
print(f"Pausing video: {name}")
elif value==0:
print(f"Cannot pause video: No video is currently playing")
else:
print(f"Video already paused: {name}") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pause_video(self):\n if self._paused:\n print(f\"Video already paused: {self._current_video.title}\")\n return\n elif self._current_video is None:\n print(\"Cannot pause video: No video is currently playing\")\n return\n print(f\"Pausing video: {self._cu... | [
"0.8277917",
"0.81578803",
"0.81201726",
"0.8063698",
"0.7832002",
"0.7822245",
"0.7746284",
"0.77101934",
"0.7540578",
"0.7526118",
"0.7477645",
"0.74383736",
"0.7433377",
"0.74296737",
"0.7347314",
"0.73419297",
"0.7341595",
"0.7311873",
"0.72468805",
"0.7224297",
"0.722429... | 0.7657883 | 8 |
Resumes playing the current video. | def continue_video(self):
global value
if value==2:
global name
value=1
print(f"Continuing video: {name}")
elif value==1:
print(f"Cannot continue video: Video is not paused") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def continue_video(self):\n if self._current_video is None:\n print(\"Cannot continue video: No video is currently playing\")\n return\n elif not self._paused:\n print(\"Cannot continue video: Video is not paused\")\n return\n print(f\"Continuing video: {sel... | [
"0.78487545",
"0.76695776",
"0.7644487",
"0.7620646",
"0.76167583",
"0.7603745",
"0.75645643",
"0.7465203",
"0.74446094",
"0.73118573",
"0.71554846",
"0.7129294",
"0.7104252",
"0.6880032",
"0.6824016",
"0.67914295",
"0.67346185",
"0.673355",
"0.66960865",
"0.6665674",
"0.6665... | 0.6646525 | 22 |
Creates a playlist with a given name. | def create_playlist(self, playlist_name):
#self._video_playlist.name=playlist_name
#self._video_playlist.caseless=playlist_name.lower()
#print(f"Successfully created new playlist: {self._video_playlist.name}")
if playlist_name.lower() not in self.playlists:
self.playlists[pla... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_playlist(self, playlist_name):\n print(\"create_playlist needs implementation\")",
"def create_playlist(self, playlist_name):\n if playlist_name.lower() in self._playlists:\n print(\"Cannot create playlist: A playlist with the same name already exists\")\n return\n ... | [
"0.85660213",
"0.85554105",
"0.8544041",
"0.84868944",
"0.8483596",
"0.84097624",
"0.8327404",
"0.8276789",
"0.81442547",
"0.7785124",
"0.76372933",
"0.7628255",
"0.7530136",
"0.7377695",
"0.7313419",
"0.7106524",
"0.7087746",
"0.70772105",
"0.70699054",
"0.7060932",
"0.70289... | 0.84133744 | 5 |
Adds a video to a playlist with a given name. | def add_to_playlist(self, playlist_name, video_id):
vid = self._video_library.get_video(video_id)
if vid and (playlist_name.lower() in self.playlists):
if video_id not in self.playlists[playlist_name.lower()]:
print("Added video to {0}: {1}".format(playlist_name, vid.title))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_to_playlist(self, playlist_name, video_id):\n video = self._video_library.get_video(video_id)\n if playlist_name.lower() not in self._playlists:\n print(f\"Cannot add video to {playlist_name}: Playlist does not exist\")\n return\n if not video:\n print(... | [
"0.8289542",
"0.8254548",
"0.81243855",
"0.8081699",
"0.78677225",
"0.7106693",
"0.70057124",
"0.6953241",
"0.6816299",
"0.6771601",
"0.6698732",
"0.6667264",
"0.6667212",
"0.66409636",
"0.65922916",
"0.6531571",
"0.65096724",
"0.64778024",
"0.64676934",
"0.64045155",
"0.6378... | 0.81706756 | 2 |
Display all videos in a playlist with a given name. | def show_playlist(self, playlist_name):
if self.playlists[playlist_name.lower()]!=[]:
print(f"Showing playlist: {playlist_name}")
for i in self.playlists[playlist_name.lower()]:
videos = self._video_library.get_all_videos()
templist = []
d... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_playlist(self, playlist_name):\n if playlist_name.lower() not in self._playlists:\n print(f\"Cannot show playlist {playlist_name}: Playlist does not exist\")\n return\n playlist = self._playlists[playlist_name.lower()]\n print(f\"Showing playlist: {playlist_name}... | [
"0.795203",
"0.7930741",
"0.7693881",
"0.7545777",
"0.74915266",
"0.68660384",
"0.6755695",
"0.6657861",
"0.6496447",
"0.62669796",
"0.6146096",
"0.6144877",
"0.6072285",
"0.6068287",
"0.6064832",
"0.60442716",
"0.6008929",
"0.59817594",
"0.5926295",
"0.59068966",
"0.59018767... | 0.7973328 | 0 |
Removes a video to a playlist with a given name. | def remove_from_playlist(self, playlist_name, video_id):
if playlist_name.lower() in self.playlists:
for i in self.playlists[playlist_name.lower()]:
videos = self._video_library.get_all_videos()
templist = []
def converttostr(input_seq, seperator):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_from_playlist(self, playlist_name, video_id):\n if playlist_name.lower() not in self.playlists:\n print(\"Cannot remove video from\", playlist_name, end=\"\")\n print(\": Playlist does not exist\")\n elif self._video_library.get_video(video_id) is None:\n p... | [
"0.8277546",
"0.8267825",
"0.82491636",
"0.81425613",
"0.7988888",
"0.7960778",
"0.7492291",
"0.7470741",
"0.743055",
"0.7393017",
"0.73424774",
"0.73083645",
"0.7294812",
"0.72602385",
"0.7201037",
"0.7155624",
"0.7128118",
"0.70940757",
"0.7084818",
"0.7070951",
"0.6355251"... | 0.81126755 | 4 |
Removes all videos from a playlist with a given name. | def clear_playlist(self, playlist_name):
if playlist_name.lower() in self.playlists:
self.playlists[playlist_name.lower()] = []
print(f'Successfully removed all videos from {playlist_name}')
else:
print(f"Cannot clear playlist {playlist_name}: Playlist does not exist"... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clear_playlist(self, playlist_name):\n playlist_id = playlist_name.lower()\n if not playlist_id in self.playlists.keys():\n print(f\"Cannot clear playlist {playlist_name}: Playlist does not exist\")\n return\n\n self.playlists.get(playlist_id).videos = []\n pri... | [
"0.82759166",
"0.810445",
"0.7842016",
"0.77024317",
"0.7658428",
"0.7567538",
"0.75538445",
"0.7424383",
"0.72478163",
"0.7101949",
"0.70759284",
"0.70302415",
"0.6900102",
"0.68801945",
"0.6860031",
"0.6858115",
"0.68081474",
"0.67604417",
"0.67214316",
"0.66617334",
"0.662... | 0.7798576 | 3 |
Deletes a playlist with a given name. | def delete_playlist(self, playlist_name):
if playlist_name.lower() in self.playlists:
self.playlists.pop(playlist_name.lower())
print(f"Deleted playlist: {playlist_name}")
else:
print(f"Cannot delete playlist {playlist_name}: Playlist does not exist") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_playlist(self, playlist_name):\n playlist_id = playlist_name.lower()\n if not playlist_id in self.playlists.keys():\n print(f\"Cannot delete playlist {playlist_name}: Playlist does not exist\")\n return\n\n self.playlists.pop(playlist_id)\n print(f\"Dele... | [
"0.8899918",
"0.88381743",
"0.8813659",
"0.8797008",
"0.8750859",
"0.8733403",
"0.78041524",
"0.7314389",
"0.7266456",
"0.7250033",
"0.7242778",
"0.72256124",
"0.7210256",
"0.71182895",
"0.7081352",
"0.70362234",
"0.6962418",
"0.69342923",
"0.69230175",
"0.69078976",
"0.68709... | 0.88254285 | 2 |
Display all the videos whose titles contain the search_term. | def search_videos(self, search_term):
videos = self._video_library.get_all_videos()
temp_list = []
for vid in videos:
# Convoluted way to display tags in required format
tags = "["
for tag in vid.tags:
tags = tags + tag + " "
tags... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def search_videos(self, search_term):\n results = []\n for video in self._video_library.get_all_videos():\n if search_term.lower() in video.title.lower() and video.flag is None:\n results.append(video)\n self.output_search_results(results, search_term)",
"def search... | [
"0.8331212",
"0.79130685",
"0.78181237",
"0.7745555",
"0.7296771",
"0.71350473",
"0.6829117",
"0.65758127",
"0.6539812",
"0.65275896",
"0.6482727",
"0.6481391",
"0.64698297",
"0.640734",
"0.638748",
"0.6354398",
"0.63542914",
"0.63518894",
"0.6330999",
"0.6296946",
"0.6252102... | 0.8280379 | 1 |
Display all videos whose tags contains the provided tag. | def search_videos_tag(self, video_tag):
videos = self._video_library.get_all_videos()
temp_list = []
for vid in videos:
# Convoluted way to display tags in required format
tags ="["
for tag in vid.tags:
tags = tags + tag + " "
tag... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def search_videos_tag(self, video_tag):\n results = []\n for video in self._video_library.get_all_videos():\n if video_tag.lower() in video.tags and video.flag is None:\n results.append(video)\n self.output_search_results(results, video_tag)",
"def search_videos_tag... | [
"0.8045308",
"0.7540733",
"0.7481872",
"0.73584425",
"0.68464065",
"0.67552704",
"0.63414866",
"0.61289597",
"0.6046852",
"0.59463876",
"0.5857648",
"0.58262694",
"0.5813439",
"0.58052194",
"0.57624304",
"0.57576835",
"0.57258624",
"0.5666013",
"0.5597602",
"0.5587654",
"0.55... | 0.77634656 | 1 |
Mark a video as flagged. | def flag_video(self, video_id, flag_reason=""):
object=self._video_library.get_video(video_id)
print(f"{object}") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def flag_video(self, video_id, flag_reason=\"Not supplied\"):\n video = self._video_library.get_video(video_id)\n if not video:\n print(\"Cannot flag video: Video does not exist\")\n return\n if video.flag is not None:\n print(\"Cannot flag video: Video is alre... | [
"0.7585753",
"0.7543017",
"0.7286989",
"0.7286989",
"0.6934897",
"0.68738246",
"0.67508376",
"0.65071416",
"0.59914064",
"0.5956641",
"0.583062",
"0.5781579",
"0.5766682",
"0.57447886",
"0.57447886",
"0.57447886",
"0.57447886",
"0.56196725",
"0.5476563",
"0.54668385",
"0.5389... | 0.6579819 | 7 |
Removes a flag from a video. | def allow_video(self, video_id):
print("allow_video needs implementation") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def allow_video(self, video_id):\n video = self._video_library.get_video(video_id)\n if not self._video_library.get_video(video_id):\n print(\"Cannot remove flag from video: Video does not exist\")\n return\n if not video.flag:\n print(\"Cannot remove flag from... | [
"0.71073616",
"0.6957776",
"0.6648356",
"0.65067405",
"0.6319069",
"0.6319069",
"0.6288646",
"0.6212749",
"0.61405927",
"0.6084444",
"0.6061432",
"0.5965828",
"0.5923353",
"0.58760494",
"0.5868266",
"0.57688993",
"0.57488066",
"0.5683442",
"0.5658963",
"0.5601935",
"0.5565338... | 0.0 | -1 |
Enable or disable the router. | async def set_enabled(self, enabled: bool) -> None:
return await self.api.set_enabled(enabled) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def toggleRouterConnected(self, flagToSet=None):\n if flagToSet is None:\n self.isRouterConnected = not (self.isRouterConnected)\n return\n self.isRouterConnected = flagToSet",
"async def async_turn_on(self):\n path = \"/ip/firewall/nat\"\n param = \".id\"\n ... | [
"0.6549837",
"0.6199958",
"0.6047816",
"0.600655",
"0.58607954",
"0.5822703",
"0.579296",
"0.57149607",
"0.57149607",
"0.5709502",
"0.5699672",
"0.56951374",
"0.56603235",
"0.5656877",
"0.5641915",
"0.563895",
"0.5634997",
"0.5631425",
"0.56173617",
"0.5610729",
"0.5604729",
... | 0.0 | -1 |
Get current active operational dataset in TLVS format, or None. | async def get_active_dataset_tlvs(self) -> bytes | None:
return await self.api.get_active_dataset_tlvs() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def async_get_active_dataset_tlvs(hass: HomeAssistant) -> bytes | None:\n if DOMAIN not in hass.data:\n raise HomeAssistantError(\"OTBR API not available\")\n\n data: OTBRData = hass.data[DOMAIN]\n return await data.get_active_dataset_tlvs()",
"def _get_data(self):\n c = Connector(se... | [
"0.64140606",
"0.53788054",
"0.5368342",
"0.5340623",
"0.5304488",
"0.5285245",
"0.5271362",
"0.52568066",
"0.525625",
"0.52145404",
"0.5213808",
"0.5200595",
"0.51775974",
"0.51763356",
"0.514455",
"0.5142501",
"0.5142501",
"0.5139437",
"0.5129725",
"0.5113209",
"0.50932395"... | 0.65660226 | 0 |
Create an active operational dataset. | async def create_active_dataset(
self, dataset: python_otbr_api.OperationalDataSet
) -> None:
return await self.api.create_active_dataset(dataset) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_dataset():\n\n dataset_id = \"{}.airflow\".format(client.project)\n dataset = bigquery.Dataset(dataset_id)\n dataset.location = \"US\"\n dataset = client.create_dataset(dataset, exists_ok=True)\n print(\"Created dataset {}.{}\".format(client.project, dataset.dataset_id))\n return datas... | [
"0.7311756",
"0.6959166",
"0.6920446",
"0.67189634",
"0.67153424",
"0.6510759",
"0.6500872",
"0.64714384",
"0.6467696",
"0.64092255",
"0.64085776",
"0.6398017",
"0.6389895",
"0.6304472",
"0.62450254",
"0.623023",
"0.62095875",
"0.6189691",
"0.6167886",
"0.6153979",
"0.6152047... | 0.7764948 | 0 |
Set up the Open Thread Border Router component. | async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
websocket_api.async_setup(hass)
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, **params):\n\n # Initialize topo\n Topo.__init__(self, **params)\n\n # Host and link configuration\n hostConfiguration = {'cpu': cpuShare()}\n linkConfiguration = {'bw': args.bandwidth, 'delay': delay(), 'max_queue_len': args.input_queue_size }\n \n # Create the actual topol... | [
"0.62192327",
"0.6034983",
"0.5965902",
"0.5813521",
"0.57604",
"0.5739103",
"0.5624199",
"0.5561005",
"0.55013895",
"0.5481573",
"0.5452983",
"0.5439202",
"0.54322267",
"0.54296595",
"0.54053646",
"0.5364516",
"0.536268",
"0.5278839",
"0.52613586",
"0.52425516",
"0.5240492",... | 0.0 | -1 |
Warn user if insecure default network settings are used. | def _warn_on_default_network_settings(
hass: HomeAssistant, entry: ConfigEntry, dataset_tlvs: bytes
) -> None:
dataset = tlv_parser.parse_tlv(dataset_tlvs.hex())
insecure = False
if (
network_key := dataset.get(tlv_parser.MeshcopTLVType.NETWORKKEY)
) is not None and bytes.fromhex(network_ke... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def insecure(self) -> bool:\n return self._insecure",
"def set_insecure(self, bool_value=True):\n self.insecure = bool_value\n self._geturl.insecure = bool_value",
"def insecure(self, insecure: bool):\n\n self._insecure = insecure",
"def no_network_access_check(user):\n return ... | [
"0.6017677",
"0.6015723",
"0.591362",
"0.58963645",
"0.5826089",
"0.580664",
"0.5791929",
"0.5757958",
"0.5702233",
"0.5702233",
"0.5658171",
"0.5645198",
"0.5638157",
"0.5638157",
"0.5621047",
"0.5604798",
"0.55833834",
"0.55188936",
"0.5460819",
"0.5445649",
"0.5445649",
... | 0.79430103 | 0 |
Set up an Open Thread Border Router config entry. | async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
api = python_otbr_api.OTBR(entry.data["url"], async_get_clientsession(hass), 10)
otbrdata = OTBRData(entry.data["url"], api)
try:
dataset_tlvs = await otbrdata.get_active_dataset_tlvs()
except (
HomeAssistantE... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, **params):\n\n # Initialize topo\n Topo.__init__(self, **params)\n\n # Host and link configuration\n hostConfiguration = {'cpu': cpuShare()}\n linkConfiguration = {'bw': args.bandwidth, 'delay': delay(), 'max_queue_len': args.input_queue_size }\n \n # Create the actual topol... | [
"0.59809196",
"0.588865",
"0.56609845",
"0.56394005",
"0.5567508",
"0.5544084",
"0.5540145",
"0.55376536",
"0.5513254",
"0.5485693",
"0.5481344",
"0.54580015",
"0.54271466",
"0.5422367",
"0.5421914",
"0.5411975",
"0.53917915",
"0.53793836",
"0.53344077",
"0.52707",
"0.5262626... | 0.0 | -1 |
Unload a config entry. | async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
hass.data.pop(DOMAIN)
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def async_unload_entry(hass, config_entry):\n unload_ok = await hass.config_entries.async_forward_entry_unload(\n config_entry, \"climate\"\n )\n return unload_ok",
"async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry):\n unload_ok = await hass.config_entries.async_unloa... | [
"0.697284",
"0.6779855",
"0.6747459",
"0.6689002",
"0.6657831",
"0.66162205",
"0.6603433",
"0.65925974",
"0.65595686",
"0.65411645",
"0.6507643",
"0.6507643",
"0.6507643",
"0.6507643",
"0.64977276",
"0.64931643",
"0.6486601",
"0.6486601",
"0.6486601",
"0.6486601",
"0.6469397"... | 0.6888074 | 1 |
Get current active operational dataset in TLVS format, or None. Returns None if there is no active operational dataset. Raises if the http status is 400 or higher or if the response is invalid. | async def async_get_active_dataset_tlvs(hass: HomeAssistant) -> bytes | None:
if DOMAIN not in hass.data:
raise HomeAssistantError("OTBR API not available")
data: OTBRData = hass.data[DOMAIN]
return await data.get_active_dataset_tlvs() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def get_active_dataset_tlvs(self) -> bytes | None:\n return await self.api.get_active_dataset_tlvs()",
"def _get_data(self):\n response = self._get_raw_data()\n if response is None:\n # error has already been logged\n return None\n\n if response.startswith(... | [
"0.6278388",
"0.51822865",
"0.50992644",
"0.50317097",
"0.49691647",
"0.49691647",
"0.49691647",
"0.49691647",
"0.49691647",
"0.49691647",
"0.49691647",
"0.49691647",
"0.49691647",
"0.49691647",
"0.49691647",
"0.49691647",
"0.49691647",
"0.49691647",
"0.49691647",
"0.49691647",... | 0.6420956 | 0 |
Command line option parser | def options_parse():
parser = argparse.ArgumentParser()
# Options for model parameters setup (only change if model training was changed)
parser.add_argument('--num_filters', type=int, default=64,
help='Filter dimensions for DenseNet (all layers same). Default=64')
parser.add_arg... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_options():\n global parser\n parser.add_option(\"-r\", \"--regions\", dest=\"input_brain_regions\",\n help=\"Input file for brain region data\",\n action=\"store\", type='string')\n\n parser.add_option(\"-g\", \"--gray\", dest=\"input_gray_levels\",\n ... | [
"0.7875108",
"0.77416253",
"0.7673511",
"0.7616269",
"0.7615143",
"0.7595156",
"0.75526184",
"0.75350857",
"0.7520856",
"0.75206095",
"0.748908",
"0.7426462",
"0.74064136",
"0.73757994",
"0.73684096",
"0.73431",
"0.7342854",
"0.7271879",
"0.72698784",
"0.7234366",
"0.72342134... | 0.7297411 | 17 |
Get the basic information about the user. | def getbasics(tfinal):
tfinal["screen_name"] = df["user"].apply(lambda x: x["screen_name"])
tfinal["user_id"] = df["user"].apply(lambda x: x["id"])
tfinal["followers_count"] = df["user"].apply(lambda x: x["followers_count"])
return tfinal | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def user_info(self):\n response = self.query('user_info')\n return response",
"def user_info(self):\n resp = self._get(get_url('user'))\n raise_on_error(resp)\n ret = resp.json()\n return UserInfo(ret)",
"def user_info(self):\n return self.auth.get_user_by_session()... | [
"0.8602612",
"0.8136225",
"0.79690456",
"0.7805218",
"0.77565444",
"0.7732912",
"0.77039087",
"0.7688922",
"0.76849806",
"0.76553595",
"0.7635081",
"0.7590047",
"0.7519128",
"0.75158465",
"0.7477178",
"0.7463014",
"0.7459062",
"0.7459062",
"0.7433174",
"0.741587",
"0.74010503... | 0.0 | -1 |
Put it all together. | def filldf(tfinal):
getbasics(tfinal)
# getusermentions(tfinal)
getretweets(tfinal)
getinreply(tfinal)
return tfinal | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wrapup(self):\n pass",
"def use(self):",
"def _collect_all(self):",
"def processing(self):\n pass",
"def finalise(self):",
"def run(self):\n\t\t\n\t\tpass",
"def final(self):\n pass",
"def all(self):",
"def all(self):",
"def merge_two_calls(self) -> None:",
"def __call_... | [
"0.68635607",
"0.61945486",
"0.61396044",
"0.61321986",
"0.5985064",
"0.59484243",
"0.59349257",
"0.5926103",
"0.5926103",
"0.58965355",
"0.5891097",
"0.5838405",
"0.58246607",
"0.58246607",
"0.5821355",
"0.5821355",
"0.5821355",
"0.5821355",
"0.5821355",
"0.5821355",
"0.5821... | 0.0 | -1 |
Get the interactions between different users. | def getinteractions(row):
# From every row of the original DataFrame.
# First we obtain the "user_id" and "screen_name".
user = row["user_id"], row["screen_name"]
# Be careful if there is no user id
if user[0] is None:
return (None, None), []
# The interactions are going to be a set... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getInterestedUsers():",
"def get_queryset(self):\n user = self.request.user\n return Interaction.objects.filter(owner=user)",
"def interactions(self) -> Sequence[Interaction[_C_out,_A_out]]:\n return self._interactions",
"def interactions(self) -> Sequence[Interaction[_C_out, Tuple[i... | [
"0.6618023",
"0.6391998",
"0.5856472",
"0.5845436",
"0.5824138",
"0.5802955",
"0.57908535",
"0.57292044",
"0.5703843",
"0.56436706",
"0.55917037",
"0.55206144",
"0.54955673",
"0.5451473",
"0.5409495",
"0.53454435",
"0.53434247",
"0.53086203",
"0.5301726",
"0.5300352",
"0.5287... | 0.5900772 | 2 |
This function is the_cats_ass. That's an overstatement. This is an understatement. See what I did there? What _you_ can do here is save the sys.ENVIRONMENT by reducing printed waste. Mew. | def the_cats_ass():
return __cat_whisperer()[Cat.ASS] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tuxedo_cat():\n return __cat_whisperer(colors=True, coat='tuxedo_colorz', logo_colorz='dark_logo_colorz')[Cat.ASS]",
"def env_cleanup(self):\n pass",
"def _create_extra_environment(self):\n return {}",
"def calico_kitty():\n return __cat_whisperer(colors=True, coat='calico_colorz', lo... | [
"0.5378321",
"0.5314823",
"0.51957476",
"0.5176816",
"0.50836897",
"0.5041659",
"0.50129634",
"0.5007439",
"0.49973828",
"0.49863762",
"0.4961463",
"0.4959659",
"0.49336305",
"0.492728",
"0.48846954",
"0.48724553",
"0.48644373",
"0.48611596",
"0.48404202",
"0.48205215",
"0.48... | 0.616136 | 0 |
Filter the results of poking the cat. Takes variable names as strings for the args. | def comb(cat, *brush):
return PrettyKitty(cat.ctx, {k: v for k, v in cat.values.items()
if k in brush}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cat(**kwargs):\n if 'params' in kwargs:\n params = kwargs['params']\n if 'flags' in kwargs:\n flags = kwargs['flags']\n command = [\"cat\"]\n\n for f in params:\n command.append(f)\n\n call(command)",
"def CatCommand(self, args, sub_opts=None, headers=None, debug=0):\n ... | [
"0.63766456",
"0.59995097",
"0.564777",
"0.5529868",
"0.5434185",
"0.5299351",
"0.5199314",
"0.5147464",
"0.501238",
"0.5005839",
"0.49969578",
"0.4989059",
"0.4971183",
"0.49100712",
"0.48868835",
"0.48775518",
"0.47976434",
"0.47956964",
"0.4789621",
"0.4775739",
"0.4743783... | 0.0 | -1 |
Omit any undesirable variables from the result. | def avoid(cat, *undesirables):
return PrettyKitty(cat.ctx, {k: v for k, v in cat.values.items()
if k not in undesirables}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unusedVars(self):\n fullcode = self.code_cfg\n variables = set([x[1:] for x in codeconfig_getvars(fullcode)])\n exceptions = set(['complexity', 'code_cfg'])\n clsvars = set(vars(self).keys())\n nones = set(filter(lambda x: self.__dict__[x] is None, clsvars))\n nones = ... | [
"0.6108275",
"0.6065515",
"0.5893631",
"0.58840024",
"0.5857133",
"0.5839786",
"0.57673234",
"0.57253194",
"0.5685147",
"0.5642761",
"0.5571985",
"0.556635",
"0.554247",
"0.55097634",
"0.547759",
"0.5425294",
"0.54203904",
"0.5398573",
"0.5384865",
"0.5326627",
"0.531577",
... | 0.0 | -1 |
You really shouldn't be poking cats. But if you insist, it is recommended to bring catnip as it's not unusual for cats to attack dicks who poke them. | def poke_the_cat(where, catnip=False):
if not catnip:
from random import randint
class BadCat(InterruptedError):
pass
if randint(1, 10) == 7:
mew = "You attempt to poke the cat but it attacks. " \
"Maybe if you gave it some catnip?"
rai... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def schrodingers_cat(peek=False):\n from random import choice, randint\n if peek:\n if randint(1, 10) % 2 == 0:\n # RIP\n return \"Nothing at all\"\n else:\n return poke_the_cat(Cat.LEGS, catnip=True)\n else:\n garbled_cries = \"mew meow wokka beocat e... | [
"0.61793715",
"0.5548466",
"0.52614313",
"0.5206707",
"0.5189093",
"0.5179284",
"0.5168439",
"0.51067805",
"0.51002204",
"0.5057231",
"0.5049274",
"0.4982071",
"0.49557567",
"0.4942977",
"0.4941298",
"0.48946017",
"0.48391628",
"0.48205256",
"0.47957787",
"0.47827622",
"0.471... | 0.66019756 | 0 |
Peek in the box for a 50/50 shot of retrieving your desired output, while the other half of the time the cat is dead and the function returns nothing at all. If you decide not to peek, the cat being neither dead nor alive responds with random nonsense. | def schrodingers_cat(peek=False):
from random import choice, randint
if peek:
if randint(1, 10) % 2 == 0:
# RIP
return "Nothing at all"
else:
return poke_the_cat(Cat.LEGS, catnip=True)
else:
garbled_cries = "mew meow wokka beocat ekkie".split()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_peek_shows_value_of_current_tail(dq_3):\n assert dq_3.peek() == 'ragtime'",
"def poke_the_cat(where, catnip=False):\n if not catnip:\n from random import randint\n\n class BadCat(InterruptedError):\n pass\n\n if randint(1, 10) == 7:\n mew = \"You attempt ... | [
"0.5551094",
"0.5481319",
"0.54402834",
"0.52876055",
"0.5216225",
"0.5209968",
"0.5209621",
"0.51197696",
"0.509371",
"0.50888205",
"0.5036659",
"0.5000694",
"0.49975404",
"0.4992409",
"0.4970316",
"0.49431387",
"0.49377355",
"0.49363643",
"0.4902926",
"0.48842472",
"0.48525... | 0.6159067 | 0 |
I can haz colorz? | def calico_kitty():
return __cat_whisperer(colors=True, coat='calico_colorz', logo_colorz='logo_colorz')[Cat.ASS] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def colour(z, i):\n if abs(z) < self.threshold:\n return 0, 0, 0\n v = np.log2(i + self.threshold - np.log2(np.log2(abs(z)))) / self.threshold\n if v < 1.0:\n return v ** b1, v ** b2, v ** b3 # coloured tones\n else:\n v = ma... | [
"0.68576366",
"0.672275",
"0.6629412",
"0.6468807",
"0.6314449",
"0.6175668",
"0.61718744",
"0.6159126",
"0.6091556",
"0.60612047",
"0.59886336",
"0.59635425",
"0.5960913",
"0.59592134",
"0.593711",
"0.592001",
"0.58705544",
"0.58628786",
"0.5832216",
"0.5817841",
"0.5800164"... | 0.0 | -1 |
Finer than a pheasant | def tuxedo_cat():
return __cat_whisperer(colors=True, coat='tuxedo_colorz', logo_colorz='dark_logo_colorz')[Cat.ASS] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def end_phase():\n pass",
"def atender(self):\n\n if self.enfila>0:\n \n self.enfila-=1\n self.fila.pop(0)",
"def End(A):\n return Hom(A,A)",
"def end_meassuring(self):\n self.enabler = 0\n #self.t.join()\n return 1",
"def finish():",
"de... | [
"0.6154273",
"0.56990314",
"0.5660295",
"0.5646709",
"0.5624932",
"0.5624932",
"0.5624932",
"0.5624932",
"0.5621548",
"0.5606399",
"0.5522237",
"0.55028677",
"0.55028677",
"0.54799473",
"0.5425177",
"0.5425177",
"0.53860223",
"0.5381831",
"0.5342247",
"0.5336071",
"0.532008",... | 0.0 | -1 |
The cat whisperer is usually very solitary and private. Thus any attempts at invoking the cat whisperer directly will be met with no resistance, because this is Python, and honestly he could use the friends. | def __cat_whisperer(**kwargs):
from inspect import currentframe
frames = []
frame = currentframe()
while frame is not None:
frame = frame.f_back
try:
c_frame = frame.f_locals.copy()
co_name = frame.f_code.co_name
except AttributeError:
break
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cat(var, wrapper, message):\n wrapper.send(messages[\"cat_toss\"].format(wrapper.source), messages[\"cat_land\"].format(), sep=\"\\n\")",
"def testEchoCatCat(self):\n pl = Pipeline(loadInitFile=False)\n repl = REPL(pl)\n repl.runCommandLine('echo hi | cat | cat')\n self.assertE... | [
"0.59018856",
"0.5861355",
"0.5858545",
"0.57538694",
"0.56366396",
"0.5491336",
"0.53796077",
"0.5355786",
"0.5333996",
"0.53020954",
"0.52790123",
"0.5236062",
"0.52325976",
"0.51591986",
"0.51591986",
"0.5084246",
"0.5084246",
"0.50796264",
"0.50266165",
"0.5013587",
"0.50... | 0.5513489 | 5 |
Event handler for scripts class, adds own processing time | def handleEvent(eventname, *kwargs):
stime = time.time()
hdl = [hdl for hdl in classes.get('eventhandler').getEventhandlers(event=eventname) if hdl.handler == 'emonitor.modules.scripts.script.Script']
scriptname = ""
if len(hdl) == 1:
if "in.scriptname" in hdl[0].getParamete... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def script(self):",
"def time_automation_listener(now):\n action()",
"def start_processing(self):",
"def run_script(self):\n pass",
"def run(self, current_time):\r\n raise NotImplementedError(\"The run() method must be implemented by \"\r\n \"each class... | [
"0.6029688",
"0.60170215",
"0.5954977",
"0.5938607",
"0.58922416",
"0.58922416",
"0.58922416",
"0.58922416",
"0.58922416",
"0.58922416",
"0.58922416",
"0.5856889",
"0.582436",
"0.5804509",
"0.57735705",
"0.5739238",
"0.5738612",
"0.57363063",
"0.5725373",
"0.5725373",
"0.5697... | 0.0 | -1 |
Initializes the widget hardware. | def _initialize_hardware(self):
# Import
try:
from gpiozero import MCP3008
except Exception as ex:
logging.error('\n *** ERROR importing gpiozero: {}'.format(ex))
# Things failed, must be running locally, not on a widget, so don't
# bother initi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_hardware(self):\n return",
"def init(self):\n self.reset()\n\n self.__interface.send_command('POWER_SETTING')\n self.__interface.send_data(0x37)\n self.__interface.send_data(0x00)\n\n self.__interface.send_command('PANEL_SETTING')\n self.__interface.send... | [
"0.7541131",
"0.69498444",
"0.69382215",
"0.68302613",
"0.68180233",
"0.6809574",
"0.67239654",
"0.6722193",
"0.67057806",
"0.6692837",
"0.6665246",
"0.6598455",
"0.6580556",
"0.6578541",
"0.6548161",
"0.65389204",
"0.6495379",
"0.64761627",
"0.6467701",
"0.64535296",
"0.6444... | 0.6526566 | 16 |
Thread that polls to get the current force on the FSR. Populates the self._average_force value. | def _force_loop(self):
NUM_SAMPLES = 10.0
# Get the initial readings
time.sleep(1)
readings = []
for i in range(0, int(NUM_SAMPLES)):
readings.insert(0, self._sensor.value)
time.sleep(self._sampling_rate)
self._average_force = sum(r for r in read... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start(self):\n lastbeat = time.time()\n averages = []\n for x in range(self.keep_amount):\n averages.append(1)\n while self.run:\n cur_amount = len(averages)\n if self.keep_amount != cur_amount:\n if self.keep_amount < cur_amount:\n ... | [
"0.6141744",
"0.57550305",
"0.5539875",
"0.551071",
"0.54476047",
"0.5357573",
"0.53213555",
"0.5257272",
"0.52194697",
"0.5190291",
"0.51847667",
"0.51847667",
"0.5159389",
"0.5158231",
"0.51533365",
"0.51522845",
"0.5108973",
"0.5106741",
"0.5078752",
"0.5078129",
"0.506391... | 0.71686685 | 0 |
Part of force API. Returns a number with the scaled force (which should end up being between 0 and about 5 based on my testing). | def force(self):
return self._divisor / self._average_force | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_scale():\r\n\r\n \r\n return 0.5",
"def getScale(self):\n return self.factor**self.turnOn",
"def scale(self):\n return self.distribution.scale",
"def scale(self, value):\r\n return (float(value)-float(self.minimum))/float(self.maximum-self.minimum)*2.0 - 1.0",
"def scale(self, va... | [
"0.7514146",
"0.72875655",
"0.7234186",
"0.711452",
"0.7060418",
"0.70115966",
"0.6901176",
"0.6861581",
"0.68096155",
"0.68067354",
"0.68016386",
"0.67743933",
"0.6736795",
"0.6702713",
"0.66959536",
"0.66959536",
"0.66875863",
"0.66495395",
"0.6553178",
"0.6551245",
"0.6538... | 0.6342841 | 28 |
Part of force API. Returns a number with the raw pressure. | def raw_force(self):
if self.live:
return self._sensor.value
# For testing
return self._test_raw_force | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def get_pressure(self) -> float: # type: ignore\n ...",
"def native_pressure(self) -> float | None:\n return self._pressure",
"def read_pressure(self):\n pRaw = self._read_multiple_bytes_as_array(self.BME280_PRESS_MSB, 3)\n\n return float(self._compensate_pressure((pRaw[0] <<... | [
"0.82014054",
"0.8120208",
"0.8058288",
"0.80572706",
"0.8028522",
"0.7965267",
"0.7960133",
"0.7925344",
"0.78824246",
"0.78773296",
"0.78055376",
"0.76049834",
"0.7570139",
"0.7537577",
"0.74433875",
"0.74054044",
"0.72677594",
"0.69811654",
"0.695675",
"0.6943918",
"0.6931... | 0.6526758 | 42 |
Groups the cell images into their respective predicted class. Useful to see visually which mistakes the model made and which class the mistakes occurred. | def display_predictions(data, predictions):
images = [[] for i in range(5)]
for i, pred in enumerate(predictions):
images[pred].append(data[i])
cols = ['Ne', 'Mo', 'Ba', 'Eo', 'Ly']
lengths = [len(w) for w in images]
fig = plt.figure()
grid = ImageGrid(fig, 111, nrows_ncols=(5, len(cols)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def classify_images():\n\n # Load the desired image\n img_path = 'dataset/colorize_images/n02085782_919.jpg'\n img = image.load_img(img_path, target_size=(299, 299))\n x = image.img_to_array(img)\n x = np.expand_dims(x, axis=0)\n x = preprocess_input(x)\n\n model = InceptionV3(weights=\"imagen... | [
"0.70386404",
"0.65294516",
"0.65029687",
"0.6423954",
"0.64230543",
"0.6364461",
"0.62974554",
"0.6266392",
"0.6211879",
"0.62009114",
"0.61849576",
"0.61780983",
"0.61658597",
"0.6103416",
"0.61006534",
"0.60835475",
"0.60513175",
"0.6041398",
"0.6017167",
"0.6014741",
"0.6... | 0.0 | -1 |
Load a saved model and generate predictions on test data. Then display the cell images organized by which prediction they were under. | def evaluate():
global_step = tf.Variable(0, name='global_step', trainable=False)
# randomize the inputs look
x, y_, data, keep_prob = blood_model.prepare_input()
# Get images and labels for blood_model.
conv_output, W_conv1, W_conv2, h_conv1, h_conv2 = blood_model.inference(data, keep_prob)
co... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prediction():\r\n\r\n loaded_model = load_model('imageTrainedModel.h5')\r\n print(loaded_model.summary())\r\n\r\n # retrieve history also:\r\n f = open('history.pckl', 'rb')\r\n history = pickle.load(f)\r\n f.close()\r\n\r\n print(history.keys())\r\n print(history)\r\n\r\n epochs = l... | [
"0.71263",
"0.7030289",
"0.70282024",
"0.7010502",
"0.69431835",
"0.68770826",
"0.68131137",
"0.6748319",
"0.66960573",
"0.6673433",
"0.6631963",
"0.66049194",
"0.6589844",
"0.6577621",
"0.6540029",
"0.65387815",
"0.65019274",
"0.649637",
"0.6476688",
"0.645932",
"0.6456553",... | 0.0 | -1 |
Find a natural gutter between start and stop, inclusive. | def get_gutter(start_obj, stop_obj):
log.debug(f'get_gutter({start_obj.group(0)}, {stop_obj.group(0)})')
start = start_obj.end(0)
stop = stop_obj.start(0)-1
gutters = list()
for column in range(start, stop+1):
if all(line.rjust(column+1)[column] == ' ' for line in lines):
gutters.append(column)
i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetNiceExtentsBySpacing(minval,maxval,spacing,tolerance):\n pass",
"def find_midpoint(start, end):\n mid = (start + end) / 2\n return int(mid)",
"def gutter_spacing(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"gutter_spacing\")",
"def gutter_spacing(self) -> Optional[... | [
"0.6075604",
"0.57111067",
"0.57065743",
"0.57065743",
"0.57065743",
"0.55262905",
"0.5473661",
"0.5458969",
"0.538811",
"0.5384582",
"0.5346922",
"0.5319414",
"0.5292439",
"0.51302606",
"0.5105891",
"0.51037973",
"0.5075034",
"0.5074723",
"0.5058725",
"0.50488275",
"0.498400... | 0.80115026 | 0 |
Param n is a number Function will enlarge the number | def enlarge(n):
return n*100 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def enlarge(n):\n\n return n* 100",
"def enlarge(n):\r\n return n * 100",
"def enlarge(self, n=2):\n c = self.center\n for i in range(len(self.points)):\n v = Vector.createFromTwoPoints(c, self.points[i])\n self.points[i].set((n * v)(c))",
"def mirror(n):\n return... | [
"0.81874907",
"0.8149599",
"0.691363",
"0.64795965",
"0.6437244",
"0.63877094",
"0.6271831",
"0.62134737",
"0.61795235",
"0.6164558",
"0.6158201",
"0.6148302",
"0.60860157",
"0.6071508",
"0.6043378",
"0.59866273",
"0.59858376",
"0.59682846",
"0.5964596",
"0.5962503",
"0.59513... | 0.80245125 | 2 |
all the private valuable is defined for test values | def __init__(self, *args, **kwargs):
self.specGenerator = WMSpecGenerator()
self.count = 0
self.maxWmSpec = kwargs.setdefault('numOfSpecs', 1)
self.type = kwargs.setdefault("type", 'ReReco')
if self.type != 'ReReco':
raise TypeError('unknown request type %s' % self.ty... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_many_values(self):\n write this test!",
"def _test(self):\n pass",
"def _test(self):\n pass",
"def _test(self):\n pass",
"def setUp(self):\n self.t = True\n self.f = False\n self.value = 25",
"def test(self):\n raise NotImplementedError",
... | [
"0.7416687",
"0.681597",
"0.681597",
"0.681597",
"0.6706734",
"0.6663227",
"0.66074175",
"0.6508342",
"0.6506361",
"0.6506361",
"0.6506361",
"0.6506361",
"0.6506361",
"0.64573824",
"0.63861674",
"0.6379714",
"0.6369126",
"0.6348164",
"0.62749034",
"0.6264271",
"0.62430596",
... | 0.0 | -1 |
Returns a list of request names of requests in runningopen state | def getRunningOpen(self, teamName):
result = []
for request in self.status:
if self.status[request] == 'running-open':
result.append(request)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _GetRequestsByState(self, state):\n requests_dir = self._spool_state_dirs[state]\n return sorted(os.listdir(requests_dir))",
"def get_available_request(self):\n for med in self.__state.__class__.__dict__:\n if med.startswith('request_'): yield med",
"def get_requests(self):\n\t\tsel... | [
"0.69532305",
"0.67579085",
"0.6556441",
"0.65352577",
"0.6497508",
"0.64858216",
"0.6394398",
"0.6211951",
"0.60207194",
"0.60156894",
"0.59925896",
"0.5909057",
"0.5878461",
"0.58699447",
"0.58357877",
"0.57668465",
"0.57654035",
"0.576168",
"0.5757679",
"0.5750489",
"0.566... | 0.7229156 | 0 |
This is just for clean up not part of emulated function | def _removeSpecs(self):
self.specGenerator.removeSpecs() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _clean_up(self):",
"def horde_cleanup(self):",
"def clean_up(self):\n\t\tpass",
"def cleanup(self):",
"def cleanup(self):",
"def cleanup(self):",
"def cleanup():",
"def clean_up(self):\n pass",
"def clean_up(self):\n pass",
"def cleanUp(self):\r\n pass",
"def finalise(s... | [
"0.7257313",
"0.71828663",
"0.7030774",
"0.70296204",
"0.70296204",
"0.70296204",
"0.69478714",
"0.68301713",
"0.68301713",
"0.6816452",
"0.67658687",
"0.67415017",
"0.6673759",
"0.65570885",
"0.65364534",
"0.65364534",
"0.651055",
"0.65074927",
"0.65074927",
"0.6496239",
"0.... | 0.0 | -1 |
Give a fake team name | def getTeam(self):
return ["The A-Team", "some other bloke"] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def team_name(self):\n return 'Team Name'",
"def yield_team(self) -> str: # pragma: no cover",
"def team_name(self, team_name):\n self.team_id = self.get_team_id(team_name)\n LOG.debug(\"Mattermost team id: %s\", self.team_id)",
"def teamname(record):\n\n tname = \"\"\n if... | [
"0.76355934",
"0.72684175",
"0.7165599",
"0.7107976",
"0.7086958",
"0.6947856",
"0.6859305",
"0.68285376",
"0.67991877",
"0.67297554",
"0.6650787",
"0.6508734",
"0.6422581",
"0.641175",
"0.6401281",
"0.6394169",
"0.63422143",
"0.6316826",
"0.6298397",
"0.62319654",
"0.6222579... | 0.6413395 | 13 |
Function for rendering the home page | def render_home():
return render_template("index.html") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def home():\n\n return render_template('home_page.html')",
"def home():\n return render_template('homepage.html')",
"def home():\n\n return render_template(\"home.html\")",
"def home():\n return render_template('home.html')",
"def home():\n return render_template('home.html')",
"def home()... | [
"0.88329524",
"0.86391366",
"0.8630416",
"0.86062366",
"0.86062366",
"0.86062366",
"0.86062366",
"0.86062366",
"0.86062366",
"0.86062366",
"0.86062366",
"0.86062366",
"0.86062366",
"0.86062366",
"0.86062366",
"0.86062366",
"0.86062366",
"0.86062366",
"0.86062366",
"0.8602575",
... | 0.88435775 | 0 |
Function for rendering an existing session page | def render_player_session(id):
sess = get_player_session(id)
if sess:
pass
#return render_template("session.html")
else:
pass
#some kind of 404
| {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loginPage():\n\n state = ''.join(random.choice(string.ascii_uppercase + string.digits)\n \t for x in xrange(32))\n login_session['state'] = state\n return render_template('login.html', STATE=state)",
"def index():\n print(\"Inside index()\")\n if \"display_name\" not in session:\... | [
"0.68190837",
"0.6669858",
"0.66534925",
"0.6565649",
"0.65498805",
"0.6485435",
"0.63670814",
"0.635986",
"0.6321983",
"0.6302406",
"0.62669337",
"0.6244736",
"0.62421983",
"0.62421983",
"0.62374693",
"0.6187892",
"0.6185891",
"0.6181225",
"0.61790746",
"0.61767036",
"0.6166... | 0.7415087 | 0 |
Function for rendering a DM session page | def render_DM_session(id):
sess = get_DM_session(id)
if sess:
pass
else:
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def render_player_session(id):\r\n\tsess = get_player_session(id)\r\n\tif sess:\r\n\t\tpass\r\n\t\t#return render_template(\"session.html\")\r\n\telse:\r\n\t\tpass\t\t\r\n\t\t#some kind of 404\r",
"def loginPage():\n\n state = ''.join(random.choice(string.ascii_uppercase + string.digits)\n \t fo... | [
"0.69160146",
"0.6585566",
"0.6536112",
"0.62708634",
"0.6269151",
"0.6269151",
"0.62596005",
"0.6238901",
"0.61822796",
"0.6137672",
"0.6050705",
"0.603166",
"0.6014789",
"0.59822565",
"0.59557796",
"0.59547424",
"0.5920551",
"0.589151",
"0.58809185",
"0.5834792",
"0.5823835... | 0.7526199 | 0 |
Return user properties from OGDS. Always returns a minimal set of the properties 'ogg.user.userid' and 'ogg.user.title' even when no ogdsuser is found. | def _collect_properties(self):
properties = {
'userid': self.user_id,
'title': self.get_fullname()
}
if not self.ogds_user:
return properties
for attribute_name in self.ogds_user_attributes:
value = getattr(self.ogds_user, attribute_name)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extract_user_gql(data):\n return {\n \"pk\": int(data[\"id\"]),\n \"username\": data[\"username\"],\n \"full_name\": data[\"full_name\"],\n \"is_private\": data[\"is_private\"],\n \"profile_pic_url\": data[\"profile_pic_url\"],\n \"is_verified\": data.get(\"is_verif... | [
"0.64163625",
"0.59113324",
"0.58720744",
"0.58373237",
"0.569525",
"0.558774",
"0.5474033",
"0.5464169",
"0.54381526",
"0.5365471",
"0.53464866",
"0.53319556",
"0.53300774",
"0.5273262",
"0.5270092",
"0.5262506",
"0.52574897",
"0.5255697",
"0.5240036",
"0.5235572",
"0.522683... | 0.7212165 | 0 |
Calls functions in each NN file to get results. Starts with python, calls run file for c++ versions | def get_results():
#Get python results
import mnist_nn
import mnist_nn_gpu
mnist_nn.save_results()
mnist_nn_gpu.save_results()
#Get cpp results
import subprocess
subprocess.call(['c++//./run.sh']) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_cpp(self):",
"def main():\n\n config = None\n\n try:\n args = get_args()\n config = process_config(args.config)\n raise RuntimeError(\"Missing or invalid arguments\")\n except Exception as e:\n logging.error(\"Failed\", exc_info=e)\n\n print(\"Create the data gener... | [
"0.65926754",
"0.6401703",
"0.63215774",
"0.63125354",
"0.6269683",
"0.62658095",
"0.6245949",
"0.6243756",
"0.622921",
"0.62033784",
"0.61332804",
"0.6127914",
"0.61143494",
"0.6087046",
"0.60750556",
"0.6072328",
"0.606391",
"0.6054718",
"0.6037091",
"0.6021028",
"0.6000744... | 0.668048 | 0 |
Create tables Start with Times table, load in the data and put into useful lists. Load lists into numpy array, then create cell text. Create columns, column colors, then create the table and save it. Repeat for accuracy table. | def create_tables(times, accuracies, batch_sizes):
#Get time data
p_cpu_times = list(times[0].values())
p_gpu_times = list(times[1].values())
c_cpu_times = list(times[2].values())
c_gpu_times = list(times[3].values())
#Get differences in times
p_diff_times = [a - b for a, b in zip(p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_display_data_table():\n\n for ccd in range(0, 10):\n for node in range(0, 4):\n file = 'ccd' + str(ccd) + '_' + str(node)\n infile = data_dir + file\n outfile = web_dir + 'Data/' + file\n\n f = open(infile, 'r')\n data = [lin... | [
"0.69752",
"0.6746598",
"0.66616607",
"0.657273",
"0.6527887",
"0.6494611",
"0.6466136",
"0.6444683",
"0.64372617",
"0.63944316",
"0.63084507",
"0.63014144",
"0.6282424",
"0.62796277",
"0.62533253",
"0.6238252",
"0.62094986",
"0.61975396",
"0.61698943",
"0.6117473",
"0.611501... | 0.7961645 | 0 |
Create accuracy plots for each batch size Load in accuracy information into useful lists, then create a plot. Each plot has the accuracy for all 4 datasets listed | def create_batch_plots(accuracies, batch_sizes):
#Get accuracy data
p_cpu_accuracy = list(accuracies[0].values())
p_gpu_accuracy = list(accuracies[1].values())
c_cpu_accuracy = list(accuracies[2].values())
c_gpu_accuracy = list(accuracies[3].values())
#Create plot for each batch size... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def accuracy_plot(LS_sizes, data_fun):\r\n\r\n opt_neigh = []\r\n\r\n #plot of optimal n_neighbors as a function of the LS size\r\n\r\n for size in LS_sizes:\r\n\r\n acc = []\r\n neighbors_values = np.arange(1,size+1,1)\r\n\r\n # For a given LS size, plots of accuracy(n_neighbors)\r\n... | [
"0.73184514",
"0.7299639",
"0.70774925",
"0.69942814",
"0.6946279",
"0.6922432",
"0.68750584",
"0.6874822",
"0.6822587",
"0.6822159",
"0.67851657",
"0.6782538",
"0.6775013",
"0.6749557",
"0.6698696",
"0.6659146",
"0.6657379",
"0.6631417",
"0.6601273",
"0.6561536",
"0.6523589"... | 0.78852516 | 0 |
Initialize a new fraction with the given numerator and denominator (default 1). | def __init__(self, numerator, denominator=1):
common_div = gcd(numerator, denominator)
if common_div == 0:
common_div = 1
self.numerator = int((numerator / common_div) / copysign(1, denominator))
self.denominator = int((denominator / common_div) / copysign(1, denominator))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, numerator, denominator=1):\n gcd1 = math.gcd(numerator, denominator)\n\n if denominator < 0:\n self.numerator = -(int(numerator/gcd1))\n self.denominator = abs(int(denominator/gcd1))\n elif denominator == 0:\n self.numerator = 1\n ... | [
"0.8137715",
"0.79004323",
"0.7554975",
"0.7540042",
"0.7523119",
"0.74793065",
"0.74483407",
"0.7292548",
"0.7187293",
"0.7100966",
"0.707507",
"0.68207115",
"0.67850834",
"0.67308176",
"0.6693192",
"0.66444474",
"0.6619234",
"0.6480323",
"0.64723444",
"0.6453896",
"0.638398... | 0.764352 | 2 |
Return the sum of two fractions as a new fraction. Use the standard formula a/b + c/d = (ad+bc)/(bd) | def __add__(self, frac):
add_new_numerator = (self.numerator * frac.denominator) +\
(frac.numerator * self.denominator)
add_new_denominator = self.denominator * frac.denominator
if add_new_denominator == 0:
raise ValueError("UNDEFINED.")
return Fra... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def simplify_fraction(a, b):\n c = gcd(a, b)\n return a // c, b // c",
"def __add__ (self, other):\n if (self.debug): print(f'enter fraction.__add__ with {other}')\n lcm = find_lcm(self.value[1], other.value[1])\n if (self.debug): print(f'{int(lcm/self.value[1])} {self.value}')\n f1 = self.equi... | [
"0.7550767",
"0.73520947",
"0.70274425",
"0.70012",
"0.68851763",
"0.68535614",
"0.6831391",
"0.6830096",
"0.6678177",
"0.66171855",
"0.6570202",
"0.6537826",
"0.6499646",
"0.6448474",
"0.64213866",
"0.6402042",
"0.63277656",
"0.6272814",
"0.62671316",
"0.62539977",
"0.618849... | 0.65008366 | 12 |
Two fractions are equal if they have the same value. Fractions are stored in proper form so the internal representation is unique (3/6 is same as 1/2). | def __eq__(self, frac):
return self.equal == frac.equal | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_equal(self):\n self.assertTrue(Fraction(7,10)==Fraction(7,10))",
"def test_notequal(self):\n self.assertTrue(Fraction(144,2)!=Fraction(8,4))",
"def test_frac_same(self):\n s1 = self.RNA(\"ACGU\")\n s2 = self.RNA(\"AACG\")\n s3 = self.RNA(\"GG\")\n s4 = self.RN... | [
"0.8099188",
"0.7660002",
"0.74295694",
"0.72934115",
"0.7253576",
"0.7143537",
"0.6919099",
"0.6876407",
"0.6799766",
"0.67680925",
"0.6742922",
"0.67288",
"0.6660526",
"0.6650963",
"0.66349375",
"0.6611294",
"0.6571344",
"0.64932424",
"0.64467835",
"0.64218277",
"0.64188033... | 0.7083102 | 6 |
Enables some of the global JAX flags for debugging. | def enable_jax_debugging_flags():
# Enable the NaN-checker behavior to cause JAX to hard-break on the first
# occurrence of a NaN.
jax.config.update('jax_debug_nans', True)
# Enable the compilation logger to check whether or not we're accidentally
# causing a lot of re-compilation (inspect logs for excessiv... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_debug(flag):\n global debug\n debug = flag\n XLM.XLM_Object.debug = flag\n XLM.xlm_library.debug = flag\n XLM.ms_stack_transformer.debug = flag\n XLM.stack_transformer.debug = flag\n XLM.excel2007.debug = flag",
"def setDebug():\n\tglobal debug\n\tdebug = True",
"def _pma_set_debug... | [
"0.7106474",
"0.6122721",
"0.6115534",
"0.59994066",
"0.59944767",
"0.599425",
"0.5859546",
"0.5831815",
"0.57899874",
"0.574849",
"0.5723658",
"0.57184064",
"0.5690623",
"0.56572646",
"0.56189394",
"0.56183857",
"0.55708146",
"0.55087733",
"0.55059654",
"0.549461",
"0.549309... | 0.84278125 | 0 |
Prints out shape of parameters and total number of trainable parameters. | def log_param_shapes(params: Any,
print_params_nested_dict: bool = False) -> int:
if print_params_nested_dict:
shape_dict = tree_map(lambda x: str(x.shape), params)
# We use json.dumps for pretty printing nested dicts.
logging.info('Printing model param shape:/n%s',
j... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_trainable_params(scope=None):\n n_params = 0\n print('name \\t| shape \\t| num parameters')\n\n for var in tf.trainable_variables(scope):\n # shape is an array of tf.Dimension\n shape = var.get_shape()\n n_elems = shape.num_elements()\n print(var.name, shape, n_elems)... | [
"0.81262803",
"0.76609623",
"0.7620059",
"0.75991726",
"0.7555964",
"0.7479064",
"0.74128604",
"0.74116015",
"0.73896194",
"0.73896194",
"0.73891115",
"0.73891115",
"0.73891115",
"0.73891115",
"0.73185104",
"0.7250894",
"0.72192323",
"0.7219136",
"0.7195513",
"0.7163983",
"0.... | 0.7029052 | 23 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.